hayadentaku 3.5.7

data/lib/dentaku/ast/arithmetic.rb

@@ -0,0 +1,292 @@
+require_relative './operation'
+require_relative '../date_arithmetic'
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module Dentaku
+  module AST
+    class Arithmetic < Operation
+      DECIMAL = /\A-?\d*\.\d+\z/.freeze
+      INTEGER = /\A-?\d+\z/.freeze
+
+      def initialize(*)
+        super
+
+        unless valid_left?
+          raise NodeError.new(:incompatible, left.type, :left),
+                "#{self.class} requires operands that are numeric or compatible types, not #{left.type}"
+        end
+
+        unless valid_right?
+          raise NodeError.new(:incompatible, right.type, :right),
+                "#{self.class} requires operands that are numeric or compatible types, not #{right.type}"
+        end
+      end
+
+      def type
+        :numeric
+      end
+
+      def operator
+        raise NotImplementedError
+      end
+
+      def value(context = {})
+        calculate(left.value(context), right.value(context))
+      end
+
+      private
+
+      def calculate(left_value, right_value)
+        l = cast(left_value)
+        r = cast(right_value)
+
+        l.public_send(operator, r)
+      rescue ::TypeError => e
+        # Right cannot be converted to a suitable type for left. e.g. [] + 1
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: r, for: l.class), e.message
+      end
+
+      def cast(val)
+        validate_value(val)
+        numeric(val)
+      end
+
+      # Coerce a value to its preferred numeric form (Integer or BigDecimal).
+      # Fast paths for the already-numeric types skip the otherwise-mandatory
+      # `val.to_s + regex` round-trip the previous implementation did on every
+      # operand of every arithmetic op.
+      def numeric(val)
+        case val
+        when Integer    then val
+        when BigDecimal then val
+        when Float      then decimal(val)
+        when String
+          if DECIMAL.match?(val)
+            decimal(val)
+          elsif INTEGER.match?(val)
+            val.to_i
+          else
+            val
+          end
+        else
+          # Fall back to the string-based check for exotic Numeric subclasses
+          # (e.g. Rational, Complex) whose to_s happens to look numeric.
+          s = val.to_s
+          case s
+          when DECIMAL then decimal(val)
+          when INTEGER then val.to_i
+          else val
+          end
+        end
+      end
+
+      def decimal(val)
+        case val
+        when BigDecimal then val
+        when String     then BigDecimal(val, Float::DIG + 1)
+        else BigDecimal(val.to_s, Float::DIG + 1)
+        end
+      rescue # return as is, in case value can't be coerced to big decimal
+        val
+      end
+
+      def datetime?(val)
+        # val is a Date, Time, or DateTime
+        return true if val.respond_to?(:strftime)
+        return false unless val.is_a?(::String)
+
+        val =~ Dentaku::TokenScanner::DATE_TIME_REGEXP
+      end
+
+      def valid_node?(node)
+        return false unless node
+
+        # Allow nodes with dependencies (identifiers that will be resolved later)
+        return true if node.dependencies.any?
+
+        # Allow compatible types
+        return true if [:numeric, :integer, :array].include?(node.type)
+
+        # Allow nodes without a type (operations, groupings)
+        return true if node.type.nil?
+
+        # Reject incompatible types
+        false
+      end
+
+      def valid_left?
+        valid_node?(left) || left.type == :datetime
+      end
+
+      def valid_right?
+        valid_node?(right) || right.type == :duration || right.type == :datetime
+      end
+
+      def validate_value(val)
+        if val.is_a?(::String)
+          validate_format(val)
+        else
+          validate_operation(val)
+        end
+      end
+
+      def validate_operation(val)
+        unless val.respond_to?(operator)
+          raise Dentaku::ArgumentError.for(:invalid_operator, operation: self.class, operator: operator),
+                "#{ self.class } requires operands that respond to #{operator}"
+        end
+      end
+
+      def validate_format(string)
+        unless string =~ /\A-?\d*(\.\d+)?\z/ && !string.empty?
+          raise Dentaku::ArgumentError.for(:invalid_value, value: string, for: BigDecimal),
+                "String input '#{string}' is not coercible to numeric"
+        end
+      end
+    end
+
+    class Addition < Arithmetic
+      def operator
+        :+
+      end
+
+      def self.precedence
+        10
+      end
+
+      def value(context = {})
+        left_value = left.value(context)
+        right_value = right.value(context)
+
+        if left.type == :datetime || datetime?(left_value)
+          Dentaku::DateArithmetic.new(left_value).add(right_value)
+        else
+          calculate(left_value, right_value)
+        end
+      end
+    end
+
+    class Subtraction < Arithmetic
+      def operator
+        :-
+      end
+
+      def self.precedence
+        10
+      end
+
+      def value(context = {})
+        left_value = left.value(context)
+        right_value = right.value(context)
+
+        if left.type == :datetime || datetime?(left_value)
+          Dentaku::DateArithmetic.new(left_value).sub(right_value)
+        else
+          calculate(left_value, right_value)
+        end
+      end
+    end
+
+    class Multiplication < Arithmetic
+      def operator
+        :*
+      end
+
+      def self.precedence
+        20
+      end
+    end
+
+    class Division < Arithmetic
+      def operator
+        :/
+      end
+
+      def value(context = {})
+        r = decimal(cast(right.value(context)))
+        raise Dentaku::ZeroDivisionError if r.zero?
+
+        cast(cast(left.value(context)) / r)
+      end
+
+      def self.precedence
+        20
+      end
+    end
+
+    class Modulo < Arithmetic
+      def self.arity
+        2
+      end
+
+      def self.precedence
+        20
+      end
+
+      def self.resolve_class(next_token)
+        next_token.nil? || next_token.operator? || next_token.close? ? Percentage : self
+      end
+
+      def operator
+        :%
+      end
+
+      def value(context = {})
+        r = decimal(cast(right.value(context)))
+        raise Dentaku::ZeroDivisionError if r.zero?
+
+        cast(cast(left.value(context)) % r)
+      end
+    end
+
+    class Percentage < Arithmetic
+      def self.arity
+        1
+      end
+
+      def initialize(child)
+        @left = child
+
+        unless valid_left?
+          raise NodeError.new(:numeric, left.type, :left),
+                "#{self.class} requires a numeric operand"
+        end
+      end
+
+      def dependencies(context = {})
+        @left.dependencies(context)
+      end
+
+      def value(context = {})
+        cast(left.value(context)) * 0.01
+      end
+
+      def operator
+        :%
+      end
+
+      def operator_spacing
+        ""
+      end
+
+      def self.precedence
+        30
+      end
+    end
+
+    class Exponentiation < Arithmetic
+      def operator
+        :**
+      end
+
+      def display_operator
+        "^"
+      end
+
+      def self.precedence
+        30
+      end
+    end
+  end
+end

