lexdrill 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 694f430036d22f39f5ee347a6220a8e977e726edb54db9f5c99d3f57bfcb8161
-  data.tar.gz: 9deb40864be7ded7ed8eb1aff88e25e20a412acf0a678526ff5d3f84f50ad69b
+  metadata.gz: 9ef368252ef581d3e56aadeef48302fef93cae68d52e95a5bb199977ffdf30fd
+  data.tar.gz: 7fb96023b0940dbce09e0cdb60d6561cc50ab52050c73536f777ca879f6f8c8d
 SHA512:
-  metadata.gz: 49b05b7ac7dda95a4fd9c34b9de6fbe29486e8a8e84285d8fbb0fe0a211785a9a7870551c3a80566725d4884dee317117c85781a313251c9094fa927a4ff857c
-  data.tar.gz: 201a4d5c23a232a4cbb1ca5b2d294e629a9984e1196133511d62262e3c8ae3c238386278735f91d184db4b7214578304861caa70b641c6f0b77988cc2f4ef00f
+  metadata.gz: 9f0786367ac59cf02606f3c6a59dec98787bb54fc938924c90321d122e8e793bff09a357220c59f4d8a3d2e705ab621ae5fbbb46fc3cc02b787aac9e38063049
+  data.tar.gz: d7ec11ee093daff986f0dd1a08ac521bf6067f0e7debf682a8183cb940c17d5a58c5f5ef7aa68c257fdd184b09017734b03dfaad7c6c357e3f92ee64c09919bb

data/README.md

@@ -40,17 +40,28 @@ banana
 cherry
 ```
 
-Run `drill next` to print the current word and advance to the next one. Each
-line is printed as `current/total:` followed by a tab and the word, in a
-randomly-picked color, e.g.:
+If you don't create one, `drill next` seeds `~/.drill.txt` with a default
+starter list (a set of NLP presuppositions) the first time it runs, so
+there's always something to drill.
 
+Run `drill next` to print the current word and advance to the next one.
+There are two output styles (`drill format simple|full`, `simple` is the
+default):
+
+**simple** — the drill sign (always blue), a space, then the word (in a
+separately-picked random color), all on one line:
 ```
-1/3:	apple
-2/3:	banana
-3/3:	cherry
-1/3:	apple
+⟳ apple
 ```
 
+**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)
+
 ### Shell integration (one-time setup)
 
 Add one line to your shell's rc file so the current word prints automatically
@@ -99,11 +110,44 @@ everything looks correctly configured.
 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, and toggle state |
+| `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 (`simple` is the default) |

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

@@ -8,7 +8,10 @@ class Lexdrill::CLI
     run_hook: %w[hook],
     run_start: %w[start],
     run_stop: %w[stop],
-    run_inspect: %w[inspect]
+    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)
@@ -48,6 +51,11 @@ class Lexdrill::CLI
         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 (simple is the default)
     HELP
     0
   end
@@ -56,10 +64,17 @@ class Lexdrill::CLI
     word = Lexdrill::WordList.next
     return print_no_words(Lexdrill::WordList::PATH) unless word
 
