decision_agent 0.2.0 → 0.3.0

data/spec/dmn/feel/simple_parser_spec.rb

@@ -0,0 +1,274 @@
+require "spec_helper"
+require "decision_agent/dmn/feel/simple_parser"
+
+RSpec.describe DecisionAgent::Dmn::Feel::SimpleParser do
+  let(:parser) { described_class.new }
+
+  describe ".can_parse?" do
+    it "returns true for simple arithmetic" do
+      expect(described_class.can_parse?("age + 5")).to be true
+      expect(described_class.can_parse?("price * 1.1")).to be true
+    end
+
+    it "returns true for logical expressions" do
+      expect(described_class.can_parse?("age >= 18 and status = active")).to be true
+    end
+
+    it "returns false for lists" do
+      expect(described_class.can_parse?("[1, 2, 3]")).to be false
+    end
+
+    it "returns false for contexts" do
+      expect(described_class.can_parse?("{x: 10}")).to be false
+    end
+
+    it "returns false for functions" do
+      expect(described_class.can_parse?("sum(scores)")).to be false
+    end
+
+    it "returns false for quantified expressions" do
+      expect(described_class.can_parse?("some x in list satisfies x > 5")).to be false
+    end
+  end
+
+  describe "#parse" do
+    describe "literals" do
+      it "parses integer" do
+        result = parser.parse("42")
+        expect(result[:type]).to eq(:literal)
+        expect(result[:value]).to eq(42)
+      end
+
+      it "parses float" do
+        result = parser.parse("3.14")
+        expect(result[:type]).to eq(:literal)
+        expect(result[:value]).to eq(3.14)
+      end
+
+      it "parses negative number" do
+        result = parser.parse("-10")
+        expect(result[:type]).to eq(:literal)
+        expect(result[:value]).to eq(-10)
+      end
+
+      it "parses string" do
+        result = parser.parse('"hello"')
+        expect(result[:type]).to eq(:literal)
+        expect(result[:value]).to eq("hello")
+      end
+
+      it "parses boolean true" do
+        result = parser.parse("true")
+        expect(result[:type]).to eq(:boolean)
+        expect(result[:value]).to be true
+      end
+
+      it "parses boolean false" do
+        result = parser.parse("false")
+        expect(result[:type]).to eq(:boolean)
+        expect(result[:value]).to be false
+      end
+    end
+
+    describe "field references" do
+      it "parses field name" do
+        result = parser.parse("age")
+        expect(result[:type]).to eq(:field)
+        expect(result[:name]).to eq("age")
+      end
+    end
+
+    describe "arithmetic operators" do
+      it "parses addition" do
+        result = parser.parse("5 + 3")
+        expect(result[:type]).to eq(:arithmetic)
+        expect(result[:operator]).to eq("+")
+        expect(result[:left][:value]).to eq(5)
+        expect(result[:right][:value]).to eq(3)
+      end
+
+      it "parses subtraction" do
+        result = parser.parse("10 - 3")
+        expect(result[:type]).to eq(:arithmetic)
+        expect(result[:operator]).to eq("-")
+      end
+
+      it "parses multiplication" do
+        result = parser.parse("4 * 5")
+        expect(result[:type]).to eq(:arithmetic)
+        expect(result[:operator]).to eq("*")
+      end
+
+      it "parses division" do
+        result = parser.parse("20 / 4")
+        expect(result[:type]).to eq(:arithmetic)
+        expect(result[:operator]).to eq("/")
+      end
+
+      it "parses exponentiation" do
+        result = parser.parse("2 ** 3")
+        expect(result[:type]).to eq(:arithmetic)
+        expect(result[:operator]).to eq("**")
+      end
+
+      it "parses modulo" do
+        result = parser.parse("10 % 3")
+        expect(result[:type]).to eq(:arithmetic)
+        expect(result[:operator]).to eq("%")
+      end
+    end
+
+    describe "operator precedence" do
+      it "respects multiplication before addition" do
+        result = parser.parse("2 + 3 * 4")
+        # Should be: 2 + (3 * 4)
+        expect(result[:operator]).to eq("+")
+        expect(result[:left][:value]).to eq(2)
+        expect(result[:right][:operator]).to eq("*")
+      end
+
+      it "respects exponentiation before multiplication" do
+        result = parser.parse("2 * 3 ** 2")
+        # Should be: 2 * (3 ** 2)
+        expect(result[:operator]).to eq("*")
+        expect(result[:right][:operator]).to eq("**")
+      end
+
+      it "handles parentheses" do
+        result = parser.parse("(2 + 3) * 4")
+        # Should be: (2 + 3) * 4
+        expect(result[:operator]).to eq("*")
+        expect(result[:left][:operator]).to eq("+")
+      end
+    end
+
+    describe "comparison operators" do
+      it "parses greater than or equal" do
+        result = parser.parse("age >= 18")
+        expect(result[:type]).to eq(:comparison)
+        expect(result[:operator]).to eq(">=")
+        expect(result[:left][:name]).to eq("age")
+        expect(result[:right][:value]).to eq(18)
+      end
+
+      it "parses less than or equal" do
+        result = parser.parse("score <= 100")
+        expect(result[:type]).to eq(:comparison)
+        expect(result[:operator]).to eq("<=")
+      end
+
+      it "parses greater than" do
+        result = parser.parse("price > 0")
+        expect(result[:type]).to eq(:comparison)
+        expect(result[:operator]).to eq(">")
+      end
+
+      it "parses less than" do
+        result = parser.parse("age < 65")
+        expect(result[:type]).to eq(:comparison)
+        expect(result[:operator]).to eq("<")
+      end
+
+      it "parses not equal" do
+        result = parser.parse("status != pending")
+        expect(result[:type]).to eq(:comparison)
+        expect(result[:operator]).to eq("!=")
+      end
+
+      it "parses equal" do
+        result = parser.parse("status = active")
+        expect(result[:type]).to eq(:comparison)
+        expect(result[:operator]).to eq("=")
+      end
+    end
+
+    describe "logical operators" do
+      it "parses AND" do
+        result = parser.parse("age >= 18 and score > 700")
+        expect(result[:type]).to eq(:logical)
+        expect(result[:operator]).to eq("and")
+        expect(result[:left][:type]).to eq(:comparison)
+        expect(result[:right][:type]).to eq(:comparison)
+      end
+
+      it "parses OR" do
+        result = parser.parse("status = active or status = pending")
+        expect(result[:type]).to eq(:logical)
+        expect(result[:operator]).to eq("or")
+      end
+
+      it "parses NOT" do
+        result = parser.parse("not active")
+        expect(result[:type]).to eq(:logical)
+        expect(result[:operator]).to eq("not")
+        expect(result[:operand][:name]).to eq("active")
+      end
+
+      it "respects AND precedence over OR" do
+        result = parser.parse("a or b and c")
+        # Should be: a or (b and c)
+        expect(result[:operator]).to eq("or")
+        expect(result[:right][:operator]).to eq("and")
+      end
+    end
+
+    describe "unary operators" do
+      it "parses unary minus" do
+        result = parser.parse("-5")
+        expect(result[:type]).to eq(:literal)
+        expect(result[:value]).to eq(-5)
+      end
+
+      it "parses unary minus with field" do
+        result = parser.parse("-age")
+        expect(result[:type]).to eq(:arithmetic)
+        expect(result[:operator]).to eq("negate")
+        expect(result[:operand][:name]).to eq("age")
+      end
+
+      it "parses unary plus (ignored)" do
+        result = parser.parse("+5")
+        expect(result[:value]).to eq(5)
+      end
+    end
+
+    describe "complex expressions" do
+      it "parses arithmetic with comparison" do
+        result = parser.parse("age + 5 >= 18")
+        expect(result[:type]).to eq(:comparison)
+        expect(result[:left][:type]).to eq(:arithmetic)
+      end
+
+      it "parses multiple logical operations" do
+        result = parser.parse("age >= 18 and age <= 65 and status = active")
+        expect(result[:type]).to eq(:logical)
+        expect(result[:operator]).to eq("and")
+      end
+
+      it "parses nested parentheses" do
+        result = parser.parse("((age + 5) * 2) >= 40")
+        expect(result[:type]).to eq(:comparison)
+      end
+    end
+
+    describe "error handling" do
+      it "raises error for empty expression" do
+        expect do
+          parser.parse("")
+        end.to raise_error(DecisionAgent::Dmn::FeelParseError, /Empty expression/)
+      end
+
+      it "raises error for unbalanced parentheses" do
+        expect do
+          parser.parse("(age + 5")
+        end.to raise_error(DecisionAgent::Dmn::FeelParseError)
+      end
+
+      it "raises error for unexpected character" do
+        expect do
+          parser.parse("age @ 5")
+        end.to raise_error(DecisionAgent::Dmn::FeelParseError, /Unexpected character/)
+      end
+    end
+  end
+end