data/lib/dentaku/ast/array.rb

@@ -0,0 +1,38 @@
+require_relative "./node"
+
+module Dentaku
+  module AST
+    class Array < Node
+      def self.arity
+      end
+
+      def self.min_param_count
+        0
+      end
+
+      def self.max_param_count
+        Float::INFINITY
+      end
+
+      def initialize(*elements)
+        @elements = *elements
+      end
+
+      def value(context = {})
+        @elements.map { |el| el.value(context) }
+      end
+
+      def dependencies(context = {})
+        @elements.flat_map { |el| el.dependencies(context) }
+      end
+
+      def type
+        nil
+      end
+
+      def accept(visitor)
+        visitor.visit_array(self)
+      end
+    end
+  end
+end

data/lib/dentaku/ast/bitwise.rb

@@ -0,0 +1,42 @@
+require_relative './operation'
+
+module Dentaku
+  module AST
+    class Bitwise < Operation
+      def value(context = {})
+        left_value = left.value(context)
+        right_value = right.value(context)
+
+        left_value.public_send(operator, right_value)
+      rescue NoMethodError => e
+        raise Dentaku::ArgumentError.for(:invalid_operator, value: left_value, for: left_value.class)
+      rescue TypeError => e
+        raise Dentaku::ArgumentError.for(:invalid_operator, value: right_value, for: right_value.class)
+      end
+    end
+
+    class BitwiseOr < Bitwise
+      def operator
+        :|
+      end
+    end
+
+    class BitwiseAnd < Bitwise
+      def operator
+        :&
+      end
+    end
+
+    class BitwiseShiftLeft < Bitwise
+      def operator
+        :<<
+      end
+    end
+
+    class BitwiseShiftRight < Bitwise
+      def operator
+        :>>
+      end
+    end
+  end
+end

