sangi 0.1.0

data/lib/sangi/renderer/ascii_renderer.rb

@@ -0,0 +1,151 @@
+module Sangi
+  module Renderer
+    class AsciiRenderer
+      LABEL_WIDTH = 7
+      CELL_WIDTH = CellRenderer::CELL_WIDTH
+
+      def initialize(config)
+        @config = config
+        @cell_renderer = CellRenderer.new(config)
+      end
+
+      def render(step, total_steps:)
+        lines = []
+        lines.concat(header_lines(step, total_steps))
+        lines << ""
+        lines.concat(message_lines(step))
+        lines << ""
+        lines.concat(board_lines(step.board))
+        lines << ""
+        lines.concat(value_lines(step.board))
+        lines << ""
+        lines << "keys: n next / p prev / r reset / e end / a auto / q quit / ? help"
+        lines.join("\n") + "\n"
+      end
+
+      private
+
+      def header_lines(step, total_steps)
+        state = step.numeric_state
+        [
+          "expr: #{state[:source]}",
+          "normalized: #{state[:normalized]}",
+          "result: #{state[:result_value]}",
+          "step: #{step.index}/#{total_steps}",
+          "mode: #{@config.mode}  zero: #{@config.zero_mode}  sign: #{@config.sign_mode}"
+        ]
+      end
+
+      def message_lines(step)
+        message = selected_message(step)
+        lines = ["Step #{step.index}: #{step.title}"]
+        lines << message if message && !message.empty?
+        lines
+      end
+
+      def selected_message(step)
+        case @config.explain_mode
+        when :none then nil
+        when :learn then step.learn_message || step.brief_message
+        else step.brief_message
+        end
+      end
+
+      def board_lines(board)
+        places = (0...board.place_count).to_a.reverse
+        lines = [place_header(places), border(places.size)]
+        %i[a b work].each do |row_name|
+          row = board.row(row_name)
+          row_cells = render_row_cells(row, places)
+          row_cells.each_with_index do |cell_line_parts, index|
+            label = index.zero? ? row_label(row, board.highlight) : ""
+            lines << format("%-#{LABEL_WIDTH}s", label) + "|" + cell_line_parts.join("|") + "|"
+          end
+          lines << border(places.size)
+        end
+        lines
+      end
+
+      def render_row_cells(row, places)
+        slash_place = slash_place_for(row)
+        rendered = places.map do |place|
+          @cell_renderer.render(
+            row.cells.fetch(place),
+            row_sign: row.sign,
+            slash: slash_place == place
+          )
+        end
+        CellRenderer::CELL_HEIGHT.times.map do |line_index|
+          parts = rendered.map { |cell_lines| cell_lines[line_index] }
+          color_negative_row?(row) ? parts.map { |part| colorize(part) } : parts
+        end
+      end
+
+      def place_header(places)
+        format("%-#{LABEL_WIDTH}s", "") +
+          places.map { |place| center(place_label(place), CELL_WIDTH) }.join(" ")
+      end
+
+      def border(place_count)
+        format("%-#{LABEL_WIDTH}s", "") + "+" + (("-" * CELL_WIDTH) + "+") * place_count
+      end
+
+      def row_label(row, highlight)
+        label = case row.name
+                when :a then "A"
+                when :b then "B"
+                else "Work"
+                end
+        label += "-" if show_modern_negative_marker?(row)
+        label += " *" if highlight && highlight[:row] == row.name
+        label
+      end
+
+      def value_lines(board)
+        [
+          "values:",
+          format("  A:     %s", board.row(:a).value),
+          format("  B:     %s", board.row(:b).value),
+          format("  Work:  %s", board.row(:work).value)
+        ]
+      end
+
+      def place_label(place)
+        labels = %w[ones tens hundreds thousands]
+        labels.fetch(place, "10^#{place}")
+      end
+
+      def center(text, width)
+        text = text[0, width]
+        left = (width - text.length) / 2
+        right = width - text.length - left
+        (" " * left) + text + (" " * right)
+      end
+
+      def slash_place_for(row)
+        return nil unless row.sign.negative?
+        return nil unless %i[slash dual].include?(effective_sign_mode)
+
+        row.cells.index { |cell| cell.value.positive? }
+      end
+
+      def show_modern_negative_marker?(row)
+        return false unless row.sign.negative? && row.magnitude.positive?
+
+        %i[modern dual].include?(effective_sign_mode)
+      end
+
+      def color_negative_row?(row)
+        row.sign.negative? && row.magnitude.positive? && effective_sign_mode == :color && @config.color
+      end
+
+      def effective_sign_mode
+        @config.sign_mode == :color && !@config.color ? :modern : @config.sign_mode
+      end
+
+      def colorize(text)
+        "\e[31m#{text}\e[0m"
+      end
+    end
+  end
+end