data/spec/dmn/feel/types_spec.rb

@@ -0,0 +1,176 @@
+require "spec_helper"
+require "decision_agent/dmn/feel/types"
+
+RSpec.describe DecisionAgent::Dmn::Feel::Types do
+  describe DecisionAgent::Dmn::Feel::Types::Number do
+    it "creates from integer" do
+      num = DecisionAgent::Dmn::Feel::Types::Number.new(42)
+      expect(num.to_ruby).to eq(42)
+      expect(num.to_i).to eq(42)
+    end
+
+    it "creates from float" do
+      num = DecisionAgent::Dmn::Feel::Types::Number.new(3.14)
+      expect(num.to_ruby).to eq(3.14)
+      expect(num.to_f).to be_within(0.001).of(3.14)
+    end
+
+    it "creates from string" do
+      num = DecisionAgent::Dmn::Feel::Types::Number.new("42.5")
+      expect(num.to_f).to be_within(0.001).of(42.5)
+    end
+
+    it "supports scale tracking" do
+      num = DecisionAgent::Dmn::Feel::Types::Number.new(42, scale: 2)
+      expect(num.scale).to eq(2)
+    end
+
+    it "raises error for invalid type" do
+      expect do
+        DecisionAgent::Dmn::Feel::Types::Number.new([])
+      end.to raise_error(DecisionAgent::Dmn::FeelTypeError)
+    end
+  end
+
+  describe DecisionAgent::Dmn::Feel::Types::Date do
+    it "creates from Time object" do
+      time = Time.new(2024, 1, 15)
+      date = DecisionAgent::Dmn::Feel::Types::Date.new(time)
+      expect(date.to_ruby).to eq(time)
+    end
+
+    it "creates from ISO 8601 string" do
+      date = DecisionAgent::Dmn::Feel::Types::Date.new("2024-01-15T10:30:00Z")
+      expect(date.to_ruby).to be_a(Time)
+    end
+
+    it "creates from date string" do
+      date = DecisionAgent::Dmn::Feel::Types::Date.new("2024-01-15")
+      expect(date.to_ruby).to be_a(Time)
+    end
+
+    it "raises error for invalid format" do
+      expect do
+        DecisionAgent::Dmn::Feel::Types::Date.new("invalid")
+      end.to raise_error(DecisionAgent::Dmn::FeelTypeError)
+    end
+  end
+
+  describe DecisionAgent::Dmn::Feel::Types::Time do
+    it "creates from Time object" do
+      time = Time.new(2024, 1, 15, 10, 30, 0)
+      feel_time = DecisionAgent::Dmn::Feel::Types::Time.new(time)
+      expect(feel_time.to_ruby).to eq(time)
+    end
+
+    it "creates from ISO 8601 string" do
+      feel_time = DecisionAgent::Dmn::Feel::Types::Time.new("2024-01-15T10:30:00Z")
+      expect(feel_time.to_ruby).to be_a(Time)
+    end
+  end
+
+  describe DecisionAgent::Dmn::Feel::Types::Duration do
+    it "parses ISO 8601 duration with years" do
+      duration = DecisionAgent::Dmn::Feel::Types::Duration.parse("P1Y")
+      expect(duration.years).to eq(1)
+      expect(duration.months).to eq(0)
+    end
+
+    it "parses ISO 8601 duration with months" do
+      duration = DecisionAgent::Dmn::Feel::Types::Duration.parse("P3M")
+      expect(duration.months).to eq(3)
+    end
+
+    it "parses ISO 8601 duration with days" do
+      duration = DecisionAgent::Dmn::Feel::Types::Duration.parse("P10D")
+      expect(duration.days).to eq(10)
+    end
+
+    it "parses ISO 8601 duration with time components" do
+      duration = DecisionAgent::Dmn::Feel::Types::Duration.parse("PT5H30M15S")
+      expect(duration.hours).to eq(5)
+      expect(duration.minutes).to eq(30)
+      expect(duration.seconds).to eq(15)
+    end
+
+    it "parses complete ISO 8601 duration" do
+      duration = DecisionAgent::Dmn::Feel::Types::Duration.parse("P1Y2M3DT4H5M6S")
+      expect(duration.years).to eq(1)
+      expect(duration.months).to eq(2)
+      expect(duration.days).to eq(3)
+      expect(duration.hours).to eq(4)
+      expect(duration.minutes).to eq(5)
+      expect(duration.seconds).to eq(6)
+    end
+
+    it "converts to seconds" do
+      duration = DecisionAgent::Dmn::Feel::Types::Duration.parse("PT1H30M")
+      expect(duration.to_seconds).to eq(5400) # 90 minutes
+    end
+
+    it "raises error for invalid format" do
+      expect do
+        DecisionAgent::Dmn::Feel::Types::Duration.parse("invalid")
+      end.to raise_error(DecisionAgent::Dmn::FeelTypeError)
+    end
+
+    it "raises error for non-P prefix" do
+      expect do
+        DecisionAgent::Dmn::Feel::Types::Duration.parse("1Y2M")
+      end.to raise_error(DecisionAgent::Dmn::FeelTypeError, /must start with 'P'/)
+    end
+  end
+
+  describe DecisionAgent::Dmn::Feel::Types::List do
+    it "wraps array" do
+      list = DecisionAgent::Dmn::Feel::Types::List.new([1, 2, 3])
+      expect(list.to_ruby).to eq([1, 2, 3])
+      expect(list[0]).to eq(1)
+      expect(list.length).to eq(3)
+    end
+  end
+
+  describe DecisionAgent::Dmn::Feel::Types::Context do
+    it "wraps hash with symbol keys" do
+      ctx = DecisionAgent::Dmn::Feel::Types::Context.new({ "name" => "John", "age" => 30 })
+      expect(ctx[:name]).to eq("John")
+      expect(ctx[:age]).to eq(30)
+    end
+
+    it "converts string keys to symbols" do
+      ctx = DecisionAgent::Dmn::Feel::Types::Context.new({ "x" => 10, "y" => 20 })
+      expect(ctx.to_ruby).to eq({ x: 10, y: 20 })
+    end
+  end
+
+  describe DecisionAgent::Dmn::Feel::Types::Converter do
+    it "converts integer to Number" do
+      result = DecisionAgent::Dmn::Feel::Types::Converter.to_feel_type(42)
+      expect(result).to be_a(DecisionAgent::Dmn::Feel::Types::Number)
+      expect(result.to_ruby).to eq(42)
+    end
+
+    it "converts array to List" do
+      result = DecisionAgent::Dmn::Feel::Types::Converter.to_feel_type([1, 2, 3])
+      expect(result).to be_a(DecisionAgent::Dmn::Feel::Types::List)
+      expect(result.to_ruby).to eq([1, 2, 3])
+    end
+
+    it "converts hash to Context" do
+      result = DecisionAgent::Dmn::Feel::Types::Converter.to_feel_type({ x: 10 })
+      expect(result).to be_a(DecisionAgent::Dmn::Feel::Types::Context)
+      expect(result.to_ruby).to eq({ x: 10 })
+    end
+
+    it "converts FEEL types to Ruby" do
+      num = DecisionAgent::Dmn::Feel::Types::Number.new(42)
+      result = DecisionAgent::Dmn::Feel::Types::Converter.to_ruby(num)
+      expect(result).to eq(42)
+    end
+
+    it "returns non-FEEL types as-is" do
+      result = DecisionAgent::Dmn::Feel::Types::Converter.to_ruby("hello")
+      expect(result).to eq("hello")
+    end
+  end
+end