decision_agent 0.3.0 → 1.1.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../errors"
 require_relative "types"
 
@@ -60,7 +62,6 @@ module DecisionAgent
         private
 
         # Tokenize the expression
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def tokenize(expr)
           tokens = []
           i = 0
@@ -68,95 +69,115 @@ module DecisionAgent
           while i < expr.length
             char = expr[i]
 
-            # Skip whitespace
             if char.match?(/\s/)
               i += 1
               next
             end
 
-            # Check for multi-character operators
-            if i + 1 < expr.length
-              two_char = expr[i, 2]
-              if %w[>= <= != ** or].include?(two_char)
-                tokens << { type: :operator, value: two_char }
-                i += 2
-                next
-              elsif two_char == "an" && i + 2 < expr.length && expr[i, 3] == "and"
-                tokens << { type: :operator, value: "and" }
-                i += 3
-                next
-              end
-            end
+            token, consumed = tokenize_char(expr, i, char, tokens)
+            raise DecisionAgent::Dmn::FeelParseError, "Unexpected character: #{char} at position #{i}" unless token
 
-            # Numbers (integer or float) - check BEFORE single char operators to handle negative numbers
-            if char.match?(/\d/) ||
-               (char == "-" && i + 1 < expr.length && expr[i + 1].match?(/\d/) &&
-                (tokens.empty? || tokens.last[:type] == :operator || tokens.last[:type] == :paren))
-              num_str = ""
-              num_str << char if char == "-"
-              i += 1 if char == "-"
-
-              while i < expr.length && expr[i].match?(/[\d.]/)
-                num_str << expr[i]
-                i += 1
-              end
-
-              value = num_str.include?(".") ? num_str.to_f : num_str.to_i
-              tokens << { type: :number, value: value }
-              next
-            end
+            tokens << token
+            i += consumed
+          end
 
-            # Single character operators
-            if "+-*/%><()=".include?(char)
-              type = %w[( )].include?(char) ? :paren : :operator
-              tokens << { type: type, value: char }
-              i += 1
-              next
-            end
+          tokens
+        end
 
-            # Quoted strings
-            if char == '"'
-              str = ""
-              i += 1
-              while i < expr.length && expr[i] != '"'
-                str << expr[i]
-                i += 1
-              end
-              i += 1 # Skip closing quote
-              tokens << { type: :string, value: str }
-              next
-            end
+        # Dispatch tokenization for a single character position
+        # Returns [token, chars_consumed] or [nil, 0] if unrecognized
+        def tokenize_char(expr, pos, char, tokens)
+          tokenize_multi_char_op(expr, pos) ||
+            tokenize_number(expr, pos, char, tokens) ||
+            tokenize_single_char_op(char) ||
+            tokenize_string(expr, pos, char) ||
+            tokenize_keyword(expr, pos, char) ||
+            [nil, 0]
+        end
 
-            # Booleans and keywords
-            if char.match?(/[a-zA-Z]/)
-              word = ""
-              while i < expr.length && expr[i].match?(/[a-zA-Z_]/)
-                word << expr[i]
-                i += 1
-              end
-
-              tokens << case word.downcase
-                        when "true"
-                          { type: :boolean, value: true }
-                        when "false"
-                          { type: :boolean, value: false }
-                        when "not"
-                          { type: :operator, value: "not" }
-                        when "and", "or"
-                          { type: :operator, value: word.downcase }
-                        else
-                          # Field reference
-                          { type: :field, value: word }
-                        end
-              next
-            end
+        # Try to match multi-character operators (>=, <=, !=, **, and, or)
+        def tokenize_multi_char_op(expr, pos)
+          return nil unless pos + 1 < expr.length
 
-            raise DecisionAgent::Dmn::FeelParseError, "Unexpected character: #{char} at position #{i}"
+          two_char = expr[pos, 2]
+          return [{ type: :operator, value: two_char }, 2] if %w[>= <= != ** or].include?(two_char)
+          return nil unless two_char == "an" && pos + 2 < expr.length && expr[pos, 3] == "and"
+
+          [{ type: :operator, value: "and" }, 3]
+        end
+
+        # Try to tokenize a number (integer or float, including negative)
+        def tokenize_number(expr, pos, char, tokens)
+          return nil unless number_start?(char, expr, pos, tokens)
+
+          num_str = String.new
+          if char == "-"
+            num_str << "-"
+            pos += 1
           end
 
