xls_function 0.1.0

data/lib/xls_function/evaluators/number_evaluator.rb

@@ -0,0 +1,18 @@
+module XlsFunction
+  module Evaluators
+    class NumberEvaluator
+      include Evaluable
+
+      attr_reader :source
+
+      def initialize(source, context)
+        @source = source
+        @context = context
+      end
+
+      def eval
+        source.to_s.to_d
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/string_evaluator.rb

@@ -0,0 +1,18 @@
+module XlsFunction
+  module Evaluators
+    class StringEvaluator
+      include Evaluable
+
+      attr_reader :source
+
+      def initialize(source, context)
+        @source = source
+        @context = context
+      end
+
+      def eval
+        source.to_s
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/true_evaluator.rb

@@ -0,0 +1,19 @@
+module XlsFunction
+  module Evaluators
+    class TrueEvaluator
+      include Evaluable
+
+      # unused, but hold for future logging...
+      attr_reader :source
+
+      def initialize(source, context)
+        @source = source
+        @context = context
+      end
+
+      def eval
+        true
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/variant_evaluator.rb

@@ -0,0 +1,24 @@
+module XlsFunction
+  module Evaluators
+    class VariantEvaluator
+      include Evaluable
+
+      attr_reader :name
+
+      def initialize(name, context)
+        @name = name.to_s
+        @context = context
+      end
+
+      def variant_context
+        context[:variants]
+      end
+
+      def eval
+        raise ::XlsFunction::Transform::VariantUndefinedError, "name: `#{name}` is undefined" unless variant_context.key?(name)
+
+        variant_context[name]
+      end
+    end
+  end
+end

data/lib/xls_function/extensions/array_extension.rb

@@ -0,0 +1,22 @@
+module XlsFunction
+  module Extensions
+    module ArrayExtension
+      class << self
+        def max_depth(array, depth = 1)
+          array.inject(depth) do |current_depth, item|
+            next current_depth unless item.is_a?(Array)
+
+            child_depth = max_depth(item, depth + 1)
+            [current_depth, child_depth].max
+          end
+        end
+      end
+
+      refine Array do
+        def max_depth(depth = 1)
+          ArrayExtension.max_depth(self, depth)
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/extensions/big_decimal_extension.rb

@@ -0,0 +1,15 @@
+module XlsFunction
+  module Extensions
+    module BigDecimalExtension
+      refine BigDecimal do
+        def to_date
+          XlsFunction::Converters::NumberConverter.decimal_to_date(self)
+        end
+
+        def to_time(now: ::XlsFunction::Converters::DateSerialConverter::ORIGIN)
+          XlsFunction::Converters::NumberConverter.decimal_to_time(self, now: now)
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/extensions/date_extension.rb

@@ -0,0 +1,11 @@
+module XlsFunction
+  module Extensions
+    module DateExtension
+      refine Date do
+        def to_serial
+          ::XlsFunction::Converters::DateSerialConverter.date_to_serial(self)
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/extensions/hash_extension.rb

@@ -0,0 +1,24 @@
+module XlsFunction
+  module Extensions
+    module HashExtension
+      class << self
+        # @param [Hash] source
+        # @param [Hash] other
+        def deep_merge(source, other, &block)
+          source.merge(other) do |key, oldval, newval|
+            next deep_merge(oldval, newval, &block) if oldval.is_a?(Hash) && newval.is_a?(Hash)
+            next block.call(key, oldval, newval) if block_given?
+
+            newval
+          end
+        end
+      end
+
+      refine Hash do
+        def deep_merge(other, &block)
+          HashExtension.deep_merge(self, other, &block)
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/extensions/time_extension.rb

@@ -0,0 +1,11 @@
+module XlsFunction
+  module Extensions
+    module TimeExtension
+      refine Time do
+        def to_serial(except_date: false)
+          ::XlsFunction::Converters::TimeSerialConverter.time_to_serial(self, except_date: except_date)
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/format_string/evaluators/elapsed_time_evaluator.rb

