lexdrill 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 694f430036d22f39f5ee347a6220a8e977e726edb54db9f5c99d3f57bfcb8161
-  data.tar.gz: 9deb40864be7ded7ed8eb1aff88e25e20a412acf0a678526ff5d3f84f50ad69b
+  metadata.gz: 0510a355aeb50c560e27a73fd9ab70350c8e5c326d5dbd0ad43138e849b0bd2f
+  data.tar.gz: 529f2a86af2ec0b735c3147bd412fe82d276f6d434e6a074deefb650270818eb
 SHA512:
-  metadata.gz: 49b05b7ac7dda95a4fd9c34b9de6fbe29486e8a8e84285d8fbb0fe0a211785a9a7870551c3a80566725d4884dee317117c85781a313251c9094fa927a4ff857c
-  data.tar.gz: 201a4d5c23a232a4cbb1ca5b2d294e629a9984e1196133511d62262e3c8ae3c238386278735f91d184db4b7214578304861caa70b641c6f0b77988cc2f4ef00f
+  metadata.gz: d9168c8d3218c457b6cf08662254d7b69f6adaef33cb1962a1dbcf4a0243c653bffbd9a74580e5cd7dbdcce9118fe0406b221d72f42b7347525a3a0adc93ee20
+  data.tar.gz: 552834f01e378765ddf7549410ad964dc254c8c286bc34605f765661f68fb232100003dedad70c18fe025e8215cdba250d0c37f0a60338f235647f3335bb1eee

data/README.md

@@ -40,15 +40,23 @@ 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.:
+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/3:	apple
-2/3:	banana
-3/3:	cherry
-1/3:	apple
+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)
@@ -99,11 +107,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 (`full` 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 (full 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/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

@@ -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,34 @@
 # 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: 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
-    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.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,10 +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.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Siarhei Kisliak
@@ -25,10 +25,12 @@ 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/format.rb
 - lib/lexdrill/inspector.rb
 - lib/lexdrill/line_formatter.rb
 - lib/lexdrill/shell_snippet.rb