seimi 0.1.0

data/lib/seimi/formula/parser.rb

@@ -0,0 +1,361 @@
+# frozen_string_literal: true
+
+module Seimi
+  class Formula
+    class Parser
+      UPPER = /[A-Z]/.freeze
+      LOWER = /[a-z]/.freeze
+      DIGIT = /[0-9]/.freeze
+      SUPERSCRIPT_DIGITS = {
+        "⁰" => "0", "¹" => "1", "²" => "2", "³" => "3", "⁴" => "4",
+        "⁵" => "5", "⁶" => "6", "⁷" => "7", "⁸" => "8", "⁹" => "9"
+      }.freeze
+      SUPERSCRIPT_SIGNS = { "⁺" => "+", "⁻" => "-" }.freeze
+
+      def initialize(source)
+        @source = String(source).strip
+      end
+
+      def parse
+        body, charge = split_charge(@source)
+        parsed = split_hydrate_segments(body).each_with_index.map do |segment, index|
+          parse_segment(segment, hydrate: index.positive?)
+        end
+
+        Formula.new(
+          @source,
+          compact_composition(parsed, :composition),
+          compact_composition(parsed, :balance_composition),
+          compact_components(parsed.flat_map { |item| item[:components] }),
+          charge
+        )
+      end
+
+      private
+
+      def parse_segment(segment, hydrate:)
+        factor, body = extract_hydrate_factor(segment, hydrate)
+        @body = body
+        @index = 0
+
+        composition, balance_composition, components = parse_group
+        raise_invalid(current_char) unless at_end?
+
+        {
+          composition: scale_hash(composition, factor),
+          balance_composition: scale_hash(balance_composition, factor),
+          components: scale_components(components, factor)
+        }
+      end
+
+      def parse_group(terminator = nil)
+        composition = {}
+        balance_composition = {}
+        components = []
+
+        until at_end?
+          char = current_char
+          return [composition, balance_composition, compact_components(components)] if terminator && char == terminator
+
+          case char
+          when "("
+            inner = parse_bracketed_group(")")
+            merge_parsed_group(composition, balance_composition, components, inner, parse_count)
+          when "["
+            parse_square_open(composition, balance_composition, components)
+          when ")", "]"
+            raise_invalid(char)
+          when "^"
+            component = parse_isotope_prefix
+            add_component(composition, balance_composition, components, component, parse_count)
+          when UPPER
+            component = parse_element_component
+            add_component(composition, balance_composition, components, component, parse_count)
+          else
+            raise_invalid(char)
+          end
+        end
+
+        raise ParseError, MSG_UNCLOSED_PAREN if terminator
+        raise_invalid("") if composition.empty?
+
+        [composition, balance_composition, compact_components(components)]
+      end
+
+      def parse_square_open(composition, balance_composition, components)
+        if next_char&.match?(DIGIT)
+          component = parse_isotope_bracket
+          add_component(composition, balance_composition, components, component, parse_count)
+          return
+        end
+
+        inner = parse_bracketed_group("]")
+        merge_parsed_group(composition, balance_composition, components, inner, parse_count)
+      end
+
+      def parse_bracketed_group(terminator)
+        advance
+        inner = parse_group(terminator)
+        raise ParseError, MSG_UNCLOSED_PAREN if at_end?
+
+        advance
+        inner
+      end
+
+      def parse_element_component
+        symbol = parse_element_symbol
+        return parse_hydrogen_isotope_alias(symbol) if hydrogen_isotope_alias?(symbol)
+
+        validate_element!(symbol)
+
+        Component.new(
+          symbol: symbol,
+          element: symbol,
+          balance_symbol: symbol,
+          count: 1,
+          atomic_mass: ELEMENTS.fetch(symbol).first
+        )
+      end
+
+      def parse_isotope_prefix
+        advance
+        mass_number = parse_required_digits
+        parse_isotope_element(mass_number)
+      end
+
+      def parse_isotope_bracket
+        advance
+        mass_number = parse_required_digits
+        component = parse_isotope_element(mass_number)
+        raise ParseError, MSG_UNCLOSED_PAREN if at_end?
+        raise_invalid(current_char) unless current_char == "]"
+
+        advance
+        component
+      end
+
+      def parse_isotope_element(mass_number)
+        symbol = parse_element_symbol
+        validate_element!(symbol)
+        mass = isotope_mass(symbol, mass_number)
+
+        Component.new(
+          symbol: "#{mass_number}#{symbol}",
+          element: symbol,
+          balance_symbol: "#{mass_number}#{symbol}",
+          count: 1,
+          atomic_mass: mass
+        )
+      end
+
+      def parse_hydrogen_isotope_alias(symbol)
+        mass_number = symbol == "D" ? 2 : 3
+
+        Component.new(
+          symbol: symbol,
+          element: "H",
+          balance_symbol: "#{mass_number}H",
+          count: 1,
+          atomic_mass: isotope_mass("H", mass_number.to_s)
+        )
+      end
+
+      def parse_element_symbol
+        symbol = current_char
+        advance
+        if !at_end? && current_char.match?(LOWER)
+          symbol += current_char
+          advance
+        end
+        symbol
+      end
+
+      def parse_required_digits
+        digits = +""
+        while !at_end? && current_char.match?(DIGIT)
+          digits << current_char
+          advance
+        end
+
+        raise_invalid(current_char || "") if digits.empty? || digits.to_i.zero?
+
+        digits
+      end
+
+      def parse_count
+        digits = +""
+        while !at_end? && current_char.match?(DIGIT)
+          digits << current_char
+          advance
+        end
+
+        return 1 if digits.empty?
+
+        count = digits.to_i
+        raise_invalid(digits) if count.zero?
+
+        count
+      end
+
+      def add_component(composition, balance_composition, components, component, factor)
+        merge_count(composition, component.element, factor)
+        merge_count(balance_composition, component.balance_symbol, factor)
+        components << component_with_count(component, factor)
+      end
+
+      def merge_parsed_group(composition, balance_composition, components, parsed, factor)
+        inner_composition, inner_balance_composition, inner_components = parsed
+        inner_composition.each { |symbol, count| merge_count(composition, symbol, count * factor) }
+        inner_balance_composition.each { |symbol, count| merge_count(balance_composition, symbol, count * factor) }
+        components.concat(scale_components(inner_components, factor))
+      end
+
+      def merge_count(hash, key, count)
+        hash[key] = hash.fetch(key, 0) + count
+      end
+
+      def validate_element!(symbol)
+        return if ELEMENTS.key?(symbol)
+
+        raise UnknownElementError, format(MSG_UNKNOWN_ELEMENT, symbol)
+      end
+
+      def isotope_mass(symbol, mass_number)
+        mass = ISOTOPE_MASSES.dig(symbol, mass_number.to_i)
+        return mass if mass
+
+        raise ParseError, format(MSG_PARSE_INVALID_CHAR, "#{mass_number}#{symbol}")
+      end
+
+      def hydrogen_isotope_alias?(symbol)
+        symbol == "D" || symbol == "T"
+      end
+
+      def split_charge(source)
+        return [source, 0] if source.empty?
+
+        caret = source.match(/\A(.+)\^(\d*)([+-])\z/)
+        return [caret[1], signed_charge(caret[2], caret[3])] if caret
+
+        superscript = source.match(/\A(.+?)([#{SUPERSCRIPT_DIGITS.keys.join}]*)([#{SUPERSCRIPT_SIGNS.keys.join}])\z/)
+        if superscript
+          digits = superscript[2].chars.map { |char| SUPERSCRIPT_DIGITS.fetch(char) }.join
+          return [superscript[1], signed_charge(digits, SUPERSCRIPT_SIGNS.fetch(superscript[3]))]
+        end
+
+        return [source, 0] unless source.end_with?("+", "-")
+
+        body = source[0...-1]
+        sign = source[-1]
+        bare_charge = body.match(/\A(.+?)(\d+)\z/)
+        if bare_charge && single_element_body?(bare_charge[1])
+          return [bare_charge[1], signed_charge(bare_charge[2], sign)]
+        end
+
+        [body, signed_charge("", sign)]
+      end
+
+      def signed_charge(digits, sign)
+        magnitude = digits.empty? ? 1 : digits.to_i
+        sign == "-" ? -magnitude : magnitude
+      end
+
+      def single_element_body?(body)
+        body.match?(/\A[A-Z][a-z]?\z/) && ELEMENTS.key?(body)
+      end
+
+      def split_hydrate_segments(source)
+        segments = []
+        buffer = +""
+        depth = 0
+
+        source.each_char do |char|
+          if (char == "." || char == "·") && depth.zero?
+            segments << buffer
+            buffer = +""
+            next
+          end
+
+          depth += 1 if char == "(" || char == "["
+          depth -= 1 if char == ")" || char == "]"
+          buffer << char
+        end
+
+        segments << buffer
+        raise_invalid("") if segments.any?(&:empty?)
+
+        segments
+      end
+
+      def extract_hydrate_factor(segment, hydrate)
+        return [1, segment] unless hydrate
+
+        match = segment.match(/\A(\d+)(.+)\z/)
+        return [1, segment] unless match
+
+        [match[1].to_i, match[2]]
+      end
+
+      def compact_composition(parsed, key)
+        parsed.each_with_object({}) do |item, result|
+          item.fetch(key).each { |symbol, count| merge_count(result, symbol, count) }
+        end
+      end
+
+      def compact_components(components)
+        components.each_with_object([]) do |component, result|
+          existing = result.find do |item|
+            item.symbol == component.symbol &&
+              item.element == component.element &&
+              item.balance_symbol == component.balance_symbol &&
+              item.atomic_mass == component.atomic_mass
+          end
+
+          if existing
+            existing.count += component.count
+          else
+            result << component.dup
+          end
+        end
+      end
+
+      def scale_hash(hash, factor)
+        hash.transform_values { |count| count * factor }
+      end
+
+      def scale_components(components, factor)
+        components.map { |component| component_with_count(component, component.count * factor) }
+      end
+
+      def component_with_count(component, count)
+        Component.new(
+          symbol: component.symbol,
+          element: component.element,
+          balance_symbol: component.balance_symbol,
+          count: count,
+          atomic_mass: component.atomic_mass
+        )
+      end
+
+      def raise_invalid(char)
+        raise ParseError, format(MSG_PARSE_INVALID_CHAR, char)
+      end
+
+      def current_char
+        @body[@index]
+      end
+
+      def next_char
+        @body[@index + 1]
+      end
+
+      def advance
+        @index += 1
+      end
+
+      def at_end?
+        @index >= @body.length
+      end
+    end
+  end
+end

data/lib/seimi/formula.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "elements"
+require_relative "errors"
+require_relative "isotopes"
+
+module Seimi
+  class Formula
+    Component = Struct.new(:symbol, :element, :balance_symbol, :count, :atomic_mass, keyword_init: true) do
+      def total_mass
+        atomic_mass * count
+      end
+    end
+
+    attr_reader :composition, :balance_composition, :charge
+
+    def self.parse(source)
+      Parser.new(source).parse
+    end
+
+    def initialize(source, composition, balance_composition, components, charge)
+      @source = source
+      @composition = composition
+      @balance_composition = balance_composition
+      @components = components
+      @charge = charge
+    end
+
+    def molar_mass
+      @components.sum(0.0) { |component| component.total_mass }
+    end
+
+    def breakdown
+      @components.map do |component|
+        [component.symbol, component.count, component.total_mass]
+      end
+    end
+
+    def charged?
+      !charge.zero?
+    end
+
+    def to_s
+      @source
+    end
+
+    def to_kobun
+      require_relative "kanji"
+      require_relative "sangi"
+
+      lines = ["〔#{self} 解剖の覚〕"]
+      @components.each do |component|
+        name = ELEMENTS.fetch(component.element).last
+        lines << "一、#{name}(#{component.symbol}) #{Kanji.decimal(component.total_mass, 3)} 匁掛ける#{Kanji.from_i(component.count)}つ"
+      end
+      lines << "電荷 #{Kanji.rational(charge)} に候" if charged?
+      lines << "〆て 分子の量 凡そ#{Kanji.decimal(molar_mass, 3)} に候"
+      lines << Sangi.render(molar_mass.round)
+      lines << "右の如く相違なく候 也"
+      lines.join("\n")
+    end
+  end
+end
+
+require_relative "formula/parser"