lexdrill 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ee9e8bd1de6b7fc437375184394a0ce42d61d9648320e6a31e83bf575cfc885
-  data.tar.gz: 27836a51638dbd08eb53a1d6f6808d94a0fb27c8e4b93cd831e96c2f5b0abe64
+  metadata.gz: 0510a355aeb50c560e27a73fd9ab70350c8e5c326d5dbd0ad43138e849b0bd2f
+  data.tar.gz: 529f2a86af2ec0b735c3147bd412fe82d276f6d434e6a074deefb650270818eb
 SHA512:
-  metadata.gz: cb860ea6fb40050205abbbdc2078d1a3e5b4f624629bb1b769a33c7bd1de3e22452d65265017cd0e7597bde5d934b04c568e96ab8f2643678392dfe86a8e2dc6
-  data.tar.gz: edbe4b9f27ced36534b9f3816840feb9216728288077af785292b12015d765db0c96170a0f8f79dc9182926323b3404517abd237ff51b47747901fb4e93632a7
+  metadata.gz: d9168c8d3218c457b6cf08662254d7b69f6adaef33cb1962a1dbcf4a0243c653bffbd9a74580e5cd7dbdcce9118fe0406b221d72f42b7347525a3a0adc93ee20
+  data.tar.gz: 552834f01e378765ddf7549410ad964dc254c8c286bc34605f765661f68fb232100003dedad70c18fe025e8215cdba250d0c37f0a60338f235647f3335bb1eee

data/README.md

@@ -1,6 +1,7 @@
 # lexdrill
 
-lexdrill prints a vocabulary word or phrase on demand, tracking how often each one has been shown.
+The `lexdrill` gem installs a `drill` command that prints a vocabulary word or
+phrase on demand, tracking how often each one has been shown.
 
 ## Installation
 
