xls_function 0.1.0

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

@@ -0,0 +1,55 @@
+module XlsFunction
+  module FormatString
+    module ParseRules
+      module Times
+        def self.included(klass)
+          klass.class_eval do
+            rule(:hour_half) { str('h').as(:hour) }
+            rule(:hour) { str('hh').as(:hour) }
+            rule(:minute_half) { str('m').as(:minute) }
+            rule(:minute) { str('mm').as(:minute) }
+            rule(:second_half) { str('s').as(:second) }
+            rule(:second) { str('ss').as(:second) }
+
+            # elapsed time expressions
+            rule(:hour_half_elapsed) { str('[h]').as(:hour_elapsed) }
+            rule(:hour_elapsed) { str('[hh]').as(:hour_elapsed) }
+            rule(:minute_half_elapsed) { str('[m]').as(:minute_elapsed) }
+            rule(:minute_elapsed) { str('[mm]').as(:minute_elapsed) }
+            rule(:second_half_elapsed) { str('[s]').as(:second_elapsed) }
+            rule(:second_elapsed) { str('[ss]').as(:second_elapsed) }
+
+            rule(:millisecond) { (str('.000') | str('.00') | str('.0')).as(:millisecond) }
+
+            rule(:ampm) do
+              (str('AM/PM') | str('am/pm') | str('A/P') | str('a/p')).as(:ampm)
+            end
+
+            rule(:hour_expression) { (hour_elapsed | hour_half_elapsed | hour | hour_half).capture(:hour_expr) }
+            rule(:minute_expression_core) { minute | minute_half }
+            # only mm after hh | before ss regarded as minutes.
+            # if hh captured or ss appears later, mm is minute expression.
+            rule(:minute_expression) do
+              dynamic do |_source, context|
+                minute_expression_core if context.captures[:hour_expr]
+              rescue Parslet::Scope::NotFound
+                minute_expression_core >> (texts.maybe >> second_expression).present?
+              end
+            end
+            rule(:second_expression) { (second_elapsed | second_half_elapsed | second | second_half) >> millisecond.maybe }
+
+            rule(:time) do
+              hour_expression | minute_elapsed | minute_half_elapsed | minute_expression | second_expression
+            end
+
+            rule(:times) do
+              (
+                time.as(:time) >> (texts.maybe >> time.as(:time)).repeat >> texts.maybe >> ampm.maybe
+              ).as(:times)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/format_string/parser.rb

@@ -0,0 +1,27 @@
+require 'xls_function/format_string/parse_rules/texts'
+require 'xls_function/format_string/parse_rules/numbers'
+require 'xls_function/format_string/parse_rules/dates'
+require 'xls_function/format_string/parse_rules/times'
+
+module XlsFunction
+  module FormatString
+    class Parser < Parslet::Parser
+      include ::XlsFunction::FormatString::ParseRules::Texts
+      include ::XlsFunction::FormatString::ParseRules::Numbers
+      include ::XlsFunction::FormatString::ParseRules::Dates
+      include ::XlsFunction::FormatString::ParseRules::Times
+
+      rule(:patterns) { times | dates | numbers | texts }
+      rule(:expression) { patterns.repeat }
+      rule(:sep) { str(';') }
+      rule(:expr_sep) { space.maybe >> sep >> space.maybe }
+      rule(:expressions) do
+        (expression.as(:for_plus) >> expr_sep >> expression.as(:for_minus) >> expr_sep >> expression.as(:for_zero) >> expr_sep >> expression.as(:for_string)) |
+        (expression.as(:for_plus) >> expr_sep >> expression.as(:for_minus) >> expr_sep >> expression.as(:for_zero)) |
+        (expression.as(:for_plus_and_zero) >> expr_sep >> expression.as(:for_minus)) |
+        expression.as(:for_all)
+      end
+      root(:expressions)
+    end
+  end
+end

data/lib/xls_function/format_string/transform.rb

