xls_function 0.1.0

data/lib/xls_function/converters/time_converter.rb

@@ -0,0 +1,158 @@
+module XlsFunction
+  module Converters
+    module TimeConverter
+      class << self
+        def try_convert(time_value)
+          [true, convert(time_value)]
+        rescue ArgumentError
+          [false, invalid_time(time_value)]
+        end
+
+        def invalid_time(time_value)
+          I18n.t('xls_function.errors.cannot_convert_to_time', source: time_value)
+        end
+
+        def convert(input)
+          case input
+          when Time
+            input
+          when Date
+            input.to_time
+          when BigDecimal
+            NumberConverter.decimal_to_time(input)
+          when Numeric
+            Time.at(input)
+          else
+            parse(input)
+          end
+        end
+
+        # @param [object] input
+        # @param [Hash] cache context
+        def convert_with_cache(input, cache)
+          cache[:cache_convert_time] ||= {}
+          cache[:cache_convert_time][input] ||= convert(input)
+        end
+
+        FORMAT_MAP = {
+          'yyyy' => '%Y',
+          'yy' => '%y',
+          'm' => '%m',
+          'mm' => '%m',
+          'mmm' => '%b',
+          'mmmm' => '%B',
+          'mmmmm' => '%B',
+          'd' => '%d',
+          'dd' => '%d',
+          'aaa' => '%w',
+          'aaaa' => '%w',
+          'ddd' => '%a',
+          'dddd' => '%A',
+          'e' => '%Jg',
+          'ee' => '%Jg',
+          'r' => '%Jg',
+          'g' => '%Je',
+          'gg' => '%Je',
+          'ggg' => '%Je',
+          'hh' => '%H',
+          'h' => '%H',
+          'M' => '%M',
+          'MM' => '%M',
+          's' => '%S',
+          'ss' => '%S',
+          '.0' => '%1N',
+          '.00' => '%2N',
+          '.000' => '%3N'
+        }.freeze
+
+        def convert_format(format, ampm_mode: false)
+          mapped = FORMAT_MAP[format]
+          mapped = '%I' if mapped == '%H' && ampm_mode
+          raise NotImplementedError, "#{format} is not supported" unless mapped
+
+          mapped
+        end
+
+        WEEKDAYS_JP = %w[日 月 火 水 木 金 土].freeze
+
+        def convert_weekday_jp(week_index)
+          WEEKDAYS_JP[week_index]
+        end
+
+        WAREKI_ALPHABETS = {
+          '明治' => 'M',
+          '大正' => 'T',
+          '昭和' => 'S',
+          '平成' => 'H',
+          '令和' => 'R'
+        }.freeze
+
+        def convert_wareki_to_alphabet(gengo)
+          WAREKI_ALPHABETS[gengo] || ''
+        end
+
+        # Accepts elapsed time expression that Time.parse cannot parse.
+        def parse(date, now = Time.now, &block)
+          Time.parse(date, now, &block)
+        rescue ArgumentError
+          result = fix_elapsed_time(date, now)
+          raise if result == :throw
+
+          Time.parse(result, now, &block)
+        end
+
+        def fix_elapsed_time(time_value, now)
+          h = Date._parse(time_value)
+          return :throw if h.key?(:yday) # give up when yday exists.
+          return :throw if !h.key?(:sec) && !h.key?(:min) && !h.key?(:hour) # give up when not elapsed time expression.
+
+          time_str, elapsed_day = fixed_time_str(h)
+          date_str = fixed_date_str(h, now, elapsed_day)
+          "#{date_str} #{time_str}"
+        end
+
+        def fixed_time_str(parsed)
+          sec = parsed.fetch(:sec, 0)
+          min = parsed.fetch(:min, 0)
+          hour = parsed.fetch(:hour, 0)
+
+          adjusted = adjust_elapsed_time(hour, min, sec)
+
+          [
+            "#{adjusted[:hour]}:#{adjusted[:minute]}:#{adjusted[:second]}#{sec_fraction_str(parsed)}#{zone_str(parsed)}",
+            adjusted[:day]
+          ]
+        end
+
+        def fixed_date_str(parsed, now, elapsed_day)
+          year = parsed.fetch(:year, now.year)
+          month = parsed.fetch(:mon, now.month)
+          day = parsed.fetch(:mday, now.day)
+          date = Date.new(year, month, day) + elapsed_day
+
+          "#{date.year}-#{date.month}-#{date.day}"
+        end
+
+        def sec_fraction_str(parsed)
+          return '' unless parsed.key?(:sec_fraction)
+
+          ".#{(parsed[:sec_fraction] * 1000).to_i.to_s.rjust(3, '0')}"
+        end
+
+        def zone_str(parsed)
+          return '' unless parsed.key?(:zone)
+
+          " #{parsed[:zone]}"
+        end
+
+        def adjust_elapsed_time(hour, minute, second)
+          elapsed_minute, s = second.divmod(60)
+          elapsed_hour, m = (minute + elapsed_minute).divmod(60)
+          elapsed_day, h = (hour + elapsed_hour).divmod(24)
+
+          { day: elapsed_day, hour: h, minute: m, second: s }
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/converters/time_serial_converter.rb

