decision_agent 0.1.1 → 0.1.3

data/spec/dsl_validation_spec.rb

@@ -4,15 +4,15 @@ RSpec.describe "DSL Validation" do
   describe DecisionAgent::Dsl::SchemaValidator do
     describe "root structure validation" do
       it "rejects non-hash input" do
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!([1, 2, 3])
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /Root element must be a hash/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /Root element must be a hash/)
       end
 
       it "rejects string input" do
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!("not a hash")
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /Root element must be a hash/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /Root element must be a hash/)
       end
 
       it "accepts valid hash input" do
@@ -21,9 +21,9 @@ RSpec.describe "DSL Validation" do
           "rules" => []
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(valid_rules)
-        }.not_to raise_error
+        end.not_to raise_error
       end
     end
 
@@ -33,9 +33,9 @@ RSpec.describe "DSL Validation" do
           "rules" => []
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'version'/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'version'/)
       end
 
       it "accepts version as symbol key" do
@@ -44,9 +44,9 @@ RSpec.describe "DSL Validation" do
           rules: []
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.not_to raise_error
+        end.not_to raise_error
       end
     end
 
@@ -56,9 +56,9 @@ RSpec.describe "DSL Validation" do
           "version" => "1.0"
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'rules'/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'rules'/)
       end
 
       it "rejects non-array rules" do
@@ -67,9 +67,9 @@ RSpec.describe "DSL Validation" do
           "rules" => "not an array"
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /must be an array/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /must be an array/)
       end
 
       it "accepts empty rules array" do
@@ -78,9 +78,9 @@ RSpec.describe "DSL Validation" do
           "rules" => []
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.not_to raise_error
+        end.not_to raise_error
       end
     end
 
@@ -91,9 +91,9 @@ RSpec.describe "DSL Validation" do
           "rules" => ["not a hash"]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /rules\[0\].*must be a hash/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /rules\[0\].*must be a hash/)
       end
 
       it "requires rule id" do
@@ -107,9 +107,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'id'/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'id'/)
       end
 
       it "requires rule if clause" do
@@ -123,9 +123,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'if'/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'if'/)
       end
 
       it "requires rule then clause" do
@@ -139,9 +139,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'then'/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'then'/)
       end
     end
 
@@ -158,9 +158,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /Condition must have one of: 'field', 'all', or 'any'/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /Condition must have one of: 'field', 'all', or 'any'/)
       end
 
       it "rejects non-hash condition" do
@@ -175,9 +175,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /Condition must be a hash/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /Condition must be a hash/)
       end
     end
 
@@ -194,9 +194,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError) do |error|
+        end.to raise_error(DecisionAgent::InvalidRuleDslError) do |error|
           expect(error.message).to match(/Condition must have one of: 'field', 'all', or 'any'/)
         end
       end
@@ -213,9 +213,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /missing 'op'/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /missing 'op'/)
       end
 
       it "validates operator is supported" do
@@ -230,9 +230,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError) do |error|
+        end.to raise_error(DecisionAgent::InvalidRuleDslError) do |error|
           expect(error.message).to include("Unsupported operator 'invalid_op'")
           expect(error.message).to include("eq, neq, gt, gte, lt, lte, in, present, blank")
         end
@@ -250,9 +250,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /missing 'value' key/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /missing 'value' key/)
       end
 
       it "allows missing value for present operator" do
@@ -267,9 +267,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.not_to raise_error
+        end.not_to raise_error
       end
 
       it "allows missing value for blank operator" do
@@ -284,9 +284,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.not_to raise_error
+        end.not_to raise_error
       end
 
       it "rejects empty field path" do
@@ -301,9 +301,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /Field path cannot be empty/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /Field path cannot be empty/)
       end
 
       it "rejects invalid dot-notation" do
@@ -318,9 +318,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /cannot have empty segments/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /cannot have empty segments/)
       end
 
       it "accepts valid dot-notation" do