@@ -0,0 +1,87 @@
+require 'xls_function/format_string/evaluators/number_evaluator'
+require 'xls_function/format_string/evaluators/time_evaluator'
+require 'xls_function/format_string/evaluators/elapsed_time_evaluator'
+
+require 'xls_function/format_string/transform_rules/texts'
+require 'xls_function/format_string/transform_rules/numbers'
+require 'xls_function/format_string/transform_rules/dates'
+require 'xls_function/format_string/transform_rules/times'
+
+module XlsFunction
+  module FormatString
+    class Transform < Parslet::Transform
+      include ::XlsFunction::FormatString::TransformRules::Texts
+      include ::XlsFunction::FormatString::TransformRules::Numbers
+      include ::XlsFunction::FormatString::TransformRules::Dates
+      include ::XlsFunction::FormatString::TransformRules::Times
+
+      rule(for_all: subtree(:for_all)) do
+        ->(input) do
+          result = for_all.map { |expr| expr.call(input) }.join
+          result != '' ? result : input
+        end
+      end
+
+      rule(for_plus_and_zero: subtree(:for_plus_and_zero), for_minus: subtree(:for_minus)) do
+        ->(input) do
+          try_result, value = ::XlsFunction::Converters::NumberConverter.try_convert(input)
+          return input unless try_result
+
+          result =
+            if value.negative?
+              for_minus.map { |expr| expr.call(input) }.join
+            else
+              for_plus_and_zero.map { |expr| expr.call(input) }.join
+            end
+
+          result != '' ? result : input
+        end
+      end
+
+      rule(for_plus: subtree(:for_plus), for_minus: subtree(:for_minus), for_zero: subtree(:for_zero)) do
+        ->(input) do
+          try_result, value = ::XlsFunction::Converters::NumberConverter.try_convert(input)
+          return input unless try_result
+
+          result =
+            if value.negative?
+              for_minus.map { |expr| expr.call(input) }.join
+            elsif value.zero?
+              for_zero.map { |expr| expr.call(input) }.join
+            else
+              for_plus.map { |expr| expr.call(input) }.join
+            end
+
+          result != '' ? result : input
+        end
+      end
+
+      rule(for_plus: subtree(:for_plus), for_minus: subtree(:for_minus), for_zero: subtree(:for_zero), for_string: subtree(:for_string)) do
+        ->(input) do
+          try_result, value = ::XlsFunction::Converters::NumberConverter.try_convert(input)
+          result =
+            if try_result
+              if value.negative?
+                for_minus.map { |expr| expr.call(input) }.join
+              elsif value.zero?
+                for_zero.map { |expr| expr.call(input) }.join
+              else
+                for_plus.map { |expr| expr.call(input) }.join
+              end
+            else
+              for_string.map { |expr| expr.call(input) }.join
+            end
+
+          result != '' ? result : input
+        end
+      end
+
+      def apply(obj, context = nil)
+        context ||= {}
+        context[:caches] ||= {}
+        context[:flags] ||= {}
+        super(obj, context)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+module XlsFunction
+  module FormatString
+    module TransformRules
+      module Dates
+        def self.included(klass)
+          klass.class_eval do
+            rule(year: simple(:year)) do |context|
+              ::XlsFunction::FormatString::Evaluators::TimeEvaluator.new(
+                context[:year],
+                context[:caches]
+              )
+            end
+
+            rule(month: simple(:month)) do |context|
+              ::XlsFunction::FormatString::Evaluators::TimeEvaluator.new(
+                context[:month],
+                context[:caches],
+                &:month
+              )
+            end
+
+            rule(day: simple(:day)) do |context|
+              ::XlsFunction::FormatString::Evaluators::TimeEvaluator.new(
+                context[:day],
+                context[:caches],
+                &:day
+              )
+            end
+
+            rule(weekday: simple(:weekday)) do |context|
+              ::XlsFunction::FormatString::Evaluators::TimeEvaluator.new(
+                context[:weekday],
+                context[:caches],
+                &:weekday
+              )
+            end
+
+            rule(wareki: simple(:wareki)) do |context|
+              ::XlsFunction::FormatString::Evaluators::TimeEvaluator.new(
+                context[:wareki],
+                context[:caches],
+                flags: context[:flags],
+                &:wareki
+              )
+            end
+
+            rule(gengo: simple(:gengo)) do |context|
+              ::XlsFunction::FormatString::Evaluators::TimeEvaluator.new(
+                context[:gengo],
+                context[:caches],
+                &:gengo
+              )
+            end
+
+            rule(gengo_wareki: simple(:gengo_wareki)) do |context|
+              gengo_func =
+                ::XlsFunction::FormatString::Evaluators::TimeEvaluator.new(
+                  'ggg',
+                  context[:caches],
+                  &:gengo
+                ).method(:call)
+
+              wareki_func =
+                ::XlsFunction::FormatString::Evaluators::TimeEvaluator.new(
+                  'ee',
+                  context[:caches],
+                  &:wareki
+                ).method(:call)
+
+              ->(input) do
+                gengo_func.call(input) + wareki_func.call(input)
+              end
+            end
+
+            rule(gannen: simple(:gannen)) do |context|
+              context[:flags][:gannen] = true
+              ->(_) { '' }
+            end
+
+            rule(date: subtree(:date)) do
+              ->(input) { date.call(input) }
+            end
+
+            rule(texts: subtree(:texts), date: subtree(:date)) do
+              ->(input) do
+                "#{texts.map { |expr| expr.call(input) }.join}#{date.call(input)}"
+              end
+            end
+
+            rule(dates: subtree(:dates)) do
+              ->(input) { Array(dates).flatten.map { |expr| expr.call(input) }.join }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module XlsFunction
+  module FormatString
+    module TransformRules
+      module Numbers
+        def self.included(klass)
+          klass.class_eval do
+            rule(digit_s: simple(:digit_s)) do
+              (->(input) do
+                s = input.to_s
+                s == '0' ? '' : s
+              end).tap do |p|
+                p.extend DigitConcern
+              end
+            end
+
+            rule(digit_z: simple(:digit_z)) do
+              (->(input) do
+                s = input.to_s
+                s != '' ? s : '0'
+              end).tap do |p|
+                p.extend DigitConcern
+              end
+            end
+
+            rule(digit_q: simple(:digit_q)) do
+              (->(input) do
+                s = input.to_s
+                s != '' ? s : ' '
+              end).tap do |p|
+                p.extend DigitConcern
+              end
+            end
+
+            rule(number: subtree(:number)) { number }
+
+            # 1 number and 1 suffix patterns such as '0%'
+            rule(number: subtree(:number), string: simple(:string)) do
+              [number, ->(_) { string }]
+            end
+
+            rule(texts: subtree(:texts), number: subtree(:number)) do
+              [texts, number]
+            end
+
+            rule(numbers: subtree(:numbers)) do
+              ::XlsFunction::FormatString::Evaluators::NumberEvaluator.new(Array(numbers).flatten)
+            end
+          end
+        end
+
+        module DigitConcern
+          def digits?
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module XlsFunction
+  module FormatString
+    module TransformRules
+      module Texts
+        def self.included(klass)
+          klass.class_eval do
+            rule(placeholder: simple(:placeholder)) do
+              ->(input) { input.to_s }
+            end
+
+            rule(string: simple(:string)) do
+              ->(_input) { string.to_s }
+            end
+
+            rule(text: subtree(:text)) { text }
+
+            rule(texts: subtree(:texts)) do
+              ->(input) { texts.map { |text| text.call(input) }.join }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/format_string/transform_rules/times.rb

