decision_agent 0.2.0 → 0.3.0

data/lib/decision_agent/dmn/feel/transformer.rb

@@ -0,0 +1,372 @@
+require "parslet"
+require_relative "../errors"
+
+module DecisionAgent
+  module Dmn
+    module Feel
+      # Transforms Parslet parse tree into AST
+      class Transformer < Parslet::Transform
+        # Literals
+        rule(null: simple(:_)) { { type: :null, value: nil } }
+
+        rule(boolean: simple(:val)) do
+          { type: :boolean, value: val.to_s == "true" }
+        end
+
+        rule(number: simple(:val)) do
+          str = val.to_s
+          value = str.include?(".") ? str.to_f : str.to_i
+          { type: :number, value: value }
+        end
+
+        rule(string: simple(:val)) do
+          { type: :string, value: val.to_s }
+        end
+
+        # Argument wrapper (unwrap the arg node to get the inner expression)
+        rule(arg: subtree(:expr)) do
+          expr
+        end
+
+        # List literal
+        rule(list_literal: { list: subtree(:items) }) do
+          items_array = case items
+                        when Array then items
+                        when Hash then [items]
+                        when nil then []
+                        else [items]
+                        end
+          { type: :list_literal, elements: items_array }
+        end
+
+        # Context entry (unwrap the entry wrapper)
+        rule(entry: { key: subtree(:k), value: subtree(:v) }) do
+          { key: k, value: v }
+        end
+
+        # Context literal
+        rule(context_literal: { context: subtree(:entries) }) do
+          entries_array = case entries
+                          when Array then entries
+                          when Hash then [entries]
+                          when nil then []
+                          else [entries]
+                          end
+
+          pairs = entries_array.map do |entry|
+            # Extract key - could be a transformed field node, string node, or raw value
+            key = if entry[:key].is_a?(Hash)
+                    # Key is a structured node
+                    case entry[:key][:type]
+                    when :field
+                      entry[:key][:name].to_s
+                    when :string
+                      entry[:key][:value].to_s
+                    when :identifier
+                      entry[:key][:name].to_s
+                    else
+                      entry[:key][:identifier]&.to_s || entry[:key][:string]&.to_s || entry[:key].to_s
+                    end
+                  elsif entry[:key].is_a?(Parslet::Slice)
+                    entry[:key].to_s
+                  else
+                    entry[:key].to_s
+                  end
+
+            [key, entry[:value]]
+          end
+
+          { type: :context_literal, pairs: pairs }
+        end
+
+        # Range literal
+        rule(range: {
+               start_bracket: simple(:sb),
+               start: subtree(:s),
+               end: subtree(:e),
+               end_bracket: simple(:eb)
+             }) do
+          {
+            type: :range,
+            start: s,
+            end: e,
+            start_inclusive: sb.to_s == "[",
+            end_inclusive: eb.to_s == "]"
+          }
+        end
+
+        # Identifier
+        rule(identifier: simple(:name)) do
+          { type: :field, name: name.to_s.strip }
+        end
+
+        # Identifier or function call (with arguments)
+        rule(identifier_or_call: { name: subtree(:name), arguments: subtree(:args) }) do
+          # It's a function call
+          args_array = case args
+                       when Array then args
+                       when Hash then args.empty? ? [] : [args]
+                       when nil then []
+                       else [args]
+                       end
+
+          func_name = case name
+                      when Hash
+                        # Handle transformed field nodes or raw identifier hashes
+                        if name[:type] == :field
+                          name[:name].to_s.strip
+                        else
+                          name[:identifier]&.to_s&.strip || name.to_s
+                        end
+                      else
+                        name.to_s.strip
+                      end
+
+          {
+            type: :function_call,
+            name: func_name,
+            arguments: args_array
+          }
+        end
+
+        # Identifier or function call (just identifier, no arguments)
+        rule(identifier_or_call: { name: subtree(:name) }) do
+          # Just an identifier
+          field_name = case name
+                       when Hash
+                         name[:identifier]&.to_s&.strip || name[:type] == :field ? name[:name] : name.to_s
+                       else
+                         name.to_s.strip
+                       end
+
+          { type: :field, name: field_name }
+        end
+
+        # Comparison operations
+        rule(comparison: { left: subtree(:l), op: simple(:o), right: subtree(:r) }) do
+          {
+            type: :comparison,
+            operator: o.to_s,
+            left: l,
+            right: r
+          }
+        end
+
+        # Between expression
+        rule(between: { value: subtree(:val), min: subtree(:min), max: subtree(:max) }) do
+          {
+            type: :between,
+            value: val,
+            min: min,
+            max: max
+          }
+        end
+
+        # In expression
+        rule(in: { value: subtree(:val), list: subtree(:list) }) do
+          {
+            type: :in,
+            value: val,
+            list: list
+          }
+        end
+
+        # Instance of
+        rule(instance_of: { value: subtree(:val), type: simple(:t) }) do
+          {
+            type: :instance_of,
+            value: val,
+            type_name: t.to_s
+          }
+        end
+
+        # Arithmetic operations
+        rule(arithmetic: { left: subtree(:l), op: simple(:o), right: subtree(:r) }) do
+          {
+            type: :arithmetic,
+            operator: o.to_s,
+            left: l,
+            right: r
+          }
+        end
+
+        rule(term: { left: subtree(:l), op: simple(:o), right: subtree(:r) }) do
+          {
+            type: :arithmetic,
+            operator: o.to_s,
+            left: l,
+            right: r
+          }
+        end
+
+        rule(exponentiation: { left: subtree(:l), op: simple(:o), right: subtree(:r) }) do
+          {
+            type: :arithmetic,
+            operator: o.to_s,
+            left: l,
+            right: r
+          }
+        end
+
+        # Unary operations
+        rule(unary: { op: simple(:o), operand: subtree(:operand) }) do
+          if o.to_s == "not"
+            {
+              type: :logical,
+              operator: "not",
+              operand: operand
+            }
+          elsif o.to_s == "-" && operand.is_a?(Hash) && operand[:type] == :number
+            # Special case: unary minus on a number literal -> negative number literal
+            {
+              type: :number,
+              value: -operand[:value]
+            }
+          else
+            {
+              type: :arithmetic,
+              operator: "negate",
+              operand: operand
+            }
+          end
+        end
+
+        # Logical operations
+        rule(or: { left: subtree(:l), or_ops: subtree(:ops) }) do
+          ops_array = Array(ops)
+          # Build nested or structure
+          ops_array.reduce(l) do |left_side, op|
+            {
+              type: :logical,
+              operator: "or",
+              left: left_side,
+              right: op[:right]
+            }
+          end
+        end
+
+        rule(and: { left: subtree(:l), and_ops: subtree(:ops) }) do
+          ops_array = Array(ops)
+          # Build nested and structure
+          ops_array.reduce(l) do |left_side, op|
+            {
+              type: :logical,
+              operator: "and",
+              left: left_side,
+              right: op[:right]
+            }
+          end
+        end
+
+        # Postfix operations (property access, function calls, filters)
+        rule(postfix: { base: subtree(:base), postfix_ops: subtree(:ops) }) do
+          ops_array = Array(ops)
+          ops_array.reduce(base) do |current, op|
+            case op
+            when Hash
+              if op[:property_access]
+                {
+                  type: :property_access,
+                  object: current,
+                  property: op[:property_access][:property][:identifier].to_s
+                }
+              elsif op[:function_call]
+                {
+                  type: :function_call,
+                  name: current,
+                  arguments: op[:function_call][:arguments] || []
+                }
+              elsif op[:filter]
+                {
+                  type: :filter,
+                  list: current,
+                  condition: op[:filter][:filter]
+                }
+              else
+                current
+              end
+            else
+              current
+            end
+          end
+        end
+
+        # If-then-else conditional
+        rule(condition: subtree(:c), then_expr: subtree(:t), else_expr: subtree(:e)) do
+          {
+            type: :conditional,
+            condition: c,
+            then_expr: t,
+            else_expr: e
+          }
+        end
+
+        # Quantified expressions
+        rule(quantifier: simple(:q), var: subtree(:v), list: subtree(:l), condition: subtree(:c)) do
+          # Variable might be already transformed to a field node or still be an identifier hash
+          var_name = if v.is_a?(Hash) && v[:type] == :field
+                       v[:name]
+                     elsif v.is_a?(Hash) && v[:identifier]
+                       v[:identifier].to_s
+                     else
+                       v.to_s
+                     end
+
+          {
+            type: :quantified,
+            quantifier: q.to_s,
+            variable: var_name,
+            list: l,
+            condition: c
+          }
+        end
+
+        # For expression
+        rule(var: subtree(:v), list: subtree(:l), return_expr: subtree(:r)) do
+          # Variable might be already transformed to a field node or still be an identifier hash
+          var_name = if v.is_a?(Hash) && v[:type] == :field
+                       v[:name]
+                     elsif v.is_a?(Hash) && v[:identifier]
+                       v[:identifier].to_s
+                     else
+                       v.to_s
+                     end
+
+          {
+            type: :for,
+            variable: var_name,
+            list: l,
+            return_expr: r
+          }
+        end
+
+        # Function definition
+        rule(function_def: { params: subtree(:params), body: subtree(:body) }) do
+          params_array = case params
+                         when Array then params.map { |p| p[:param][:identifier].to_s }
+                         when Hash then [params[:param][:identifier].to_s]
+                         when nil then []
+                         else []
+                         end
+
+          {
+            type: :function_definition,
+            parameters: params_array,
+            body: body
+          }
+        end
+
+        # Helper to convert parse tree to AST
+        def self.to_ast(parse_tree)
+          new.apply(parse_tree)
+        rescue StandardError => e
+          raise FeelTransformError.new(
+            "Failed to transform parse tree to AST: #{e.message}",
+            parse_tree: parse_tree,
+            error: e
+          )
+        end
+      end
+    end
+  end
+end