@@ -335,9 +335,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.not_to raise_error
+        end.not_to raise_error
       end
     end
 
@@ -354,9 +354,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /'all' condition must contain an array/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /'all' condition must contain an array/)
       end
 
       it "requires array for any condition" do
@@ -371,9 +371,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /'any' condition must contain an array/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /'any' condition must contain an array/)
       end
 
       it "validates nested conditions in all" do
@@ -392,9 +392,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /Unsupported operator/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /Unsupported operator/)
       end
 
       it "validates nested conditions in any" do
@@ -405,7 +405,7 @@ RSpec.describe "DSL Validation" do
               "id" => "rule_1",
               "if" => {
                 "any" => [
-                  { "field" => "priority" }  # Missing op
+                  { "field" => "priority" } # Missing op
                 ]
               },
               "then" => { "decision" => "escalate" }
@@ -413,9 +413,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /missing 'op'/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /missing 'op'/)
       end
     end
 
@@ -432,9 +432,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /then.*Must be a hash/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /then.*Must be a hash/)
       end
 
       it "requires decision field in then clause" do
@@ -449,9 +449,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'decision'/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'decision'/)
       end
 
       it "validates weight is numeric" do
@@ -466,9 +466,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /weight.*Must be a number/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /weight.*Must be a number/)
       end
 
       it "validates weight is between 0 and 1" do
@@ -483,9 +483,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /weight.*between 0.0 and 1.0/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /weight.*between 0.0 and 1.0/)
       end
 
       it "validates reason is a string" do
@@ -500,9 +500,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError, /reason.*Must be a string/)
+        end.to raise_error(DecisionAgent::InvalidRuleDslError, /reason.*Must be a string/)
       end
 
       it "accepts valid then clause with all fields" do
@@ -521,9 +521,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.not_to raise_error
+        end.not_to raise_error
       end
     end
 
@@ -533,16 +533,16 @@ RSpec.describe "DSL Validation" do
           "version" => "1.0",
           "rules" => [
             {
-              "id" => "rule_1",
+              "id" => "rule_1"
               # Missing if clause
               # Missing then clause
             }
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError) do |error|
+        end.to raise_error(DecisionAgent::InvalidRuleDslError) do |error|
           expect(error.message).to include("1.")
           expect(error.message).to include("2.")
           expect(error.message).to match(/validation failed with 2 errors/)
@@ -561,9 +561,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError) do |error|
+        end.to raise_error(DecisionAgent::InvalidRuleDslError) do |error|
           expect(error.message).to include("rules[0].if")
           expect(error.message).to include("Supported operators:")
         end
@@ -592,9 +592,9 @@ RSpec.describe "DSL Validation" do
           ]
         }
 
-        expect {
+        expect do
           DecisionAgent::Dsl::SchemaValidator.validate!(rules)
-        }.to raise_error(DecisionAgent::InvalidRuleDslError) do |error|
+        end.to raise_error(DecisionAgent::InvalidRuleDslError) do |error|
           expect(error.message).to include("rules[0].if.all[0].any[1]")
           expect(error.message).to include("Unsupported operator")
         end
@@ -606,17 +606,17 @@ RSpec.describe "DSL Validation" do
     it "uses SchemaValidator for validation" do
       invalid_json = '{"version": "1.0", "rules": "not an array"}'
 
-      expect {
+      expect do
         DecisionAgent::Dsl::RuleParser.parse(invalid_json)
-      }.to raise_error(DecisionAgent::InvalidRuleDslError, /must be an array/)
+      end.to raise_error(DecisionAgent::InvalidRuleDslError, /must be an array/)
     end
 
     it "provides helpful error for malformed JSON" do
       malformed_json = '{"version": "1.0", "rules": [,,,]}'
 