@@ -0,0 +1,97 @@
+module XlsFunction
+  module FormatString
+    module TransformRules
+      module Times
+        def self.included(klass)
+          klass.class_eval do
+            rule(hour: simple(:hour)) do |context|
+              ::XlsFunction::FormatString::Evaluators::TimeEvaluator.new(
+                context[:hour],
+                context[:caches],
+                flags: context[:flags],
+                &:hour
+              )
+            end
+
+            rule(hour_elapsed: simple(:hour_elapsed)) do |context|
+              ::XlsFunction::FormatString::Evaluators::ElapsedTimeEvaluator.new(
+                context[:caches],
+                half: context[:hour_elapsed] == '[h]',
+                &:hour
+              )
+            end
+
+            rule(minute: simple(:minute)) do |context|
+              ::XlsFunction::FormatString::Evaluators::TimeEvaluator.new(
+                context[:minute],
+                context[:caches],
+                minute_mode: true,
+                &:minute
+              )
+            end
+
+            rule(minute_elapsed: simple(:minute_elapsed)) do |context|
+              ::XlsFunction::FormatString::Evaluators::ElapsedTimeEvaluator.new(
+                context[:caches],
+                half: context[:minute_elapsed] == '[m]',
+                &:minute
+              )
+            end
+
+            rule(second: simple(:second)) do |context|
+              ::XlsFunction::FormatString::Evaluators::TimeEvaluator.new(
+                context[:second],
+                context[:caches],
+                &:second
+              )
+            end
+
+            rule(second: simple(:second), millisecond: simple(:millisecond)) do |context|
+              ->(input) do
+                second_func = ::XlsFunction::FormatString::Evaluators::TimeEvaluator.new(
+                  context[:second],
+                  context[:caches],
+                  &:second
+                )
+                millisecond_func = ::XlsFunction::FormatString::Evaluators::TimeEvaluator.new(
+                  context[:millisecond],
+                  context[:caches]
+                )
+                "#{second_func.call(input)}.#{millisecond_func.call(input)}"
+              end
+            end
+
+            rule(second_elapsed: simple(:second_elapsed)) do |context|
+              ::XlsFunction::FormatString::Evaluators::ElapsedTimeEvaluator.new(
+                context[:caches],
+                half: context[:second_elapsed] == '[s]',
+                &:second
+              )
+            end
+
+            rule(ampm: simple(:ampm)) do |context|
+              context[:flags][:ampm] = true
+              ->(input) do
+                time = ::XlsFunction::Converters::TimeConverter.convert_with_cache(input, context[:caches])
+                am, pm = context[:ampm].to_s.split('/')
+                time.hour <= 11 ? am : pm
+              end
+            end
+
+            rule(time: subtree(:time)) { time }
+
+            rule(texts: subtree(:texts), time: subtree(:time)) do
+              ->(input) do
+                "#{texts.map { |expr| expr.call(input) }.join}#{time.call(input)}"
+              end
+            end
+
+            rule(times: subtree(:time)) do
+              ->(input) { Array(time).flatten.map { |expr| expr.call(input) }.join }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xls_function/format_string.rb

