keisanjaku 0.1.0

data/lib/keisanjaku/scale.rb

@@ -0,0 +1,205 @@
+module Keisanjaku
+  class ScaleError < ArgumentError; end
+
+  class Scale
+    DEGREE = Math::PI / 180.0
+    S_MIN_DEGREES = Math.asin(0.1) / DEGREE
+    T_MIN_DEGREES = Math.atan(0.1) / DEGREE
+
+    attr_reader :name, :kind, :decades
+
+    def initialize(name, kind:, decades: 1)
+      @name = name.to_s.upcase
+      @kind = kind
+      @decades = decades
+    end
+
+    def position(value)
+      numeric = Float(value)
+      pos = case kind
+            when :log
+              require_range(numeric, 1.0, 10.0)
+              Math.log10(numeric)
+            when :inverse_log
+              require_range(numeric, 1.0, 10.0)
+              1.0 - Math.log10(numeric)
+            when :power
+              require_range(numeric, 1.0, 10.0**decades)
+              Math.log10(numeric) / decades
+            when :linear
+              require_range(numeric, 0.0, 1.0)
+              numeric
+            when :sin
+              require_range(numeric, S_MIN_DEGREES, 90.0)
+              Math.log10(10.0 * Math.sin(numeric * DEGREE))
+            when :tan
+              require_range(numeric, T_MIN_DEGREES, 45.0)
+              Math.log10(10.0 * Math.tan(numeric * DEGREE))
+            else
+              raise ScaleError, "unknown scale kind: #{kind}"
+            end
+      clamp_unit(pos)
+    end
+
+    def value_at(pos)
+      numeric = clamp_unit(Float(pos))
+      case kind
+      when :log
+        10.0**numeric
+      when :inverse_log
+        10.0**(1.0 - numeric)
+      when :power
+        10.0**(decades * numeric)
+      when :linear
+        numeric
+      when :sin
+        Math.asin((10.0**numeric) / 10.0) / DEGREE
+      when :tan
+        Math.atan((10.0**numeric) / 10.0) / DEGREE
+      else
+        raise ScaleError, "unknown scale kind: #{kind}"
+      end
+    end
+
+    def ticks(width)
+      case kind
+      when :log, :inverse_log
+        log_ticks(width)
+      when :power
+        power_ticks(width)
+      when :linear
+        linear_ticks(width)
+      when :sin
+        trigonometric_ticks(:sin, width)
+      when :tan
+        trigonometric_ticks(:tan, width)
+      else
+        []
+      end
+    end
+
+    def self.fetch(name)
+      key = name.to_s.upcase
+      SCALES.fetch(key) { raise ScaleError, "unknown scale: #{name}" }
+    end
+
+    def self.names
+      SCALES.keys
+    end
+
+    private
+
+    def require_range(value, min, max)
+      return if value >= min - 1e-12 && value <= max + 1e-12
+
+      raise ScaleError, "#{name} value #{value} is outside #{min}..#{max}"
+    end
+
+    def clamp_unit(pos)
+      return 0.0 if pos.abs < 1e-12
+      return 1.0 if (pos - 1.0).abs < 1e-12
+      return pos if pos >= 0.0 && pos <= 1.0
+
+      raise ScaleError, "#{name} position #{pos} is outside 0..1"
+    end
+
+    def add_tick(ticks, width, pos, label, level)
+      col = (clamp_unit(pos) * (width - 1)).round
+      current = ticks[col]
+      if current.nil? || level < current[:level]
+        ticks[col] = { col: col, label: label, level: level }
+      end
+    end
+
+    def log_ticks(width)
+      ticks = {}
+      if width >= 90
+        (10..99).each do |n|
+          value = n / 10.0
+          level = (n % 10).zero? || n == 10 ? 0 : 2
+          label = level.zero? ? major_log_label(value) : nil
+          add_tick(ticks, width, position(value), label, level)
+        end
+      else
+        (2..18).each do |n|
+          value = n / 2.0
+          level = value == value.floor ? 0 : 1
+          label = level.zero? ? major_log_label(value) : nil
+          add_tick(ticks, width, position(value), label, level)
+        end
+      end
+      add_tick(ticks, width, position(10.0), "1", 0)
+      ticks.values.sort_by { |tick| tick[:col] }
+    end
+
+    def major_log_label(value)
+      rounded = value.round
+      rounded == 10 ? "1" : rounded.to_s
+    end
+
+    def power_ticks(width)
+      ticks = {}
+      (0...decades).each do |decade|
+        base = 10**decade
+        (1..9).each do |n|
+          value = base * n
+          add_tick(ticks, width, position(value), n.to_s, 0)
+          next if width < 90 || n == 9
+
+          add_tick(ticks, width, position(value + base * 0.5), nil, 1)
+        end
+      end
+      add_tick(ticks, width, position(10.0**decades), "1", 0)
+      ticks.values.sort_by { |tick| tick[:col] }
+    end
+
+    def linear_ticks(width)
+      ticks = {}
+      step = width >= 90 ? 0.05 : 0.1
+      count = (1.0 / step).round
+      (0..count).each do |n|
+        value = n * step
+        major = (value * 10).round == value * 10
+        label = if major
+                  value.zero? ? "0" : (value == 1.0 ? "1" : format(".%d", (value * 10).round))
+                end
+        add_tick(ticks, width, position(value), label, major ? 0 : 1)
+      end
+      ticks.values.sort_by { |tick| tick[:col] }
+    end
+
+    def trigonometric_ticks(type, width)
+      values = if type == :sin
+                 [S_MIN_DEGREES, 6, 10, 15, 20, 30, 45, 60, 90]
+               else
+                 [T_MIN_DEGREES, 6, 10, 15, 20, 30, 45]
+               end
+      ticks = {}
+      values.each do |value|
+        label = value == values.first ? "5.7" : value.round.to_s
+        add_tick(ticks, width, position(value), label, 0)
+      end
+      if width >= 90
+        max = type == :sin ? 90 : 45
+        (6..max).each do |degree|
+          next if values.any? { |value| (value - degree).abs < 1e-9 }
+
+          add_tick(ticks, width, position(degree), nil, 2)
+        end
+      end
+      ticks.values.sort_by { |tick| tick[:col] }
+    end
+  end
+
+  Scale::SCALES = {
+    "K" => Scale.new("K", kind: :power, decades: 3),
+    "A" => Scale.new("A", kind: :power, decades: 2),
+    "B" => Scale.new("B", kind: :power, decades: 2),
+    "CI" => Scale.new("CI", kind: :inverse_log),
+    "C" => Scale.new("C", kind: :log),
+    "S" => Scale.new("S", kind: :sin),
+    "T" => Scale.new("T", kind: :tan),
+    "D" => Scale.new("D", kind: :log),
+    "L" => Scale.new("L", kind: :linear)
+  }.freeze
+end