@@ -0,0 +1,97 @@
+module XlsFunction
+  module Converters
+    module TimeSerialConverter
+      H_UNIT = (BigDecimal('1') / 24)
+      M_UNIT = (H_UNIT / 60)
+      S_UNIT = (M_UNIT / 60)
+      MS_UNIT = (S_UNIT / 1000)
+
+      ORIGIN_TIME = Time.new(1899, 12, 31, 0, 0, 0).freeze
+
+      class << self
+        def time_to_serial(time, except_date: false)
+          (except_date ? 0 : DateSerialConverter.date_to_serial(time.to_date)) +
+            (
+              hour_value_of(time) +
+              minute_value_of(time) +
+              second_value_of(time) +
+              millisecond_value_of(time)
+            ).round(15)
+        end
+
+        # @param [BigDecimal] time_serial
+        def serial_to_time(time_serial, now = ORIGIN_TIME)
+          Time.parse(TimeSerial.new(time_serial).to_s, now.to_time)
+        end
+
+        private
+
+        def hour_value_of(time)
+          time.hour * H_UNIT
+        end
+
+        def minute_value_of(time)
+          time.min * M_UNIT
+        end
+
+        def second_value_of(time)
+          time.sec * S_UNIT
+        end
+
+        def millisecond_value_of(time)
+          time.usec.to_s.rjust(6, '0')[0, 3].to_i * MS_UNIT
+        end
+      end
+
+      class TimeSerial
+        attr_reader :serial
+
+        def initialize(serial)
+          @serial = serial.frac
+        end
+
+        def hour
+          @hour ||= (serial / H_UNIT).round(15).to_i
+        end
+
+        def minute
+          @minute ||= (without_hour / M_UNIT).round(15).to_i
+        end
+
+        def second
+          @second ||= (without_hour_and_minute / S_UNIT).round(15).to_i
+        end
+
+        def millisecond
+          @millisecond ||= (without_hour_and_minute_and_second / MS_UNIT).round(15).to_i
+        end
+
+        def to_s
+          "#{pad_zero(&:hour)}:#{pad_zero(&:minute)}:#{pad_zero(&:second)}#{millisecond_suffix}"
+        end
+
+        private
+
+        def without_hour
+          serial - (H_UNIT * hour)
+        end
+
+        def without_hour_and_minute
+          without_hour - (M_UNIT * minute)
+        end
+
+        def without_hour_and_minute_and_second
+          without_hour_and_minute - (S_UNIT * second)
+        end
+
+        def pad_zero(count = 2, &block)
+          block.call(self).to_s.rjust(count, '0')
+        end
+
+        def millisecond_suffix
+          millisecond.zero? ? '' : ".#{pad_zero(3, &:millisecond)}"
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/default_logger.rb

@@ -0,0 +1,7 @@
+module XlsFunction
+  class DefaultLogger
+    def write(log)
+      pp log
+    end
+  end
+end

data/lib/xls_function/error.rb