@@ -0,0 +1,24 @@
+# Parse `format_text` of TEXT function.
+# Some specifications are not supported.
+# - Exponent, Fraction
+# - Convert Chinese characters number
+# - Monospace conversion with underscore
+# - Cell width filling with asterisks
+# - Buddhist calendar
+# - Islamic calendar
+# - Text coloring
+
+require 'xls_function/format_string/parser'
+require 'xls_function/format_string/transform'
+
+module XlsFunction
+  module FormatString
+    class << self
+      def evaluate_converter(format_string, context)
+        parser = XlsFunction::FormatString::Parser.new
+        transform = XlsFunction::FormatString::Transform.new
+        transform.apply(parser.parse(format_string), context)
+      end
+    end
+  end
+end

data/lib/xls_function/i18n.rb

@@ -0,0 +1,4 @@
+require 'i18n'
+
+path = Dir["#{File.expand_path('locales', __dir__)}/*.yml"]
+I18n.load_path << path

data/lib/xls_function/locales/en.yml

@@ -0,0 +1,65 @@
+en:
+  xls_function:
+    descriptions:
+      and: AND(logical1, [logical2], ...) returns TRUE if all its arguments evaluate to TRUE, and returns FALSE if one or more arguments evaluate to FALSE.
+      asc: ASC(text) For Double-byte character set (DBCS) languages, the function changes full-width (double-byte) characters to half-width (single-byte) characters.
+      char: CHAR(number) Returns the character specified by a number.
+      clean: CLEAN(text) Removes all nonprintable characters from text.
+      code: CODE(text) Returns a numeric code for the first character in a text string.
+      concat: CONCAT(text1, [text2],…) Combines the text from multiple ranges and/or strings.
+      datevalue: DATEVALUE(date_text) Converts a date that is stored as text to a serial number that Excel recognizes as a date.
+      date: DATE(year,month,day) Returns the sequential serial number that represents a particular date.
+      day: DAY(serial_number) Returns the day of a date, represented by a serial number. The day is given as an integer ranging from 1 to 31.
+      dbcs: DBCS(text) Converts half-width (single-byte) letters within a character string to full-width (double-byte) characters. The name of the function (and the characters that it converts) depends upon your language settings.
+      edate: EDATE(start_date, months) Returns the serial number that represents the date that is the indicated number of months before or after a specified date (the start_date).
+      eomonth: EOMONTH(start_date, months) Returns the serial number for the last day of the month that is the indicated number of months before or after start_date.
+      exact: EXACT(text1, text2) Compares two text strings and returns TRUE if they are exactly the same, FALSE otherwise.
+      find: FIND(find_text, within_text, [start_num]) Locate one text string within a second text string, and return the number of the starting position of the first text string from the first character of the second text string. Always counts each character, whether single-byte or double-byte, as 1, no matter what the default language setting is.
+      fixed: FIXED(number, [decimals], [no_commas]) Rounds a number to the specified number of decimals, formats the number in decimal format using a period and commas, and returns the result as text.
+      hour: HOUR(serial_number) Returns the hour of a time value. The hour is given as an integer, ranging from 0 (12:00 A.M.) to 23 (11:00 P.M.).
+      if: IF(logical_test, value_if_true, [value_if_false]) Use the IF function to return one value if a condition is true and another value if it's false.
+      ifs: IFS(logical_test1, value_if_true1, [logical_test2, value_if_true2], [logical_test3, value_if_true3],…) Checks whether one or more conditions are met, and returns a value that corresponds to the first TRUE condition.
+      int: INT(number) Rounds a number down to the nearest integer.
+      iserror: ISERROR(value) Returns TRUE if value refers to any error value.
+      isnumber: ISNUMBER(value) Returns TRUE if value refers to a number.
+      lambda: LAMBDA([parameter1, parameter2, …,] calculation) Use a LAMBDA function to create custom, reusable functions and call them by a friendly name. *Do not use this directly.
+      left: LEFT(text, [num_chars]) Returns the first character or characters in a text string, based on the number of characters you specify.
+      len: LEN(text) Returns the number of characters in a text string.
+      let: LET(name1, name_value1, calculation_or_name2, [name_value2, calculation_or_name3...]) Assigns names to calculation results. This allows storing intermediate calculations, values, or defining names inside a formula.
+      lower: LOWER(text) Converts all uppercase letters in a text string to lowercase.
+      mid: MID(text, start_num, num_chars) Returns a specific number of characters from a text string, starting at the position you specify, based on the number of characters you specify.
+      minute: MINUTE(serial_number) Returns the minutes of a time value. The minute is given as an integer, ranging from 0 to 59.
+      month: MONTH(serial_number) Returns the month of a date represented by a serial number. The month is given as an integer, ranging from 1 (January) to 12 (December).
+      not: NOT(logical) Reverses the value of its argument.
+      now: NOW() Returns the serial number of the current date and time.
+      or: OR(logical1, [logical2], ...) Returns TRUE if any of its arguments evaluate to TRUE, and returns FALSE if all of its arguments evaluate to FALSE.
+      power: POWER(number, power) Returns the result of a number raised to a power.
+      proper: Capitalizes the first letter in a text string and any other letters in text that follow any character other than a letter. Converts all other letters to lowercase letters.
+      replace: REPLACE(old_text, start_num, num_chars, new_text) Replaces part of a text string, based on the number of characters you specify, with a different text string.
+      rept: REPT(text, number_times) Repeats text a given number of times.
+      right: RIGHT(text,[num_chars]) Returns the last character or characters in a text string, based on the number of characters you specify.
+      rounddown: ROUNDDOWN(number, num_digits) Rounds a number down, toward zero.
+      roundup: ROUNDUP(number, num_digits) Rounds a number up, away from 0 (zero).
+      round: ROUND(number, num_digits) Rounds a number to a specified number of digits.
+      second: SECOND(serial_number) Returns the seconds of a time value. The second is given as an integer in the range 0 (zero) to 59.
+      sqrt: SQRT(number) Returns a positive square root.
+      substitute: SUBSTITUTE(text, old_text, new_text, [instance_num]) Substitutes new_text for old_text in a text string.
+      text: TEXT(value, format_text) Lets you change the way a number appears by applying formatting to it with format codes.
+      time: TIME(hour, minute, second) Returns the decimal number for a particular time.
+      timevalue: TIMEVALUE(time_text) Returns the decimal number of the time represented by a text string.
+      today: TODAY() Returns the serial number of the current date.
+      trim: TRIM(text) Removes all spaces from text except for single spaces between words.
+      trunc: TRUNC(number, [num_digits]) Truncates a number to an integer by removing the fractional part of the number.
+      unichar: UNICHAR(number) Returns the Unicode character that is referenced by the given numeric value.
+      unicode: UNICODE(text) Returns the number (code point) corresponding to the first character of the text.
+      upper: UPPER(text) Converts text to uppercase.
+      value: VALUE(text) Converts a text string that represents a number to a number.
+      year: YEAR(serial_number) Returns the year corresponding to a date. The year is returned as an integer in the range 1900-9999.
+    errors:
+      out_of_range: Value is out of range. %{value}
+      missing_target: Missing %{target} in %{source}.
+      number_is_negative: "%{label} is negative. %{number}"
+      cannot_convert_to_number: Cannot convert %{source} to number.
+      cannot_convert_to_date: Cannot convert %{source} to date.
+      cannot_convert_to_time: Cannot convert %{source} to time.
+      invalid_value_for_function: Invalid value for formula or function.