data/lib/keisanjaku/terminal_viewport.rb

@@ -0,0 +1,107 @@
+require "io/console"
+require "rbconfig"
+require_relative "renderer"
+
+module Keisanjaku
+  class TerminalViewport
+    POLL_INTERVAL = 0.25
+
+    attr_reader :width
+
+    def initialize(width: nil, provider: nil, poll_interval: POLL_INTERVAL, platform: nil, right_margin: 0, clamp_fixed_width: false)
+      @requested_width = width
+      @fixed = !width.nil?
+      @provider = provider || -> { IO.console&.winsize&.last || Renderer::DEFAULT_WIDTH }
+      @poll_interval = poll_interval
+      @platform = platform || RbConfig::CONFIG["host_os"]
+      @right_margin = [right_margin.to_i, 0].max
+      @clamp_fixed_width = clamp_fixed_width
+      @dirty = false
+      @last_poll = Time.now
+      @previous_winch_handler = nil
+      @width = normalize_width(target_width)
+    end
+
+    def install
+      return self if fixed_width?
+      return self unless Signal.list.key?("WINCH")
+      return self if windows?
+
+      @previous_winch_handler = Signal.trap("WINCH") { @dirty = true }
+      self
+    rescue ArgumentError
+      self
+    end
+
+    def restore
+      return unless @previous_winch_handler
+
+      Signal.trap("WINCH", @previous_winch_handler)
+      @previous_winch_handler = nil
+    rescue ArgumentError
+      nil
+    end
+
+    def current_width
+      return width if fixed_width?
+
+      refresh if @dirty || poll_due?
+      width
+    end
+
+    def refresh_needed?
+      return false if fixed_width?
+
+      signaled = @dirty
+      return false unless signaled || poll_due?
+
+      previous_width = @width
+      refresh
+      signaled || previous_width != @width
+    end
+
+    def refresh
+      @width = normalize_width(target_width)
+      @dirty = false
+      @last_poll = Time.now
+      width
+    end
+
+    def fixed_width?
+      @fixed && !@clamp_fixed_width
+    end
+
+    private
+
+    def target_width
+      return usable_width unless @fixed
+      return @requested_width.to_i unless @clamp_fixed_width
+
+      [@requested_width.to_i, usable_width].min
+    end
+
+    def usable_width
+      read_width.to_i - @right_margin
+    end
+
+    def read_width
+      @provider.call
+    rescue StandardError
+      Renderer::DEFAULT_WIDTH
+    end
+
+    def normalize_width(value)
+      [value.to_i, Renderer::MIN_WIDTH].max
+    end
+
+    def poll_due?
+      return false unless windows?
+
+      Time.now - @last_poll >= @poll_interval
+    end
+
+    def windows?
+      @platform.match?(/mswin|mingw|cygwin/i)
+    end
+  end
+end