-          tokens
+          while pos < expr.length && expr[pos].match?(/[\d.]/)
+            num_str << expr[pos]
+            pos += 1
+          end
+
+          value = num_str.include?(".") ? num_str.to_f : num_str.to_i
+          [{ type: :number, value: value }, (char == "-" ? 1 : 0) + num_str.delete("-").length]
+        end
+
+        def number_start?(char, expr, pos, tokens)
+          return true if char.match?(/\d/)
+
+          char == "-" && pos + 1 < expr.length && expr[pos + 1].match?(/\d/) &&
+            (tokens.empty? || tokens.last[:type] == :operator || tokens.last[:type] == :paren)
+        end
+
+        # Try to tokenize a single-character operator or parenthesis
+        def tokenize_single_char_op(char)
+          return nil unless "+-*/%><()=".include?(char)
+
+          type = %w[( )].include?(char) ? :paren : :operator
+          [{ type: type, value: char }, 1]
+        end
+
+        # Try to tokenize a quoted string
+        def tokenize_string(expr, pos, char)
+          return nil unless char == '"'
+
+          str = String.new
+          idx = pos + 1
+          while idx < expr.length && expr[idx] != '"'
+            str << expr[idx]
+            idx += 1
+          end
+          idx += 1 # Skip closing quote
+
+          [{ type: :string, value: str }, idx - pos]
+        end
+
+        # Try to tokenize a keyword (boolean, operator, or field reference)
+        def tokenize_keyword(expr, pos, char)
+          return nil unless char.match?(/[a-zA-Z]/)
+
+          word = String.new
+          idx = pos
+          while idx < expr.length && expr[idx].match?(/[a-zA-Z_]/)
+            word << expr[idx]
+            idx += 1
+          end
+
+          [keyword_token(word), idx - pos]
+        end
+
+        def keyword_token(word)
+          case word.downcase
+          when "true"  then { type: :boolean, value: true }
+          when "false" then { type: :boolean, value: false }
+          when "not"   then { type: :operator, value: "not" }
+          when "and", "or" then { type: :operator, value: word.downcase }
+          else { type: :field, value: word }
+          end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         # Parse expression with operator precedence
         def parse_expression(min_precedence = 0)

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "parslet"
 require_relative "../errors"
 
@@ -6,6 +8,54 @@ module DecisionAgent
     module Feel
       # Transforms Parslet parse tree into AST
       class Transformer < Parslet::Transform
+        # Extract a context entry key from various node representations
+        def self.extract_entry_key(key_node)
+          return key_node.to_s if key_node.is_a?(Parslet::Slice)
+          return key_node.to_s unless key_node.is_a?(Hash)
+
+          case key_node[:type]
+          when :field      then key_node[:name].to_s
+          when :string     then key_node[:value].to_s
+          when :identifier then key_node[:name].to_s
+          else
+            key_node[:identifier]&.to_s || key_node[:string]&.to_s || key_node.to_s
+          end
+        end
+
+        # Extract a name string from a node that may be a Hash or raw value
+        def self.extract_name(name_node)
+          return name_node.to_s.strip unless name_node.is_a?(Hash)
+          return name_node[:name].to_s.strip if name_node[:type] == :field
+
+          name_node[:identifier]&.to_s&.strip || name_node.to_s
+        end
+
+        # Apply a single postfix operation to the current AST node
+        def self.apply_postfix_op(current, op)
+          return current unless op.is_a?(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
+        end
+
+        # Extract variable name from a potentially transformed node
+        def self.extract_variable_name(var_node)
+          if var_node.is_a?(Hash) && var_node[:type] == :field
+            var_node[:name]
+          elsif var_node.is_a?(Hash) && var_node[:identifier]
+            var_node[:identifier].to_s
+          else
+            var_node.to_s
+          end
+        end
+
         # Literals
         rule(null: simple(:_)) { { type: :null, value: nil } }
 
@@ -54,26 +104,7 @@ module DecisionAgent
                           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]]
+            [Transformer.extract_entry_key(entry[:key]), entry[:value]]
           end
 
           { type: :context_literal, pairs: pairs }
@@ -110,36 +141,16 @@ module DecisionAgent
                        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,
+            name: Transformer.extract_name(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 }
+          { type: :field, name: Transformer.extract_name(name) }
         end
 
         # Comparison operations