data/lib/sangi/renderer/cell_renderer.rb

@@ -0,0 +1,97 @@
+module Sangi
+  module Renderer
+    class CellRenderer
+      CELL_WIDTH = 11
+      CELL_HEIGHT = 5
+
+      def initialize(config)
+        @config = config
+      end
+
+      def render(cell, row_sign: 1, slash: false)
+        lines = blank_lines
+        if cell.value.zero?
+          render_zero(lines)
+        elsif cell.orientation == :vertical
+          render_vertical(lines, cell)
+        else
+          render_horizontal(lines, cell)
+        end
+        put_char(lines, 0, 9, "/") if slash && row_sign.negative?
+        lines
+      end
+
+      private
+
+      def blank_lines
+        Array.new(CELL_HEIGHT) { " " * CELL_WIDTH }
+      end
+
+      def render_zero(lines)
+        case @config.zero_mode
+        when :digit
+          put_text(lines, 1, 5, "0")
+        when :circle
+          put_text(lines, 1, 5, "o")
+        end
+      end
+
+      def render_vertical(lines, cell)
+        cell.five_rods.size.times do |index|
+          put_text(lines, [index, CELL_HEIGHT - 1].min, 3, "-----")
+        end
+
+        unit_row = cell.five_rods.empty? ? 2 : [cell.five_rods.size, CELL_HEIGHT - 1].min
+        unit_positions(cell.unit_rods.size).each do |column|
+          put_char(lines, unit_row, column, "|")
+        end
+      end
+
+      def render_horizontal(lines, cell)
+        five_positions(cell.five_rods.size).each do |column|
+          CELL_HEIGHT.times { |row| put_char(lines, row, column, "|") }
+        end
+
+        start_row = cell.five_rods.empty? ? 0 : 1
+        cell.unit_rods.size.times do |index|
+          row = [start_row + index, CELL_HEIGHT - 1].min
+          put_text(lines, row, 3, "-----")
+        end
+      end
+
+      def unit_positions(count)
+        positions = {
+          1 => [5],
+          2 => [4, 6],
+          3 => [3, 5, 7],
+          4 => [2, 4, 6, 8],
+          5 => [1, 3, 5, 7, 9]
+        }
+        positions.fetch([count, 5].min, [])
+      end
+
+      def five_positions(count)
+        positions = {
+          1 => [5],
+          2 => [4, 6]
+        }
+        positions.fetch([count, 2].min, [])
+      end
+
+      def put_text(lines, row, column, text)
+        text.chars.each_with_index do |char, offset|
+          put_char(lines, row, column + offset, char)
+        end
+      end
+
+      def put_char(lines, row, column, char)
+        return if row.negative? || row >= CELL_HEIGHT
+        return if column.negative? || column >= CELL_WIDTH
+
+        chars = lines[row].chars
+        chars[column] = char
+        lines[row] = chars.join
+      end
+    end
+  end
+end

data/lib/sangi/repl.rb