@@ -8,7 +9,7 @@ lexdrill prints a vocabulary word or phrase on demand, tracking how often each o
 gem install lexdrill
 ```
 
-### `lexdrill: command not found` after install?
+### `drill: command not found` after install?
 
 This happens when the gem's executable directory isn't on your `PATH` — common with a
 plain system Ruby (no rbenv/rvm). Fix it in one step:
@@ -27,3 +28,123 @@ source ~/.zshrc
 
 Using an rbenv-managed Ruby? Run `rbenv rehash` instead. Using rvm? You shouldn't hit
 this — rvm keeps gem executable directories on `PATH` automatically.
+
+## Usage
+
+Create a `.drill.txt` file — one word or phrase per line — in your home directory,
+or in a specific project directory to give that project its own list:
+
+```
+apple
+banana
+cherry
+```
+
+Run `drill next` to print the current word and advance to the next one.
+There are two output styles (`drill format simple|full`, `full` is the
+default):
+
+**full** — `counter/total⟳[loop_start-loop_end]` on one line, the word on
+the next, in a randomly-picked color:
+```
+1/6⟳[1-3]
+apple
+```
+(word 1 of 6 total; currently in the loop spanning words 1-3)
+
+**simple** — three drill signs (always blue), then the word on its own
+line in a separately-picked random color:
+```
+⟳⟳⟳
+apple
+```
+
+### Shell integration (one-time setup)
+
+Add one line to your shell's rc file so the current word prints automatically
+before each prompt. This is a **one-time step** — the line stays in your rc file
+and takes effect in every new shell session from then on; you never need to run it
+again by hand.
+
+Add it near the **end** of the file, after anything that sets up your `PATH`
+(rvm/rbenv init, Homebrew, etc.) — otherwise the shell may not know where
+`drill` lives yet when this line runs. Guarding it with `command -v` also
+means it never errors, even on a machine/session where `drill` isn't on
+`PATH` for some reason.
+
+**zsh** — add to `~/.zshrc`:
+```zsh
+if command -v drill >/dev/null 2>&1; then
+  eval "$(drill hook zsh)"
+fi
+```
+
+**bash** — add to `~/.bashrc`:
+```bash
+if command -v drill >/dev/null 2>&1; then
+  eval "$(drill hook bash)"
+fi
+```
+
+Then open a new shell (or `source ~/.zshrc` / `source ~/.bashrc`) to pick it up.
+
+#### Hook not firing in new terminal windows/tabs (rvm users)?
+
+Run `drill inspect` first — if it shows `Toggle: enabled` and a valid words
+file, the tool itself is fine and the problem is that the hook function never
+got registered in that session.
+
+A common cause with rvm: rvm's installer sometimes puts its actual
+PATH-loading line (`[[ -s "$HOME/.rvm/scripts/rvm" ]] && source
+"$HOME/.rvm/scripts/rvm"`) in `~/.zlogin` (zsh) or `~/.bash_profile` (bash).
+Those files only run for **login shells** — but many terminal emulators
+(e.g. kitty) open new windows/tabs as **non-login** interactive shells, which
+only source `~/.zshrc`/`~/.bashrc`. So rvm's gemset `bin/` directory (where
+`drill` lives) never makes it onto `PATH` in those sessions, even though
+everything looks correctly configured.
+
+**Fix:** move that line into `~/.zshrc` / `~/.bashrc` (before the `drill`
+hook block above, so it runs first) instead of relying on it only being in
+`~/.zlogin` / `~/.bash_profile`. It's safe to leave it in both places.
+
+### Rhythm (`beat`)
+
+By default `next` just advances one word at a time. You can instead have it
+repeat loops of consecutive words — e.g. a loop of 3 words shown twice each
+before moving on:
+
+```bash
+drill beat 3 2     # loop size 3, repeat each loop 2 times
+```
+
+`drill beat none` turns it back off (plain word-by-word again). This is a
+**global** setting — it applies everywhere, independent of which project's
+`.drill.txt` is currently active.
+
+There are also named shortcuts for common loop sizes, one word/phrase apart:
+
+| Loop size | Alias    |
+|-----------|----------|
+| 2         | `polka`  |
+| 3         | `waltz`  |
+| 4         | `rock`   |
+| 5         | `jazz`   |
+| 6         | `jiga`   |
+| 7         | `balkan` |
+| 8         | `samba`  |
+
+`drill waltz 16` is shorthand for `drill beat 3 16`. Repetitions default to
+`8` if you leave them off — `drill jazz` alone is `drill beat 5 8`, and
+`drill beat 4` alone is `drill beat 4 8`.
+
+### Commands
+
+| Command | What it does |
+|---|---|
+| `drill next` | Print the current word and advance |
+| `drill start` / `drill stop` | Pause/resume the automatic per-prompt hook (doesn't affect manual `next`) |
+| `drill inspect` | Show the active `.drill.txt`/`.drill.counter` paths, word count, counter value, toggle, and beat state |
+| `drill hook zsh\|bash` | Print the shell integration snippet (used above) |
+| `drill beat <2-8> <repetitions>` / `drill beat none` | Set or disable the rhythm |
+| `drill polka\|waltz\|rock\|jazz\|jiga\|balkan\|samba <repetitions>` | Shorthand for a fixed loop size (see table above) |
+| `drill format simple\|full` | Set the output style (`full` is the default) |

data/lexdrill.gemspec

@@ -23,6 +23,6 @@ Gem::Specification.new do |spec|
     Dir["lib/**/*.rb"] + Dir["bin/*"] + %w[README.md LICENSE.txt lexdrill.gemspec Gemfile]
   end
   spec.bindir = "bin"
-  spec.executables = ["lexdrill"]
+  spec.executables = ["drill"]
   spec.require_paths = ["lib"]
 end

data/lib/lexdrill/beat.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+# Global rhythm config: repeats loops of `loop_size` consecutive words
+# `repetitions` times before advancing to the next loop. Lives at
+# ~/.drill.beat, independent of whichever project's .drill.txt is active.
+# Disabled (plain word-by-word advance) unless explicitly configured.
+module Lexdrill::Beat
+  PATH = File.join(Dir.home, ".drill.beat")
+  MIN_LOOP_SIZE = 2
+  MAX_LOOP_SIZE = 8
+  DEFAULT_REPETITIONS = 8
+
+  ALIASES = {
+    "polka" => 2,
+    "waltz" => 3,
+    "rock" => 4,
+    "jazz" => 5,
+    "jiga" => 6,
+    "balkan" => 7,
+    "samba" => 8
+  }.freeze
+
+  # index: 0-based word index. chunk_start/chunk_end: 1-based word positions
+  # spanned by the current loop. loop_number: which repeat pass (1-based)
+  # through the current loop. total_loops: the configured repetitions.
+  LoopInfo = Struct.new(:index, :chunk_start, :chunk_end, :loop_number, :total_loops, keyword_init: true)
+
+  def self.configured?
+    File.exist?(PATH)
+  end
+
+  def self.set(loop_size, repetitions)
+    File.write(PATH, "#{loop_size} #{repetitions}")
+  end
+
+  def self.clear
+    FileUtils.rm_f(PATH)
+  end
+
+  def self.valid_loop_size?(value)
+    (MIN_LOOP_SIZE..MAX_LOOP_SIZE).cover?(value)
+  end
+
+  def self.repetitions_or_default(value)
+    value ? value.to_i : DEFAULT_REPETITIONS
+  end
+
+  def self.loop_size
+    settings[0]
+  end
+
+  def self.repetitions
+    settings[1]
+  end
+
+  # Total steps in one full cycle through the word list at the current
+  # rhythm, or plain `word_count` when no beat is configured.
+  def self.cycle_length(word_count)
+    return word_count unless configured?
+
+    chunk_sizes(word_count).sum { |size| size * repetitions }
+  end
+
+  # Maps a step (already bounded within cycle_length) to a word index.
+  def self.index_for(word_count, step)
+    loop_info(word_count, step).index
+  end
+
+  # Full detail on where `step` falls: word index, the current loop's word
+  # range, which repeat pass it is, and how many total. A single "loop"
+  # spanning the whole list (shown once) when no beat is configured.
+  def self.loop_info(word_count, step)
+    unless configured?
+      return LoopInfo.new(index: step, chunk_start: 1, chunk_end: word_count, loop_number: 1, total_loops: 1)
+    end
+
+    locate(word_count, step)
+  end
+
+  def self.locate(word_count, step)
+    offset = 0
+    chunk_sizes(word_count).each do |size|
+      span = size * repetitions
+      return locate_within(offset, size, step) if step < span
+
+      step -= span
+      offset += size
+    end
+    LoopInfo.new(index: 0, chunk_start: 1, chunk_end: word_count, loop_number: 1, total_loops: 1)
+  end
+  private_class_method :locate
+
+  def self.locate_within(offset, size, step)
+    LoopInfo.new(
+      index: offset + (step % size),
+      chunk_start: offset + 1,
+      chunk_end: offset + size,
+      loop_number: (step / size) + 1,
+      total_loops: repetitions
+    )
+  end
+  private_class_method :locate_within
+
+  def self.settings
+    return [nil, nil] unless configured?
+
+    parts = File.read(PATH).strip.split
+    [parts[0].to_i, parts[1].to_i]
+  end
+  private_class_method :settings
+
+  def self.chunk_sizes(word_count)
+    full, remainder = word_count.divmod(loop_size)
+    sizes = Array.new(full, loop_size)
+    sizes << remainder if remainder.positive?
+    sizes
+  end
+  private_class_method :chunk_sizes
+end

data/lib/lexdrill/cli.rb

@@ -4,7 +4,14 @@ class Lexdrill::CLI
   COMMANDS = {
     print_version: %w[version --version -v],
     print_help: %w[help --help -h],
-    run_next: %w[next]
+    run_next: %w[next],
+    run_hook: %w[hook],
+    run_start: %w[start],
+    run_stop: %w[stop],
+    run_inspect: %w[inspect],
+    run_beat: %w[beat],
+    run_beat_alias: %w[polka waltz rock jazz jiga balkan samba],
+    run_format: %w[format]
   }.freeze
 
   def self.start(argv = ARGV)
@@ -34,12 +41,21 @@ class Lexdrill::CLI
 
   def print_help
     puts <<~HELP
-      lexdrill #{Lexdrill::VERSION} — vocabulary drilling in your terminal
+      drill #{Lexdrill::VERSION} — vocabulary drilling in your terminal
 
       Usage:
-        lexdrill version   Print the gem version
-        lexdrill help      Show this help
-        lexdrill next      Print the current word and advance
+        drill version   Print the gem version
+        drill help      Show this help
+        drill next      Print the current word and advance
+        drill hook <zsh|bash>   Print the shell integration snippet
+        drill start     Resume drilling (undoes stop)
+        drill stop      Pause drilling everywhere until `start`
+        drill inspect   Show the active config/counter/toggle state
+        drill beat <2-8> [repetitions]   Set the rhythm (repetitions defaults to 8)
+        drill beat none                 Disable the rhythm
+        drill polka|waltz|rock|jazz|jiga|balkan|samba [repetitions]
+                        Shorthand for a fixed loop size (2 through 8, in order)
+        drill format simple|full   Set the output style (full is the default)
     HELP
     0
   end
@@ -48,17 +64,114 @@ class Lexdrill::CLI
     word = Lexdrill::WordList.next
     return print_no_words(Lexdrill::WordList::PATH) unless word
 
-    puts word
+    puts colored_line(word)
     0
   end
 
+  def colored_line(word)
+    text = Lexdrill::LineFormatter.format(word)
+    return text if Lexdrill::Format.simple?
+
+    Lexdrill::Colorizer.paint(text)
+  end
+
   def print_no_words(path)
-    warn "lexdrill: no words found in #{path}"
+    warn "drill: no words found in #{path}"
+    1
+  end
+
+  def run_hook
+    shell = argv[1]
+    return print_hook_usage unless shell
+
+    print_hook_snippet(shell)
+  end
+
+  def print_hook_usage
+    warn "usage: drill hook <zsh|bash>"
+    1
+  end
+
+  def print_hook_snippet(shell)
+    puts Lexdrill::ShellSnippet.for(shell)
+    0
+  rescue ArgumentError => error
+    warn "drill: #{error.message}"
+    1
+  end
+
+  def run_start
+    Lexdrill::Toggle.start
+    0
+  end
+
+  def run_stop
+    Lexdrill::Toggle.stop
+    0
+  end
+
+  def run_inspect
+    puts Lexdrill::Inspector.report
+    0
+  end
+
+  def run_beat
+    arg = argv[1]
+    return print_beat_usage unless arg
+    return clear_beat if arg == "none"
+
+    set_beat(arg.to_i, Lexdrill::Beat.repetitions_or_default(argv[2]))
+  end
+
+  def run_beat_alias
+    loop_size = Lexdrill::Beat::ALIASES.fetch(argv.first)
+    set_beat(loop_size, Lexdrill::Beat.repetitions_or_default(argv[1]))
+  end
+
+  def set_beat(loop_size, repetitions)
+    return print_invalid_loop_size unless Lexdrill::Beat.valid_loop_size?(loop_size)
+    return print_invalid_repetitions unless repetitions.positive?
+
+    Lexdrill::Beat.set(loop_size, repetitions)
+    0
+  end
+
+  def clear_beat
+    Lexdrill::Beat.clear
+    0
+  end
+
+  def print_beat_usage
+    warn "usage: drill beat <#{Lexdrill::Beat::MIN_LOOP_SIZE}-#{Lexdrill::Beat::MAX_LOOP_SIZE}> " \
+         "<repetitions> | drill beat none"
+    1
+  end
+
+  def print_invalid_loop_size
+    warn "drill: loop size must be between #{Lexdrill::Beat::MIN_LOOP_SIZE} and #{Lexdrill::Beat::MAX_LOOP_SIZE}"
+    1
+  end
+
+  def print_invalid_repetitions
+    warn "drill: repetitions must be a positive number"
+    1
+  end
+
+  def run_format
+    mode = argv[1]
+    return print_format_usage unless Lexdrill::Format::VALID.include?(mode)
+
+    Lexdrill::Format.set(mode)
+    0
+  end
+
+  def print_format_usage
+    warn "usage: drill format <#{Lexdrill::Format::VALID.join('|')}>"
     1
   end
 
   def print_unknown_command(command)
-    warn "lexdrill: unknown command #{command.inspect}"
+    warn "drill: unknown command #{command.inspect}"
     print_help
     1
   end

data/lib/lexdrill/colorizer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Wraps text in an ANSI color code.
+module Lexdrill::Colorizer
+  CODES = [31, 32, 33, 34, 35, 36, 91, 92, 93, 94, 95, 96].freeze
+  BLUE = 34
+
+  def self.paint(text)
+    wrap(text, CODES.sample)
+  end
+
+  def self.paint_blue(text)
+    wrap(text, BLUE)
+  end
+
+  def self.wrap(text, code)
+    "\e[#{code}m#{text}\e[0m"
+  end
+  private_class_method :wrap
+end

data/lib/lexdrill/format.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Global display mode for `next`'s output: "full" (position + loop info) or
+# "simple" (just the word). Lives at ~/.drill.format; defaults to "full".
+module Lexdrill::Format
+  PATH = File.join(Dir.home, ".drill.format")
+  SIMPLE = "simple"
+  FULL = "full"
+  VALID = [SIMPLE, FULL].freeze
+
+  def self.current
+    return FULL unless File.exist?(PATH)
+
+    value = File.read(PATH).strip
+    VALID.include?(value) ? value : FULL
+  end
+
+  def self.set(mode)
+    File.write(PATH, mode)
+  end
+
+  def self.simple?
+    current == SIMPLE
+  end
+end

data/lib/lexdrill/inspector.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Builds a human-readable snapshot of lexdrill's current config/state, for
+# `drill inspect` — which files are active, how many words, the counter
+# value, and whether drilling is currently stopped.
+module Lexdrill::Inspector
+  def self.report
+    <<~REPORT
+      drill #{Lexdrill::VERSION}
+
+      Words file:    #{Lexdrill::WordList::PATH} (#{words_summary})
+      Counter file:  #{Lexdrill::WordList::COUNTER_PATH} (value: #{counter_value})
+      Toggle:        #{toggle_summary}
+      Beat:          #{beat_summary}
+      Format:        #{Lexdrill::Format.current}
+      LEXDRILL_PATH: #{ENV.fetch('LEXDRILL_PATH', '(not set)')}
+    REPORT
+  end
+
+  def self.words_summary
+    return "missing" unless File.exist?(Lexdrill::WordList::PATH)
+
+    "#{Lexdrill::WordList.words.size} word(s)"
+  end
+
+  def self.counter_value
+    Lexdrill::Counter.new(Lexdrill::WordList::COUNTER_PATH).value
+  end
+
+  def self.toggle_summary
+    return "enabled" if Lexdrill::Toggle.enabled?
+
+    "stopped (#{Lexdrill::Toggle::PATH})"
+  end
+
+  def self.beat_summary
+    return "not set (plain word-by-word)" unless Lexdrill::Beat.configured?
+
+    "loop #{Lexdrill::Beat.loop_size}, repeat #{Lexdrill::Beat.repetitions}"
+  end
+end

data/lib/lexdrill/line_formatter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Formats a shown word for display. In "simple" mode: three drill signs in
+# blue, then the word on its own line in a separately-picked random color.
+# In "full" mode (the default):
+# "{counter}/{total}{SEPARATOR}[{loop_start}-{loop_end}]\n{word}" — counter
+# is the word's own 1-based position in the list, re-derived through
+# Lexdrill::Beat so it stays meaningful even when a rhythm repeats steps.
+module Lexdrill::LineFormatter
+  SEPARATOR = "⟳"
+  SIMPLE_HEADER = SEPARATOR * 3
+
+  def self.format(word)
+    return simple(word) if Lexdrill::Format.simple?
+
+    full(word)
+  end
+
+  def self.simple(word)
+    "#{Lexdrill::Colorizer.paint_blue(SIMPLE_HEADER)}\n#{Lexdrill::Colorizer.paint(word)}"
+  end
+
+  def self.full(word)
+    total = Lexdrill::WordList.words.size
+    info = loop_info(total)
+    "#{info.index + 1}/#{total}#{SEPARATOR}[#{info.chunk_start}-#{info.chunk_end}]\n#{word}"
+  end
+
+  def self.loop_info(total)
+    counter = Lexdrill::Counter.new(Lexdrill::WordList::COUNTER_PATH)
+    step_used = counter.value - 1
+    Lexdrill::Beat.loop_info(total, step_used)
+  end
+end

data/lib/lexdrill/shell_snippet.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Generates the zsh/bash shell integration snippet for `drill hook`.
+module Lexdrill::ShellSnippet
+  ZSH = <<~SNIPPET
+    drill_precmd() {
+      [[ -f "$HOME/.drill.disabled" ]] && return
+      command drill next 2>/dev/null
+    }
+    if [[ -z "${precmd_functions[(r)drill_precmd]}" ]]; then
+      precmd_functions+=(drill_precmd)
+    fi
+  SNIPPET
+
+  BASH = <<~SNIPPET
+    drill_precmd() {
+      [ -f "$HOME/.drill.disabled" ] && return
+      command drill next 2>/dev/null
+    }
+    case ";${PROMPT_COMMAND:-};" in
+      *";drill_precmd;"*) ;;
+      *) PROMPT_COMMAND="drill_precmd;${PROMPT_COMMAND}" ;;
+    esac
+  SNIPPET
+
+  def self.for(shell_name)
+    case shell_name.to_s
+    when "zsh" then ZSH
+    when "bash" then BASH
+    else
+      raise ArgumentError, "unsupported shell #{shell_name.inspect} (expected \"zsh\" or \"bash\")"
+    end
+  end
+end

data/lib/lexdrill/toggle.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+# Global pause/resume switch for the shell hook, independent of which
+# project's .drill.txt is active. Enabled by default; the marker file's
+# presence means stopped.
+module Lexdrill::Toggle
+  PATH = File.join(Dir.home, ".drill.disabled")
+
+  def self.enabled?
+    !File.exist?(PATH)
+  end
+
+  def self.start
+    FileUtils.rm_f(PATH)
+  end
+
+  def self.stop
+    File.write(PATH, "")
+  end
+end

data/lib/lexdrill/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lexdrill
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/lexdrill/word_list.rb

@@ -19,8 +19,9 @@ class Lexdrill::WordList
 
   def self.take_index(size)
     counter = Lexdrill::Counter.new(COUNTER_PATH)
-    index = counter.bounded_value(size)
+    cycle_length = Lexdrill::Beat.cycle_length(size)
+    step = counter.bounded_value(cycle_length)
     counter.increment
-    index
+    Lexdrill::Beat.index_for(size, step)
   end
 end

data/lib/lexdrill.rb

@@ -3,5 +3,12 @@
 require_relative "lexdrill/version"
 require_relative "lexdrill/config"
 require_relative "lexdrill/counter"
+require_relative "lexdrill/beat"
 require_relative "lexdrill/word_list"
+require_relative "lexdrill/toggle"
+require_relative "lexdrill/shell_snippet"
+require_relative "lexdrill/inspector"
+require_relative "lexdrill/colorizer"
+require_relative "lexdrill/format"
+require_relative "lexdrill/line_formatter"
 require_relative "lexdrill/cli"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lexdrill
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Siarhei Kisliak
@@ -15,19 +15,26 @@ description: lexdrill prints a vocabulary word or phrase on demand, tracking how
 email:
 - kislak7@gmail.com
 executables:
-- lexdrill
+- drill
 extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
 - LICENSE.txt
 - README.md
-- bin/lexdrill
+- bin/drill
 - lexdrill.gemspec
 - lib/lexdrill.rb
+- lib/lexdrill/beat.rb
 - lib/lexdrill/cli.rb
+- lib/lexdrill/colorizer.rb
 - lib/lexdrill/config.rb
 - lib/lexdrill/counter.rb
+- lib/lexdrill/format.rb
+- lib/lexdrill/inspector.rb
+- lib/lexdrill/line_formatter.rb
+- lib/lexdrill/shell_snippet.rb
+- lib/lexdrill/toggle.rb
 - lib/lexdrill/version.rb
 - lib/lexdrill/word_list.rb
 homepage: https://github.com/kislak/lexdrill