data/lib/dentaku/ast/case/case_conditional.rb

@@ -0,0 +1,38 @@
+require 'dentaku/exceptions'
+
+module Dentaku
+  module AST
+    class CaseConditional < Node
+      attr_reader :when,
+                  :then
+
+      def self.min_param_count
+        2
+      end
+
+      def self.max_param_count
+        2
+      end
+
+      def initialize(when_statement, then_statement)
+        @when = when_statement
+        unless @when.is_a?(AST::CaseWhen)
+          raise ParseError.for(:node_invalid), 'Expected first argument to be a CaseWhen'
+        end
+
+        @then = then_statement
+        unless @then.is_a?(AST::CaseThen)
+          raise ParseError.for(:node_invalid), 'Expected second argument to be a CaseThen'
+        end
+      end
+
+      def dependencies(context = {})
+        @when.dependencies(context) + @then.dependencies(context)
+      end
+
+      def accept(visitor)
+        visitor.visit_case_conditional(self)
+      end
+    end
+  end
+end

data/lib/dentaku/ast/case/case_else.rb

@@ -0,0 +1,35 @@
+module Dentaku
+  module AST
+    class CaseElse < Node
+      attr_reader :node
+
+      def initialize(node)
+        @node = node
+      end
+
+      def value(context = {})
+        @node.value(context)
+      end
+
+      def dependencies(context = {})
+        @node.dependencies(context)
+      end
+
+      def self.arity
+        1
+      end
+
+      def self.min_param_count
+        1
+      end
+
+      def self.max_param_count
+        1
+      end
+
+      def accept(visitor)
+        visitor.visit_else(self)
+      end
+    end
+  end
+end

data/lib/dentaku/ast/case/case_switch_variable.rb

@@ -0,0 +1,35 @@
+module Dentaku
+  module AST
+    class CaseSwitchVariable < Node
+      attr_reader :node
+
+      def initialize(node)
+        @node = node
+      end
+
+      def value(context = {})
+        @node.value(context)
+      end
+
+      def dependencies(context = {})
+        @node.dependencies(context)
+      end
+
+      def self.arity
+        1
+      end
+
+      def self.min_param_count
+        1
+      end
+
+      def self.max_param_count
+        1
+      end
+
+      def accept(visitor)
+        visitor.visit_switch(self)
+      end
+    end
+  end
+end

data/lib/dentaku/ast/case/case_then.rb

@@ -0,0 +1,35 @@
+module Dentaku
+  module AST
+    class CaseThen < Node
+      attr_reader :node
+
+      def initialize(node)
+        @node = node
+      end
+
+      def value(context = {})
+        @node.value(context)
+      end
+
+      def dependencies(context = {})
+        @node.dependencies(context)
+      end
+
+      def self.arity
+        1
+      end
+
+      def self.min_param_count
+        1
+      end
+
+      def self.max_param_count
+        1
+      end
+
+      def accept(visitor)
+        visitor.visit_then(self)
+      end
+    end
+  end
+end

data/lib/dentaku/ast/case/case_when.rb