@@ -0,0 +1,45 @@
+module Sangi
+  class REPL
+    def initialize(config:, input: STDIN, output: STDOUT)
+      @config = config
+      @input = input
+      @output = output
+    end
+
+    def start
+      loop do
+        @output.print "sangi> "
+        line = @input.gets
+        break if line.nil?
+
+        line = line.strip
+        next if line.empty?
+        break if %w[:q :quit].include?(line)
+
+        if line == ":help"
+          show_help
+          next
+        end
+
+        run_expression(line)
+      end
+      0
+    end
+
+    private
+
+    def run_expression(source)
+      expression = Parser.new(@config).parse(source)
+      steps = Engine.new(@config).build_steps(expression)
+      renderer = Renderer::AsciiRenderer.new(@config)
+      StepViewer.new(steps: steps, renderer: renderer, input: @input, output: @output).start
+    rescue Sangi::Error => e
+      @output.puts e.message
+    end
+
+    def show_help
+      @output.puts "式を入力すると計算を開始します。例: 128+47, 100-7, -12+7, 3--5"
+      @output.puts ":help ヘルプ / :q 終了 / :quit 終了"
+    end
+  end
+end

data/lib/sangi/rod.rb

@@ -0,0 +1,16 @@
+module Sangi
+  class Rod
+    attr_reader :id, :kind
+
+    def initialize(id:, kind:)
+      raise ValidationError, "invalid rod kind" unless %i[unit five].include?(kind)
+
+      @id = id
+      @kind = kind
+    end
+
+    def value
+      kind == :five ? 5 : 1
+    end
+  end
+end

data/lib/sangi/rod_factory.rb

@@ -0,0 +1,13 @@
+module Sangi
+  class RodFactory
+    def initialize
+      @next_id = 1
+    end
+
+    def build(kind)
+      rod = Rod.new(id: @next_id, kind: kind)
+      @next_id += 1
+      rod
+    end
+  end
+end

data/lib/sangi/row.rb

@@ -0,0 +1,51 @@
+module Sangi
+  class Row
+    attr_reader :name
+    attr_accessor :sign, :cells
+
+    def self.from_integer(name:, value:, place_count:, rod_factory:)
+      sign = value <=> 0
+      digits = SignedNumber.from_integer(value.abs).digits
+      cells = place_count.times.map do |place|
+        Cell.from_digit(
+          place_index: place,
+          digit: digits.fetch(place, 0),
+          rod_factory: rod_factory
+        )
+      end
+      new(name: name, sign: sign, cells: cells)
+    end
+
+    def initialize(name:, sign:, cells:)
+      @name = name
+      @sign = sign
+      @cells = cells
+      normalize_zero_sign!
+    end
+
+    def magnitude
+      cells.each_with_index.sum do |cell, place_index|
+        cell.value * (10**place_index)
+      end
+    end
+
+    def value
+      current_magnitude = magnitude
+      return 0 if current_magnitude.zero?
+
+      sign * current_magnitude
+    end
+
+    def normalize_zero_sign!
+      @sign = 0 if magnitude.zero?
+    end
+
+    def clone_deep
+      Row.new(
+        name: name,
+        sign: sign,
+        cells: cells.map(&:clone_deep)
+      )
+    end
+  end
+end

data/lib/sangi/signed_number.rb

@@ -0,0 +1,23 @@
+module Sangi
+  class SignedNumber
+    attr_reader :sign, :digits
+
+    def self.from_integer(value)
+      sign = value <=> 0
+      digits = value.abs.to_s.chars.reverse.map(&:to_i)
+      digits = [0] if digits.empty?
+      new(sign: sign, digits: digits)
+    end
+
+    def initialize(sign:, digits:)
+      @digits = digits.empty? ? [0] : digits
+      @sign = @digits.all?(&:zero?) ? 0 : sign
+    end
+
+    def to_i
+      return 0 if sign.zero?
+
+      sign * digits.reverse.join.to_i
+    end
+  end
+end

data/lib/sangi/step.rb

@@ -0,0 +1,16 @@
+module Sangi
+  class Step
+    attr_reader :index, :title, :brief_message, :learn_message
+    attr_reader :event, :board, :numeric_state
+
+    def initialize(index:, title:, brief_message:, learn_message:, event:, board:, numeric_state:)
+      @index = index
+      @title = title
+      @brief_message = brief_message
+      @learn_message = learn_message
+      @event = event
+      @board = board
+      @numeric_state = numeric_state
+    end
+  end
+end

