xls_function 0.1.0

data/lib/xls_function/evaluators/function_evaluator.rb

@@ -0,0 +1,133 @@
+module XlsFunction
+  module Evaluators
+    class FunctionEvaluator
+      include Evaluable
+      include ArgumentsDefinable
+      include ErrorDetector
+      include ClassDictionary
+
+      using ::XlsFunction::Extensions::ArrayExtension
+      using ::XlsFunction::Extensions::HashExtension
+
+      def initialize(context)
+        @context = context
+      end
+
+      def arg_list
+        @arg_list ||= Array(context[:arglist])
+      end
+
+      # @override
+      def evaluate(runtime_context = nil)
+        rescue_with StandardError do
+          merge_context(runtime_context) do
+            before_eval
+            # Don't evaluate when returns error
+            return error_value if error?
+
+            eval_or_map_eval
+          end
+        end
+      end
+
+      def before_eval
+        eval_arglist
+      end
+
+      def eval_arglist
+        definitions = self.class.arg_definitions
+        return if definitions.empty?
+
+        definitions.zip(arg_list).each do |(name, default, type), arg|
+          value = arg ? evaluate_or_self(arg) : default
+          value = convert_to(value, type)
+          instance_variable_set(:"@#{name}", value)
+          detect_error(value)
+          break if error?
+        end
+      end
+
+      def evaluate_or_self(arg)
+        arg.respond_to?(:evaluate) ? arg.evaluate(context) : arg
+      end
+
+      def convert_to(value, type)
+        return value unless type
+
+        succeed, result = XlsFunction::Converter.try_convert_to(type, value)
+        succeed ? result : XlsFunction::ErrorValue.value!(class_info(result))
+      end
+
+      def eval_or_map_eval
+        args = defined_args
+        if args.any? { |arg| arg.is_a?(Array) }
+          map_eval(args)
+        else
+          eval
+        end
+      end
+
+      def map_eval(args)
+        arg_array = args.map { |x| Array(x) }
+                        .then { |xs| xs.length == 1 ? xs : xs[0].product(*xs[1..]) }
+        return XlsFunction::ErrorValue.na(class_info(error_message(:invalid_value_for_function))) if arg_array.max_depth > 2
+
+        arg_array.map do |arg|
+          to_proc.call(*arg) # Executes each created arguments as argument of self.
+        end
+      end
+
+      def detect_error(value)
+        return unless value.is_a?(XlsFunction::ErrorValue)
+
+        @error_value = value
+      end
+
+      def error?
+        !!error_value
+      end
+
+      def variant_context
+        context[:variants]
+      end
+
+      def to_proc
+        self.class.to_proc(context)
+      end
+
+      def error_message(key, **placeholders)
+        I18n.t("xls_function.errors.#{key}", **placeholders)
+      end
+
+      class << self
+        alias function_as register_dictionary
+
+        def create(context)
+          new(context)
+        end
+
+        def to_h
+          {
+            class: name,
+            proc: to_proc,
+            description: translated_description
+          }
+        end
+
+        def translated_description
+          I18n.t("xls_function.descriptions.#{@register_key}", default: @description)
+        end
+
+        def to_proc(context = {})
+          proc do |*arglist|
+            new(arglist, context).evaluate
+          end
+        end
+      end
+    end
+  end
+end
+
+Dir[File.expand_path('functions', __dir__) << '/*.rb'].sort.each do |file|
+  require file
+end

data/lib/xls_function/evaluators/functions/and.rb

@@ -0,0 +1,21 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class And < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :and
+
+        def eval_arglist
+          # Skip common argument evaluation and assignment for short-circuit
+        end
+
+        def eval
+          arg_list.each do |arg|
+            return false unless arg.evaluate(context)
+          end
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/asc.rb

@@ -0,0 +1,17 @@
+require 'nkf'
+
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Asc < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :asc
+
+        define_arg :source
+
+        def eval
+          NKF.nkf('-w -Z4 -x --ic=UTF-8 --oc=UTF-8', source)
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/char.rb

@@ -0,0 +1,19 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Char < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :char
+
+        define_arg :number
+
+        def eval
+          return '' unless number.respond_to?(:to_i)
+
+          number.to_i.chr
+        rescue RangeError => e
+          e.message
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/clean.rb

