+Maintainer: $maintainer
+Homepage: $homepage
Architecture: $architecture
Provides: $PROJECT_NAME
Conflicts: $conflictname
diff --git a/doc/README-ja.md b/doc/README-ja.md
index c338e4f2..2906a049 100644
--- a/doc/README-ja.md
+++ b/doc/README-ja.md
@@ -13,7 +13,7 @@
インストール •
カスタマイズ •
プロジェクトの目標と既存の類似したOSS •
- 翻訳 [中文][日本語]
+ 翻訳 [中文][日本語][한국어]
### シンタックスハイライト
@@ -180,7 +180,7 @@ apt install bat
batの最新リリースを実行する場合、または Ubuntu/Debian の古いバージョンを使用している場合は、[release page](https://github.com/sharkdp/bat/releases) から最新の `.deb` パッケージをダウンロードし、
次の方法でインストールします:
```bash
-sudo dpkg -i bat_0.12.1_amd64.deb # adapt version number and architecture
+sudo dpkg -i bat_0.13.0_amd64.deb # adapt version number and architecture
```
### On Alpine Linux
@@ -500,11 +500,11 @@ export BAT_CONFIG_PATH="/path/to/bat.conf"
# Use italic text on the terminal (not supported on all terminals)
--italic-text=always
-# Use C++ syntax (instead of C) for .h header files
---map-syntax h:cpp
+# Use C++ syntax for .ino files
+--map-syntax "*.ino:C++"
-# Use "gitignore" highlighting for ".ignore" files
---map-syntax .ignore:.gitignore
+# Use ".gitignore"-style highlighting for ".ignore" files
+--map-syntax ".ignore:Git Ignore"
```
## Windows での `bat` の利用
diff --git a/doc/README-ko.md b/doc/README-ko.md
new file mode 100644
index 00000000..fff0c94b
--- /dev/null
+++ b/doc/README-ko.md
@@ -0,0 +1,560 @@
+
+ 
+ 
+ 
+ 
+ 
+
+ 문법 강조와 깃 통합 기능의 cat(1) 클론
+
+
+
+ 주요 기능들 •
+ 사용법 •
+ 설치 •
+ 커스터마이즈 •
+ 프로젝트 목표와 대안들 •
+ 번역 [中文][日本語]
+
+
+### 문법 강조
+
+`bat`은 다양한 프로그래밍 언어와 마크업 언어에 대해 문법 강조(Syntax highlighting)기능을 지원하고 있습니다:
+
+
+
+### Git 통합
+
+`bat`은 `git`을 통해 인덱스와 함께 변경분을 표시합니다 (왼쪽 바를 확인하세요):
+
+
+
+### 표시할 수 없는 문자 처리
+
+`-A`/`--show-all` 옵션을 사용하여 표시할수 없는 문자를 시각화 해줍니다:
+
+
+
+### 자동 페이징
+
+하나의 화면에 비해 출력이 너무 큰 경우, `less` 를 이용해 출력들을 연결할 수 있습니다.
+
+### 파일 연결
+
+이 뿐만 아니라 파일을 연결할 때도 사용 할 수 있습니다. :wink: `bat`가 인터렉티브 하지 않은(non-interactive)가 감지하면 (예를 들어,다른 프로세스 혹은 파일과 파이프라인을 연결 한 경우) `bat`은 `cat`을 대신하여 동작하며 일반 파일 내용을 표기해줍니다.
+
+## 사용법
+
+터미널에서 하나의 파일 표시하기
+
+```bash
+> bat README.md
+```
+
+여러 파일 한번에 보여주기
+
+```bash
+> bat src/*.rs
+```
+
+stdin에서 읽고, 자동으로 맞는 문법 강조 적용하기
+
+```bash
+> curl -s https://sh.rustup.rs | bat
+```
+
+stdin에서 읽고, 명시적으로 언어 지정하여 적용하기
+
+```bash
+> yaml2json .travis.yml | json_pp | bat -l json
+```
+
+표시할 수 없는 문자 처리하기
+```bash
+> bat -A /etc/hosts
+```
+
+`cat` 대신 사용하기:
+
+```bash
+bat > note.md # quickly create a new file
+
+bat header.md content.md footer.md > document.md
+
+bat -n main.rs # show line numbers (only)
+
+bat f - g # output 'f', then stdin, then 'g'.
+```
+
+### 다른 툴과의 통합
+
+#### `find` 와 `fd`
+
+`find`의 `-exec` 옵션을 사용하여 `bat`의 모든 검색 결과를 미리 볼 수 있습니다:
+```bash
+find … -exec bat {} +
+```
+
+[`fd`](https://github.com/sharkdp/fd)를 사용하고 있는 경우, `-X`/`--exec-batch` 옵션을 이용하여 동일하게 사용할 수 있습니다:
+```bash
+fd … -X bat
+```
+
+#### `ripgrep`
+
+[`batgrep`](https://github.com/eth-p/bat-extras/blob/master/doc/batgrep.md)과 함께, [`ripgrep`](https://github.com/BurntSushi/ripgrep)의 검색 결과를 `bat`을 이용하여 볼 수 있습니다.
+
+```bash
+batgrep needle src/
+```
+
+#### `tail -f`
+
+`bat` 과 `tail -f`를 함께 사용하여, 특정 파일을 문법 강조하며 지속적으로 모니터링 할 수 있습니다.
+```bash
+tail -f /var/log/pacman.log | bat --paging=never -l log
+```
+이 작업을 하려면 페이징 기능을 꺼야합니다. 또, 자동 감지가 되지 않기 때문에, 적용되어야할 문법을 명시적(`-l log`)으로 지정해야 합니다.
+
+#### `git`
+
+`bat`과 `git show`를 함께 사용하여 주어진 파일의 이전 기록을 문법 강조와 함께 볼 수 있습니다:
+```bash
+git show v0.6.0:src/main.rs | bat -l rs
+```
+
+diffs 내에서 문법 강조 표시는 현재 지원되지 않습니다. 이 기능은 [`delta`](https://github.com/dandavison/delta)에서 찾아 볼 수 있습니다.
+
+#### `xclip`
+
+`bat` 출력에서 라인 넘버와 Git 수정 내역이 같이 있어 파일 내용을 복사하기가 어려울 수도 있습니다. 이 경우에는 `-p`/`--plain` 옵션을 사용 하거나 출력 시 파이프라인으로 `xclip`을 사용하면 됩니다:
+```bash
+bat main.cpp | xclip
+```
+`bat` 에서는 리다이렉트된 것으로 감지하여, 파일 내용만 출력합니다.
+
+#### `man`
+
+`bat`은 `MANPAGER` 환경 변수 설정을 통해 `man`에 대하여 컬러 페이져를 사용할 수 있습니다:
+
+```bash
+export MANPAGER="sh -c 'col -bx | bat -l man -p'"
+man 2 select
+```
+
+포매팅 문제가 발생한다면, `MANROFFOPT="-c"` 설정 해야 할 수도 있습니다 .
+
+새 커맨드에서 이 번들을 사용하려면, [`batman`](https://github.com/eth-p/bat-extras/blob/master/doc/batman.md)을 이용 할 수 있습니다.
+
+
+참고 : [Manpage syntax](../assets/syntaxes/Manpage.sublime-syntax)는 이 저장소에서 개발되고 있으며, 아직 작업 중 입니다.
+
+#### `prettier` / `shfmt` / `rustfmt`
+
+[`prettybat`](https://github.com/eth-p/bat-extras/blob/master/doc/prettybat.md) 스크립트는 코드를 포맷팅하고 `bat`으로 출력해주는 랩퍼(wrapper) 입니다.
+
+
+## 설치
+
+[](https://repology.org/project/bat/versions)
+
+### On Ubuntu
+*... 그리고 기타 Debian 기반의 Linux 배포판들.*
+
+Ubuntu Eoan 19.10 혹은 Debian unstable sid 이후 버전 부터는 [Ubuntu용 `bat` 패키지](https://packages.ubuntu.com/eoan/bat)나 [Debian용 `bat` 패키지](https://packages.debian.org/sid/bat) 를 설치 할 수 있습니다.
+
+```bash
+apt install bat
+```
+
+만약 최근 릴리즈된 bat을 사용을 원하거나 buntu/Debian 예전 버전을 사용하는 경우, [릴리즈 페이지](https://github.com/sharkdp/bat/releases)에서 다음과 같이 `.deb` 패키지를 받아 설치 할 수도 있습니다:
+
+```bash
+sudo dpkg -i bat_0.13.0_amd64.deb # adapt version number and architecture
+```
+
+### On Alpine Linux
+
+공식 소스를 통해 [`bat` 패키지](https://pkgs.alpinelinux.org/packages?name=bat) 를 설치 할 수 있습니다:
+
+```bash
+apk add bat
+```
+
+### On Arch Linux
+
+공식 소스를 통해 [`bat` 패키지](https://www.archlinux.org/packages/community/x86_64/bat/)를 설치할 수 있습니다:
+
+```bash
+pacman -S bat
+```
+
+### On Fedora
+
+[공식 Fedora 모듈 저장소](https://docs.fedoraproject.org/en-US/modularity/using-modules/)에서 [`bat` 패키지](https://koji.fedoraproject.org/koji/packageinfo?packageID=27506)을 설치할 수 있습니다:
+
+```bash
+dnf install bat
+```
+
+### On Gentoo Linux
+
+공식 소스를 통해 [`bat` 패키지](https://packages.gentoo.org/packages/sys-apps/bat)를 설치할 수 있습니다.
+
+```bash
+emerge sys-apps/bat
+```
+
+### On Void Linux
+
+xbps-install를 이용해 `bat`을 설치할 수 있습니다:
+```bash
+xbps-install -S bat
+```
+
+### On FreeBSD
+
+pkg를 이용하여 미리 컴파일된 [`bat` 패키지](https://www.freshports.org/textproc/bat)를 설치할 수 있습니다:
+
+```bash
+pkg install bat
+```
+
+또는 FreeBSD 포트에서 직접 빌드할 수도 있습니다:
+
+```bash
+cd /usr/ports/textproc/bat
+make install
+```
+
+### Via nix
+
+[nix package manager](https://nixos.org/nix)를 이용해 `bat`을 설치할 수 있습니다:
+
+```bash
+nix-env -i bat
+```
+
+### On openSUSE
+
+zypper을 이용해 `bat`을 설치할 수 있습니다:
+
+```bash
+zypper install bat
+```
+
+### On macOS
+
+[Homebrew](http://braumeister.org/formula/bat)를 이용해 `bat`을 설치할 수 있습니다:
+
+```bash
+brew install bat
+```
+
+또는 [MacPorts](https://ports.macports.org/port/bat/summary)를 사용할 수도 있습니다:
+
+```bash
+port install bat
+```
+
+### On Windows
+
+Windows에서 `bat`을 설치할 수 있는 몇 가지 옵션들이 있습니다. 먼저 `bat`을 설치 한 후, ["Windows에서 사용하기"](#Windows에서-사용하기) 참고하시기 바랍니다.
+
+#### With Chocolatey
+
+[Chocolatey](https://chocolatey.org/packages/Bat)를 이용해 `bat`을 설치할 수 있습니다:
+```bash
+choco install bat
+```
+
+#### With Scoop
+
+[scoop](https://scoop.sh/)을 이용해 `bat`을 설치할 수 있습니다:
+```bash
+scoop install bat
+```
+[Visual C++ Redistributable 패키지](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads)를 같이 설치해 주어야 합니다.
+
+#### From prebuilt binaries:
+
+[릴리즈 페이지](https://github.com/sharkdp/bat/releases)에서 빌드된 바이너리를 다운받을 수 있습니다.
+
+[Visual C++ Redistributable 패키지](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads)를 같이 설치해 주어야 합니다.
+
+### Via Docker
+
+컨테이너에서 `bat`을 사용할 수 있는 [Docker image](https://hub.docker.com/r/danlynn/bat/)가 있습니다.:
+```bash
+docker pull danlynn/bat
+alias bat='docker run -it --rm -e BAT_THEME -e BAT_STYLE -e BAT_TABS -v "$(pwd):/myapp" danlynn/bat'
+```
+
+### Via Ansible
+
+[Ansible](https://www.ansible.com/)을 사용해 `bat`을 설치할 수 있습니다:
+
+```bash
+# Install role on local machine
+ansible-galaxy install aeimer.install_bat
+```
+
+```yaml
+---
+# Playbook to install bat
+- host: all
+ roles:
+ - aeimer.install_bat
+```
+
+- [Ansible Galaxy](https://galaxy.ansible.com/aeimer/install_bat)
+- [GitHub](https://github.com/aeimer/ansible-install-bat)
+
+다음 배포판들에서 동작합니다:
+- Debian/Ubuntu
+- ARM (eg. Raspberry PI)
+- Arch Linux
+- Void Linux
+- FreeBSD
+- MacOS
+
+### From binaries
+
+[릴리즈 페이지](https://github.com/sharkdp/bat/releases)에서 다양한 환경을 위해 빌드된 버전들을 확인 할 수 있습니다. 정적 링크 바이너리들은 아카이브에서 파일 이름에 `musl` 이 포함 파일로 확인 할 수 있습니다.
+
+### From source
+
+`bat`의 소스를 직접 빌드하기 위해서는, Rust 1.36 이상이 필요하며 `cargo`를 이용해 빌드할 수 있습니다.
+
+```bash
+cargo install bat
+```
+
+일부 플랫폼에서는 `llvm` 그리고/또는 `libclang-dev` 설치가 필요할 수도 있습니다.
+
+## 커스터마이즈
+
+### 문법 강조 테마
+
+`bat --list-themes`을 사용하면, 현재 사용 가능한 문법 강조 테마들을 확인할 수 있습니다. `TwoDark` 테마 선택하는 경우, `--theme=TwoDark` 옵션과 함께 `bat`을 사용하거나 환경변수에서 `BAT_THEME`를 `TwoDark`로 세팅해주면 됩니다. 쉘 시작 파일에 `export BAT_THEME="TwoDark"` 를 정의해 계속 사용도 가능합니다. 이 밖에 `bat`의 [설정 파일](#설정-파일)을 이용할 수도 있습니다.
+
+다른 테마를 미리 보고 싶은경우 다음 명령어와 같이 사용할 수 있습니다.(이 경우 [`fzf`](https://github.com/junegunn/fzf)가 필요합니다.)
+
+```bash
+bat --list-themes | fzf --preview="bat --theme={} --color=always /path/to/file"
+```
+`bat`의 기본 테마는 어두운 배경색 터미널에 적합합니다. 만일 밝은 배경색을 사용할 경우에는 `GitHub` 이나 `OneHalfLight` 과 같은 테마가 더 잘 어울립니다. 아래 [새로운 테마 추가하기](#새로운-테마-추가하기)에 따라 커스텀 테마를 사용할수도 있습니다.
+
+### 출력 스타일
+
+`--style` 옵션을 이용하여 `bat`의 출력 스타일을 변경 할 수 있습니다. 예를 들어, `--style=numbers,changes`는 Git 변경분과 라인 넘버에 대해서만 출력하며 눈금과 파일 헤더가 표시되지 않습니다. `BAT_STYLE` 환경 변수로 정의하여 계속해서 사용하거나`bat`의 [설정 파일](#설정-파일)을 사용할 수도 있습니다.
+
+### 새로운 문법 강조 / 언어 추가하기
+
+`bat`은 문법 강조를 위해 [`syntect`](https://github.com/trishume/syntect/) 라이브러리를 사용하고 있습니다. `syntect`는 [Sublime Text의 `.sublime-syntax` 파일](https://www.sublimetext.com/docs/3/syntax.html)과 테마를 읽을 수 있습니다. 새로운 문법 강조를 추가하는 방법은 다음과 같습니다.
+
+우선 문법 정의 파일을 넣을 폴더를 만듭니다:
+
+```bash
+mkdir -p "$(bat --config-dir)/syntaxes"
+cd "$(bat --config-dir)/syntaxes"
+
+# Put new '.sublime-syntax' language definition files
+# in this folder (or its subdirectories), for example:
+git clone https://github.com/tellnobody1/sublime-purescript-syntax
+```
+
+다음 명령어를 통해 파일을 바이너리 캐시로 파싱합니다.
+
+```bash
+bat cache --build
+```
+
+마지막으로 `bat --list-languages`을 통해 새로운 언어가 사용 가능한지 확인합니다.
+
+기본 설정으로 돌아가려면, 다음 명령어를 이용합니다.:
+
+```bash
+bat cache --clear
+```
+
+### 새로운 테마 추가하기
+
+새로운 문법 정의 추가와 매우 유사합니다.
+
+먼저, 새로운 문법 강조 테마 폴더를 만듭니다.
+```bash
+mkdir -p "$(bat --config-dir)/themes"
+cd "$(bat --config-dir)/themes"
+
+# Download a theme in '.tmTheme' format, for example:
+git clone https://github.com/greggb/sublime-snazzy
+
+# Update the binary cache
+bat cache --build
+```
+
+마지막으로 `bat --list-themes`을 통해 새로운 테마가 사용 가능한지 확인합니다.
+
+### 다른 페이져 사용하기
+
+`bat`은 환경변수 `PAGER`로 사용할 페이져를 명시합니다. 만약 이 변수가 정의되어있지 않다면 `less`가 기본입니다. 만약 다른 페이져를 사용하고 싶다면 `PAGER` 변수를 수정하거나 `BAT_PAGER` 환경 변수로 `PAGER` 대신 정의 할 수도 있습니다.
+
+만약 커맨드라인 인수로 넘기려면, `PAGER`/`BAT_PAGER` 변수를 정의를 통해 사용 할 수 있습니다. :
+
+```bash
+export BAT_PAGER="less -RF"
+```
+
+환경 변수 대신, `bat`의 [설정 파일](#설정-파일)에서 페이져를 설정 할 수도 있습니다.(`--pager` 옵션)
+
+**참고**: 기본적으로 페이져가 `less`로 설정 되어있다면, `bat`은 다음 옵션들을 받을 수 있습니다: `-R`/`--RAW-CONTROL-CHARS`,
+`-F`/`--quit-if-one-screen` 그리고 `-X`/`--no-init`. 마지막 옵션(`-X`)은 530 이전 버전에서만 사용됩니다.
+
+`-R` 옵션은 ANSI 컬러를 올바르게 해석하기 위해 필요합니다. 두번째 옵션 (`-F`)은 출력 크기가 터미널의 세로 크기보다 작을 경우 즉시 종료되도록 합니다.
+페이져를 종료하기 위해 `q`를 누를 필요 없기 때문에 작은 파일을 다룰 때 용이합니다. 세번째 옵션(`-X`)는 `less` 이전 버전의 `--quit-if-one-screen` 기능과 함께 버그를 잡을 때 필요합니다. 안타깝게도, `less`의 마우스 휠 지원은 종료합니다.
+
+`less` 예전 버전에서 마우스 휠 기능을 활성화 시키려면, `-R` 옵션을 사용하면 됩니다. (위의 예제처럼, 이 옵션은 quit-if-one-screen 기능을 비활성화 시킵니다.)
+530 이하 버전에서는 그대로 사용할 수 있습니다.
+
+### 다크 모드
+
+macOS에서 다크 모드를 사용하고 있다면, OS 테마에 따라 다른 테마를 사용하도록 `bat`의 구성할 수 있습니다. 아래 코드는 라이트 모드에서는 `default` 테마를 다크모드에서는 `Github` 테마를 사용하는 방법입니다.
+
+```bash
+alias cat="bat --theme=\$(defaults read -globalDomain AppleInterfaceStyle &> /dev/null && echo default || echo GitHub)"
+```
+
+## 설정 파일
+
+`bat` 설정 파일로 커스터마이즈 할 수 있습니다. 파일의 위치는 운영 체제에 따라 다릅니다. 아래 커맨드를 통해 시스템의 기본 경로를 알 수 있습니다.
+```
+bat --config-file
+```
+
+또는, `BAT_CONFIG_PATH` 환경 변수를 사용하여 `bat`의 설정 파일 위치를 지정할 수 있습니다.
+```bash
+export BAT_CONFIG_PATH="/path/to/bat.conf"
+```
+
+### 포맷
+
+설정 파일은 명령어 인수들의 리스트 입니다. `bat --help`를 이용하여 가능한 옵션들과 값들을 확인해 볼 수 있습니다. 또, `#` 으로 주석을 추가할수도 있습니다.
+
+설정 파일의 예:
+```bash
+# Set the theme to "TwoDark"
+--theme="TwoDark"
+
+# Show line numbers, Git modifications and file header (but no grid)
+--style="numbers,changes,header"
+
+# Use italic text on the terminal (not supported on all terminals)
+--italic-text=always
+
+# Use C++ syntax for .ino files
+--map-syntax "*.ino:C++"
+
+# Use ".gitignore"-style highlighting for ".ignore" files
+--map-syntax ".ignore:Git Ignore"
+```
+
+## Windows에서 사용하기
+
+`bat` 대부분의 경우 Windows에서 기본적으로 잘 작동하지만, 일부 기능에는 추가 적인 구성이 필요할 수 있습니다.
+
+### 페이징
+
+Windows는 `more` 형식의 매우 제한된 페이저만이 포함되어있습니다. `less`용 Windows 바이너리는 [이 홈페이지](http://www.greenwoodsoftware.com/less/download.html)나 [Chocolatey](https://chocolatey.org/packages/Less)에서 다운로드 받을 수 있습니다. 이를 사용하려면 바이너리를 `PATH` 디렉토리에 배치하거나 [환경 변수로 정의](#using-a-different-pager) 하세요. [Chocolatey 패키지](#on-windows)로 `less`를 자동으로 설치할 수 있습니다.
+
+### 색상
+
+Windows 10은 기본 내장기능으로 [v1511](https://en.wikipedia.org/wiki/Windows_10_version_history#Version_1511_(November_Update)) 이후의 `conhost.exe`(Command Prompt) 와 PowerShell, 그리고 최신 버전의 bash에서 색상을 지원합니다. 이전 버전의 Windows에서는, [ConEmu](https://conemu.github.io/)가 포함 된 [Cmder](http://cmder.net/)를 사용할 수 있습니다 .
+
+**참고:** `less`의 Git과 MSYS 버전은 Windows에서 색상을 올바르게 해석하지 않습니다. 다른 페이져가 설치되어 있지 않은 경우, `--paging=never` 하거나 `BAT_PAGER`를 빈 문자열로 설정하여 페이징을 완전히 비활성화 할 수 있습니다 .
+
+### Cygwin
+
+Windows에서의 `bat`은 기본적으로 Cygwin의 unix 스타일의 경로(`/cygdrive/*`)를 지원하지 않습니다. cygwin 절대경로를 인자로 받았을 때, `bat`은 다음과 같이 오류를 반환합니다. `:The system cannot find the path specified. (os error 3)`
+
+이 경우, wrapper를 만들거나 다음 함수를 `.bash_profile`추가하여 문제를 해결하실 수 있습니다 :
+
+```bash
+bat() {
+ local index
+ local args=("$@")
+ for index in $(seq 0 ${#args[@]}) ; do
+ case "${args[index]}" in
+ -*) continue;;
+ *) [ -e "${args[index]}" ] && args[index]="$(cygpath --windows "${args[index]}")";;
+ esac
+ done
+ command bat "${args[@]}"
+}
+```
+
+## 트러블슈팅
+
+### 터미널과 색상
+
+`bat`은 터미널 트루컬러 지원 여부와 상관없이 동작합니다. 하지만, 문법 강조 테마의 색상이 8-bit 컬러에는 최적화 되어 있지 않고 있으며, 24-bit 트루컬러 지원하는 터미널 사용하는 것을 적극 권장합니다.(`terminator`, `konsole`, `iTerm2`, ...). [이 글](https://gist.github.com/XVilka/8346728)에서 24-bit 트루컬러 지원하는 터미널들을 찾아보실 수 있습니다.
+
+사용하고 있는 터미널에서 `COLORTERM`을 `truecolor` 혹은
+`24bit`으로 설정 되어있는지 확인하세요. 만약 아니라면, `bat`은 24-bit escape sequence를 지원되는지 여부를 판단 할 수 없습니다. (그리고 8-bit 색상으로 돌아갑니다.)
+
+### 라인 숫자와 눈금이 잘 보이지 않는 경우
+
+다른 테마를 사용해 보세요. (`bat --list-themes`에서 테마들을 확인해 볼 수 있습니다.) `OneHalfDark` 과 `OneHalfLight` 테마는 눈금과 선의 색을 밝게 합니다.
+
+### 파일 인코딩
+
+`bat`은 기본적으로 UTF-8과 UTF-8을 제공합니다. 다른 파일 인코딩의 경우, 자동 감지 되지 않으므로 UTF-8로 먼저 변환해 주어야 합니다. 이렇게 할 때, `iconv`를 사용 할 수 있습니다. 예를 들어, Latin-1 (ISO-8859-1)로 인코딩된 PHP파일이라면 다음과 같이 사용할 수 있습니다.:
+``` bash
+iconv -f ISO-8859-1 -t UTF-8 my-file.php | bat
+```
+참고: `bat`으로 자동 감지가 되지 않는 경우에는 `-l`/`--language` 옵션을 사용할 수도 있습니다.
+
+## 배포
+
+```bash
+# Recursive clone to retrieve all submodules
+git clone --recursive https://github.com/sharkdp/bat
+
+# Build (debug version)
+cd bat
+cargo build --bins
+
+# Run unit tests and integration tests
+cargo test
+
+# Install (release version)
+cargo install
+
+# Build a bat binary with modified syntaxes and themes
+bash assets/create.sh
+cargo install -f
+```
+
+## 메인테이너들
+
+- [sharkdp](https://github.com/sharkdp)
+- [eth-p](https://github.com/eth-p)
+
+## 프로젝트 목표와 대안들
+
+`bat`은 아래와 같은 목표를 달성하려고 합니다:
+
+- 아름답고 발전된 문법 강조 기능
+- Git 연동을 통한 파일 수정 내역 확인
+- (POSIX)`cat`의 대체제
+- 사용자 친화적인 CLI 제공
+
+
+비슷한 프로그램들을 찾고 있다면, 많은 대안들이 있습니다. 비교는 [이 문서]((doc/alternatives.md))를 참조해주세요.
+
+## 라이센스
+Copyright (c) 2018-2020 [bat-developers](https://github.com/sharkdp/bat).
+
+`bat`는 MIT 라이센스 및 Apache 라이센스 2.0의 조건에 따라 배포됩니다.
+
+라이센스 세부사항은 [LICENSE-APACHE](LICENSE-APACHE)와 [LICENSE-MIT](LICENSE-MIT)를 참조하세요.
diff --git a/examples/cat.rs b/examples/cat.rs
new file mode 100644
index 00000000..73d8bb2b
--- /dev/null
+++ b/examples/cat.rs
@@ -0,0 +1,33 @@
+/// A very simple colorized `cat` clone, using `bat` as a library.
+/// See `src/bin/bat` for the full `bat` application.
+use bat::{
+ config::{Config, InputFile, StyleComponent, StyleComponents},
+ Controller, HighlightingAssets,
+};
+use console::Term;
+use std::process;
+
+fn main() {
+ let files = std::env::args_os().skip(1).collect::>();
+
+ if files.is_empty() {
+ eprintln!("No input files specified");
+ process::exit(1);
+ }
+
+ let config = Config {
+ term_width: Term::stdout().size().1 as usize,
+ colored_output: true,
+ true_color: true,
+ style_components: StyleComponents::new(&[
+ StyleComponent::Header,
+ StyleComponent::Grid,
+ StyleComponent::Numbers,
+ ]),
+ files: files.iter().map(|file| InputFile::Ordinary(file)).collect(),
+ ..Default::default()
+ };
+ let assets = HighlightingAssets::from_binary();
+
+ Controller::new(&config, &assets).run().expect("no errors");
+}
diff --git a/examples/simple.rs b/examples/simple.rs
index 16e0e71f..009e10c7 100644
--- a/examples/simple.rs
+++ b/examples/simple.rs
@@ -1,35 +1,20 @@
+/// A simple program that prints its own source code using the bat library
use bat::{
- assets::HighlightingAssets,
- controller::Controller,
- inputfile::InputFile,
- style::{OutputComponent, OutputComponents},
- Config,
+ config::{Config, InputFile},
+ Controller, HighlightingAssets,
};
-use console::Term;
-use std::process;
+use std::ffi::OsStr;
fn main() {
- let files = std::env::args_os().skip(1).collect::>();
-
- if files.is_empty() {
- eprintln!("No input files specified");
- process::exit(1);
- }
+ let path_to_this_file = OsStr::new(file!());
let config = Config {
- term_width: Term::stdout().size().1 as usize,
+ files: vec![InputFile::Ordinary(path_to_this_file)],
colored_output: true,
true_color: true,
- output_components: OutputComponents::new(&[
- OutputComponent::Header,
- OutputComponent::Grid,
- OutputComponent::Numbers,
- ]),
- files: files.iter().map(|file| InputFile::Ordinary(file)).collect(),
- theme: "1337".into(),
..Default::default()
};
- let assets = HighlightingAssets::new();
+ let assets = HighlightingAssets::from_binary();
Controller::new(&config, &assets).run().expect("no errors");
}
diff --git a/src/assets.rs b/src/assets.rs
index b757e4af..bc87eb36 100644
--- a/src/assets.rs
+++ b/src/assets.rs
@@ -1,41 +1,35 @@
-use std::borrow::Cow;
use std::collections::BTreeMap;
use std::fs::{self, File};
use std::io::BufReader;
-use std::path::{Path, PathBuf};
+use std::path::Path;
use syntect::dumps::{dump_to_file, from_binary, from_reader};
use syntect::highlighting::{Theme, ThemeSet};
use syntect::parsing::{SyntaxReference, SyntaxSet, SyntaxSetBuilder};
-use crate::dirs::PROJECT_DIRS;
-
use crate::errors::*;
use crate::inputfile::{InputFile, InputFileReader};
-use crate::syntax_mapping::SyntaxMapping;
-
-pub const BAT_THEME_DEFAULT: &str = "Monokai Extended";
+use crate::syntax_mapping::{MappingTarget, SyntaxMapping};
#[derive(Debug)]
pub struct HighlightingAssets {
- pub syntax_set: SyntaxSet,
- pub theme_set: ThemeSet,
+ pub(crate) syntax_set: SyntaxSet,
+ pub(crate) theme_set: ThemeSet,
+ fallback_theme: Option<&'static str>,
}
impl HighlightingAssets {
- pub fn new() -> Self {
- Self::from_cache().unwrap_or_else(|_| Self::from_binary())
+ pub fn default_theme() -> &'static str {
+ "Monokai Extended"
}
- pub fn from_files(dir: Option<&Path>, start_empty: bool) -> Result {
- let source_dir = dir.unwrap_or_else(|| PROJECT_DIRS.config_dir());
-
- let mut theme_set = if start_empty {
+ pub fn from_files(source_dir: &Path, include_integrated_assets: bool) -> Result {
+ let mut theme_set = if include_integrated_assets {
+ Self::get_integrated_themeset()
+ } else {
ThemeSet {
themes: BTreeMap::new(),
}
- } else {
- Self::get_integrated_themeset()
};
let theme_dir = source_dir.join("themes");
@@ -48,7 +42,7 @@ impl HighlightingAssets {
);
}
- let mut syntax_set_builder = if start_empty {
+ let mut syntax_set_builder = if !include_integrated_assets {
let mut builder = SyntaxSetBuilder::new();
builder.add_plain_text_syntax();
builder
@@ -69,15 +63,15 @@ impl HighlightingAssets {
Ok(HighlightingAssets {
syntax_set: syntax_set_builder.build(),
theme_set,
+ fallback_theme: None,
})
}
- fn from_cache() -> Result {
- let theme_set_path = theme_set_path();
- let syntax_set_file = File::open(&syntax_set_path()).chain_err(|| {
+ pub fn from_cache(theme_set_path: &Path, syntax_set_path: &Path) -> Result {
+ let syntax_set_file = File::open(syntax_set_path).chain_err(|| {
format!(
"Could not load cached syntax set '{}'",
- syntax_set_path().to_string_lossy()
+ syntax_set_path.to_string_lossy()
)
})?;
let syntax_set: SyntaxSet = from_reader(BufReader::new(syntax_set_file))
@@ -95,6 +89,7 @@ impl HighlightingAssets {
Ok(HighlightingAssets {
syntax_set,
theme_set,
+ fallback_theme: None,
})
}
@@ -106,18 +101,18 @@ impl HighlightingAssets {
from_binary(include_bytes!("../assets/themes.bin"))
}
- fn from_binary() -> Self {
+ pub fn from_binary() -> Self {
let syntax_set = Self::get_integrated_syntaxset();
let theme_set = Self::get_integrated_themeset();
HighlightingAssets {
syntax_set,
theme_set,
+ fallback_theme: None,
}
}
- pub fn save(&self, dir: Option<&Path>) -> Result<()> {
- let target_dir = dir.unwrap_or_else(|| PROJECT_DIRS.cache_dir());
+ pub fn save_to_cache(&self, target_dir: &Path) -> Result<()> {
let _ = fs::create_dir_all(target_dir);
let theme_set_path = target_dir.join("themes.bin");
let syntax_set_path = target_dir.join("syntaxes.bin");
@@ -149,22 +144,36 @@ impl HighlightingAssets {
Ok(())
}
- pub fn get_theme(&self, theme: &str) -> &Theme {
+ pub fn set_fallback_theme(&mut self, theme: &'static str) {
+ self.fallback_theme = Some(theme);
+ }
+
+ pub fn syntaxes(&self) -> &[SyntaxReference] {
+ self.syntax_set.syntaxes()
+ }
+
+ pub fn themes(&self) -> impl Iterator- {
+ self.theme_set.themes.keys()
+ }
+
+ pub(crate) fn get_theme(&self, theme: &str) -> &Theme {
match self.theme_set.themes.get(theme) {
Some(theme) => theme,
None => {
- use ansi_term::Colour::Yellow;
- eprintln!(
- "{}: Unknown theme '{}', using default.",
- Yellow.paint("[bat warning]"),
- theme
- );
- &self.theme_set.themes[BAT_THEME_DEFAULT]
+ if theme != "" {
+ use ansi_term::Colour::Yellow;
+ eprintln!(
+ "{}: Unknown theme '{}', using default.",
+ Yellow.paint("[bat warning]"),
+ theme
+ );
+ }
+ &self.theme_set.themes[self.fallback_theme.unwrap_or(Self::default_theme())]
}
}
}
- pub fn get_syntax(
+ pub(crate) fn get_syntax(
&self,
language: Option<&str>,
filename: InputFile,
@@ -175,25 +184,28 @@ impl HighlightingAssets {
(Some(language), _) => self.syntax_set.find_syntax_by_token(language),
(None, InputFile::Ordinary(filename)) => {
let path = Path::new(filename);
+
let file_name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
let extension = path.extension().and_then(|x| x.to_str()).unwrap_or("");
- let file_name = mapping.replace(file_name);
- let extension = mapping.replace(extension);
-
let ext_syntax = self
.syntax_set
.find_syntax_by_extension(&file_name)
.or_else(|| self.syntax_set.find_syntax_by_extension(&extension));
- let line_syntax = if ext_syntax.is_none() {
- String::from_utf8(reader.first_line.clone())
- .ok()
- .and_then(|l| self.syntax_set.find_syntax_by_first_line(&l))
- } else {
- None
- };
+ let line_syntax = String::from_utf8(reader.first_line.clone())
+ .ok()
+ .and_then(|l| self.syntax_set.find_syntax_by_first_line(&l));
- ext_syntax.or(line_syntax)
+ let absolute_path = path.canonicalize().ok().unwrap_or(path.to_owned());
+ match mapping.get_syntax_for(absolute_path) {
+ Some(MappingTarget::MapTo(syntax_name)) => {
+ // TODO: we should probably return an error here if this syntax can not be
+ // found. Currently, we just fall back to 'plain'.
+ self.syntax_set.find_syntax_by_name(syntax_name)
+ }
+ Some(MappingTarget::MapToUnknown) => line_syntax,
+ None => ext_syntax.or(line_syntax),
+ }
}
(None, InputFile::StdIn) => String::from_utf8(reader.first_line.clone())
.ok()
@@ -205,28 +217,120 @@ impl HighlightingAssets {
}
}
-fn theme_set_path() -> PathBuf {
- PROJECT_DIRS.cache_dir().join("themes.bin")
-}
+#[cfg(test)]
+mod tests {
+ use std::ffi::OsStr;
+ use std::fs::File;
+ use std::io;
+ use std::io::Write;
-fn syntax_set_path() -> PathBuf {
- PROJECT_DIRS.cache_dir().join("syntaxes.bin")
-}
+ use tempdir::TempDir;
-pub fn config_dir() -> Cow<'static, str> {
- PROJECT_DIRS.config_dir().to_string_lossy()
-}
+ use crate::assets::HighlightingAssets;
+ use crate::inputfile::InputFile;
+ use crate::syntax_mapping::{MappingTarget, SyntaxMapping};
-pub fn cache_dir() -> Cow<'static, str> {
- PROJECT_DIRS.cache_dir().to_string_lossy()
-}
+ struct SyntaxDetectionTest<'a> {
+ assets: HighlightingAssets,
+ pub syntax_mapping: SyntaxMapping<'a>,
+ temp_dir: TempDir,
+ }
-pub fn clear_assets() {
- print!("Clearing theme set cache ... ");
- fs::remove_file(theme_set_path()).ok();
- println!("okay");
+ impl<'a> SyntaxDetectionTest<'a> {
+ fn new() -> Self {
+ SyntaxDetectionTest {
+ assets: HighlightingAssets::from_binary(),
+ syntax_mapping: SyntaxMapping::builtin(),
+ temp_dir: TempDir::new("bat_syntax_detection_tests")
+ .expect("creation of temporary directory"),
+ }
+ }
- print!("Clearing syntax set cache ... ");
- fs::remove_file(syntax_set_path()).ok();
- println!("okay");
+ fn synax_for_file_with_content(&self, file_name: &str, first_line: &str) -> String {
+ let file_path = self.temp_dir.path().join(file_name);
+ {
+ let mut temp_file = File::create(&file_path).unwrap();
+ writeln!(temp_file, "{}", first_line).unwrap();
+ }
+
+ let input_file = InputFile::Ordinary(OsStr::new(&file_path));
+ let syntax = self.assets.get_syntax(
+ None,
+ input_file,
+ &mut input_file.get_reader(&io::stdin()).unwrap(),
+ &self.syntax_mapping,
+ );
+
+ syntax.name.clone()
+ }
+
+ fn syntax_for_file(&self, file_name: &str) -> String {
+ self.synax_for_file_with_content(file_name, "")
+ }
+ }
+
+ #[test]
+ fn syntax_detection_basic() {
+ let test = SyntaxDetectionTest::new();
+
+ assert_eq!(test.syntax_for_file("test.rs"), "Rust");
+ assert_eq!(test.syntax_for_file("test.cpp"), "C++");
+ assert_eq!(test.syntax_for_file("test.build"), "NAnt Build File");
+ assert_eq!(
+ test.syntax_for_file("PKGBUILD"),
+ "Bourne Again Shell (bash)"
+ );
+ assert_eq!(test.syntax_for_file(".bashrc"), "Bourne Again Shell (bash)");
+ assert_eq!(test.syntax_for_file("Makefile"), "Makefile");
+ }
+
+ #[test]
+ fn syntax_detection_well_defined_mapping_for_duplicate_extensions() {
+ let test = SyntaxDetectionTest::new();
+
+ assert_eq!(test.syntax_for_file("test.h"), "C++");
+ assert_eq!(test.syntax_for_file("test.sass"), "Sass");
+ assert_eq!(test.syntax_for_file("test.hs"), "Haskell (improved)");
+ assert_eq!(test.syntax_for_file("test.js"), "JavaScript (Babel)");
+ }
+
+ #[test]
+ fn syntax_detection_first_line() {
+ let test = SyntaxDetectionTest::new();
+
+ assert_eq!(
+ test.synax_for_file_with_content("my_script", "#!/bin/bash"),
+ "Bourne Again Shell (bash)"
+ );
+ assert_eq!(
+ test.synax_for_file_with_content("build", "#!/bin/bash"),
+ "Bourne Again Shell (bash)"
+ );
+ assert_eq!(
+ test.synax_for_file_with_content("my_script", " bool {
@@ -79,7 +78,7 @@ impl App {
pub fn config(&self) -> Result {
let files = self.files();
- let output_components = self.output_components()?;
+ let style_components = self.style_components()?;
let paging_mode = match self.matches.value_of("paging") {
Some("always") => PagingMode::Always,
@@ -105,17 +104,17 @@ impl App {
}
};
- let mut syntax_mapping = SyntaxMapping::new();
+ let mut syntax_mapping = SyntaxMapping::builtin();
if let Some(values) = self.matches.values_of("map-syntax") {
for from_to in values {
let parts: Vec<_> = from_to.split(':').collect();
if parts.len() != 2 {
- return Err("Invalid syntax mapping. The format of the -m/--map-syntax option is 'from:to'.".into());
+ return Err("Invalid syntax mapping. The format of the -m/--map-syntax option is ':'. For example: '*.cpp:C++'.".into());
}
- syntax_mapping.insert(parts[0], parts[1]);
+ syntax_mapping.insert(parts[0], MappingTarget::MapTo(parts[1]))?;
}
}
@@ -158,7 +157,7 @@ impl App {
Some("character") => OutputWrap::Character,
Some("never") => OutputWrap::None,
Some("auto") | _ => {
- if output_components.plain() {
+ if style_components.plain() {
OutputWrap::None
} else {
OutputWrap::Character
@@ -188,7 +187,7 @@ impl App {
.or_else(|| env::var("BAT_TABS").ok())
.and_then(|t| t.parse().ok())
.unwrap_or(
- if output_components.plain() && paging_mode == PagingMode::Never {
+ if style_components.plain() && paging_mode == PagingMode::Never {
0
} else {
4
@@ -201,33 +200,34 @@ impl App {
.or_else(|| env::var("BAT_THEME").ok())
.map(|s| {
if s == "default" {
- String::from(BAT_THEME_DEFAULT)
+ String::from(HighlightingAssets::default_theme())
} else {
s
}
})
- .unwrap_or_else(|| String::from(BAT_THEME_DEFAULT)),
- line_ranges: LineRanges::from(
- self.matches
- .values_of("line-range")
- .map(|vs| vs.map(LineRange::from).collect())
- .transpose()?
- .unwrap_or_else(|| vec![]),
- ),
- output_components,
+ .unwrap_or_else(|| String::from(HighlightingAssets::default_theme())),
+ line_ranges: self
+ .matches
+ .values_of("line-range")
+ .map(|vs| vs.map(LineRange::from).collect())
+ .transpose()?
+ .map(LineRanges::from)
+ .unwrap_or_default(),
+ style_components,
syntax_mapping,
pager: self.matches.value_of("pager"),
use_italic_text: match self.matches.value_of("italic-text") {
Some("always") => true,
_ => false,
},
- highlight_lines: LineRanges::from(
- self.matches
- .values_of("highlight-line")
- .map(|ws| ws.map(LineRange::from).collect())
- .transpose()?
- .unwrap_or_else(|| vec![LineRange { lower: 0, upper: 0 }]),
- ),
+ highlighted_lines: self
+ .matches
+ .values_of("highlight-line")
+ .map(|ws| ws.map(LineRange::from).collect())
+ .transpose()?
+ .map(LineRanges::from)
+ .map(|lr| HighlightedLineRanges(lr))
+ .unwrap_or_default(),
filenames: self
.matches
.values_of("file-name")
@@ -252,23 +252,23 @@ impl App {
.unwrap_or_else(|| vec![InputFile::StdIn])
}
- fn output_components(&self) -> Result {
+ fn style_components(&self) -> Result {
let matches = &self.matches;
- Ok(OutputComponents(
+ Ok(StyleComponents(
if matches.value_of("decorations") == Some("never") {
HashSet::new()
} else if matches.is_present("number") {
- [OutputComponent::Numbers].iter().cloned().collect()
+ [StyleComponent::Numbers].iter().cloned().collect()
} else if matches.is_present("plain") {
- [OutputComponent::Plain].iter().cloned().collect()
+ [StyleComponent::Plain].iter().cloned().collect()
} else {
- let env_style_components: Option> = env::var("BAT_STYLE")
+ let env_style_components: Option> = env::var("BAT_STYLE")
.ok()
.map(|style_str| {
style_str
.split(',')
- .map(|x| OutputComponent::from_str(&x))
- .collect::>>()
+ .map(|x| StyleComponent::from_str(&x))
+ .collect::>>()
})
.transpose()?;
@@ -277,12 +277,12 @@ impl App {
.map(|styles| {
styles
.split(',')
- .map(|style| style.parse::())
+ .map(|style| style.parse::())
.filter_map(|style| style.ok())
.collect::>()
})
.or(env_style_components)
- .unwrap_or_else(|| vec![OutputComponent::Full])
+ .unwrap_or_else(|| vec![StyleComponent::Full])
.into_iter()
.map(|style| style.components(self.interactive_output))
.fold(HashSet::new(), |mut acc, components| {
diff --git a/src/bin/bat/assets.rs b/src/bin/bat/assets.rs
new file mode 100644
index 00000000..ed07bdb3
--- /dev/null
+++ b/src/bin/bat/assets.rs
@@ -0,0 +1,38 @@
+use std::borrow::Cow;
+use std::fs;
+use std::path::PathBuf;
+
+use crate::directories::PROJECT_DIRS;
+
+use bat::HighlightingAssets;
+
+fn theme_set_path() -> PathBuf {
+ PROJECT_DIRS.cache_dir().join("themes.bin")
+}
+
+fn syntax_set_path() -> PathBuf {
+ PROJECT_DIRS.cache_dir().join("syntaxes.bin")
+}
+
+pub fn config_dir() -> Cow<'static, str> {
+ PROJECT_DIRS.config_dir().to_string_lossy()
+}
+
+pub fn cache_dir() -> Cow<'static, str> {
+ PROJECT_DIRS.cache_dir().to_string_lossy()
+}
+
+pub fn clear_assets() {
+ print!("Clearing theme set cache ... ");
+ fs::remove_file(theme_set_path()).ok();
+ println!("okay");
+
+ print!("Clearing syntax set cache ... ");
+ fs::remove_file(syntax_set_path()).ok();
+ println!("okay");
+}
+
+pub fn assets_from_cache_or_binary() -> HighlightingAssets {
+ HighlightingAssets::from_cache(&theme_set_path(), &syntax_set_path())
+ .unwrap_or(HighlightingAssets::from_binary())
+}
diff --git a/src/bin/bat/clap_app.rs b/src/bin/bat/clap_app.rs
index 41827cd8..a430b844 100644
--- a/src/bin/bat/clap_app.rs
+++ b/src/bin/bat/clap_app.rs
@@ -260,13 +260,13 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
.multiple(true)
.takes_value(true)
.number_of_values(1)
- .value_name("from:to")
- .help("Map a file extension or name to an existing syntax.")
+ .value_name("glob:syntax")
+ .help("Use the specified syntax for files matching the glob pattern ('*.cpp:C++').")
.long_help(
- "Map a file extension or file name to an existing syntax (specified by a file \
- extension or file name). For example, to highlight *.build files with the \
- Python syntax, use '-m build:py'. To highlight files named '.myignore' with \
- the Git Ignore syntax, use '-m .myignore:gitignore'.",
+ "Map a glob pattern to an existing syntax name. The glob pattern is matched \
+ on the full path and the filename. For example, to highlight *.build files \
+ with the Python syntax, use -m '*.build:Python'. To highlight files named \
+ '.myignore' with the Git Ignore syntax, use -m '.myignore:Git Ignore'.",
)
.takes_value(true),
)
@@ -293,7 +293,7 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
.arg(
Arg::with_name("style")
.long("style")
- .value_name("style-components")
+ .value_name("components")
// Need to turn this off for overrides_with to work as we want. See the bottom most
// example at https://docs.rs/clap/2.32.0/clap/struct.Arg.html#method.overrides_with
.use_delimiter(false)
diff --git a/src/bin/bat/config.rs b/src/bin/bat/config.rs
index 95f76559..b8854844 100644
--- a/src/bin/bat/config.rs
+++ b/src/bin/bat/config.rs
@@ -5,7 +5,7 @@ use std::path::PathBuf;
use shell_words;
-use bat::dirs::PROJECT_DIRS;
+use crate::directories::PROJECT_DIRS;
pub fn config_file() -> PathBuf {
env::var("BAT_CONFIG_PATH")
diff --git a/src/dirs.rs b/src/bin/bat/directories.rs
similarity index 67%
rename from src/dirs.rs
rename to src/bin/bat/directories.rs
index 03cef44d..e57a58c0 100644
--- a/src/dirs.rs
+++ b/src/bin/bat/directories.rs
@@ -1,8 +1,8 @@
-use crate::dirs_rs;
+use std::env;
use std::path::{Path, PathBuf};
-#[cfg(target_os = "macos")]
-use std::env;
+use dirs;
+use lazy_static::lazy_static;
/// Wrapper for 'dirs' that treats MacOS more like Linux, by following the XDG specification.
/// This means that the `XDG_CACHE_HOME` and `XDG_CONFIG_HOME` environment variables are
@@ -14,25 +14,16 @@ pub struct BatProjectDirs {
impl BatProjectDirs {
fn new() -> Option {
- #[cfg(target_os = "macos")]
- let cache_dir_op = env::var_os("XDG_CACHE_HOME")
- .map(PathBuf::from)
- .filter(|p| p.is_absolute())
- .or_else(|| dirs_rs::home_dir().map(|d| d.join(".cache")));
-
- #[cfg(not(target_os = "macos"))]
- let cache_dir_op = dirs_rs::cache_dir();
-
- let cache_dir = cache_dir_op.map(|d| d.join("bat"))?;
+ let cache_dir = BatProjectDirs::get_cache_dir()?;
#[cfg(target_os = "macos")]
let config_dir_op = env::var_os("XDG_CONFIG_HOME")
.map(PathBuf::from)
.filter(|p| p.is_absolute())
- .or_else(|| dirs_rs::home_dir().map(|d| d.join(".config")));
+ .or_else(|| dirs::home_dir().map(|d| d.join(".config")));
#[cfg(not(target_os = "macos"))]
- let config_dir_op = dirs_rs::config_dir();
+ let config_dir_op = dirs::config_dir();
let config_dir = config_dir_op.map(|d| d.join("bat"))?;
@@ -42,6 +33,25 @@ impl BatProjectDirs {
})
}
+ pub fn get_cache_dir() -> Option {
+ // on all OS prefer BAT_CACHE_PATH if set
+ let cache_dir_op = env::var_os("BAT_CACHE_PATH").map(PathBuf::from);
+ if cache_dir_op.is_some() {
+ return cache_dir_op;
+ }
+
+ #[cfg(target_os = "macos")]
+ let cache_dir_op = env::var_os("XDG_CACHE_HOME")
+ .map(PathBuf::from)
+ .filter(|p| p.is_absolute())
+ .or_else(|| dirs::home_dir().map(|d| d.join(".cache")));
+
+ #[cfg(not(target_os = "macos"))]
+ let cache_dir_op = dirs::cache_dir();
+
+ cache_dir_op.map(|d| d.join("bat"))
+ }
+
pub fn cache_dir(&self) -> &Path {
&self.cache_dir
}
diff --git a/src/bin/bat/main.rs b/src/bin/bat/main.rs
index 17138d05..c759575c 100644
--- a/src/bin/bat/main.rs
+++ b/src/bin/bat/main.rs
@@ -4,9 +4,13 @@
#[macro_use]
extern crate clap;
+extern crate dirs as dirs_rs;
+
mod app;
+mod assets;
mod clap_app;
mod config;
+mod directories;
use std::collections::HashSet;
use std::ffi::OsStr;
@@ -19,25 +23,31 @@ use ansi_term::Colour::Green;
use ansi_term::Style;
use crate::{app::App, config::config_file};
-use bat::controller::Controller;
+use assets::{assets_from_cache_or_binary, cache_dir, clear_assets, config_dir};
+use bat::Controller;
+use directories::PROJECT_DIRS;
use bat::{
- assets::{cache_dir, clear_assets, config_dir, HighlightingAssets},
+ config::{Config, InputFile, StyleComponent, StyleComponents},
errors::*,
- inputfile::InputFile,
- style::{OutputComponent, OutputComponents},
- Config,
+ HighlightingAssets,
};
fn run_cache_subcommand(matches: &clap::ArgMatches) -> Result<()> {
if matches.is_present("build") {
- let source_dir = matches.value_of("source").map(Path::new);
- let target_dir = matches.value_of("target").map(Path::new);
+ let source_dir = matches
+ .value_of("source")
+ .map(Path::new)
+ .unwrap_or_else(|| PROJECT_DIRS.config_dir());
+ let target_dir = matches
+ .value_of("target")
+ .map(Path::new)
+ .unwrap_or_else(|| PROJECT_DIRS.cache_dir());
let blank = matches.is_present("blank");
- let assets = HighlightingAssets::from_files(source_dir, blank)?;
- assets.save(target_dir)?;
+ let assets = HighlightingAssets::from_files(source_dir, !blank)?;
+ assets.save_to_cache(target_dir)?;
} else if matches.is_present("clear") {
clear_assets();
}
@@ -46,9 +56,8 @@ fn run_cache_subcommand(matches: &clap::ArgMatches) -> Result<()> {
}
pub fn list_languages(config: &Config) -> Result<()> {
- let assets = HighlightingAssets::new();
+ let assets = assets_from_cache_or_binary();
let mut languages = assets
- .syntax_set
.syntaxes()
.iter()
.filter(|syntax| !syntax.hidden && !syntax.file_extensions.is_empty())
@@ -109,19 +118,18 @@ pub fn list_languages(config: &Config) -> Result<()> {
}
pub fn list_themes(cfg: &Config) -> Result<()> {
- let assets = HighlightingAssets::new();
- let themes = &assets.theme_set.themes;
+ let assets = assets_from_cache_or_binary();
let mut config = cfg.clone();
let mut style = HashSet::new();
- style.insert(OutputComponent::Plain);
+ style.insert(StyleComponent::Plain);
config.files = vec![InputFile::ThemePreviewFile];
- config.output_components = OutputComponents(style);
+ config.style_components = StyleComponents(style);
let stdout = io::stdout();
let mut stdout = stdout.lock();
if config.colored_output {
- for (theme, _) in themes.iter() {
+ for theme in assets.themes() {
writeln!(
stdout,
"Theme: {}\n",
@@ -132,7 +140,7 @@ pub fn list_themes(cfg: &Config) -> Result<()> {
writeln!(stdout)?;
}
} else {
- for (theme, _) in themes.iter() {
+ for theme in assets.themes() {
writeln!(stdout, "{}", theme)?;
}
}
@@ -141,7 +149,7 @@ pub fn list_themes(cfg: &Config) -> Result<()> {
}
fn run_controller(config: &Config) -> Result {
- let assets = HighlightingAssets::new();
+ let assets = assets_from_cache_or_binary();
let controller = Controller::new(&config, &assets);
controller.run()
}
@@ -199,7 +207,7 @@ fn main() {
match result {
Err(error) => {
- handle_error(&error);
+ default_error_handler(&error);
process::exit(1);
}
Ok(false) => {
diff --git a/src/config.rs b/src/config.rs
new file mode 100644
index 00000000..b0d58609
--- /dev/null
+++ b/src/config.rs
@@ -0,0 +1,96 @@
+pub use crate::inputfile::InputFile;
+pub use crate::line_range::{HighlightedLineRanges, LineRange, LineRanges};
+pub use crate::style::{StyleComponent, StyleComponents};
+pub use crate::syntax_mapping::{MappingTarget, SyntaxMapping};
+pub use crate::wrap::OutputWrap;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum PagingMode {
+ Always,
+ QuitIfOneScreen,
+ Never,
+}
+
+impl Default for PagingMode {
+ fn default() -> Self {
+ PagingMode::Never
+ }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Config<'a> {
+ /// List of files to print
+ pub files: Vec>,
+
+ /// The explicitly configured language, if any
+ pub language: Option<&'a str>,
+
+ /// Whether or not to show/replace non-printable characters like space, tab and newline.
+ pub show_nonprintable: bool,
+
+ /// The character width of the terminal
+ pub term_width: usize,
+
+ /// The width of tab characters.
+ /// Currently, a value of 0 will cause tabs to be passed through without expanding them.
+ pub tab_width: usize,
+
+ /// Whether or not to simply loop through all input (`cat` mode)
+ pub loop_through: bool,
+
+ /// Whether or not the output should be colorized
+ pub colored_output: bool,
+
+ /// Whether or not the output terminal supports true color
+ pub true_color: bool,
+
+ /// Style elements (grid, line numbers, ...)
+ pub style_components: StyleComponents,
+
+ /// Text wrapping mode
+ pub output_wrap: OutputWrap,
+
+ /// Pager or STDOUT
+ pub paging_mode: PagingMode,
+
+ /// Specifies the lines that should be printed
+ pub line_ranges: LineRanges,
+
+ /// The syntax highlighting theme
+ pub theme: String,
+
+ /// File extension/name mappings
+ pub syntax_mapping: SyntaxMapping<'a>,
+
+ /// Command to start the pager
+ pub pager: Option<&'a str>,
+
+ /// Whether or not to use ANSI italics
+ pub use_italic_text: bool,
+
+ /// Ranges of lines which should be highlighted with a special background color
+ pub highlighted_lines: HighlightedLineRanges,
+
+ /// Name of file to display when printing
+ pub filenames: Option>,
+}
+
+#[test]
+fn default_config_should_include_all_lines() {
+ use crate::line_range::RangeCheckResult;
+
+ assert_eq!(
+ Config::default().line_ranges.check(17),
+ RangeCheckResult::InRange
+ );
+}
+
+#[test]
+fn default_config_should_highlight_no_lines() {
+ use crate::line_range::RangeCheckResult;
+
+ assert_ne!(
+ Config::default().highlighted_lines.0.check(17),
+ RangeCheckResult::InRange
+ );
+}
diff --git a/src/controller.rs b/src/controller.rs
index 96633133..21c7f81c 100644
--- a/src/controller.rs
+++ b/src/controller.rs
@@ -2,12 +2,12 @@ use std::io::{self, Write};
use std::path::Path;
use crate::assets::HighlightingAssets;
+use crate::config::{Config, PagingMode};
use crate::errors::*;
use crate::inputfile::{InputFile, InputFileReader};
use crate::line_range::{LineRanges, RangeCheckResult};
use crate::output::OutputType;
use crate::printer::{InteractivePrinter, Printer, SimplePrinter};
-use crate::{Config, PagingMode};
pub struct Controller<'a> {
config: &'a Config<'a>,
@@ -20,6 +20,10 @@ impl<'b> Controller<'b> {
}
pub fn run(&self) -> Result {
+ self.run_with_error_handler(default_error_handler)
+ }
+
+ pub fn run_with_error_handler(&self, handle_error: impl Fn(&Error)) -> Result {
// Do not launch the pager if NONE of the input files exist
let mut paging_mode = self.config.paging_mode;
if self.config.paging_mode != PagingMode::Never {
@@ -93,7 +97,7 @@ impl<'b> Controller<'b> {
input_file: InputFile<'a>,
file_name: Option<&str>,
) -> Result<()> {
- if !reader.first_line.is_empty() || self.config.output_components.header() {
+ if !reader.first_line.is_empty() || self.config.style_components.header() {
printer.print_header(writer, input_file, file_name)?;
}
@@ -120,7 +124,7 @@ impl<'b> Controller<'b> {
while reader.read_line(&mut line_buffer)? {
match line_ranges.check(line_number) {
- RangeCheckResult::OutsideRange => {
+ RangeCheckResult::BeforeOrBetweenRanges => {
// Call the printer in case we need to call the syntax highlighter
// for this line. However, set `out_of_range` to `true`.
printer.print_line(true, writer, line_number, &line_buffer)?;
@@ -128,7 +132,7 @@ impl<'b> Controller<'b> {
}
RangeCheckResult::InRange => {
- if self.config.output_components.snip() {
+ if self.config.style_components.snip() {
if first_range {
first_range = false;
mid_range = true;
diff --git a/src/errors.rs b/src/errors.rs
new file mode 100644
index 00000000..a0f7e5eb
--- /dev/null
+++ b/src/errors.rs
@@ -0,0 +1,25 @@
+use error_chain::error_chain;
+
+error_chain! {
+ foreign_links {
+ Clap(::clap::Error);
+ Io(::std::io::Error);
+ SyntectError(::syntect::LoadingError);
+ ParseIntError(::std::num::ParseIntError);
+ GlobParsingError(::globset::Error);
+ }
+}
+
+pub fn default_error_handler(error: &Error) {
+ match error {
+ Error(ErrorKind::Io(ref io_error), _)
+ if io_error.kind() == ::std::io::ErrorKind::BrokenPipe =>
+ {
+ ::std::process::exit(0);
+ }
+ _ => {
+ use ansi_term::Colour::Red;
+ eprintln!("{}: {}", Red.paint("[bat error]"), error);
+ }
+ };
+}
diff --git a/src/inputfile.rs b/src/inputfile.rs
index e79c931d..4a2c6f26 100644
--- a/src/inputfile.rs
+++ b/src/inputfile.rs
@@ -10,8 +10,8 @@ const THEME_PREVIEW_FILE: &[u8] = include_bytes!("../assets/theme_preview.rs");
pub struct InputFileReader<'a> {
inner: Box,
- pub first_line: Vec,
- pub content_type: Option,
+ pub(crate) first_line: Vec,
+ pub(crate) content_type: Option,
}
impl<'a> InputFileReader<'a> {
@@ -36,7 +36,7 @@ impl<'a> InputFileReader<'a> {
}
}
- pub fn read_line(&mut self, buf: &mut Vec) -> io::Result {
+ pub(crate) fn read_line(&mut self, buf: &mut Vec) -> io::Result {
if self.first_line.is_empty() {
let res = self.inner.read_until(b'\n', buf).map(|size| size > 0)?;
@@ -60,7 +60,7 @@ pub enum InputFile<'a> {
}
impl<'a> InputFile<'a> {
- pub fn get_reader(&self, stdin: &'a io::Stdin) -> Result {
+ pub(crate) fn get_reader(&self, stdin: &'a io::Stdin) -> Result {
match self {
InputFile::StdIn => Ok(InputFileReader::new(stdin.lock())),
InputFile::Ordinary(filename) => {
diff --git a/src/lib.rs b/src/lib.rs
index 5723145d..8178f497 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,12 +1,6 @@
// `error_chain!` can recurse deeply
#![recursion_limit = "1024"]
-#[macro_use]
-extern crate error_chain;
-
-#[macro_use]
-extern crate lazy_static;
-
extern crate ansi_term;
extern crate atty;
extern crate console;
@@ -18,118 +12,23 @@ extern crate shell_words;
extern crate syntect;
extern crate wild;
-pub mod assets;
-pub mod controller;
+pub(crate) mod assets;
+pub mod config;
+pub(crate) mod controller;
mod decorations;
mod diff;
-pub mod dirs;
-pub mod inputfile;
+pub mod errors;
+pub(crate) mod inputfile;
mod less;
-pub mod line_range;
+pub(crate) mod line_range;
mod output;
mod preprocessor;
-mod printer;
-pub mod style;
-pub mod syntax_mapping;
+pub(crate) mod printer;
+pub(crate) mod style;
+pub(crate) mod syntax_mapping;
mod terminal;
+pub(crate) mod wrap;
-pub mod errors {
- error_chain! {
- foreign_links {
- Clap(::clap::Error);
- Io(::std::io::Error);
- SyntectError(::syntect::LoadingError);
- ParseIntError(::std::num::ParseIntError);
- }
- }
-
- pub fn handle_error(error: &Error) {
- match error {
- Error(ErrorKind::Io(ref io_error), _)
- if io_error.kind() == ::std::io::ErrorKind::BrokenPipe =>
- {
- ::std::process::exit(0);
- }
- _ => {
- use ansi_term::Colour::Red;
- eprintln!("{}: {}", Red.paint("[bat error]"), error);
- }
- };
- }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum PagingMode {
- Always,
- QuitIfOneScreen,
- Never,
-}
-
-impl Default for PagingMode {
- fn default() -> Self {
- PagingMode::Never
- }
-}
-
-use inputfile::InputFile;
-use line_range::LineRanges;
-use style::{OutputComponents, OutputWrap};
-use syntax_mapping::SyntaxMapping;
-
-#[derive(Debug, Clone, Default)]
-pub struct Config<'a> {
- /// List of files to print
- pub files: Vec>,
-
- /// The explicitly configured language, if any
- pub language: Option<&'a str>,
-
- /// Whether or not to show/replace non-printable characters like space, tab and newline.
- pub show_nonprintable: bool,
-
- /// The character width of the terminal
- pub term_width: usize,
-
- /// The width of tab characters.
- /// Currently, a value of 0 will cause tabs to be passed through without expanding them.
- pub tab_width: usize,
-
- /// Whether or not to simply loop through all input (`cat` mode)
- pub loop_through: bool,
-
- /// Whether or not the output should be colorized
- pub colored_output: bool,
-
- /// Whether or not the output terminal supports true color
- pub true_color: bool,
-
- /// Style elements (grid, line numbers, ...)
- pub output_components: OutputComponents,
-
- /// Text wrapping mode
- pub output_wrap: OutputWrap,
-
- /// Pager or STDOUT
- pub paging_mode: PagingMode,
-
- /// Specifies the lines that should be printed
- pub line_ranges: LineRanges,
-
- /// The syntax highlighting theme
- pub theme: String,
-
- /// File extension/name mappings
- pub syntax_mapping: SyntaxMapping,
-
- /// Command to start the pager
- pub pager: Option<&'a str>,
-
- /// Whether or not to use ANSI italics
- pub use_italic_text: bool,
-
- /// Lines to highlight
- pub highlight_lines: LineRanges,
-
- /// Name of file to display when printing
- pub filenames: Option>,
-}
+pub use assets::HighlightingAssets;
+pub use controller::Controller;
+pub use printer::{InteractivePrinter, Printer, SimplePrinter};
diff --git a/src/line_range.rs b/src/line_range.rs
index 5dfbd3b3..b7cfee5f 100644
--- a/src/line_range.rs
+++ b/src/line_range.rs
@@ -6,20 +6,22 @@ pub struct LineRange {
pub upper: usize,
}
-impl LineRange {
- pub fn from(range_raw: &str) -> Result {
- LineRange::parse_range(range_raw)
- }
-
- pub fn new() -> LineRange {
+impl Default for LineRange {
+ fn default() -> LineRange {
LineRange {
lower: usize::min_value(),
upper: usize::max_value(),
}
}
+}
- pub fn parse_range(range_raw: &str) -> Result {
- let mut new_range = LineRange::new();
+impl LineRange {
+ pub fn from(range_raw: &str) -> Result {
+ LineRange::parse_range(range_raw)
+ }
+
+ fn parse_range(range_raw: &str) -> Result {
+ let mut new_range = LineRange::default();
if range_raw.bytes().nth(0).ok_or("Empty line range")? == b':' {
new_range.upper = range_raw[1..].parse()?;
@@ -48,7 +50,7 @@ impl LineRange {
}
}
- pub fn is_inside(&self, line: usize) -> bool {
+ pub(crate) fn is_inside(&self, line: usize) -> bool {
line >= self.lower && line <= self.upper
}
}
@@ -97,19 +99,27 @@ pub enum RangeCheckResult {
InRange,
// Before the first range or within two ranges
- OutsideRange,
+ BeforeOrBetweenRanges,
// Line number is outside of all ranges and larger than the last range.
AfterLastRange,
}
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
pub struct LineRanges {
ranges: Vec,
largest_upper_bound: usize,
}
impl LineRanges {
+ pub fn none() -> LineRanges {
+ LineRanges::from(vec![])
+ }
+
+ pub fn all() -> LineRanges {
+ LineRanges::from(vec![LineRange::default()])
+ }
+
pub fn from(ranges: Vec) -> LineRanges {
let largest_upper_bound = ranges
.iter()
@@ -122,17 +132,32 @@ impl LineRanges {
}
}
- pub fn check(&self, line: usize) -> RangeCheckResult {
- if self.ranges.is_empty() | self.ranges.iter().any(|r| r.is_inside(line)) {
+ pub(crate) fn check(&self, line: usize) -> RangeCheckResult {
+ if self.ranges.iter().any(|r| r.is_inside(line)) {
RangeCheckResult::InRange
} else if line < self.largest_upper_bound {
- RangeCheckResult::OutsideRange
+ RangeCheckResult::BeforeOrBetweenRanges
} else {
RangeCheckResult::AfterLastRange
}
}
}
+impl Default for LineRanges {
+ fn default() -> Self {
+ Self::all()
+ }
+}
+
+#[derive(Debug, Clone)]
+pub struct HighlightedLineRanges(pub LineRanges);
+
+impl Default for HighlightedLineRanges {
+ fn default() -> Self {
+ HighlightedLineRanges(LineRanges::none())
+ }
+}
+
#[cfg(test)]
fn ranges(rs: &[&str]) -> LineRanges {
LineRanges::from(rs.iter().map(|r| LineRange::from(r).unwrap()).collect())
@@ -142,7 +167,7 @@ fn ranges(rs: &[&str]) -> LineRanges {
fn test_ranges_simple() {
let ranges = ranges(&["3:8"]);
- assert_eq!(RangeCheckResult::OutsideRange, ranges.check(2));
+ assert_eq!(RangeCheckResult::BeforeOrBetweenRanges, ranges.check(2));
assert_eq!(RangeCheckResult::InRange, ranges.check(5));
assert_eq!(RangeCheckResult::AfterLastRange, ranges.check(9));
}
@@ -151,11 +176,11 @@ fn test_ranges_simple() {
fn test_ranges_advanced() {
let ranges = ranges(&["3:8", "11:20", "25:30"]);
- assert_eq!(RangeCheckResult::OutsideRange, ranges.check(2));
+ assert_eq!(RangeCheckResult::BeforeOrBetweenRanges, ranges.check(2));
assert_eq!(RangeCheckResult::InRange, ranges.check(5));
- assert_eq!(RangeCheckResult::OutsideRange, ranges.check(9));
+ assert_eq!(RangeCheckResult::BeforeOrBetweenRanges, ranges.check(9));
assert_eq!(RangeCheckResult::InRange, ranges.check(11));
- assert_eq!(RangeCheckResult::OutsideRange, ranges.check(22));
+ assert_eq!(RangeCheckResult::BeforeOrBetweenRanges, ranges.check(22));
assert_eq!(RangeCheckResult::InRange, ranges.check(28));
assert_eq!(RangeCheckResult::AfterLastRange, ranges.check(31));
}
@@ -174,15 +199,22 @@ fn test_ranges_open_low() {
fn test_ranges_open_high() {
let ranges = ranges(&["3:", "2:5"]);
- assert_eq!(RangeCheckResult::OutsideRange, ranges.check(1));
+ assert_eq!(RangeCheckResult::BeforeOrBetweenRanges, ranges.check(1));
assert_eq!(RangeCheckResult::InRange, ranges.check(3));
assert_eq!(RangeCheckResult::InRange, ranges.check(5));
assert_eq!(RangeCheckResult::InRange, ranges.check(9));
}
#[test]
-fn test_ranges_empty() {
- let ranges = ranges(&[]);
+fn test_ranges_all() {
+ let ranges = LineRanges::all();
assert_eq!(RangeCheckResult::InRange, ranges.check(1));
}
+
+#[test]
+fn test_ranges_none() {
+ let ranges = LineRanges::none();
+
+ assert_ne!(RangeCheckResult::InRange, ranges.check(1));
+}
diff --git a/src/output.rs b/src/output.rs
index 081cb160..3bad301b 100644
--- a/src/output.rs
+++ b/src/output.rs
@@ -6,9 +6,9 @@ use std::process::{Child, Command, Stdio};
use shell_words;
+use crate::config::PagingMode;
use crate::errors::*;
use crate::less::retrieve_less_version;
-use crate::PagingMode;
#[derive(Debug)]
pub enum OutputType {
diff --git a/src/printer.rs b/src/printer.rs
index 64d42d1d..3924cd62 100644
--- a/src/printer.rs
+++ b/src/printer.rs
@@ -20,6 +20,7 @@ use encoding::{DecoderTrap, Encoding};
use unicode_width::UnicodeWidthChar;
use crate::assets::HighlightingAssets;
+use crate::config::Config;
use crate::decorations::{
Decoration, GridBorderDecoration, LineChangesDecoration, LineNumberDecoration,
};
@@ -29,9 +30,8 @@ use crate::errors::*;
use crate::inputfile::{InputFile, InputFileReader};
use crate::line_range::RangeCheckResult;
use crate::preprocessor::{expand_tabs, replace_nonprintable};
-use crate::style::OutputWrap;
use crate::terminal::{as_terminal_escaped, to_ansi_color};
-use crate::Config;
+use crate::wrap::OutputWrap;
pub trait Printer {
fn print_header(
@@ -126,11 +126,11 @@ impl<'a> InteractivePrinter<'a> {
// Create decorations.
let mut decorations: Vec> = Vec::new();
- if config.output_components.numbers() {
+ if config.style_components.numbers() {
decorations.push(Box::new(LineNumberDecoration::new(&colors)));
}
- if config.output_components.changes() {
+ if config.style_components.changes() {
decorations.push(Box::new(LineChangesDecoration::new(&colors)));
}
@@ -140,7 +140,7 @@ impl<'a> InteractivePrinter<'a> {
// The grid border decoration isn't added until after the panel_width calculation, since the
// print_horizontal_line, print_header, and print_footer functions all assume the panel
// width is without the grid border.
- if config.output_components.grid() && !decorations.is_empty() {
+ if config.style_components.grid() && !decorations.is_empty() {
decorations.push(Box::new(GridBorderDecoration::new(&colors)));
}
@@ -162,7 +162,7 @@ impl<'a> InteractivePrinter<'a> {
None
} else {
// Get the Git modifications
- line_changes = if config.output_components.changes() {
+ line_changes = if config.style_components.changes() {
match file {
InputFile::Ordinary(filename) => get_git_diff(filename),
_ => None,
@@ -216,7 +216,7 @@ impl<'a> InteractivePrinter<'a> {
text_truncated,
" ".repeat(self.panel_width - 1 - text_truncated.len())
);
- if self.config.output_components.grid() {
+ if self.config.style_components.grid() {
format!("{} │ ", text_filled)
} else {
format!("{}", text_filled)
@@ -240,7 +240,7 @@ impl<'a> Printer for InteractivePrinter<'a> {
file: InputFile,
file_name: Option<&str>,
) -> Result<()> {
- if !self.config.output_components.header() {
+ if !self.config.style_components.header() {
if Some(ContentType::BINARY) == self.content_type && !self.config.show_nonprintable {
let input = match file {
InputFile::Ordinary(filename) => format!(
@@ -259,14 +259,14 @@ impl<'a> Printer for InteractivePrinter<'a> {
input
)?;
} else {
- if self.config.output_components.grid() {
+ if self.config.style_components.grid() {
self.print_horizontal_line(handle, '┬')?;
}
}
return Ok(());
}
- if self.config.output_components.grid() {
+ if self.config.style_components.grid() {
self.print_horizontal_line(handle, '┬')?;
write!(
@@ -305,7 +305,7 @@ impl<'a> Printer for InteractivePrinter<'a> {
mode
)?;
- if self.config.output_components.grid() {
+ if self.config.style_components.grid() {
if self.content_type.map_or(false, |c| c.is_text()) || self.config.show_nonprintable {
self.print_horizontal_line(handle, '┼')?;
} else {
@@ -317,7 +317,7 @@ impl<'a> Printer for InteractivePrinter<'a> {
}
fn print_footer(&mut self, handle: &mut dyn Write) -> Result<()> {
- if self.config.output_components.grid()
+ if self.config.style_components.grid()
&& (self.content_type.map_or(false, |c| c.is_text()) || self.config.show_nonprintable)
{
self.print_horizontal_line(handle, '┴')
@@ -395,7 +395,7 @@ impl<'a> Printer for InteractivePrinter<'a> {
// Line highlighting
let highlight_this_line =
- self.config.highlight_lines.check(line_number) == RangeCheckResult::InRange;
+ self.config.highlighted_lines.0.check(line_number) == RangeCheckResult::InRange;
let background_color = self
.background_color_highlight
diff --git a/src/style.rs b/src/style.rs
index e06bba79..a906553a 100644
--- a/src/style.rs
+++ b/src/style.rs
@@ -4,7 +4,7 @@ use std::str::FromStr;
use crate::errors::*;
#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
-pub enum OutputComponent {
+pub enum StyleComponent {
Auto,
Changes,
Grid,
@@ -15,92 +15,80 @@ pub enum OutputComponent {
Plain,
}
-#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
-pub enum OutputWrap {
- Character,
- None,
-}
-
-impl Default for OutputWrap {
- fn default() -> Self {
- OutputWrap::None
- }
-}
-
-impl OutputComponent {
- pub fn components(self, interactive_terminal: bool) -> &'static [OutputComponent] {
+impl StyleComponent {
+ pub fn components(self, interactive_terminal: bool) -> &'static [StyleComponent] {
match self {
- OutputComponent::Auto => {
+ StyleComponent::Auto => {
if interactive_terminal {
- OutputComponent::Full.components(interactive_terminal)
+ StyleComponent::Full.components(interactive_terminal)
} else {
- OutputComponent::Plain.components(interactive_terminal)
+ StyleComponent::Plain.components(interactive_terminal)
}
}
- OutputComponent::Changes => &[OutputComponent::Changes],
- OutputComponent::Grid => &[OutputComponent::Grid],
- OutputComponent::Header => &[OutputComponent::Header],
- OutputComponent::Numbers => &[OutputComponent::Numbers],
- OutputComponent::Snip => &[OutputComponent::Snip],
- OutputComponent::Full => &[
- OutputComponent::Changes,
- OutputComponent::Grid,
- OutputComponent::Header,
- OutputComponent::Numbers,
- OutputComponent::Snip,
+ StyleComponent::Changes => &[StyleComponent::Changes],
+ StyleComponent::Grid => &[StyleComponent::Grid],
+ StyleComponent::Header => &[StyleComponent::Header],
+ StyleComponent::Numbers => &[StyleComponent::Numbers],
+ StyleComponent::Snip => &[StyleComponent::Snip],
+ StyleComponent::Full => &[
+ StyleComponent::Changes,
+ StyleComponent::Grid,
+ StyleComponent::Header,
+ StyleComponent::Numbers,
+ StyleComponent::Snip,
],
- OutputComponent::Plain => &[],
+ StyleComponent::Plain => &[],
}
}
}
-impl FromStr for OutputComponent {
+impl FromStr for StyleComponent {
type Err = Error;
fn from_str(s: &str) -> Result {
match s {
- "auto" => Ok(OutputComponent::Auto),
- "changes" => Ok(OutputComponent::Changes),
- "grid" => Ok(OutputComponent::Grid),
- "header" => Ok(OutputComponent::Header),
- "numbers" => Ok(OutputComponent::Numbers),
- "snip" => Ok(OutputComponent::Snip),
- "full" => Ok(OutputComponent::Full),
- "plain" => Ok(OutputComponent::Plain),
+ "auto" => Ok(StyleComponent::Auto),
+ "changes" => Ok(StyleComponent::Changes),
+ "grid" => Ok(StyleComponent::Grid),
+ "header" => Ok(StyleComponent::Header),
+ "numbers" => Ok(StyleComponent::Numbers),
+ "snip" => Ok(StyleComponent::Snip),
+ "full" => Ok(StyleComponent::Full),
+ "plain" => Ok(StyleComponent::Plain),
_ => Err(format!("Unknown style '{}'", s).into()),
}
}
}
#[derive(Debug, Clone, Default)]
-pub struct OutputComponents(pub HashSet);
+pub struct StyleComponents(pub HashSet);
-impl OutputComponents {
- pub fn new(components: &[OutputComponent]) -> OutputComponents {
- OutputComponents(components.iter().cloned().collect())
+impl StyleComponents {
+ pub fn new(components: &[StyleComponent]) -> StyleComponents {
+ StyleComponents(components.iter().cloned().collect())
}
pub fn changes(&self) -> bool {
- self.0.contains(&OutputComponent::Changes)
+ self.0.contains(&StyleComponent::Changes)
}
pub fn grid(&self) -> bool {
- self.0.contains(&OutputComponent::Grid)
+ self.0.contains(&StyleComponent::Grid)
}
pub fn header(&self) -> bool {
- self.0.contains(&OutputComponent::Header)
+ self.0.contains(&StyleComponent::Header)
}
pub fn numbers(&self) -> bool {
- self.0.contains(&OutputComponent::Numbers)
+ self.0.contains(&StyleComponent::Numbers)
}
pub fn snip(&self) -> bool {
- self.0.contains(&OutputComponent::Snip)
+ self.0.contains(&StyleComponent::Snip)
}
pub fn plain(&self) -> bool {
- self.0.iter().all(|c| c == &OutputComponent::Plain)
+ self.0.iter().all(|c| c == &StyleComponent::Plain)
}
}
diff --git a/src/syntax_mapping.rs b/src/syntax_mapping.rs
index 3126ac9c..72cb021c 100644
--- a/src/syntax_mapping.rs
+++ b/src/syntax_mapping.rs
@@ -1,35 +1,111 @@
-use std::borrow::Cow;
-use std::collections::HashMap;
+use std::path::Path;
+
+use crate::errors::Result;
+
+use globset::{Candidate, GlobBuilder, GlobMatcher};
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum MappingTarget<'a> {
+ MapTo(&'a str),
+ MapToUnknown,
+}
#[derive(Debug, Clone, Default)]
-pub struct SyntaxMapping(HashMap);
+pub struct SyntaxMapping<'a> {
+ mappings: Vec<(GlobMatcher, MappingTarget<'a>)>,
+}
-impl SyntaxMapping {
- pub fn new() -> SyntaxMapping {
+impl<'a> SyntaxMapping<'a> {
+ pub fn empty() -> SyntaxMapping<'a> {
Default::default()
}
- pub fn insert(&mut self, from: impl Into, to: impl Into) -> Option {
- self.0.insert(from.into(), to.into())
+ pub fn builtin() -> SyntaxMapping<'a> {
+ let mut mapping = Self::empty();
+ mapping.insert("*.h", MappingTarget::MapTo("C++")).unwrap();
+ mapping
+ .insert("build", MappingTarget::MapToUnknown)
+ .unwrap();
+ mapping
+ .insert("**/.ssh/config", MappingTarget::MapTo("SSH Config"))
+ .unwrap();
+ mapping
+ .insert(
+ "/etc/profile",
+ MappingTarget::MapTo("Bourne Again Shell (bash)"),
+ )
+ .unwrap();
+
+ mapping
}
- pub fn replace<'a>(&self, input: impl Into>) -> Cow<'a, str> {
- let input = input.into();
- match self.0.get(input.as_ref()) {
- Some(s) => Cow::from(s.clone()),
- None => input,
+ pub fn insert(&mut self, from: &str, to: MappingTarget<'a>) -> Result<()> {
+ let glob = GlobBuilder::new(from)
+ .case_insensitive(false)
+ .literal_separator(true)
+ .build()?;
+ self.mappings.push((glob.compile_matcher(), to));
+ Ok(())
+ }
+
+ pub(crate) fn get_syntax_for(&self, path: impl AsRef) -> Option> {
+ let candidate = Candidate::new(path.as_ref());
+ let canddidate_filename = path.as_ref().file_name().map(Candidate::new);
+ for (ref glob, ref syntax) in self.mappings.iter().rev() {
+ if glob.is_match_candidate(&candidate)
+ || canddidate_filename
+ .as_ref()
+ .map_or(false, |filename| glob.is_match_candidate(filename))
+ {
+ return Some(*syntax);
+ }
}
+ None
}
}
#[test]
fn basic() {
- let mut map = SyntaxMapping::new();
- map.insert("Cargo.lock", "toml");
- map.insert(".ignore", ".gitignore");
+ let mut map = SyntaxMapping::empty();
+ map.insert("/path/to/Cargo.lock", MappingTarget::MapTo("TOML"))
+ .ok();
+ map.insert("/path/to/.ignore", MappingTarget::MapTo("Git Ignore"))
+ .ok();
- assert_eq!("toml", map.replace("Cargo.lock"));
- assert_eq!("other.lock", map.replace("other.lock"));
+ assert_eq!(
+ map.get_syntax_for("/path/to/Cargo.lock"),
+ Some(MappingTarget::MapTo("TOML"))
+ );
+ assert_eq!(map.get_syntax_for("/path/to/other.lock"), None);
- assert_eq!(".gitignore", map.replace(".ignore"));
+ assert_eq!(
+ map.get_syntax_for("/path/to/.ignore"),
+ Some(MappingTarget::MapTo("Git Ignore"))
+ );
+}
+
+#[test]
+fn user_can_override_builtin_mappings() {
+ let mut map = SyntaxMapping::builtin();
+
+ assert_eq!(
+ map.get_syntax_for("/etc/profile"),
+ Some(MappingTarget::MapTo("Bourne Again Shell (bash)"))
+ );
+ map.insert("/etc/profile", MappingTarget::MapTo("My Syntax"))
+ .ok();
+ assert_eq!(
+ map.get_syntax_for("/etc/profile"),
+ Some(MappingTarget::MapTo("My Syntax"))
+ );
+}
+
+#[test]
+fn builtin_mappings() {
+ let map = SyntaxMapping::builtin();
+
+ assert_eq!(
+ map.get_syntax_for("/path/to/build"),
+ Some(MappingTarget::MapToUnknown)
+ );
}
diff --git a/src/wrap.rs b/src/wrap.rs
new file mode 100644
index 00000000..211469ab
--- /dev/null
+++ b/src/wrap.rs
@@ -0,0 +1,11 @@
+#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
+pub enum OutputWrap {
+ Character,
+ None,
+}
+
+impl Default for OutputWrap {
+ fn default() -> Self {
+ OutputWrap::None
+ }
+}
diff --git a/tests/no_duplicate_extensions.rs b/tests/no_duplicate_extensions.rs
new file mode 100644
index 00000000..20dfc349
--- /dev/null
+++ b/tests/no_duplicate_extensions.rs
@@ -0,0 +1,35 @@
+use std::collections::HashSet;
+
+use bat::HighlightingAssets;
+
+#[test]
+fn no_duplicate_extensions() {
+ const KNOWN_EXCEPTIONS: &[&'static str] = &[
+ // The '.h' extension currently appears in multiple syntaxes: C, C++, Objective C,
+ // Objective C++
+ "h",
+ // In addition to the standard Haskell syntax in 'Packages', we also ship the 'Cabal'
+ // syntax which comes with a "Haskell (improved)" syntax.
+ "hs",
+ // In addition to the standard JavaScript syntax in 'Packages', we also ship the
+ // 'Javascript (Babel)' syntax.
+ "js",
+ // The "Ruby Haml" syntax also comes with a '.sass' extension. However, we make sure
+ // that 'sass' is mapped to the 'Sass' syntax.
+ "sass",
+ ];
+
+ let assets = HighlightingAssets::from_binary();
+
+ let mut extensions = HashSet::new();
+
+ for syntax in assets.syntaxes() {
+ for extension in &syntax.file_extensions {
+ assert!(
+ KNOWN_EXCEPTIONS.contains(&extension.as_str()) || extensions.insert(extension),
+ "File extension / pattern \"{}\" appears twice in the syntax set",
+ extension
+ );
+ }
+ }
+}
diff --git a/tests/syntax_detection.rs b/tests/syntax_detection.rs
deleted file mode 100644
index 23a52de9..00000000
--- a/tests/syntax_detection.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-use std::ffi::OsStr;
-use std::fs::File;
-use std::io;
-use std::io::Write;
-
-use tempdir::TempDir;
-
-use bat::assets::HighlightingAssets;
-use bat::inputfile::InputFile;
-use bat::syntax_mapping::SyntaxMapping;
-
-struct SyntaxDetectionTest {
- assets: HighlightingAssets,
- pub syntax_mapping: SyntaxMapping,
- temp_dir: TempDir,
-}
-
-impl SyntaxDetectionTest {
- fn new() -> Self {
- SyntaxDetectionTest {
- assets: HighlightingAssets::new(),
- syntax_mapping: SyntaxMapping::new(),
- temp_dir: TempDir::new("bat_syntax_detection_tests")
- .expect("creation of temporary directory"),
- }
- }
-
- fn syntax_name_with_content(&self, file_name: &str, first_line: &str) -> String {
- let file_path = self.temp_dir.path().join(file_name);
- {
- let mut temp_file = File::create(&file_path).unwrap();
- writeln!(temp_file, "{}", first_line).unwrap();
- }
-
- let input_file = InputFile::Ordinary(OsStr::new(&file_path));
- let syntax = self.assets.get_syntax(
- None,
- input_file,
- &mut input_file.get_reader(&io::stdin()).unwrap(),
- &self.syntax_mapping,
- );
-
- syntax.name.clone()
- }
-
- fn syntax_name(&self, file_name: &str) -> String {
- self.syntax_name_with_content(file_name, "")
- }
-}
-
-#[test]
-fn syntax_detection_basic() {
- let test = SyntaxDetectionTest::new();
-
- assert_eq!(test.syntax_name("test.rs"), "Rust");
- assert_eq!(test.syntax_name("test.cpp"), "C++");
- assert_eq!(test.syntax_name("PKGBUILD"), "Bourne Again Shell (bash)");
-}
-
-#[test]
-fn syntax_detection_first_line() {
- let test = SyntaxDetectionTest::new();
-
- assert_eq!(
- test.syntax_name_with_content("my_script", "#!/bin/bash"),
- "Bourne Again Shell (bash)"
- );
- assert_eq!(test.syntax_name_with_content("my_script", "