@@ -0,0 +1,49 @@
+module XlsFunction
+  # Default Error
+  class EvaluationError < StandardError
+  end
+
+  class ErrorValue < String
+    attr_reader :error_info
+
+    def initialize(string = '', error_info = '')
+      @error_info = error_info
+      super(string)
+    end
+
+    def to_s
+      super + error_info
+    end
+
+    def error?
+      true
+    end
+
+    class << self
+      # @return #VALUE!
+      def value!(error_info = '')
+        new(ERROR_VALUE, error_info)
+      end
+
+      # @return #NUM!
+      def num!(error_info = '')
+        new(ERROR_NUM, error_info)
+      end
+
+      # @return #N/A
+      def na(error_info = '')
+        new(ERROR_NA, error_info)
+      end
+    end
+  end
+
+  ERROR_VALUE = '#VALUE!'.freeze
+  ERROR_NUM = '#NUM!'.freeze
+  ERROR_NA = '#N/A'.freeze
+
+  ERRORS = [
+    ERROR_VALUE,
+    ERROR_NUM,
+    ERROR_NA
+  ].freeze
+end

data/lib/xls_function/evaluators/arguments_definable.rb

@@ -0,0 +1,39 @@
+module XlsFunction
+  module Evaluators
+    module ArgumentsDefinable
+      def self.included(klass)
+        klass.class_eval do
+          class << self
+            def arg_definitions
+              @arg_definitions || []
+            end
+
+            def inherited(subclass)
+              super
+              subclass.instance_variable_set(:@arg_definitions, arg_definitions.dup)
+            end
+          end
+        end
+
+        klass.extend(ClassMethods)
+      end
+
+      private
+
+      def defined_args
+        self.class.arg_definitions.map do |name, _default, _type|
+          instance_variable_get("@#{name}")
+        end
+      end
+
+      module ClassMethods
+        def define_arg(name, default: nil, type: nil)
+          @arg_definitions ||= []
+
+          @arg_definitions << [name, default, type]
+          attr_reader(name)
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/binary_operation_evaluator.rb

@@ -0,0 +1,20 @@
+module XlsFunction
+  module Evaluators
+    class BinaryOperationEvaluator < FunctionEvaluator
+      define_arg :left
+      define_arg :right
+
+      class << self
+        alias operator_as register_dictionary
+
+        def create(left, right, context)
+          new(context.merge(arglist: [left, right]))
+        end
+      end
+    end
+  end
+end
+
+Dir[File.expand_path('binary_operations', __dir__) << '/*.rb'].sort.each do |file|
+  require file
+end

data/lib/xls_function/evaluators/binary_operations/add.rb

@@ -0,0 +1,13 @@
+module XlsFunction
+  module Evaluators
+    module BinaryOperations
+      class Add < ::XlsFunction::Evaluators::BinaryOperationEvaluator
+        operator_as '+'
+
+        def eval
+          left + right
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/binary_operations/concat.rb

@@ -0,0 +1,13 @@
+module XlsFunction
+  module Evaluators
+    module BinaryOperations
+      class Concat < ::XlsFunction::Evaluators::BinaryOperationEvaluator
+        operator_as '&'
+
+        def eval
+          "#{left}#{right}"
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/binary_operations/divide.rb

@@ -0,0 +1,13 @@
+module XlsFunction
+  module Evaluators
+    module BinaryOperations
+      class Divide < ::XlsFunction::Evaluators::BinaryOperationEvaluator
+        operator_as '/'
+
+        def eval
+          left / right
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/binary_operations/equal.rb

@@ -0,0 +1,13 @@
+module XlsFunction
+  module Evaluators
+    module BinaryOperations
+      class Equal < ::XlsFunction::Evaluators::BinaryOperationEvaluator
+        operator_as '='
+
+        def eval
+          left == right
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/binary_operations/greater_than.rb

@@ -0,0 +1,13 @@
+module XlsFunction
+  module Evaluators
+    module BinaryOperations
+      class GreaterThan < ::XlsFunction::Evaluators::BinaryOperationEvaluator
+        operator_as '>'
+
+        def eval
+          left > right
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/binary_operations/greater_than_or_equal_to.rb