-      expect {
+      expect do
         DecisionAgent::Dsl::RuleParser.parse(malformed_json)
-      }.to raise_error(DecisionAgent::InvalidRuleDslError) do |error|
+      end.to raise_error(DecisionAgent::InvalidRuleDslError) do |error|
         expect(error.message).to include("Invalid JSON syntax")
         expect(error.message).to include("Common issues")
       end
@@ -634,15 +634,15 @@ RSpec.describe "DSL Validation" do
         ]
       }
 
-      expect {
+      expect do
         DecisionAgent::Dsl::RuleParser.parse(rules_hash)
-      }.not_to raise_error
+      end.not_to raise_error
     end
 
     it "rejects invalid input types" do
-      expect {
-        DecisionAgent::Dsl::RuleParser.parse(12345)
-      }.to raise_error(DecisionAgent::InvalidRuleDslError, /Expected JSON string or Hash/)
+      expect do
+        DecisionAgent::Dsl::RuleParser.parse(12_345)
+      end.to raise_error(DecisionAgent::InvalidRuleDslError, /Expected JSON string or Hash/)
     end
   end
 end

data/spec/edge_cases_spec.rb

@@ -47,7 +47,7 @@ RSpec.describe "Edge Cases" do
 
   describe "confidence edge cases" do
     it "raises error when confidence exceeds 1.0" do
-      expect {
+      expect do
         DecisionAgent::Decision.new(
           decision: "test",
           confidence: 1.5,
@@ -55,11 +55,11 @@ RSpec.describe "Edge Cases" do
           evaluations: [],
           audit_payload: {}
         )
-      }.to raise_error(DecisionAgent::InvalidConfidenceError)
+      end.to raise_error(DecisionAgent::InvalidConfidenceError)
     end
 
     it "raises error when confidence is negative" do
-      expect {
+      expect do
         DecisionAgent::Decision.new(
           decision: "test",
           confidence: -0.1,
@@ -67,7 +67,7 @@ RSpec.describe "Edge Cases" do
           evaluations: [],
           audit_payload: {}
         )
-      }.to raise_error(DecisionAgent::InvalidConfidenceError)
+      end.to raise_error(DecisionAgent::InvalidConfidenceError)
     end
 
     it "accepts confidence at boundary values" do
@@ -94,25 +94,25 @@ RSpec.describe "Edge Cases" do
 
   describe "weight edge cases" do
     it "raises error when weight exceeds 1.0" do
-      expect {
+      expect do
         DecisionAgent::Evaluation.new(
           decision: "test",
           weight: 1.5,
           reason: "test",
           evaluator_name: "test"
         )
-      }.to raise_error(DecisionAgent::InvalidWeightError)
+      end.to raise_error(DecisionAgent::InvalidWeightError)
     end
 
     it "raises error when weight is negative" do
-      expect {
+      expect do
         DecisionAgent::Evaluation.new(
           decision: "test",
           weight: -0.1,
           reason: "test",
           evaluator_name: "test"
         )
-      }.to raise_error(DecisionAgent::InvalidWeightError)
+      end.to raise_error(DecisionAgent::InvalidWeightError)
     end
 
     it "accepts weight at boundary values" do
@@ -206,9 +206,9 @@ RSpec.describe "Edge Cases" do
     it "freezes context data to prevent modification" do
       context = DecisionAgent::Context.new({ user: "alice" })
 
-      expect {
+      expect do
         context.to_h[:user] = "bob"
-      }.to raise_error(FrozenError)
+      end.to raise_error(FrozenError)
     end
 
     it "freezes evaluation fields" do
@@ -313,16 +313,16 @@ RSpec.describe "Edge Cases" do
 
       evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
       context = DecisionAgent::Context.new({
-        a: {
-          b: {
-            c: {
-              d: {
-                e: "deep"
-              }
-            }
-          }
-        }
-      })
+                                             a: {
+                                               b: {
+                                                 c: {
+                                                   d: {
+                                                     e: "deep"
+                                                   }
+                                                 }
+                                               }
+                                             }
+                                           })
 
       evaluation = evaluator.evaluate(context)
 
