seimi 0.1.0

data/lib/seimi/kanji.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Seimi
+  module Kanji
+    DIGITS = %w[〇 一 二 三 四 五 六 七 八 九].freeze
+    PARSE_DIGITS = DIGITS.each_with_index.to_h.merge("零" => 0).freeze
+    SMALL_UNITS = { "十" => 10, "百" => 100, "千" => 1000 }.freeze
+    LARGE_UNITS = [["兆", 1_000_000_000_000], ["億", 100_000_000], ["万", 10_000]].freeze
+
+    module_function
+
+    def from_i(number)
+      integer = Integer(number)
+      return "零" if integer.zero?
+      return "負#{from_i(-integer)}" if integer.negative?
+
+      groups = []
+      while integer.positive?
+        groups << integer % 10_000
+        integer /= 10_000
+      end
+
+      groups.each_with_index.filter_map do |group, index|
+        next if group.zero?
+
+        "#{under_10000(group)}#{large_unit_at(index)}"
+      end.reverse.join
+    end
+
+    def to_i(text)
+      source = String(text)
+      return 0 if source == "零" || source == "〇"
+
+      negative = source.start_with?("負")
+      source = source.delete_prefix("負")
+      total = 0
+
+      LARGE_UNITS.each do |unit, scale|
+        next unless source.include?(unit)
+
+        head, source = source.split(unit, 2)
+        total += under_10000_to_i(head) * scale
+      end
+
+      total += under_10000_to_i(source)
+      negative ? -total : total
+    end
+
+    def rational(value)
+      rational = Rational(value)
+      return from_i(rational.numerator) if rational.denominator == 1
+
+      numerator = rational.numerator
+      sign = numerator.negative? ? "負" : ""
+      "#{sign}#{from_i(rational.denominator)}分の#{from_i(numerator.abs)}"
+    end
+
+    def decimal(value, digits = 3)
+      formatted = format("%.#{digits}f", value)
+      integer, fraction = formatted.split(".", 2)
+      "#{from_i(integer.to_i)}・#{fraction.chars.map { |char| DIGITS[char.to_i] }.join}"
+    end
+
+    def under_10000(number)
+      integer = Integer(number)
+      raise ArgumentError, "out of range" if integer.negative? || integer >= 10_000
+
+      thousands, rem = integer.divmod(1000)
+      hundreds, rem = rem.divmod(100)
+      tens, ones = rem.divmod(10)
+
+      [
+        unit_part(thousands, "千"),
+        unit_part(hundreds, "百"),
+        unit_part(tens, "十"),
+        ones.positive? ? DIGITS[ones] : nil
+      ].compact.join
+    end
+
+    def large_unit_at(index)
+      case index
+      when 0 then ""
+      when 1 then "万"
+      when 2 then "億"
+      when 3 then "兆"
+      else
+        raise ArgumentError, "number is too large"
+      end
+    end
+
+    def unit_part(value, unit)
+      return nil if value.zero?
+      return unit if value == 1
+
+      "#{DIGITS[value]}#{unit}"
+    end
+
+    def under_10000_to_i(text)
+      return 0 if text.empty?
+
+      total = 0
+      current = nil
+
+      text.each_char do |char|
+        if PARSE_DIGITS.key?(char)
+          current = PARSE_DIGITS.fetch(char)
+        elsif SMALL_UNITS.key?(char)
+          total += (current || 1) * SMALL_UNITS.fetch(char)
+          current = nil
+        else
+          raise ArgumentError, "unknown kanji digit: #{char}"
+        end
+      end
+
+      total + (current || 0)
+    end
+  end
+end