data/lib/xls_function/locales/ja.yml

@@ -0,0 +1,65 @@
+ja:
+  xls_function:
+    descriptions:
+      and: AND(条件1, [条件2], ...) すべての引数が TRUE と評価された場合は TRUE を返し、1 つ以上の引数が FALSE と評価された場合は FALSE を返します。
+      asc: ASC(文字列) 2 バイト文字セット (DBCS) 言語の場合、全角 (2 バイト) 文字を半角 (1 バイト) 文字に変更します。
+      char: CHAR(数値) 数値で指定された文字を返します。
+      clean: CLEAN(文字列) 印刷できない文字を文字列からすべて削除します。
+      code: CODE(文字列) テキスト文字列内の先頭文字の数値コードを返します。
+      concat: CONCAT(テキスト1, [テキスト2],…) 複数の範囲や文字列のテキストを結合します。
+      datevalue: DATEVALUE(日付文字列) 文字列として格納された日付を、Excel で日付として認識できるシリアル値に変換します。
+      date: DATE(年,月,日) 特定の日付を表す連続したシリアル値を返します。
+      day: DAY(シリアル値) シリアル番号で表された、日付の日情報を返します。 日情報は 1 ～ 31 の範囲内の整数で示されます。
+      dbcs: DBCS(文字列) 文字列内の半角 (1 バイト) の英数カナ文字を全角 (2 バイト) の文字に変換します。
+      edate: EDATE(開始日, 月) 開始日から起算して、指定された月数だけ前または後の日付に対応するシリアル値を返します。
+      eomonth: EOMONTH(開始日, 月) 開始日から起算して、指定された月数だけ前または後の月の最終日に対応するシリアル値を返します。
+      exact: EXACT(文字列 1, 文字列 2) 2 つの文字列を比較して、まったく同じである場合は TRUE を、そうでない場合は FALSE を返します。
+      find: FIND(検索文字列, 対象, [開始位置]) 指定された文字列を他の文字列の中で検索し、その文字列が最初に現れる位置を左端から数え、その番号を返します。既定の言語の設定に関係なく、1 バイト文字も 2 バイト文字も、各文字が常に 1 つとして数えられます。
+      fixed: FIXED(数値, [桁数], [桁区切り]) 指定した桁数に四捨五入し、結果をピリオド (.) とカンマ (,) を使って書式設定した文字列に変換して返します。
+      hour: HOUR(シリアル値) 時刻から時間の値を返します。 戻り値は 0 (午前 0 時) ～ 23 (午後 11 時) の範囲の整数となります。
+      if: IF(論理式, [値が真の場合], [値が偽の場合]) IF 関数を使うと、条件が true または false の場合に、それぞれ別の値を返すことができます。
+      ifs: IFS(logical_test1, value_if_true1, [logical_test2, value_if_true2], [logical_test3, value_if_true3],…) 1 つ以上の条件が満たされているかどうかをチェックして、最初の TRUE 条件に対応する値を返します。
+      int: INT(数値) 指定された数値を最も近い整数に切り捨てます。
+      iserror: ISERROR(テストの対象) テストの対象が任意のエラー値を参照するとき TRUE を返します。
+      isnumber: ISNUMBER(テストの対象) テストの対象が数値を参照するとき TRUE を返します。
+      lambda: LAMBDA([parameter1, parameter2, ...,] 計算) LAMBDA 関数を使用して、カスタムで再利用可能な関数を作成し、フレンドリ名で呼び出します。※直接利用しないでください。
+      left: LEFT(文字列, [文字数]) 文字列の先頭から指定された数の文字を返します。
+      len: LEN(文字列) 文字列の文字数を返します。
+      let: LET (name1、name_value1、calculation_or_name2、[name_value2、calculation_or_name3...]) 計算結果に名前を割り当てます。 これにより、中間計算、値、定義名などを数式内に格納できます。
+      lower: LOWER(文字列) 文字列に含まれる英大文字をすべて小文字に変換します。
+      mid: MID(文字列, 開始位置, 文字数) 文字列の指定された位置から指定された文字数の文字を返します。
+      minute: MINUTE(シリアル値) 時刻の分を返します。 戻り値は 0 (分) ～ 59 (分) の範囲の整数となります。
+      month: MONTH(シリアル値) データに含まれる月をシリアル値で返します。 戻り値は 1 (月) ～ 12 (月) の範囲の整数となります。
+      not: NOT(論理値) 引数の値を反転させます。
+      now: NOW() 現在の日付と時刻に対応するシリアル値を返します。
+      or: OR(論理式1, [論理式2], ...) いずれかの引数が TRUE と評価された場合は TRUE を返し、すべての引数が FALSE と評価された場合は FALSE を返します。
+      power: POWER(数値, 指数) 数値のべき乗を返します。
+      proper: PROPER(文字列) 英字文字列の単語の先頭の文字、および記号の次の文字を大文字に変換します。 それ以外の英字はすべて小文字にします。
+      replace: REPLACE(文字列, 開始位置, 文字数, 置換文字列) 文字列に含まれる、指定された文字数の文字を別の文字に置き換えます。
+      rept: REPT(文字列, 繰り返し回数) 文字列を指定された回数だけ繰り返して表示します。
+      right: RIGHT(文字列,[文字数]) 文字列の末尾 (右端) から指定された文字数の文字を返します。
+      rounddown: ROUNDDOWN(数値, 桁数) 数値を指定された桁数で切り捨てます。
+      roundup: ROUNDUP(数値, 桁数) 数値を指定された桁数に切り上げます。
+      round: ROUND(数値, 桁数) 数値を四捨五入して指定された桁数にします。
+      second: SECOND(シリアル値) 時刻の秒を返します。 戻り値は 0 (秒) ～ 59 (秒) の範囲の整数となります。
+      sqrt: SQRT(数値) 正の平方根を返します。
+      substitute: SUBSTITUTE(文字列, 検索文字列, 置換文字列, [置換対象]) 文字列に含まれる検索文字列を置換文字列へ置換します。
+      text: TEXT(value, format_text) 表示形式コードを使用して数値に書式設定を適用することで、数値の表示方法を変更することができます。
+      time: TIME(時, 分, 秒) 指定した時刻に対応する小数を返します。
+      timevalue: TIMEVALUE(時刻文字列) 文字列で表された時刻を小数に変換します。
+      today: TODAY() 現在の日付に対応するシリアル値を返します。
+      trim: TRIM(文字列) 各単語間のスペースは 1 つ残し、不要なスペースをすべて削除します。
+      trunc: TRUNC(数値, [桁数]) 数値の小数部を切り捨てて、整数または指定した桁数に変換します。
+      unichar: UNICHAR(数値) 指定された数値により参照される Unicode 文字を返します。
+      unicode: UNICODE(文字列) 文字列の最初の文字に対応する番号 (コード ポイント) を返します。
+      upper: UPPER(文字列) 文字列を大文字に変換します。
+      value: VALUE(文字列) 数値を表す文字列を数値に変換します。
+      year: YEAR(シリアル値) 日付に対応する年を返します。 戻り値は、1900 (年) ～ 9999 (年) の範囲の整数となります。
+    errors:
+      out_of_range: 範囲外の値が指定されています。%{value}
+      missing_target: 文字列%{source}中に%{target}が見つかりません。
+      number_is_negative: "%{label}が負の値になっています。%{number}"
+      cannot_convert_to_number: "%{source}は数値に変換できません。"
+      cannot_convert_to_date: "%{source}は日付に変換できません。"
+      cannot_convert_to_time: "%{source}は時刻に変換できません。"
+      invalid_value_for_function: 値が数式または関数に対して無効です。

data/lib/xls_function/parse_rules/binary_operation.rb

@@ -0,0 +1,28 @@
+module XlsFunction
+  module ParseRules
+    module BinaryOperation
+      def self.included(klass)
+        klass.class_eval do
+          rule(:power_operator) { str('^').as(:operator) >> space? }
+          rule(:multiple_divide_operator) { match['*/'].as(:operator) >> space? }
+          rule(:plus_minus_opeartor) { match['+-'].as(:operator) >> space? }
+          rule(:concat_opeartor) { str('&').as(:operator) >> space? }
+          rule(:comparison_operator) { (str('>') | str('>=') | str('<') | str('<=') | str('=') | str('<>')).as(:operator) >> space? }
+
+          rule(:binary_operation) do
+            infix_expression(
+              preferred_binary_operation | single_expression,
+              [power_operator, 5, :left],
+              [multiple_divide_operator, 4, :left],
+              [plus_minus_opeartor, 3, :left],
+              [concat_opeartor, 2, :left],
+              [comparison_operator, 1, :left]
+            ) { |l, o, r| { left: l, operator: o[:operator], right: r } }
+          end
+
+          rule(:preferred_binary_operation) { lparen >> binary_operation >> rparen }
+        end
+      end
+    end
+  end
+end