@@ -334,7 +334,7 @@ RSpec.describe "Edge Cases" do
   describe "audit adapter errors" do
     it "propagates errors from audit adapter" do
       failing_adapter = Class.new(DecisionAgent::Audit::Adapter) do
-        def record(decision, context)
+        def record(_decision, _context)
           raise StandardError, "Audit failed"
         end
       end
@@ -345,9 +345,9 @@ RSpec.describe "Edge Cases" do
         audit_adapter: failing_adapter.new
       )
 
-      expect {
+      expect do
         agent.decide(context: {})
-      }.to raise_error(StandardError, "Audit failed")
+      end.to raise_error(StandardError, "Audit failed")
     end
   end
 end

data/spec/examples/feedback_aware_evaluator_spec.rb

@@ -152,7 +152,7 @@ RSpec.describe Examples::FeedbackAwareEvaluator do
     it "clamps weight to minimum 0.0" do
       result = evaluator.evaluate(
         context,
-        feedback: { past_accuracy: -1.0 }  # Invalid, but should be handled
+        feedback: { past_accuracy: -1.0 } # Invalid, but should be handled
       )
 
       expect(result.weight).to be >= 0.0
@@ -161,7 +161,7 @@ RSpec.describe Examples::FeedbackAwareEvaluator do
     it "clamps weight to maximum 1.0" do
       result = evaluator.evaluate(
         context,
-        feedback: { past_accuracy: 2.0 }  # Would produce 1.6, should clamp to 1.0
+        feedback: { past_accuracy: 2.0 } # Would produce 1.6, should clamp to 1.0
       )
 
       expect(result.weight).to be <= 1.0
@@ -254,7 +254,7 @@ RSpec.describe Examples::FeedbackAwareEvaluator do
 
       result = high_weight_evaluator.evaluate(
         context,
-        feedback: { source: "expert_review" }  # 0.9 * 1.2 = 1.08, should clamp to 1.0
+        feedback: { source: "expert_review" } # 0.9 * 1.2 = 1.08, should clamp to 1.0
       )
 
       expect(result.weight).to eq(1.0)
@@ -330,7 +330,7 @@ RSpec.describe Examples::FeedbackAwareEvaluator do
       )
 
       expect(result.decision).to eq("approve")
-      expect(result.confidence).to eq(1.0)  # Single evaluator normalized to 1.0
+      expect(result.confidence).to eq(1.0) # Single evaluator normalized to 1.0
     end
 
     it "respects feedback in agent context" do
@@ -357,7 +357,7 @@ RSpec.describe Examples::FeedbackAwareEvaluator do
 
       result = agent.decide(
         context: {},
-        feedback: { past_accuracy: 0.5 }  # Reduces feedback_eval weight to 0.4
+        feedback: { past_accuracy: 0.5 } # Reduces feedback_eval weight to 0.4
       )
 
       expect(result.decision).to eq("approve")
@@ -385,7 +385,7 @@ RSpec.describe Examples::FeedbackAwareEvaluator do
 
       result_with_feedback = agent.decide(
         context: {},
-        feedback: { past_accuracy: 0.5 }  # Reduces feedback_eval to 0.4
+        feedback: { past_accuracy: 0.5 } # Reduces feedback_eval to 0.4
       )
       # MaxWeight still picks static_eval (0.9 > 0.4)
       expect(result_with_feedback.decision).to eq("reject")
@@ -399,7 +399,7 @@ RSpec.describe Examples::FeedbackAwareEvaluator do
     it "handles feedback with string keys" do
       result = evaluator.evaluate(
         context,
-        feedback: { "override" => "reject" }  # String key instead of symbol
+        feedback: { "override" => "reject" } # String key instead of symbol
       )
 
       # Should not match because code expects symbols