-    puts Lexdrill::Colorizer.paint(Lexdrill::LineFormatter.format(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 "drill: no words found in #{path}"
     1
@@ -100,6 +115,61 @@ class Lexdrill::CLI
     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 "drill: unknown command #{command.inspect}"
     print_help

data/lib/lexdrill/colorizer.rb

@@ -1,10 +1,20 @@
 # frozen_string_literal: true
 
-# Wraps text in a randomly-picked ANSI color code from a fixed palette.
+# 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)
-    "\e[#{CODES.sample}m#{text}\e[0m"
+    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/config.rb

@@ -13,6 +13,10 @@ module Lexdrill::Config
     ENV.fetch("LEXDRILL_PATH", nil) || dir_path || Dir.home
   end
 
+  def self.home_drill_path
+    File.join(Dir.home, FILENAME)
+  end
+
   DRILL_PATH = File.join(base_path, FILENAME)
   COUNTER_PATH = File.join(base_path, COUNTER_FILENAME)
 end

data/lib/lexdrill/default_words.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# The starter list seeded into ~/.drill.txt on first run, when neither an
+# LEXDRILL_PATH override nor a project-local .drill.txt exists yet.
+module Lexdrill::DefaultWords
+  WORDS = [
+    "The map is not the territory",
+    "Respect for other people's model of the world",
+    "Mind and body are parts of the same system",
+    "You cannot not communicate",
+    "The meaning of your communication is the response you get",
+    "People operate out of the best choice available to them",
+    "Every behavior has a positive intention",
+    "People have all the resources they need to succeed",
+    "There is no failure only feedback",
+    "If what you are doing isn't working do something else",
+    "The person with the most flexibility controls the system",
+    "Choice is better than no choice",
+    "If one person can do something anyone can learn to do it",
+    "Modeling successful performance leads to excellence",
+    "All procedures should increase wholeness and choice",
+    "Individuals are not their behaviors",
+    "Resistance in a listener is a sign of a lack of flexibility in the communicator",
+    "We process all information through our five senses",
+    "Clean feedback is the breakfast of champions",
+    "Possible in the world is possible for me it is only a matter of how"
+  ].freeze
+
+  TEXT = "#{WORDS.join("\n")}\n".freeze
+end

data/lib/lexdrill/format.rb

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

data/lib/lexdrill/inspector.rb

@@ -11,6 +11,8 @@ module Lexdrill::Inspector
       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
@@ -30,4 +32,10 @@ module Lexdrill::Inspector
 
     "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

@@ -1,11 +1,33 @@
 # frozen_string_literal: true
 
-# Formats a shown word as "{line_number}/{total}:\t{word}". The just-advanced
-# counter value equals the 1-based position of the word that was shown.
+# Formats a shown word for display. In "simple" mode: the drill sign (in
+# blue), a space, then the word (in a separately-picked random color), all
+# on one line. 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 = "⟳"
+
   def self.format(word)
+    return simple(word) if Lexdrill::Format.simple?
+
+    full(word)
+  end
+
+  def self.simple(word)
+    "#{Lexdrill::Colorizer.paint_blue(SEPARATOR)} #{Lexdrill::Colorizer.paint(word)}"
+  end
+
+  def self.full(word)
     total = Lexdrill::WordList.words.size
-    line_number = Lexdrill::Counter.new(Lexdrill::WordList::COUNTER_PATH).value
-    "#{line_number}/#{total}:\t#{word}"
+    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/version.rb

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

data/lib/lexdrill/word_list.rb

@@ -1,16 +1,27 @@
 # frozen_string_literal: true
 
 # Reads vocabulary words/phrases from a `.drill.txt` file, one per line, and
-# advances a persisted counter to show "the current word" each time.
+# advances a persisted counter to show "the current word" each time. On a
+# fresh install with no project-local or LEXDRILL_PATH-overridden list, seeds
+# ~/.drill.txt with a default starter list instead of coming up empty.
 class Lexdrill::WordList
   PATH = Lexdrill::Config::DRILL_PATH
   COUNTER_PATH = Lexdrill::Config::COUNTER_PATH
+  HOME_PATH = Lexdrill::Config.home_drill_path
 
   def self.words
-    @words ||= File.exist?(PATH) && File.readlines(PATH).map(&:strip).reject(&:empty?)
+    seed_default_at_home
+    @words ||= File.exist?(PATH) && File.readlines(PATH, encoding: "UTF-8").map(&:strip).reject(&:empty?)
     @words ||= []
   end
 
+  def self.seed_default_at_home
+    return if PATH != HOME_PATH || File.exist?(PATH)
+
+    File.write(PATH, Lexdrill::DefaultWords::TEXT, encoding: "UTF-8")
+  end
+  private_class_method :seed_default_at_home
+
   def self.next
     return nil if words.empty?
 
@@ -19,8 +30,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,10 +3,13 @@
 require_relative "lexdrill/version"
 require_relative "lexdrill/config"
 require_relative "lexdrill/counter"
+require_relative "lexdrill/beat"
+require_relative "lexdrill/default_words"
 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.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Siarhei Kisliak
@@ -25,10 +25,13 @@ files:
 - 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/default_words.rb
+- lib/lexdrill/format.rb
 - lib/lexdrill/inspector.rb
 - lib/lexdrill/line_formatter.rb
 - lib/lexdrill/shell_snippet.rb