@@ -0,0 +1,22 @@
+require 'nkf'
+
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Clean < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :clean
+
+        define_arg :source
+
+        TARGET_CHARS = (0..31).map(&:chr).join
+        # Remove nonprinting characters in the Unicode character set.
+        TARGET_CHARS_UNI = [127, 129, 141, 143, 144, 157].map { |n| n.chr(Encoding::UTF_8) }.join
+
+        def eval
+          s = source.delete(TARGET_CHARS)
+          s.delete!(TARGET_CHARS_UNI) || s
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/code.rb

@@ -0,0 +1,18 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Code < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :code
+
+        define_arg :source
+
+        def eval
+          s = source.to_s
+          return if s.empty?
+
+          s.ord
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Concat < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :concat
+
+        MAX_ARGUMENTS_COUNT = 253
+        MAX_ARGUMENTS_COUNT.times do |n|
+          text_name = :"text#{n + 1}"
+          define_arg text_name
+        end
+
+        def text_of(number)
+          send(:"text#{number}")
+        end
+
+        def eval
+          arr = Array.new(MAX_ARGUMENTS_COUNT) do |index|
+            text_of(index + 1)
+          end
+
+          arr.compact.join
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/date.rb

@@ -0,0 +1,57 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class DateFn < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :date
+
+        define_arg :year
+        define_arg :month
+        define_arg :day
+
+        using ::XlsFunction::Extensions::DateExtension
+
+        def eval
+          return ::XlsFunction::ErrorValue.num!(out_of_range) if year_i >= 10_000
+
+          date = Date.new(year_value, 1, 1)
+          date >>= month_value
+          date += day_value
+
+          date_value = date.to_serial
+          return ::XlsFunction::ErrorValue.num!(out_of_range) if date_value.negative?
+
+          date_value
+        end
+
+        def year_value
+          year_i >= 1900 ? year_i : year_i + 1900
+        end
+
+        def month_value
+          month_i - 1
+        end
+
+        def day_value
+          day_i - 1
+        end
+
+        def year_i
+          @year_i ||= year.to_i
+        end
+
+        def month_i
+          @month_i ||= month.to_i
+        end
+
+        def day_i
+          @day_i ||= day.to_i
+        end
+
+        def out_of_range
+          message = error_message(:out_of_range, value: "#{year}, #{month}, #{day}")
+          class_info(message)
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/date_value.rb

@@ -0,0 +1,17 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Datevalue < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :datevalue
+
+        define_arg :date_value, type: :date
+
+        using XlsFunction::Extensions::DateExtension
+
+        def eval
+          date_value.to_serial
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/day.rb

@@ -0,0 +1,15 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Day < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :day
+
+        define_arg :date_value, type: :date
+
+        def eval
+          date_value.day
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/dbcs.rb

@@ -0,0 +1,18 @@
+require 'nkf'
+
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Dbcs < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :dbcs
+
+        define_arg :source
+
+        def eval
+          NKF.nkf('-w -X --ic=UTF-8 --oc=UTF-8', source)
+             .tr('A-Z0-9', 'Ａ-Ｚ０-９')
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/e_date.rb

@@ -0,0 +1,19 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class EDate < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :edate
+
+        define_arg :date_value, type: :date
+        define_arg :month, type: :number
+
+        using XlsFunction::Extensions::DateExtension
+
+        def eval
+          new_date = date_value >> month.to_i
+          new_date.to_serial
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/e_o_month.rb

@@ -0,0 +1,20 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class EOMonth < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :eomonth
+
+        define_arg :date_value, type: :date
+        define_arg :month, type: :number
+
+        using XlsFunction::Extensions::DateExtension
+
+        def eval
+          new_date = date_value >> month.to_i
+          last_date_of_month = Date.new(new_date.year, new_date.month, -1)
+          last_date_of_month.to_serial
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/exact.rb

@@ -0,0 +1,16 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Exact < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :exact
+
+        define_arg :source_1
+        define_arg :source_2
+
+        def eval
+          source_1 == source_2
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/find.rb