@@ -0,0 +1,13 @@
+module XlsFunction
+  module Evaluators
+    module BinaryOperations
+      class GreaterThanOrEqualTo < ::XlsFunction::Evaluators::BinaryOperationEvaluator
+        operator_as '>='
+
+        def eval
+          left >= right
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/binary_operations/less_than.rb

@@ -0,0 +1,13 @@
+module XlsFunction
+  module Evaluators
+    module BinaryOperations
+      class LessThan < ::XlsFunction::Evaluators::BinaryOperationEvaluator
+        operator_as '<'
+
+        def eval
+          left < right
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/binary_operations/less_than_or_equal_to.rb

@@ -0,0 +1,13 @@
+module XlsFunction
+  module Evaluators
+    module BinaryOperations
+      class LessThanOrEqualTo < ::XlsFunction::Evaluators::BinaryOperationEvaluator
+        operator_as '<='
+
+        def eval
+          left <= right
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/binary_operations/multiple.rb

@@ -0,0 +1,13 @@
+module XlsFunction
+  module Evaluators
+    module BinaryOperations
+      class Multiple < ::XlsFunction::Evaluators::BinaryOperationEvaluator
+        operator_as '*'
+
+        def eval
+          left * right
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/binary_operations/not_equal.rb

@@ -0,0 +1,13 @@
+module XlsFunction
+  module Evaluators
+    module BinaryOperations
+      class NotEqual < ::XlsFunction::Evaluators::BinaryOperationEvaluator
+        operator_as '<>'
+
+        def eval
+          left != right
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/binary_operations/power.rb

@@ -0,0 +1,13 @@
+module XlsFunction
+  module Evaluators
+    module BinaryOperations
+      class Power < ::XlsFunction::Evaluators::BinaryOperationEvaluator
+        operator_as '^'
+
+        def eval
+          left**right
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/binary_operations/subtract.rb

@@ -0,0 +1,13 @@
+module XlsFunction
+  module Evaluators
+    module BinaryOperations
+      class Subtract < ::XlsFunction::Evaluators::BinaryOperationEvaluator
+        operator_as '-'
+
+        def eval
+          left - right
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/class_dictionary.rb

@@ -0,0 +1,30 @@
+module XlsFunction
+  module Evaluators
+    module ClassDictionary
+      def self.included(klass)
+        klass.class_eval do
+          class << self
+            def register_dictionary(key, value = self)
+              @register_key = key
+              dictionary[key] = value
+            end
+
+            def from_dictionary(key)
+              dictionary[key]
+            end
+
+            def description(text)
+              @description = text
+            end
+
+            private
+
+            def dictionary
+              XlsFunction.class_dictionary
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/error_detector.rb

@@ -0,0 +1,29 @@
+module XlsFunction
+  module Evaluators
+    module ErrorDetector
+      def self.included(klass)
+        klass.class_eval do
+          attr_reader :error_value
+        end
+      end
+
+      def rescue_with(error_class)
+        yield
+      rescue error_class => e
+        if XlsFunction.verbose
+          XlsFunction.logger.write(e.inspect)
+          XlsFunction.logger.write(e.backtrace)
+        end
+        ::XlsFunction::ErrorValue.value!(class_info(e.message))
+      end
+
+      def class_info(message = '')
+        "#{class_name.upcase}:#{message}"
+      end
+
+      def class_name
+        self.class.name&.split('::')&.last || 'Class'
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/evaluable.rb

@@ -0,0 +1,37 @@
+module XlsFunction
+  module Evaluators
+    module Evaluable
+      using ::XlsFunction::Extensions::HashExtension
+
+      def self.included(klass)
+        klass.class_eval do
+          attr_reader :context
+        end
+      end
+
+      def evaluate(runtime_context = nil)
+        merge_context(runtime_context) do
+          before_eval
+          eval
+        end
+      end
+
+      private
+
+      def merge_context(runtime_context = nil)
+        origin_context = context
+        @context = runtime_context.deep_merge(context) if runtime_context && runtime_context != context
+
+        yield
+      ensure
+        @context = origin_context
+      end
+
+      def before_eval; end
+
+      def eval
+        raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/false_evaluator.rb

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