@@ -260,35 +271,7 @@ module DecisionAgent
 
         # 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
+          Array(ops).reduce(base) { |current, op| Transformer.apply_postfix_op(current, op) }
         end
 
         # If-then-else conditional
@@ -303,19 +286,10 @@ module DecisionAgent
 
         # 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,
+            variable: Transformer.extract_variable_name(v),
             list: l,
             condition: c
           }
@@ -323,18 +297,9 @@ module DecisionAgent
 
         # 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,
+            variable: Transformer.extract_variable_name(v),
             list: l,
             return_expr: r
           }
@@ -355,17 +320,6 @@ module DecisionAgent
             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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "time"
 require "date"
 require "bigdecimal"

data/lib/decision_agent/dmn/importer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "parser"
 require_relative "validator"
 require_relative "adapter"

data/lib/decision_agent/dmn/model.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "errors"
 
 module DecisionAgent
@@ -53,10 +55,6 @@ module DecisionAgent
         @decision_table = table
       end
 
-      def add_information_requirement(requirement)
-        @information_requirements << requirement
-      end
-
       def freeze
         @id.freeze
         @name.freeze

data/lib/decision_agent/dmn/parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "nokogiri"
 require "securerandom"
 require_relative "model"

data/lib/decision_agent/dmn/testing.rb

@@ -227,8 +227,9 @@ module DecisionAgent
             # This would need to be enhanced to track which rule matched
             evaluator.evaluate(context: context)
             # In a full implementation, we'd track the matched rule
-          rescue StandardError
-            # Ignore errors for coverage calculation
+          rescue StandardError => e
+            # Log errors during coverage calculation but continue
+            warn "[DecisionAgent] Coverage evaluation failed for test case: #{e.message}"
           end
         end
 

data/lib/decision_agent/dmn/validator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "errors"
 require_relative "feel/evaluator"
 
@@ -210,9 +212,9 @@ module DecisionAgent
         when "PRIORITY"
           # Check that outputs have defined allowed values with priorities
           table.outputs.each do |output|
-            unless output.instance_variable_get(:@allowed_values)
-              @warnings << "#{path}: PRIORITY hit policy requires outputs to have defined allowed values"
-            end
+            next if output.instance_variable_get(:@allowed_values)
+
+            @warnings << "#{path}: PRIORITY hit policy requires outputs to have defined allowed values"
           end
         end
       end

data/lib/decision_agent/dmn/visualizer.rb

@@ -65,8 +65,8 @@ module DecisionAgent
         svg = [
           %(<svg xmlns="http://www.w3.org/2000/svg" width="#{width}" height="#{height}" viewBox="0 0 #{width} #{height}">),
           "<defs>",
-          '  <marker id="arrowhead" markerWidth="10" markerHeight="10" refX="9" refY="3" orient="auto">',
-          '    <polygon points="0 0, 10 3, 0 6" fill="#666" />',
+          %(  <marker id="arrowhead" markerWidth="10" markerHeight="10" refX="9" refY="3" orient="auto">),
+          %(    <polygon points="0 0, 10 3, 0 6" fill="#666" />),
           "  </marker>",
           "</defs>",
           "<g>"
@@ -264,8 +264,8 @@ module DecisionAgent
         svg = [
           %(<svg xmlns="http://www.w3.org/2000/svg" width="#{width}" height="#{height}" viewBox="0 0 #{width} #{height}">),
           "<defs>",
-          '  <marker id="arrowhead" markerWidth="10" markerHeight="10" refX="9" refY="3" orient="auto">',
-          '    <polygon points="0 0, 10 3, 0 6" fill="#666" />',
+          %(  <marker id="arrowhead" markerWidth="10" markerHeight="10" refX="9" refY="3" orient="auto">),
+          %(    <polygon points="0 0, 10 3, 0 6" fill="#666" />),
           "  </marker>",
           "</defs>",
           "<g>"
@@ -288,8 +288,9 @@ module DecisionAgent
         # Use topological sort to arrange nodes in layers
         begin
           order = @graph.topological_order
-        rescue StandardError
-          # If circular, just use the order as-is
+        rescue StandardError => e
+          # If circular dependency detected, fall back to unordered keys
+          warn "[DecisionAgent] Topological sort failed (possible circular dependency): #{e.message}"
           order = @graph.decisions.keys
         end