@@ -0,0 +1,28 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Find < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :find
+
+        define_arg :find_text
+        define_arg :within_text
+        define_arg :start, default: 1
+
+        def eval
+          index = within_text.index(find_text, start - 1)
+
+          if index
+            index + 1
+          else
+            ::XlsFunction::ErrorValue.value!(missing_target)
+          end
+        end
+
+        def missing_target
+          message = error_message(:missing_target, source: within_text, target: find_text)
+          class_info(message)
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/fixed.rb

@@ -0,0 +1,46 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Fixed < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :fixed
+
+        define_arg :number
+        define_arg :digits, default: 2
+        define_arg :no_format, default: false
+        define_arg :delimiter, default: ','
+        define_arg :separator, default: '.'
+
+        DELIMITER_REGEX = /(\d)(?=(\d\d\d)+(?!\d))/.freeze
+
+        def eval
+          rounded = round
+
+          if no_format
+            rounded.to_s
+          else
+            delimit(rounded)
+          end
+        end
+
+        def round
+          n = number.round(digits)
+          if digits.positive?
+            n.to_f
+          else
+            n.to_i
+          end
+        end
+
+        def delimit(num)
+          i, f = num.to_s.split('.')
+          i.gsub!(DELIMITER_REGEX) do |digit|
+            "#{digit}#{delimiter}"
+          end
+
+          [i, f].compact
+                .join(separator)
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/hour.rb

@@ -0,0 +1,15 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Hour < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :hour
+
+        define_arg :time_value, type: :time
+
+        def eval
+          time_value.hour
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/if.rb

@@ -0,0 +1,24 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class If < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :if
+
+        define_arg :condition
+        define_arg :if_true
+        define_arg :if_false
+
+        def eval_arglist
+          # Skip common argument evaluation and assignment for short-circuit
+          @condition = arg_list[0]
+          @if_true = arg_list[1]
+          @if_false = arg_list[2]
+        end
+
+        def eval
+          condition.evaluate(context) ? if_true.evaluate(context) : if_false.evaluate(context)
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/ifs.rb

@@ -0,0 +1,20 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Ifs < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :ifs
+
+        def eval_arglist
+          # Skip common argument evaluation and assignment for short-circuit
+        end
+
+        def eval
+          # Return the first result expr is true
+          arg_list.each_slice(2) do |expr, value|
+            return value&.evaluate(context) if expr&.evaluate(context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/int.rb

@@ -0,0 +1,15 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Int < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :int
+
+        define_arg :number, type: :number
+
+        def eval
+          number.floor(0).to_d
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/iserror.rb

@@ -0,0 +1,20 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Iserror < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :iserror
+
+        define_arg :value
+
+        def eval
+          value.is_a?(::XlsFunction::ErrorValue)
+        end
+
+        # return false to avoid skip eval
+        def error?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/isnumber.rb

@@ -0,0 +1,15 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Isnumber < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :isnumber
+
+        define_arg :source
+
+        def eval
+          source.is_a?(Numeric)
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/evaluators/functions/lambda.rb

@@ -0,0 +1,57 @@
+module XlsFunction
+  module Evaluators
+    module Functions
+      class Lambda < ::XlsFunction::Evaluators::FunctionEvaluator
+        function_as :lambda
+
+        def eval_arglist
+          # Skip common argument evaluation and assignment
+        end
+
+        def eval
+          # arguments at lambda
+          # the last one is calculation
+          calculation = arg_list.pop
+          # returns as anonymous class
+          klass = Class.new(Function)
+
+          klass.define_singleton_method(:create) do |context|
+            klass.new(context, calculation)
+          end
+
+          # define variant as argument
+          arg_list.each do |variant|
+            klass.define_arg variant.name.to_sym
+          end
+
+          klass
+        end
+
+        class Function < ::XlsFunction::Evaluators::FunctionEvaluator
+          # use in lambda
+          attr_reader :calculation
+
+          def initialize(context, calculation)
+            super(context)
+            @calculation = calculation
+          end
+
+          def eval_arglist
+            super
+            return if error?
+
+            # set to variant
+            self.class.arg_definitions.each do |name, _default, _type|
+              variant_context[name.to_s] = instance_variable_get("@#{name}")
+            end
+          end
+
+          def eval
+            # run with composed context
+            calculation.evaluate(context)
+          end
+        end
+      end
+    end
+  end
+end