zen_to_i 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7159a12adbda141423184a4769d10011e872607f7504df9f10ff47146d25880
-  data.tar.gz: 8b34203aaad6483c34acf49d7f7e3b07972a0dec470a56cfef3598156c9ab22d
+  metadata.gz: 2caafd58ade6791a65d28c27e8e11d0ad4c67bb24d89640b9b7d1fc80831844a
+  data.tar.gz: dbe72c43236b37f92064779d2a3637d4945fc3c7536ee83e68c2e2d0a8f2166c
 SHA512:
-  metadata.gz: 66e00c3a2e43a09b7cf8e8cfa78d504fd798a8403c1f787ad4e03f7a34bd1ff05d2ac4033e80405cba4fe0a8b77c09c4fca7b656751c912ea067789f81ba0a56
-  data.tar.gz: e2a84957f2e08f246c001bbfd94b4bfc1e1bbe56d2a8a1c21a51d14684d072e394060a912be352ca6a938140975b8dd79c3aeeea888abebb9e431dbddea36042
+  metadata.gz: 95264694be883ae9fb324a90fd4fb61047f1ff6a117aa3aab8aed04d7586f9417c7c222a29a807cd1e2853b4d81726d8543de1a26321c3ed5dffe41dda6ff37a
+  data.tar.gz: 78c65fc1b572ccd8983c5115eb79b536e10c8d7e34ffa3f664928573ceb9c746c124bb928fbbe01c920ebafbbd9ea8b52feb0ffad3a41c68ed69c6cd2ba93a8d

data/README.md