data/lib/decision_agent/dmn/feel/types.rb

@@ -0,0 +1,276 @@
+require "time"
+require "date"
+require "bigdecimal"
+require_relative "../errors"
+
+module DecisionAgent
+  module Dmn
+    module Feel
+      # Type system for FEEL values
+      # Provides thin wrappers around Ruby types to maintain FEEL semantics
+      module Types
+        # Wrapper for numbers with precision tracking
+        class Number
+          attr_reader :value, :scale
+
+          def initialize(value, scale: nil)
+            @value = case value
+                     when BigDecimal then value
+                     when String then BigDecimal(value)
+                     when Integer, Float then value
+                     else
+                       raise FeelTypeError, "Cannot convert #{value.class} to Number: #{value.inspect}"
+                     end
+            @scale = scale
+          end
+
+          def to_ruby
+            @value
+          end
+
+          def to_i
+            @value.to_i
+          end
+
+          def to_f
+            @value.to_f
+          end
+
+          def ==(other)
+            return @value == other.value if other.is_a?(Number)
+
+            @value == other
+          end
+
+          def inspect
+            "#<Feel::Number #{@value}#{" (scale: #{@scale})" if @scale}>"
+          end
+        end
+
+        # Wrapper for dates (ISO 8601)
+        class Date
+          attr_reader :value
+
+          def initialize(value)
+            @value = case value
+                     when ::Time, ::Date, ::DateTime then value
+                     when String then parse_date(value)
+                     else
+                       raise FeelTypeError, "Cannot convert #{value.class} to Date: #{value.inspect}"
+                     end
+          end
+
+          def to_ruby
+            @value
+          end
+
+          def ==(other)
+            return @value == other.value if other.is_a?(Date)
+
+            @value == other
+          end
+
+          def inspect
+            "#<Feel::Date #{@value}>"
+          end
+
+          private
+
+          def parse_date(str)
+            # Try ISO 8601 formats first
+            iso_result = begin
+              ::Time.iso8601(str)
+            rescue ArgumentError
+              nil
+            end
+
+            return iso_result if iso_result
+
+            # Fall back to Date parsing
+            ::Date.parse(str).to_time
+          rescue ::Date::Error => e
+            raise FeelTypeError, "Invalid date format: #{e.message}"
+          end
+        end
+
+        # Wrapper for time values
+        class Time
+          attr_reader :value
+
+          def initialize(value)
+            @value = case value
+                     when ::Time then value
+                     when String then parse_time(value)
+                     else
+                       raise FeelTypeError.new(
+                         "Cannot convert to Time",
+                         expected_type: "Time",
+                         actual_type: value.class,
+                         value: value
+                       )
+                     end
+          end
+
+          def to_ruby
+            @value
+          end
+
+          def ==(other)
+            return @value == other.value if other.is_a?(Time)
+
+            @value == other
+          end
+
+          def inspect
+            "#<Feel::Time #{@value}>"
+          end
+
+          private
+
+          def parse_time(str)
+            # Try ISO 8601 time parsing
+            ::Time.iso8601(str)
+          rescue ArgumentError => e
+            raise FeelTypeError.new(
+              "Invalid time format: #{e.message}",
+              expected_type: "ISO 8601 time",
+              value: str
+            )
+          end
+        end
+
+        # Wrapper for durations (ISO 8601: P1Y2M3DT4H5M6S)
+        class Duration
+          attr_reader :years, :months, :days, :hours, :minutes, :seconds
+
+          def initialize(years: 0, months: 0, days: 0, hours: 0, minutes: 0, seconds: 0)
+            @years = years
+            @months = months
+            @days = days
+            @hours = hours
+            @minutes = minutes
+            @seconds = seconds
+          end
+
+          # Parse ISO 8601 duration string
+          # Examples: P1Y, P1M, P1D, PT1H, PT1M, PT1S, P1Y2M3DT4H5M6S
+          def self.parse(iso_string)
+            raise FeelTypeError, "Duration must be a string, got #{iso_string.class}" unless iso_string.is_a?(String)
+            raise FeelTypeError, "Invalid duration format: must start with 'P'" unless iso_string.start_with?("P")
+
+            # Split on 'T' to separate date and time parts
+            parts = iso_string[1..].split("T")
+            date_part = parts[0] || ""
+            time_part = parts[1] || ""
+
+            duration_attrs = {}
+
+            # Parse date part (Y, M, D)
+            duration_attrs[:years] = extract_unit(date_part, "Y")
+            duration_attrs[:months] = extract_unit(date_part, "M")
+            duration_attrs[:days] = extract_unit(date_part, "D")
+
+            # Parse time part (H, M, S)
+            duration_attrs[:hours] = extract_unit(time_part, "H")
+            duration_attrs[:minutes] = extract_unit(time_part, "M")
+            duration_attrs[:seconds] = extract_unit(time_part, "S")
+
+            new(**duration_attrs)
+          end
+
+          # Convert to total seconds (approximation for date parts)
+          def to_seconds
+            total = @seconds
+            total += @minutes * 60
+            total += @hours * 3600
+            total += @days * 86_400
+            total += @months * 2_592_000 # 30 days average
+            total += @years * 31_536_000 # 365 days
+            total
+          end
+
+          def to_ruby
+            to_seconds
+          end
+
+          def ==(other)
+            return false unless other.is_a?(Duration)
+
+            @years == other.years &&
+              @months == other.months &&
+              @days == other.days &&
+              @hours == other.hours &&
+              @minutes == other.minutes &&
+              @seconds == other.seconds
+          end
+
+          def inspect
+            "#<Feel::Duration P#{@years}Y#{@months}M#{@days}DT#{@hours}H#{@minutes}M#{@seconds}S>"
+          end
+
+          def self.extract_unit(str, unit)
+            match = str.match(/(\d+(?:\.\d+)?)#{unit}/)
+            match ? match[1].to_f.to_i : 0
+          end
+        end
+
+        # Wrapper for lists (adds FEEL semantics to Ruby Array)
+        class List < Array
+          def initialize(array = [])
+            super
+          end
+
+          def to_ruby
+            to_a
+          end
+
+          def inspect
+            "#<Feel::List #{to_a.inspect}>"
+          end
+        end
+
+        # Wrapper for contexts (FEEL key-value maps)
+        class Context < Hash
+          def initialize(hash = {})
+            super()
+            hash.each { |k, v| self[k.to_sym] = v }
+          end
+
+          def to_ruby
+            to_h
+          end
+
+          def inspect
+            "#<Feel::Context #{to_h.inspect}>"
+          end
+        end
+
+        # Type conversion utilities
+        module Converter
+          def self.to_feel_type(value)
+            case value
+            when Integer, Float, BigDecimal
+              Number.new(value)
+            when ::Time, ::DateTime
+              Time.new(value)
+            when ::Date
+              Date.new(value)
+            when Array
+              List.new(value)
+            when Hash
+              Context.new(value)
+            else
+              value # Return as-is for strings, booleans, etc.
+            end
+          end
+
+          def self.to_ruby(value)
+            return value.to_ruby if value.respond_to?(:to_ruby)
+
+            value
+          end
+        end
+      end
+    end
+  end
+end