data/lib/seimi/sangi.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Seimi
+  module Sangi
+    CELL_WIDTH = 5
+    CELL_HEIGHT = 5
+
+    module_function
+
+    def render(number)
+      digits = Integer(number).abs.digits.reverse
+      cells = digits.each_with_index.map do |digit, index|
+        power = digits.length - index - 1
+        power.even? ? vertical_cell(digit) : horizontal_cell(digit)
+      end
+
+      [frame("┌", "┬", "┐", cells.length),
+       *body_lines(cells),
+       frame("└", "┴", "┘", cells.length)].join("\n")
+    end
+
+    def vertical_cell(digit)
+      return empty_cell if digit.zero?
+
+      rows = blank_cell
+      if digit <= 5
+        digit.times { |index| rows[index] = "  |  " }
+      else
+        rows[0] = " --- "
+        (digit - 5).times { |index| rows[index + 1] = "  |  " }
+      end
+      rows
+    end
+
+    def horizontal_cell(digit)
+      return empty_cell if digit.zero?
+
+      rows = blank_cell
+      if digit <= 5
+        digit.times { |index| rows[CELL_HEIGHT - 1 - index] = " --- " }
+      else
+        rows[0] = "  |  "
+        (digit - 5).times { |index| rows[CELL_HEIGHT - 1 - index] = " --- " }
+      end
+      rows
+    end
+
+    def body_lines(cells)
+      (0...CELL_HEIGHT).map do |line|
+        "│#{cells.map { |cell| cell[line] }.join("│")}│"
+      end
+    end
+
+    def frame(left, middle, right, count)
+      "#{left}#{Array.new(count, "─" * CELL_WIDTH).join(middle)}#{right}"
+    end
+
+    def blank_cell
+      Array.new(CELL_HEIGHT, " " * CELL_WIDTH)
+    end
+
+    def empty_cell
+      ["     ", "     ", " [ ] ", "     ", "     "]
+    end
+  end
+end

data/lib/seimi/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Seimi
+  VERSION = "0.1.0"
+end

data/lib/seimi.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "seimi/version"
+require_relative "seimi/errors"
+require_relative "seimi/elements"
+require_relative "seimi/kanji"
+require_relative "seimi/sangi"
+require_relative "seimi/formula"
+require_relative "seimi/equation"
+
+module Seimi
+  def self.molar_mass(formula)
+    Formula.parse(formula).molar_mass
+  end
+end

data/test/test_buntai.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class TestBuntai < Minitest::Test
+  PROHIBITED = /(です|ます|である|ください)/
+  REQUIRED = /(候|也|べし|給え)/
+
+  def test_error_messages_have_required_style
+    constants = Seimi.constants.grep(/\AMSG_/)
+
+    refute_empty constants
+    constants.each do |constant|
+      value = Seimi.const_get(constant)
+      refute_match PROHIBITED, value
+      assert_match REQUIRED, value
+    end
+  end
+
+  def test_readme_body_uses_required_style
+    readme = File.read(File.expand_path("../README.md", __dir__), encoding: "UTF-8")
+    body = readme.gsub(/```.*?```/m, "")
+
+    refute_match PROHIBITED, body
+  end
+end

data/test/test_cli.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "open3"
+require "rbconfig"
+require_relative "test_helper"
+
+class TestCLI < Minitest::Test
+  EXE = File.expand_path("../exe/seimi", __dir__)
+
+  def test_kaibou_success
+    stdout, stderr, status = Open3.capture3(RbConfig.ruby, "-Ilib", EXE, "kaibou", "Ca(OH)2")
+
+    assert_predicate status, :success?, stderr
+    assert_includes stdout, "候"
+    assert_includes stdout, "七十四"
+  end
+
+  def test_kaibou_error
+    stdout, stderr, status = Open3.capture3(RbConfig.ruby, "-Ilib", EXE, "kaibou", "Xx")
+
+    refute_predicate status, :success?, stdout
+    assert_equal 1, status.exitstatus
+    assert_includes stderr, "咎:"
+  end
+end