@@ -0,0 +1,42 @@
+module XlsFunction
+  module FormatString
+    module Evaluators
+      class ElapsedTimeEvaluator
+        attr_reader :cache, :half, :parse_proc
+
+        using ::XlsFunction::Extensions::DateExtension
+        using ::XlsFunction::Extensions::TimeExtension
+
+        def initialize(cache, half: true, &parse_proc)
+          @cache = cache
+          @half = half
+          @parse_proc = parse_proc
+        end
+
+        def call(input)
+          time = ::XlsFunction::Converters::TimeConverter.convert_with_cache(input, cache)
+
+          result = parse_proc.call(self, time).to_i.to_s
+          half ? result : result.rjust(2, '0')
+        end
+
+        def hour(time)
+          elapsed_days = days_from_origin(time)
+          elapsed_days * 24 + time.hour
+        end
+
+        def minute(time)
+          hour(time) * 60 + time.min
+        end
+
+        def second(time)
+          minute(time) * 60 + time.sec
+        end
+
+        def days_from_origin(time)
+          time.to_date.to_serial
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/format_string/evaluators/number_evaluator.rb

@@ -0,0 +1,243 @@
+module XlsFunction
+  module FormatString
+    module Evaluators
+      # @todo refactoring...
+      # rubocop:disable Metrics/AbcSize
+      class NumberEvaluator
+        attr_reader :parts
+
+        def initialize(parts)
+          @parts = parts
+        end
+
+        def call(input)
+          extract_parts!(input)
+          value = adjust_value(input)
+          format_value(value)
+        rescue ArgumentError
+          input
+        end
+
+        def interger_parts
+          @interger_parts ||= PartsList.new
+        end
+
+        def decimal_parts
+          @decimal_parts ||= PartsList.new
+        end
+
+        def parts_length
+          @parts_length ||= parts.length
+        end
+
+        def extract_parts!(input)
+          parts_target = interger_parts
+
+          comma_index = []
+          @parts.each_with_index do |expr, i|
+            if expr.respond_to?(:digits?)
+              parts_target.add_parts(expr, i, true)
+              next
+            end
+
+            # evaluate except number placeholder
+            str = expr.call(input)
+            # switch stack when decimal point comes
+            parts_target = decimal_parts if str == '.'
+            # count comma
+            if str == ','
+              comma_index << i
+              # ignore
+              next
+            end
+            # last % is parcentage flag
+            @has_parcentage = true if str == '%' && (i == parts_length - 1)
+
+            parts_target.add_parts(str, i, false)
+          end.compact
+          check_comma(comma_index)
+        end
+
+        # ↓ check comma
+        # When % exists, check 2 or 1 chars before from %.
+        # If not, check last 2 or 1 chars.
+        def comma_index_pattern_thousands
+          offset = @has_parcentage ? 2 : 1
+          [parts_length - offset]
+        end
+
+        def comma_index_pattern_millions
+          offset = @has_parcentage ? 2 : 1
+          [parts_length - offset - 1, parts_length - offset]
+        end
+
+        def check_comma(comma_index)
+          return if comma_index.empty?
+
+          if (comma_index_pattern_millions - comma_index).empty?
+            @unit = :millions
+            @format = true unless (comma_index - comma_index_pattern_millions).empty?
+          elsif (comma_index_pattern_thousands - comma_index).empty?
+            @unit = :thousands
+            @format = true unless (comma_index - comma_index_pattern_thousands).empty?
+          else
+            @format = true
+          end
+        end
+
+        def adjust_value(value)
+          decimal_value = value.to_s.to_d
+
+          case @unit
+          when :millions
+            decimal_value /= '1000000'.to_d
+          when :thousands
+            decimal_value /= '1000'.to_d
+          end
+
+          decimal_value *= '100'.to_d if @has_parcentage
+
+          decimal_value
+        end
+
+        def format_value(value)
+          value_stack = ValueStack.new(value, decimal_parts.size, @format)
+
+          # format decimals
+          decimal_chars =
+            create_dec_pair(decimal_parts, value_stack).reverse
+                                                       .then { |value_pairs| eval_pairs(value_pairs) }
+                                                       .reverse
+                                                       .join
+
+          # format integers
+          integer_chars =
+            create_int_pair(interger_parts, value_stack).reverse
+                                                        .then { |value_pairs| eval_pairs(value_pairs, int_remain: value_stack.int_remain?) }
+                                                        .join
+
+          "#{!value_stack.empty? ? value_stack.to_s : ''}#{integer_chars}#{decimal_chars}"
+        end
+
+        def create_dec_pair(parts_list, value_stack)
+          parts_list.parts_with_index.map do |part, index|
+            if parts_list.num?(index)
+              [value_stack.shift_dec, part]
+            else
+              [part, nil] # means already evaluated
+            end
+          end
+        end
+
+        def create_int_pair(parts_list, value_stack)
+          parts_list.parts_with_index.reverse.map do |part, index|
+            if parts_list.num?(index)
+              [value_stack.pop_int, part]
+            else
+              [part, nil]
+            end
+          end
+        end
+
+        def eval_pairs(value_eval_pairs, int_remain: false)
+          require_zero = false
+          value_eval_pairs.map do |value, eval|
+            next value unless eval
+
+            evaluated_value = eval.call(value)
+            if evaluated_value.strip != '' && evaluated_value != '0'
+              require_zero = true
+              next evaluated_value
+            end
+
+            # `#` returns empty if zero but must return zero if higher place exists.
+            next '0' if evaluated_value == '' && (require_zero || int_remain)
+
+            evaluated_value
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      class PartsList
+        attr_reader :parts_with_index
+
+        def initialize
+          @parts_with_index = []
+          @num_indexies = []
+        end
+
+        def add_parts(part, index, is_num)
+          @parts_with_index << [part, index]
+          @num_indexies << index if is_num
+        end
+
+        def num?(index)
+          @num_indexies.include?(index)
+        end
+
+        def size
+          parts_with_index.size
+        end
+      end
+
+      # decomposes a number and takes from last.
+      class ValueStack
+        def initialize(source, dec_digit, format)
+          # reduce 1 because dec_digit include decimal point.
+          # call to_d because round(0) in ruby 3.0 returns integer.
+          value = dec_digit.positive? ? source.round(dec_digit - 1).to_d : source.round(0).to_d
+          str = value.to_s('F')
+          int, dec = str.split('.')
+
+          @ints = format ? int_split_with_comma(int) : int.split('')
+          @decs = dec_digit.positive? ? dec.split('') : []
+        end
+
+        def int_split_with_comma(int_s)
+          result = []
+          count = 0
+          arr = int_s.split('')
+          length = arr.length
+          length.times do |i|
+            result.unshift(arr.pop)
+            count += 1
+            next if count < 3 || i == length - 1
+
+            result.unshift(',')
+            count = 0
+          end
+          result
+        end
+
+        def pop_int
+          s = @ints.pop
+          return s unless @ints.last == ','
+
+          # return with comma if exists
+          @ints.pop + s
+        end
+
+        def shift_dec
+          @decs.shift
+        end
+
+        def empty?
+          @ints.empty? && @decs.empty?
+        end
+
+        def int_remain?
+          @ints.filter { |x| x != '-' }
+               .any?
+        end
+
+        def to_s
+          s = @ints.join
+          return s if @decs.empty? || @decs == ['0']
+
+          "#{s}.#{@decs.join}"
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/format_string/evaluators/time_evaluator.rb