@@ -3,36 +3,36 @@
 
 [![Actions Status](https://github.com/yoshitsugu/zen_to_i/workflows/test/badge.svg)](https://github.com/yoshitsugu/zen_to_i/actions)
 
-## Installation
+## インストール
 
-Install via RubyGems.
+RubyGems からインストールします。
 
     $ gem install zen_to_i
 
-Or, use Bundler. Add this line to your application's Gemfile:
+または Bundler を使います。アプリケーションの Gemfile に次の行を追加してください。
 
 ```ruby
 gem "zen_to_i"
 ```
 
-Then run:
+その後、次を実行します。
 
     $ bundle
 
-## Usage
+## 使い方
 
-### 1. Use the `zen_to_i` command from your shell
+### 1. シェルから `zen_to_i` コマンドを使う
 
     $ zen_to_i "一二三"
     123
 
-    # or use a pipe
+    # パイプで渡すこともできます
     $ echo "一二三" | zen_to_i
     123
 
-Please run `bundle exec zen_to_i` if you installed the gem via Bundler.
+Bundler経由で gem をインストールした場合は `bundle exec zen_to_i` を実行してください。
 
-### 2. Use it in your Ruby script
+### 2. Ruby スクリプト内で使う
 
 ```ruby
 require 'zen_to_i'
@@ -49,9 +49,24 @@ require 'zen_to_i'
 "三兆五十二万四十八".zen_to_i
 #=> "3000000520048"
 ```
-Note that `zen_to_i` returns a String, not an Integer.
+`zen_to_i` は Integer ではなく String を返すことに注意してください。
 
-You can also override `to_i` with a refinement. The override is active only in the lexical scope where `using ZenToI::Refine` appears, and returns an Integer like the built-in `to_i` method.
+位（十・百・千）が大きい順に並ぶ場合は同じ数の桁として解釈します。同じ位が重なったり小さい位から大きい位へ並んだりした場合は、別の数として連結します。
+
+```ruby
+"百十".zen_to_i
+#=> "110"
+
+"十十".zen_to_i
+#=> "1010"
+
+"十百".zen_to_i
+#=> "10100"
+```
+
+万・億・兆の並びは従来どおりセクションの加算として扱います（`一億一億` は `200000000`）。位記号を含まない漢数字だけの並び（例: `〇〇七`）は、先頭のゼロを落とさずそのまま連結します。
+
+refinement で `to_i` を上書きすることもできます。上書きは `using ZenToI::Refine` が書かれた語彙スコープ内だけで有効で、組み込みの `to_i` メソッドと同様に Integer を返します。
 
 ```ruby
 require "zen_to_i/refine"
@@ -65,7 +80,7 @@ using ZenToI::Refine
 #=> 123
 ```
 
-You can also replace `String#to_i` globally by requiring `zen_to_i/string_ext`. This affects all strings in the process; the original `to_i` implementation remains available as `String#_to_i`. Use this only when a global override is intended.
+`zen_to_i/string_ext` を require すると `String#to_i` をプロセス全体で置き換えることもできます。これはプロセス内のすべての文字列に影響します。元の `to_i` の実装は `String#_to_i` として残ります。グローバルな上書きが意図している場合にのみ使ってください。
 
 ```ruby
 require "zen_to_i/string_ext"
@@ -77,6 +92,16 @@ require "zen_to_i/string_ext"
 #=> 123
 ```
 
+基数を指定した `to_i` も使えます。基数は漢数字を変換した後の文字列に適用されるため、漢数字と基数を組み合わせると直感と異なる値になります。
+
+```ruby
+"十六".to_i(16)
+#=> 22   # 十六 は 16 ではない
+
+"一〇".to_i(2)
+#=> 2
+```
+
 
 ## Contributing
 

data/lib/zen_to_i/constant.rb

@@ -12,11 +12,11 @@ module ZenToI
       KANORDER_F = { "万" => 10**4, "億" => 10**8, "兆" => 10**12,
                      "" => 1, "萬" => 10**4 }.freeze
       ALL_KANSUUJI = KANNUM.keys + KANORDER.keys + KANORDER_F.keys
-      MAX_LOOP = 100
-      KANORDER_F_KEYS_REGEX = /([^#{KANORDER_F.keys.join("")}]*)([#{KANORDER_F.keys.join("")}]?)/
-      KANORDER_KEYS_REGEX = /([^#{KANORDER.keys.join("")}]*)([#{KANORDER.keys.join("")}]?)/
-      ALL_KANSUUJI_REGEX = /([#{ALL_KANSUUJI.join("")}]+)/
-      KANNUM_PAIR_REGEX = /([#{KANNUM.keys.join("")}])([#{KANNUM.keys.join("")}])/
+      ASCII_DIGITS = (0..9).map(&:to_s)
+      # 半角数字が漢数字ブロックに混ざる場合（例: 3万）も漢数字側として扱う
+      ALL_KANSUUJI_REGEX = /([#{ALL_KANSUUJI.join("")}#{ASCII_DIGITS.join("")}]+)/
+      # 半角数字だけのブロック（例: 007）は数値として評価せず素通しする
+      ASCII_DIGITS_ONLY_REGEX = /\A[0-9]+\z/
     end
   end
 

data/lib/zen_to_i/mixin.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "constant"
+require_relative "parser"
 
 module ZenToI
   module Mixin
@@ -14,8 +15,7 @@ module ZenToI
     private
 
       def kanji2num(str)
-        array = split_kansuuji(str)
-        array = split_kansuuji_detail(array)
+        array = split_kansuuji(zen2han(str))
         result = convert_kansuuji(array)
         result.join("")
       end
@@ -29,55 +29,15 @@ module ZenToI
         string.split(ALL_KANSUUJI_REGEX)
       end
 
-      # 位を表す数ではない普通の漢数字が続いていたらわける
-      def split_kansuuji_detail(array)
-        array_tmp = array.clone
-        array_result = array.clone
-        (1..MAX_LOOP).each do |_i|
-          array_result = split_kansuuji_detail_inner(array_result)
-          return array_result if array_result == array_tmp
-
-          array_tmp = array_result.clone
-        end
-        array_result
-      end
-
-      def split_kansuuji_detail_inner(array)
-        ary = array.map do |a|
-          if ALL_KANSUUJI_REGEX.match?(a)
-            a.gsub(KANNUM_PAIR_REGEX, '\1,\2').split(",")
-          else
-            a
-          end
-        end
-        ary.flatten
-      end
-
-      # ４桁ごとの単位（万、億、兆など）でまずわけ、
-      # それぞれに対して漢数字→数字を実行している。
+      # 漢数字ブロックだけを数値化する。半角数字だけのブロック（007 など）は素通しする。
       def convert_kansuuji(array)
         array.map do |a|
-          if ALL_KANSUUJI_REGEX.match?(a)
-            sum_kansuuji(a)
-          else
-            a
-          end
-        end
-      end
-
-      def sum_kansuuji(str)
-        str.scan(KANORDER_F_KEYS_REGEX).inject(0) do |ret, (unit, order_f)|
-          ret + (unit_to_i(unit, order_f) * KANORDER_F[order_f].to_i)
+          kansuuji_block?(a) ? ::ZenToI::Parser.call(a) : a
         end
       end
 
-      # 大字だけの表記は 1 個分として数え、scan の末尾の空一致は桁を持たないので 0 とする。
-      def unit_to_i(unit, order_f)
-        return order_f.empty? ? 0 : 1 if unit.empty?
-
-        unit.scan(KANORDER_KEYS_REGEX).inject(-1) do |tmp, (kanji, order)|
-          tmp + (KANNUM[kanji].to_i * KANORDER[order].to_i)
-        end
+      def kansuuji_block?(str)
+        !ASCII_DIGITS_ONLY_REGEX.match?(str) && ALL_KANSUUJI_REGEX.match?(str)
       end
   end
 end

data/lib/zen_to_i/parser.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "constant"
+
+module ZenToI
+  # 漢数字ブロック（例: "三兆五十二万四十八"）を整数に変換する。
+  module Parser
+    include ::ZenToI::Constant
+
+    module_function
+
+    # 位記号（十百千万億兆）を含まない数字だけのブロックは、先頭ゼロを保持するため
+    # 数値化せず各桁をそのまま連結する（例: 〇〇七 => "007"）。
+    def call(str)
+      return digit_string(str) unless order_marker?(str)
+
+      chunks = tokenize(str).slice_after { |kind, _| kind == :order_f }
+      chunks.sum do |chunk|
+        body, multiplier = split_chunk(chunk)
+        section_value(body, multiplier)
+      end.to_s
+    end
+
+    def digit_string(str)
+      tokenize(str).map { |_kind, value| value.to_s }.join
+    end
+
+    # 万・億・兆で終わるまとまりは、その単位を乗数として切り離す。
+    def split_chunk(chunk)
+      last = chunk.last
+      return [chunk, 1] unless last.first == :order_f
+
+      [chunk[0..-2], last.last]
+    end
+
+    # 単位単体（万など）は 1 個分として数える。
+    # セクション内は「位のあとの数字2桁目以降で分割」してから各チャンクを評価し連結する。
+    def section_value(tokens, multiplier)
+      return multiplier if tokens.empty?
+
+      split_after_order_tail(tokens).map { |chunk| eval_section(chunk) }.join.to_i * multiplier
+    end
+
+    # 位記号（十百千）または大単位（万億兆）を含むか。
+    def order_marker?(str)
+      str.each_char.any? { |char| KANORDER.key?(char) || KANORDER_F.key?(char) }
+    end
+
+    # 半角数字の連続は1つの数として扱う（例: 3千500 の "500"）。
+    def tokenize(str)
+      str.scan(/[0-9]+|./).filter_map do |char|
+        kind, value = token_of(char)
+        [kind, value] if kind
+      end
+    end
+
+    def token_of(char)
+      if KANNUM.key?(char)
+        [:num, KANNUM[char]]
+      elsif ASCII_DIGITS_ONLY_REGEX.match?(char)
+        [:num, char.to_i]
+      elsif KANORDER.key?(char)
+        [:order, KANORDER[char]]
+      elsif KANORDER_F.key?(char)
+        [:order_f, KANORDER_F[char]]
+      end
+    end
+
+    # 位のあとに続く数字は1桁だけ同じ数に入れ、2桁目以降は別の数として分割する。
+    # （例: 百二三十 => 百二 | 三十 => "102" + "30" = "10230"）
+    def split_after_order_tail(tokens)
+      seen_order = false
+      tokens.slice_when do |before, after|
+        cut = seen_order && before.first == :num && after.first == :num
+        seen_order ||= before.first == :order
+        cut
+      end
+    end
+
+    # 位が小さくなる間は同じ数の桁として加算し、同じ位か大きい位が来たら別の数として連結する。
+    def eval_section(tokens)
+      state = { completed: [], current: 0, last_order: nil, pending: nil }
+      tokens.each { |token| apply_token(state, token) }
+      finish_section(state)
+    end
+
+    def apply_token(state, (kind, value))
+      case kind
+      when :num
+        apply_num(state, value)
+      when :order
+        apply_order(state, value)
+      end
+    end
+
+    def apply_num(state, value)
+      state[:pending] = state[:pending].nil? ? value : (state[:pending] * 10) + value
+    end
+
+    def apply_order(state, value)
+      coefficient = state[:pending].nil? ? 1 : state[:pending]
+      if state[:last_order].nil? || value < state[:last_order]
+        state[:current] += coefficient * value
+      else
+        state[:completed] << state[:current]
+        state[:current] = coefficient * value
+      end
+      state[:last_order] = value
+      state[:pending] = nil
+    end
+
+    def finish_section(state)
+      state[:current] += state[:pending] unless state[:pending].nil?
+      state[:completed] << state[:current]
+      state[:completed].join.to_i
+    end
+  end
+end

data/lib/zen_to_i/to_i.rb

@@ -9,8 +9,8 @@ module ZenToI
     # ネイティブ実装を捕捉し、どのロード順でも素の to_i を参照できるようにする。
     ORIGINAL_TO_I = String.instance_method(:to_i) unless const_defined?(:ORIGINAL_TO_I, false)
 
-    def to_i
-      ORIGINAL_TO_I.bind(zen_to_i).call
+    def to_i(*)
+      ORIGINAL_TO_I.bind(zen_to_i).call(*)
     end
 
     def _to_i(*)

data/lib/zen_to_i/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ZenToI
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zen_to_i
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - yoshitsugu
@@ -23,6 +23,7 @@ files:
 - lib/zen_to_i.rb
 - lib/zen_to_i/constant.rb
 - lib/zen_to_i/mixin.rb
+- lib/zen_to_i/parser.rb
 - lib/zen_to_i/refine.rb
 - lib/zen_to_i/string_ext.rb
 - lib/zen_to_i/to_i.rb