data/test/test_equation.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class TestEquation < Minitest::Test
+  def test_iron_oxide
+    result = Seimi::Equation.balance("Fe + O2 -> Fe2O3")
+
+    assert_equal [4, 3, 2], result.coefficients
+    assert_equal ["Fe", "O2", "Fe2O3"], result.species
+    assert_equal 2, result.lhs_size
+    assert_equal ["Fe", "O"], result.elements
+    assert_equal "4Fe + 3O2 -> 2Fe2O3", result.to_s
+  end
+
+  def test_propane
+    result = Seimi::Equation.balance("C3H8 + O2 -> CO2 + H2O")
+
+    assert_equal [1, 5, 3, 4], result.coefficients
+  end
+
+  def test_permanganate_and_hydrochloric_acid
+    result = Seimi::Equation.balance("KMnO4 + HCl -> KCl + MnCl2 + H2O + Cl2")
+
+    assert_equal [2, 16, 2, 2, 8, 5], result.coefficients
+  end
+
+  def test_unbalanced
+    assert_raises(Seimi::UnbalancedError) do
+      Seimi::Equation.balance("H2 -> H2O")
+    end
+  end
+
+  def test_matrix_contains_rational_values
+    result = Seimi::Equation.balance("Fe + O2 -> Fe2O3")
+
+    assert result.matrix.all? { |row| row.all? { |value| value.is_a?(Rational) } }
+  end
+
+  def test_ionic_equation_balances_charge
+    result = Seimi::Equation.balance("Ag+ + Cl- -> AgCl")
+
+    assert_equal [1, 1, 1], result.coefficients
+    assert_includes result.elements, Seimi::Equation::CHARGE_BALANCE_SYMBOL
+    assert_equal [Rational(1), Rational(-1), Rational(0)], result.matrix.last
+  end
+
+  def test_ionic_equation_without_spaces
+    result = Seimi::Equation.balance("Ag++Cl-->AgCl")
+
+    assert_equal [1, 1, 1], result.coefficients
+    assert_equal ["Ag+", "Cl-", "AgCl"], result.species
+  end
+
+  def test_multivalent_ionic_equation_without_spaces
+    result = Seimi::Equation.balance("Ba^2++SO4^2-->BaSO4")
+
+    assert_equal [1, 1, 1], result.coefficients
+    assert_equal ["Ba^2+", "SO4^2-", "BaSO4"], result.species
+  end
+
+  def test_hydrate_equation
+    result = Seimi::Equation.balance("CuSO4·5H2O -> CuSO4 + H2O")
+
+    assert_equal [1, 1, 5], result.coefficients
+  end
+
+  def test_isotope_labels_are_balanced_separately
+    assert_raises(Seimi::UnbalancedError) do
+      Seimi::Equation.balance("[13C]O2 -> CO2")
+    end
+  end
+end