@@ -0,0 +1,103 @@
+module XlsFunction
+  module FormatString
+    module Evaluators
+      class TimeEvaluator
+        attr_reader :source, :cache, :minute_mode, :flags, :after_effect
+
+        def initialize(source, cache, minute_mode: false, flags: {}, &after_effect)
+          @source = source.to_s
+          @cache = cache
+          @minute_mode = minute_mode
+          @flags = flags
+          @after_effect = after_effect
+        end
+
+        def call(input)
+          time = ::XlsFunction::Converters::TimeConverter.convert_with_cache(input, cache)
+          format = convert_format
+          result = convert_to_string(time, format)
+          return result unless after_effect
+
+          after_effect.call(self, result)
+        end
+
+        def convert_format
+          XlsFunction::Converters::TimeConverter.convert_format(modified_source, ampm_mode: ampm_mode)
+        end
+
+        def ampm_mode
+          flags[:ampm]
+        end
+
+        def modified_source
+          minute_mode ? source.upcase : source.downcase
+        end
+
+        def convert_to_string(time, format)
+          if format.start_with?('%J')
+            time.to_date.strftime(format)
+          else
+            time.strftime(format)
+          end
+        end
+
+        # ↓ after_effects: treat formats not covered by strftime
+        def month(value)
+          return value[1..] if source == 'm' && value.start_with?('0')
+          return value[0] if source == 'mmmmm'
+
+          value
+        end
+
+        def day(value)
+          return value[1..] if source == 'd' && value.start_with?('0')
+
+          value
+        end
+
+        def weekday(value)
+          return ::XlsFunction::Converters::TimeConverter.convert_weekday_jp(value.to_i) if source == 'aaa'
+          return "#{::XlsFunction::Converters::TimeConverter.convert_weekday_jp(value.to_i)}曜日" if source == 'aaaa'
+
+          value
+        end
+
+        def wareki(value)
+          return '元' if gannen && value == '1'
+          return value.rjust(2, '0') if %w[ee r].include?(source)
+
+          value
+        end
+
+        def gannen
+          flags[:gannen]
+        end
+
+        def gengo(value)
+          return ::XlsFunction::Converters::TimeConverter.convert_wareki_to_alphabet(value) if source == 'g'
+          return value[0] if source == 'gg'
+
+          value
+        end
+
+        def hour(value)
+          return value[1..] if source == 'h' && value.length == 2 && value.start_with?('0')
+
+          value
+        end
+
+        def minute(value)
+          return value[1..] if source == 'm' && value.length == 2 && value.start_with?('0')
+
+          value
+        end
+
+        def second(value)
+          return value[1..] if source == 's' && value.length == 2 && value.start_with?('0')
+
+          value
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/format_string/parse_rules/dates.rb