data/lib/keisanjaku/version.rb

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

data/lib/keisanjaku.rb

@@ -0,0 +1,13 @@
+require_relative "keisanjaku/version"
+require_relative "keisanjaku/scale"
+require_relative "keisanjaku/rule_state"
+require_relative "keisanjaku/ansi"
+require_relative "keisanjaku/renderer"
+require_relative "keisanjaku/terminal_viewport"
+require_relative "keisanjaku/input"
+require_relative "keisanjaku/parser"
+require_relative "keisanjaku/planner"
+require_relative "keisanjaku/procedure"
+require_relative "keisanjaku/engine"
+require_relative "keisanjaku/drill"
+require_relative "keisanjaku/app"

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: keisanjaku
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: keisanjaku is a Ruby terminal slide rule simulator with sandbox, demo,
+  and drill modes.
+email:
+- t.yudai92@gmail.com
+executables:
+- keisanjaku
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- exe/keisanjaku
+- lib/keisanjaku.rb
+- lib/keisanjaku/ansi.rb
+- lib/keisanjaku/app.rb
+- lib/keisanjaku/drill.rb
+- lib/keisanjaku/engine.rb
+- lib/keisanjaku/input.rb
+- lib/keisanjaku/modes/demo.rb
+- lib/keisanjaku/modes/drill.rb
+- lib/keisanjaku/modes/sandbox.rb
+- lib/keisanjaku/parser.rb
+- lib/keisanjaku/planner.rb
+- lib/keisanjaku/procedure.rb
+- lib/keisanjaku/renderer.rb
+- lib/keisanjaku/rule_state.rb
+- lib/keisanjaku/scale.rb
+- lib/keisanjaku/terminal_viewport.rb
+- lib/keisanjaku/version.rb
+homepage: https://rubygems.org/gems/keisanjaku
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://rubygems.org/gems/keisanjaku
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: A terminal slide rule simulator.
+test_files: []