@@ -0,0 +1,39 @@
+module Dentaku
+  module AST
+    class CaseWhen < Operation
+      attr_reader :node
+
+      def initialize(node)
+        @node = node
+      end
+
+      def value(context = {})
+        @node.value(context)
+      end
+
+      def dependencies(context = {})
+        @node.dependencies(context)
+      end
+
+      def self.arity
+        1
+      end
+
+      def self.min_param_count
+        1
+      end
+
+      def self.max_param_count
+        1
+      end
+
+      def accept(visitor)
+        visitor.visit_when(self)
+      end
+
+      def to_s
+        'WHEN'
+      end
+    end
+  end
+end

data/lib/dentaku/ast/case.rb

@@ -0,0 +1,93 @@
+require_relative './case/case_conditional'
+require_relative './case/case_when'
+require_relative './case/case_then'
+require_relative './case/case_switch_variable'
+require_relative './case/case_else'
+require 'dentaku/exceptions'
+
+module Dentaku
+  module AST
+    # Examples of using in a formula:
+    #
+    #     CASE x WHEN 1 THEN 2 WHEN 3 THEN 4 ELSE END
+    #
+    #     CASE fruit
+    #     WHEN 'apple'
+    #       THEN 1 * quantity
+    #     WHEN 'banana'
+    #       THEN 2 * quantity
+    #     ELSE
+    #       3 * quantity
+    #     END
+    class Case < Node
+      attr_reader :switch, :conditions, :else
+
+      def self.min_param_count
+        2
+      end
+
+      def self.max_param_count
+        Float::INFINITY
+      end
+
+      def initialize(*nodes)
+        @switch = nodes.shift
+
+        unless @switch.is_a?(AST::CaseSwitchVariable)
+          raise ParseError.for(:node_invalid), 'Case missing switch variable'
+        end
+
+        @conditions = nodes
+
+        @else = nil
+        @else = @conditions.pop if @conditions.last.is_a?(AST::CaseElse)
+
+        @conditions.each do |condition|
+          unless condition.is_a?(AST::CaseConditional)
+            raise ParseError.for(:node_invalid), "#{condition} is not a CaseConditional"
+          end
+        end
+      end
+
+      def value(context = {})
+        switch_value = @switch.value(context)
+        @conditions.each do |condition|
+          if condition.when.value(context) == switch_value
+            return condition.then.value(context)
+          end
+        end
+
+        if @else
+          return @else.value(context)
+        else
+          raise ArgumentError.for(:invalid_value), "No block matched the switch value '#{switch_value}'"
+        end
+      end
+
+      def dependencies(context = {})
+        # TODO: should short-circuit
+        switch_dependencies(context) +
+        condition_dependencies(context) +
+        else_dependencies(context)
+      end
+
+      def accept(visitor)
+        visitor.visit_case(self)
+      end
+
+      private
+
+      def switch_dependencies(context = {})
+        @switch.dependencies(context)
+      end
+
+      def condition_dependencies(context = {})
+        @conditions.flat_map { |condition| condition.dependencies(context) }
+      end
+
+      def else_dependencies(context = {})
+        @else ? @else.dependencies(context) : []
+      end
+    end
+  end
+end

data/lib/dentaku/ast/combinators.rb

@@ -0,0 +1,50 @@
+require_relative './operation'
+
+module Dentaku
+  module AST
+    class Combinator < Operation
+      def initialize(*)
+        super
+
+        unless valid_node?(left)
+          raise NodeError.new(:logical, left.type, :left),
+                "#{self.class} requires logical operands"
+        end
+        unless valid_node?(right)
+          raise NodeError.new(:logical, right.type, :right),
+                "#{self.class} requires logical operands"
+        end
+      end
+
+      def type
+        :logical
+      end
+
+      private
+
+      def valid_node?(node)
+        node && (node.dependencies.any? || node.type == :logical)
+      end
+    end
+
+    class And < Combinator
+      def operator
+        :and
+      end
+
+      def value(context = {})
+        left.value(context) && right.value(context)
+      end
+    end
+
+    class Or < Combinator
+      def operator
+        :or
+      end
+
+      def value(context = {})
+        left.value(context) || right.value(context)
+      end
+    end
+  end
+end