data/lib/sangi/step_builder.rb

@@ -0,0 +1,87 @@
+module Sangi
+  class StepBuilder
+    attr_reader :config, :expression, :board, :result_value, :rod_factory, :steps
+
+    def initialize(config:, expression:, board:, result_value:, rod_factory:)
+      @config = config
+      @expression = expression
+      @board = board
+      @result_value = result_value
+      @rod_factory = rod_factory
+      @steps = []
+    end
+
+    def push(title:, brief_message:, event:, learn_message: nil)
+      steps << Step.new(
+        index: steps.size + 1,
+        title: title,
+        brief_message: brief_message,
+        learn_message: learn_message || brief_message,
+        event: event,
+        board: board.clone_deep,
+        numeric_state: numeric_state
+      )
+    end
+
+    def place_rod(row:, place:, kind:, title: "棒を置く", brief_message: nil, learn_message: nil, event_type: :place_rod)
+      cell = work_cell(row, place)
+      cell.add_rod(rod_factory.build(kind))
+      board.highlight = { row: row, place_index: place }
+      push(
+        title: title,
+        brief_message: brief_message || "#{row_label(row)}の#{place_name(place)}に#{rod_name(kind)}棒を1本置きます。",
+        learn_message: learn_message || "#{place_name(place)}に#{rod_value_name(kind)}を表す棒を1本追加します。",
+        event: Event.new(type: event_type, row: row, place_index: place, kind: kind)
+      )
+    end
+
+    def remove_rod(row:, place:, kind:, title: "棒を取り除く", brief_message: nil, learn_message: nil, event_type: :remove_rod)
+      cell = work_cell(row, place)
+      removed = cell.remove_rod(kind)
+      raise InternalError, "#{row_label(row)}の#{place_name(place)}に#{rod_name(kind)}棒がありません。" if removed.nil?
+
+      board.highlight = { row: row, place_index: place }
+      push(
+        title: title,
+        brief_message: brief_message || "#{row_label(row)}の#{place_name(place)}から#{rod_name(kind)}棒を1本取り除きます。",
+        learn_message: learn_message || "#{place_name(place)}から#{rod_value_name(kind)}を表す棒を1本取り除きます。",
+        event: Event.new(type: event_type, row: row, place_index: place, kind: kind)
+      )
+    end
+
+    def row_label(row)
+      row == :work ? "Work" : row.to_s.upcase
+    end
+
+    def rod_name(kind)
+      kind == :five ? "five" : "unit"
+    end
+
+    def rod_value_name(kind)
+      kind == :five ? "5" : "1"
+    end
+
+    def place_name(place)
+      names = %w[一の位 十の位 百の位 千の位 万の位 十万の位 百万の位 千万の位 一億の位 十億の位]
+      names.fetch(place, "10^#{place}の位")
+    end
+
+    private
+
+    def work_cell(row, place)
+      board.row(row).cells.fetch(place)
+    end
+
+    def numeric_state
+      {
+        source: expression.source,
+        normalized: expression.normalized_source,
+        result_value: result_value,
+        left: expression.left,
+        right: expression.right,
+        effective_right: expression.effective_right,
+        work_value: board.row(:work).value
+      }
+    end
+  end
+end

data/lib/sangi/step_viewer.rb