data/test/test_formula.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class TestFormula < Minitest::Test
+  def test_molar_mass_shortcut
+    assert_in_delta 18.015, Seimi.molar_mass("H2O"), 0.001
+  end
+
+  def test_parenthesized_formula
+    assert_equal({ "Ca" => 1, "O" => 2, "H" => 2 }, Seimi::Formula.parse("Ca(OH)2").composition)
+  end
+
+  def test_nested_count_formula
+    assert_equal({ "Mg" => 3, "P" => 2, "O" => 8 }, Seimi::Formula.parse("Mg3(PO4)2").composition)
+  end
+
+  def test_unknown_element_message
+    error = assert_raises(Seimi::UnknownElementError) do
+      Seimi::Formula.parse("Xx")
+    end
+
+    assert_equal format(Seimi::MSG_UNKNOWN_ELEMENT, "Xx"), error.message
+    assert_equal 118, Seimi::ELEMENTS.length
+  end
+
+  def test_ion_charge
+    sulfate = Seimi::Formula.parse("SO4^2-")
+    ammonium = Seimi::Formula.parse("NH4+")
+    iron = Seimi::Formula.parse("Fe3+")
+
+    assert_equal({ "S" => 1, "O" => 4 }, sulfate.composition)
+    assert_equal(-2, sulfate.charge)
+    assert_equal({ "N" => 1, "H" => 4 }, ammonium.composition)
+    assert_equal(1, ammonium.charge)
+    assert_equal({ "Fe" => 1 }, iron.composition)
+    assert_equal(3, iron.charge)
+  end
+
+  def test_hydrate_formula
+    formula = Seimi::Formula.parse("CuSO4·5H2O")
+
+    assert_equal({ "Cu" => 1, "S" => 1, "O" => 9, "H" => 10 }, formula.composition)
+    assert_in_delta 249.677, formula.molar_mass, 0.001
+  end
+
+  def test_isotope_formula
+    formula = Seimi::Formula.parse("[13C]H4")
+
+    assert_equal({ "C" => 1, "H" => 4 }, formula.composition)
+    assert_equal({ "13C" => 1, "H" => 4 }, formula.balance_composition)
+    assert_in_delta 17.0353548351, formula.molar_mass, 0.000001
+    assert_equal ["13C", 1, 13.0033548351], formula.breakdown.first
+  end
+
+  def test_exact_isotope_formula
+    formula = Seimi::Formula.parse("[13C][1H]4")
+
+    assert_in_delta 17.03465496402, formula.molar_mass, 0.000000001
+  end
+
+  def test_deuterium_and_tritium_aliases
+    deuterium_water = Seimi::Formula.parse("D2O")
+    tritium = Seimi::Formula.parse("T2")
+
+    assert_equal({ "H" => 2, "O" => 1 }, deuterium_water.composition)
+    assert_equal({ "2H" => 2, "O" => 1 }, deuterium_water.balance_composition)
+    assert_in_delta 20.0272035562, deuterium_water.molar_mass, 0.000000001
+    assert_equal({ "H" => 2 }, tritium.composition)
+    assert_equal({ "3H" => 2 }, tritium.balance_composition)
+  end
+
+  def test_unknown_isotope
+    assert_raises(Seimi::ParseError) do
+      Seimi::Formula.parse("[999C]H4")
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "minitest/autorun"
+require "seimi"

data/test/test_kanji.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class TestKanji < Minitest::Test
+  def test_from_i_and_to_i_round_trip
+    [0, 7, 10, 58, 100, 1858, 10_005, 27_682_574_402].each do |number|
+      assert_equal number, Seimi::Kanji.to_i(Seimi::Kanji.from_i(number))
+    end
+  end
+
+  def test_specific_kanji
+    assert_equal "千八百五十八", Seimi::Kanji.from_i(1858)
+    assert_equal 1858, Seimi::Kanji.to_i("千八百五十八")
+  end
+
+  def test_rational
+    assert_equal "三分の一", Seimi::Kanji.rational(Rational(1, 3))
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: seimi
+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:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: 化学式の分子の量を秤り、反応式の割合の数を厳密に釣合はすRubyGemに候
+email:
+- t.yudai92@gmail.com
+executables:
+- seimi
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/seimi
+- lib/seimi.rb
+- lib/seimi/cli.rb
+- lib/seimi/elements.rb
+- lib/seimi/equation.rb
+- lib/seimi/errors.rb
+- lib/seimi/formula.rb
+- lib/seimi/formula/parser.rb
+- lib/seimi/isotopes.rb
+- lib/seimi/kanji.rb
+- lib/seimi/sangi.rb
+- lib/seimi/version.rb
+- test/test_buntai.rb
+- test/test_cli.rb
+- test/test_equation.rb
+- test/test_formula.rb
+- test/test_helper.rb
+- test/test_kanji.rb
+homepage: https://github.com/ydah/seimi
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/ydah/seimi
+  changelog_uri: https://github.com/ydah/seimi/blob/main/CHANGELOG.md
+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: 舎密の式を解剖し釣合はする絡繰に候
+test_files: []