@@ -0,0 +1,53 @@
+module XlsFunction
+  module FormatString
+    module ParseRules
+      module Dates
+        def self.included(klass)
+          klass.class_eval do
+            rule(:year_half) { str('yy').as(:year) }
+            rule(:year) { str('yyyy').as(:year) }
+            rule(:month_half) { str('m').as(:month) }
+            rule(:month) { str('mm').as(:month) }
+            rule(:month_3) { str('mmm').as(:month) }
+            rule(:month_4) { str('mmmm').as(:month) }
+            rule(:month_5) { str('mmmmm').as(:month) }
+            rule(:day_half) { str('d').as(:day) }
+            rule(:day) { str('dd').as(:day) }
+            rule(:weekday) { str('aaa').as(:weekday) }
+            rule(:weekday_4) { str('aaaa').as(:weekday) }
+            rule(:weekday_d) { str('ddd').as(:weekday) }
+            rule(:weekday_d_4) { str('dddd').as(:weekday) }
+
+            rule(:wareki_year_half) { str('e').as(:wareki) }
+            rule(:wareki_year) { (str('ee') | str('r')).as(:wareki) }
+            rule(:gengo) { str('g').as(:gengo) }
+            rule(:gengo_2) { (str('gg')).as(:gengo) }
+            rule(:gengo_3) { str('ggg').as(:gengo) }
+
+            rule(:gengo_wareki) { (str('gggee') | str('rr')).as(:gengo_wareki) }
+            rule(:gannen) { str('[$-ja-JP-x-gannen]').as(:gannen) }
+
+            rule(:date) do
+              (
+                year | year_half |
+                month_5 | month_4 | month_3 | month | month_half |
+                day | day_half |
+                weekday_d_4 | weekday_d | weekday_4 | weekday |
+                gengo_wareki |
+                wareki_year | wareki_year_half |
+                gengo_3 | gengo_2 | gengo |
+                gannen
+              ).as(:date)
+            end
+
+            rule(:dates) do
+              (
+                date >> (texts.maybe >> date).repeat
+              ).as(:dates)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/format_string/parse_rules/numbers.rb

@@ -0,0 +1,31 @@
+module XlsFunction
+  module FormatString
+    module ParseRules
+      module Numbers
+        def self.included(klass)
+          klass.class_eval do
+            rule(:digit_s) { str('#').as(:digit_s) }
+            rule(:digit_z) { str('0').as(:digit_z) }
+            rule(:digit_q) { str('?').as(:digit_q) }
+
+            rule(:number) { (digit_s | digit_z | digit_q).as(:number) }
+
+            rule(:suffixable) do
+              str(',').as(:string).repeat(1, 2) |
+                str('%').as(:string) |
+                str('.').as(:string)
+            end
+
+            rule(:numbers) do
+              (
+                (
+                  number >> (texts.maybe >> number).repeat
+                ) >> suffixable.maybe
+              ).as(:numbers)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/format_string/parse_rules/texts.rb

@@ -0,0 +1,25 @@
+module XlsFunction
+  module FormatString
+    module ParseRules
+      module Texts
+        def self.included(klass)
+          klass.class_eval do
+            rule(:space) { match('\s').repeat(1) }
+
+            rule(:default) { str('G/標準').as(:placeholder) }
+            rule(:placeholder) { str('@').as(:placeholder) }
+
+            rule(:escaped_string) { str('!') >> match('.').as(:string) }
+
+            rule(:string) do
+              (expr_sep | time | ampm | date | number).absent? >> any.as(:string)
+            end
+
+            rule(:text) { (escaped_string | placeholder | default | string).as(:text) }
+            rule(:texts) { text.repeat(1).as(:texts) }
+          end
+        end
+      end
+    end
+  end
+end