@@ -0,0 +1,124 @@
+require "io/console"
+require "io/wait"
+
+module Sangi
+  class StepViewer
+    AUTOPLAY_INTERVAL = 0.35
+
+    def initialize(steps:, renderer:, input: STDIN, output: STDOUT, clear_screen: true)
+      @steps = steps
+      @renderer = renderer
+      @input = input
+      @output = output
+      @clear_screen = clear_screen
+      @current_index = 0
+      @width_warning = TerminalWidthWarning.new(output: output)
+    end
+
+    def start
+      return if @steps.empty?
+
+      @exit_requested = false
+      loop do
+        render_current
+        handle_key(read_key)
+        break if @exit_requested
+      end
+    end
+
+    private
+
+    def render_current
+      clear
+      warning = @width_warning.message(@steps)
+      @output.puts warning if warning
+      @output.print @renderer.render(@steps[@current_index], total_steps: @steps.size)
+    end
+
+    def next_step
+      @current_index = [@current_index + 1, @steps.size - 1].min
+    end
+
+    def previous_step
+      @current_index = [@current_index - 1, 0].max
+    end
+
+    def handle_key(key)
+      case key
+      when "n", "\r", "\n"
+        next_step
+      when "p"
+        previous_step
+      when "r"
+        @current_index = 0
+      when "e"
+        @current_index = @steps.size - 1
+      when "a"
+        autoplay
+      when "?"
+        show_key_help
+      when "q", "\u0003"
+        @exit_requested = true
+      end
+    end
+
+    def autoplay
+      loop do
+        key = read_key_with_timeout(AUTOPLAY_INTERVAL)
+        break if handle_autoplay_key(key)
+        break if @current_index >= @steps.size - 1
+
+        @current_index += 1
+        render_current
+      end
+    end
+
+    def handle_autoplay_key(key)
+      case key
+      when nil
+        false
+      when "a"
+        true
+      when "q", "\u0003"
+        @exit_requested = true
+        true
+      else
+        handle_key(key)
+        true
+      end
+    end
+
+    def show_key_help
+      @output.puts
+      @output.puts "n/Enter: next, p: previous, r: reset, e: end, a: auto, q: quit"
+      @output.puts "press any key to continue"
+      read_key
+    end
+
+    def read_key
+      return @input.getch if @input.is_a?(IO) && @input.respond_to?(:getch)
+
+      @input.gets&.chars&.first || "q"
+    end
+
+    def read_key_with_timeout(timeout)
+      return read_key if buffered_input_available?
+      return nil unless @input.is_a?(IO) && @input.respond_to?(:wait_readable)
+      return nil unless @input.wait_readable(timeout)
+
+      read_key
+    end
+
+    def buffered_input_available?
+      @input.respond_to?(:pos) &&
+        @input.respond_to?(:string) &&
+        @input.pos < @input.string.length
+    end
+
+    def clear
+      return unless @clear_screen
+
+      @output.print "\e[2J\e[H"
+    end
+  end
+end

data/lib/sangi/terminal_width_warning.rb

@@ -0,0 +1,56 @@
+require "io/console"
+
+module Sangi
+  class TerminalWidthWarning
+    def initialize(output:)
+      @output = output
+    end
+
+    def message(steps)
+      width = terminal_width
+      return nil if width.nil? || steps.empty?
+
+      required = required_width(steps)
+      return nil if required <= width
+
+      "warning: terminal width is #{width}, but this board needs about #{required} columns; output may wrap."
+    end
+
+    def warn_once(steps, error_output:)
+      warning = message(steps)
+      error_output.puts warning if warning
+    end
+
+    private
+
+    def terminal_width
+      return nil unless @output.respond_to?(:tty?) && @output.tty?
+
+      width_from_output || width_from_console
+    end
+
+    def width_from_output
+      return nil unless @output.respond_to?(:winsize)
+
+      @output.winsize[1]
+    rescue SystemCallError
+      nil
+    end
+
+    def width_from_console
+      console = IO.console
+      return nil unless console
+
+      console.winsize[1]
+    rescue SystemCallError
+      nil
+    end
+
+    def required_width(steps)
+      max_places = steps.map { |step| step.board.place_count }.max || 0
+      Renderer::AsciiRenderer::LABEL_WIDTH +
+        (Renderer::CellRenderer::CELL_WIDTH + 1) * max_places +
+        1
+    end
+  end
+end

data/lib/sangi/version.rb

@@ -0,0 +1,3 @@
+module Sangi
+  VERSION = "0.1.0"
+end