moxml 0.1.7 → 0.1.9

data/spec/moxml/xpath/ruby/generator_spec.rb

@@ -0,0 +1,421 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::XPath::Ruby::Generator do
+  let(:generator) { described_class.new }
+  let(:node_class) { Moxml::XPath::Ruby::Node }
+
+  describe "#process" do
+    it "dispatches to the appropriate on_* method based on node type" do
+      node = node_class.new(:lit, ["10"])
+      expect(generator.process(node)).to eq("10")
+    end
+  end
+
+  describe "#on_followed_by" do
+    it "joins multiple statements with blank lines" do
+      stmt1 = node_class.new(:lit, ["a"])
+      stmt2 = node_class.new(:lit, ["b"])
+      stmt3 = node_class.new(:lit, ["c"])
+      node = node_class.new(:followed_by, [stmt1, stmt2, stmt3])
+
+      result = generator.process(node)
+      expect(result).to eq("a\n\nb\n\nc")
+    end
+
+    it "processes each child node" do
+      assign1 = node_class.new(:assign, [
+                                 node_class.new(:lit, ["x"]),
+                                 node_class.new(:lit, ["10"]),
+                               ])
+      assign2 = node_class.new(:assign, [
+                                 node_class.new(:lit, ["y"]),
+                                 node_class.new(:lit, ["20"]),
+                               ])
+      node = node_class.new(:followed_by, [assign1, assign2])
+
+      result = generator.process(node)
+      expect(result).to eq("x = 10\n\ny = 20")
+    end
+  end
+
+  describe "#on_assign" do
+    it "generates an assignment statement" do
+      var = node_class.new(:lit, ["x"])
+      val = node_class.new(:lit, ["10"])
+      node = node_class.new(:assign, [var, val])
+
+      result = generator.process(node)
+      expect(result).to eq("x = 10")
+    end
+
+    it "handles complex expressions" do
+      var = node_class.new(:lit, ["result"])
+      val = node_class.new(:send, [
+                             node_class.new(:lit, ["a"]),
+                             "+",
+                             node_class.new(:lit, ["b"]),
+                           ])
+      node = node_class.new(:assign, [var, val])
+
+      result = generator.process(node)
+      expect(result).to eq("result = a.+(b)")
+    end
+  end
+
+  describe "#on_massign" do
+    it "generates a multiple assignment statement" do
+      vars = [
+        node_class.new(:lit, ["x"]),
+        node_class.new(:lit, ["y"]),
+      ]
+      val = node_class.new(:lit, ["[1, 2]"])
+      node = node_class.new(:massign, [vars, val])
+
+      result = generator.process(node)
+      expect(result).to eq("x, y = [1, 2]")
+    end
+
+    it "handles three or more variables" do
+      vars = [
+        node_class.new(:lit, ["a"]),
+        node_class.new(:lit, ["b"]),
+        node_class.new(:lit, ["c"]),
+      ]
+      val = node_class.new(:lit, ["[1, 2, 3]"])
+      node = node_class.new(:massign, [vars, val])
+
+      result = generator.process(node)
+      expect(result).to eq("a, b, c = [1, 2, 3]")
+    end
+  end
+
+  describe "#on_begin" do
+    it "wraps code in a begin/end block" do
+      body = node_class.new(:lit, ["x + y"])
+      node = node_class.new(:begin, [body])
+
+      result = generator.process(node)
+      expect(result).to include("begin")
+      expect(result).to include("x + y")
+      expect(result).to include("end")
+    end
+  end
+
+  describe "#on_eq" do
+    it "generates an equality comparison" do
+      left = node_class.new(:lit, ["x"])
+      right = node_class.new(:lit, ["10"])
+      node = node_class.new(:eq, [left, right])
+
+      result = generator.process(node)
+      expect(result).to eq("x == 10")
+    end
+
+    it "handles complex expressions on both sides" do
+      left = node_class.new(:send, [
+                              node_class.new(:lit, ["a"]),
+                              "length",
+                            ])
+      right = node_class.new(:lit, ["5"])
+      node = node_class.new(:eq, [left, right])
+
+      result = generator.process(node)
+      expect(result).to eq("a.length == 5")
+    end
+  end
+
+  describe "#on_and" do
+    it "generates a boolean and expression" do
+      left = node_class.new(:lit, ["x"])
+      right = node_class.new(:lit, ["y"])
+      node = node_class.new(:and, [left, right])
+
+      result = generator.process(node)
+      expect(result).to eq("x && y")
+    end
+  end
+
+  describe "#on_or" do
+    it "generates a boolean or expression with parentheses" do
+      left = node_class.new(:lit, ["x"])
+      right = node_class.new(:lit, ["y"])
+      node = node_class.new(:or, [left, right])
+
+      result = generator.process(node)
+      expect(result).to eq("(x || y)")
+    end
+  end
+
+  describe "#on_if" do
+    it "generates an if statement without else" do
+      condition = node_class.new(:lit, ["x > 10"])
+      body = node_class.new(:lit, ['puts "yes"'])
+      node = node_class.new(:if, [condition, body])
+
+      result = generator.process(node)
+      expect(result).to include("if x > 10")
+      expect(result).to include('puts "yes"')
+      expect(result).to include("end")
+      expect(result).not_to include("else")
+    end
+
+    it "generates an if/else statement when else_body is present" do
+      condition = node_class.new(:lit, ["x > 10"])
+      body = node_class.new(:lit, ['puts "yes"'])
+      else_body = node_class.new(:lit, ['puts "no"'])
+      node = node_class.new(:if, [condition, body, else_body])
+
+      result = generator.process(node)
+      expect(result).to include("if x > 10")
+      expect(result).to include('puts "yes"')
+      expect(result).to include("else")
+      expect(result).to include('puts "no"')
+      expect(result).to include("end")
+    end
+  end
+
+  describe "#on_while" do
+    it "generates a while loop" do
+      condition = node_class.new(:lit, ["x < 10"])
+      body = node_class.new(:lit, ["x += 1"])
+      node = node_class.new(:while, [condition, body])
+
+      result = generator.process(node)
+      expect(result).to include("while x < 10")
+      expect(result).to include("x += 1")
+      expect(result).to include("end")
+    end
+  end
+
+  describe "#on_send" do
+    it "generates a method call without receiver" do
+      node = node_class.new(:send,
+                            [nil, "puts", node_class.new(:string, ["hello"])])
+
+      result = generator.process(node)
+      expect(result).to eq('puts("hello")')
+    end
+
+    it "generates a method call with receiver" do
+      receiver = node_class.new(:lit, ["str"])
+      node = node_class.new(:send, [receiver, "upcase"])
+
+      result = generator.process(node)
+      expect(result).to eq("str.upcase")
+    end
+
+    it "generates a method call with receiver and arguments" do
+      receiver = node_class.new(:lit, ["arr"])
+      arg = node_class.new(:lit, ["0"])
+      node = node_class.new(:send, [receiver, "at", arg])
+
+      result = generator.process(node)
+      expect(result).to eq("arr.at(0)")
+    end
+
+    it "handles multiple arguments" do
+      receiver = node_class.new(:lit, ["str"])
+      arg1 = node_class.new(:lit, ["0"])
+      arg2 = node_class.new(:lit, ["5"])
+      node = node_class.new(:send, [receiver, "slice", arg1, arg2])
+
+      result = generator.process(node)
+      expect(result).to eq("str.slice(0, 5)")
+    end
+
+    it "handles bracket notation for array access" do
+      receiver = node_class.new(:lit, ["arr"])
+      arg = node_class.new(:lit, ["0"])
+      node = node_class.new(:send, [receiver, "[]", arg])
+
+      result = generator.process(node)
+      expect(result).to eq("arr[0]")
+    end
+
+    it "handles bracket notation without arguments" do
+      receiver = node_class.new(:lit, ["arr"])
+      node = node_class.new(:send, [receiver, "[]"])
+
+      result = generator.process(node)
+      expect(result).to eq("arr[]")
+    end
+  end
+
+  describe "#on_block" do
+    it "generates a block with single argument" do
+      receiver = node_class.new(:send, [
+                                  node_class.new(:lit, ["items"]),
+                                  "each",
+                                ])
+      arg = node_class.new(:lit, ["item"])
+      body = node_class.new(:send, [
+                              nil,
+                              "puts",
+                              node_class.new(:lit, ["item"]),
+                            ])
+      node = node_class.new(:block, [receiver, [arg], body])
+
+      result = generator.process(node)
+      expect(result).to include("items.each do |item|")
+      expect(result).to include("puts(item)")
+      expect(result).to include("end")
+    end
+
+    it "generates a block with multiple arguments" do
+      receiver = node_class.new(:send, [
+                                  node_class.new(:lit, ["hash"]),
+                                  "each",
+                                ])
+      arg1 = node_class.new(:lit, ["key"])
+      arg2 = node_class.new(:lit, ["value"])
+      body = node_class.new(:lit, ["body"])
+      node = node_class.new(:block, [receiver, [arg1, arg2], body])
+
+      result = generator.process(node)
+      expect(result).to include("hash.each do |key, value|")
+      expect(result).to include("body")
+    end
+
+    it "handles blocks without body" do
+      receiver = node_class.new(:send, [
+                                  node_class.new(:lit, ["items"]),
+                                  "each",
+                                ])
+      arg = node_class.new(:lit, ["item"])
+      node = node_class.new(:block, [receiver, [arg], nil])
+
+      result = generator.process(node)
+      expect(result).to include("items.each do |item|")
+      expect(result).to include("end")
+    end
+  end
+
+  describe "#on_range" do
+    it "generates a range expression" do
+      start = node_class.new(:lit, ["1"])
+      stop = node_class.new(:lit, ["10"])
+      node = node_class.new(:range, [start, stop])
+
+      result = generator.process(node)
+      expect(result).to eq("(1..10)")
+    end
+
+    it "handles complex expressions as range boundaries" do
+      start = node_class.new(:send, [
+                               node_class.new(:lit, ["arr"]),
+                               "first",
+                             ])
+      stop = node_class.new(:send, [
+                              node_class.new(:lit, ["arr"]),
+                              "last",
+                            ])
+      node = node_class.new(:range, [start, stop])
+
+      result = generator.process(node)
+      expect(result).to eq("(arr.first..arr.last)")
+    end
+  end
+
+  describe "#on_string" do
+    it "generates a string literal with proper escaping" do
+      node = node_class.new(:string, ["hello world"])
+
+      result = generator.process(node)
+      expect(result).to eq('"hello world"')
+    end
+
+    it "properly escapes special characters" do
+      node = node_class.new(:string, ['hello "world"'])
+
+      result = generator.process(node)
+      expect(result).to eq('"hello \"world\""')
+    end
+
+    it "handles newlines" do
+      node = node_class.new(:string, ["hello\nworld"])
+
+      result = generator.process(node)
+      expect(result).to eq('"hello\nworld"')
+    end
+  end
+
+  describe "#on_symbol" do
+    it "generates a symbol literal" do
+      node = node_class.new(:symbol, ["test"])
+
+      result = generator.process(node)
+      expect(result).to eq(":test")
+    end
+
+    it "handles symbols with special characters" do
+      node = node_class.new(:symbol, ["test_symbol"])
+
+      result = generator.process(node)
+      expect(result).to eq(":test_symbol")
+    end
+  end
+
+  describe "#on_lit" do
+    it "returns the literal value as-is" do
+      node = node_class.new(:lit, ["42"])
+
+      result = generator.process(node)
+      expect(result).to eq("42")
+    end
+
+    it "handles variable names" do
+      node = node_class.new(:lit, ["my_var"])
+
+      result = generator.process(node)
+      expect(result).to eq("my_var")
+    end
+
+    it "handles any string literal" do
+      node = node_class.new(:lit, ["some_expression"])
+
+      result = generator.process(node)
+      expect(result).to eq("some_expression")
+    end
+  end
+
+  describe "integration tests" do
+    it "generates valid Ruby code for complex expressions" do
+      # Create: x = 10; if x > 5; puts "big"; else; puts "small"; end
+      x_var = node_class.new(:lit, ["x"])
+      ten = node_class.new(:lit, ["10"])
+      assignment = x_var.assign(ten)
+
+      condition = node_class.new(:send,
+                                 [x_var, ">", node_class.new(:lit, ["5"])])
+      if_body = node_class.new(:send,
+                               [nil, "puts", node_class.new(:string, ["big"])])
+      else_body = node_class.new(:send,
+                                 [nil, "puts",
+                                  node_class.new(:string, ["small"])])
+      if_stmt = node_class.new(:if, [condition, if_body, else_body])
+
+      program = assignment.followed_by(if_stmt)
+
+      code = generator.process(program)
+      expect(code).to be_a(String)
+
+      # Verify code can be parsed (basic syntax check)
+      expect { eval("lambda { #{code} }") }.not_to raise_error
+    end
+
+    it "generates code for nested blocks" do
+      # Create: [1,2,3].each { |x| puts x }
+      arr = node_class.new(:lit, ["[1,2,3]"])
+      each_call = node_class.new(:send, [arr, "each"])
+      arg = node_class.new(:lit, ["x"])
+      body = node_class.new(:send, [nil, "puts", node_class.new(:lit, ["x"])])
+      block = node_class.new(:block, [each_call, [arg], body])
+
+      code = generator.process(block)
+      expect(code).to include("[1,2,3].each do |x|")
+      expect(code).to include("puts(x)")
+    end
+  end
+end

data/spec/moxml/xpath/ruby/node_spec.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::XPath::Ruby::Node do
+  describe "#initialize" do
+    it "creates a node with type and children" do
+      node = described_class.new(:lit, ["10"])
+      expect(node.type).to eq(:lit)
+      expect(node.to_a).to eq(["10"])
+    end
+
+    it "creates a node with empty children by default" do
+      node = described_class.new(:lit)
+      expect(node.type).to eq(:lit)
+      expect(node.to_a).to eq([])
+    end
+
+    it "converts type to symbol" do
+      node = described_class.new("lit", ["10"])
+      expect(node.type).to eq(:lit)
+    end
+  end
+
+  describe "#to_a and #to_ary" do
+    it "returns the children array" do
+      children = ["a", "b", "c"]
+      node = described_class.new(:test, children)
+      expect(node.to_a).to eq(children)
+      expect(node.to_ary).to eq(children)
+    end
+  end
+
+  describe "#to_array" do
+    it "returns a :send node calling to_a on the receiver" do
+      node = described_class.new(:lit, ["items"])
+      result = node.to_array
+
+      expect(result.type).to eq(:send)
+      expect(result.to_a).to eq([node, :to_a])
+    end
+  end
+
+  describe "#assign" do
+    it "creates an assignment node" do
+      var = described_class.new(:lit, ["x"])
+      val = described_class.new(:lit, ["10"])
+      result = var.assign(val)
+
+      expect(result.type).to eq(:assign)
+      expect(result.to_a).to eq([var, val])
+    end
+
+    it "wraps followed_by nodes in begin block" do
+      var = described_class.new(:lit, ["x"])
+      val = described_class.new(:followed_by, [
+                                  described_class.new(:lit, ["a"]),
+                                  described_class.new(:lit, ["b"]),
+                                ])
+      result = var.assign(val)
+
+      expect(result.type).to eq(:assign)
+      assigned_val = result.to_a[1]
+      expect(assigned_val.type).to eq(:begin)
+    end
+  end
+
+  describe "#eq" do
+    it "creates an equality comparison node" do
+      left = described_class.new(:lit, ["10"])
+      right = described_class.new(:lit, ["20"])
+      result = left.eq(right)
+
+      expect(result.type).to eq(:eq)
+      expect(result.to_a).to eq([left, right])
+    end
+  end
+
+  describe "#and" do
+    it "creates a boolean and node" do
+      left = described_class.new(:lit, ["true"])
+      right = described_class.new(:lit, ["false"])
+      result = left.and(right)
+
+      expect(result.type).to eq(:and)
+      expect(result.to_a).to eq([left, right])
+    end
+  end
+
+  describe "#or" do
+    it "creates a boolean or node" do
+      left = described_class.new(:lit, ["true"])
+      right = described_class.new(:lit, ["false"])
+      result = left.or(right)
+
+      expect(result.type).to eq(:or)
+      expect(result.to_a).to eq([left, right])
+    end
+  end
+
+  describe "#not" do
+    it "creates a boolean not node using !" do
+      node = described_class.new(:lit, ["true"])
+      result = node.not
+
+      # The not method calls !self, which should create appropriate node
+      # Since Node inherits from BasicObject and undefines !,
+      # we need to verify the behavior
+      expect(result).to be_a(described_class)
+    end
+  end
+
+  describe "#is_a?" do
+    it "creates a :send node for is_a? method call" do
+      node = described_class.new(:lit, ["obj"])
+      result = node.is_a?(String)
+
+      expect(result.type).to eq(:send)
+      expect(result.to_a[0]).to eq(node)
+      expect(result.to_a[1]).to eq("is_a?")
+      expect(result.to_a[2].type).to eq(:lit)
+      expect(result.to_a[2].to_a[0]).to eq("String")
+    end
+  end
+
+  describe "#add_block" do
+    it "wraps node in a block with arguments and body" do
+      receiver = described_class.new(:lit, ["items"])
+      arg = described_class.new(:lit, ["item"])
+      body = described_class.new(:lit, ["body"])
+
+      result = receiver.add_block(arg) { body }
+
+      expect(result.type).to eq(:block)
+      expect(result.to_a[0]).to eq(receiver)
+      expect(result.to_a[1]).to eq([arg])
+      expect(result.to_a[2]).to eq(body)
+    end
+
+    it "accepts multiple arguments" do
+      receiver = described_class.new(:lit, ["hash"])
+      arg1 = described_class.new(:lit, ["key"])
+      arg2 = described_class.new(:lit, ["value"])
+      body = described_class.new(:lit, ["body"])
+
+      result = receiver.add_block(arg1, arg2) { body }
+
+      expect(result.type).to eq(:block)
+      expect(result.to_a[1]).to eq([arg1, arg2])
+    end
+  end
+
+  describe "#wrap" do
+    it "wraps the node in a begin node" do
+      node = described_class.new(:lit, ["10"])
+      result = node.wrap
+
+      expect(result.type).to eq(:begin)
+      expect(result.to_a).to eq([node])
+    end
+  end
+
+  describe "#if_true" do
+    it "creates an if statement with the node as condition" do
+      condition = described_class.new(:lit, ["x > 10"])
+      body = described_class.new(:lit, ['puts "yes"'])
+
+      result = condition.if_true { body }
+
+      expect(result.type).to eq(:if)
+      expect(result.to_a[0]).to eq(condition)
+      expect(result.to_a[1]).to eq(body)
+    end
+  end
+
+  describe "#if_false" do
+    it "creates an if !condition statement" do
+      condition = described_class.new(:lit, ["x > 10"])
+      body = described_class.new(:lit, ['puts "no"'])
+
+      result = condition.if_false { body }
+
+      expect(result.type).to eq(:if)
+      # Should have a not applied to condition
+      negated_condition = result.to_a[0]
+      expect(negated_condition).to be_a(described_class)
+    end
+  end
+
+  describe "#while_true" do
+    it "creates a while loop with the node as condition" do
+      condition = described_class.new(:lit, ["x < 10"])
+      body = described_class.new(:lit, ["x += 1"])
+
+      result = condition.while_true { body }
+
+      expect(result.type).to eq(:while)
+      expect(result.to_a[0]).to eq(condition)
+      expect(result.to_a[1]).to eq(body)
+    end
+  end
+
+  describe "#else" do
+    it "adds an else clause to an if node" do
+      condition = described_class.new(:lit, ["x > 10"])
+      if_body = described_class.new(:lit, ["a"])
+      else_body = described_class.new(:lit, ["b"])
+
+      if_node = condition.if_true { if_body }
+      result = if_node.else { else_body }
+
+      expect(result.type).to eq(:if)
+      expect(result.to_a[0]).to eq(condition)
+      expect(result.to_a[1]).to eq(if_body)
+      expect(result.to_a[2]).to eq(else_body)
+    end
+  end
+
+  describe "#followed_by" do
+    it "chains two nodes together" do
+      first = described_class.new(:lit, ["a"])
+      second = described_class.new(:lit, ["b"])
+
+      result = first.followed_by(second)
+
+      expect(result.type).to eq(:followed_by)
+      expect(result.to_a[0]).to eq(first)
+      expect(result.to_a[1]).to eq(second)
+    end
+
+    it "accepts a block to provide the second node" do
+      first = described_class.new(:lit, ["a"])
+      second = described_class.new(:lit, ["b"])
+
+      result = first.followed_by { second }
+
+      expect(result.type).to eq(:followed_by)
+      expect(result.to_a[0]).to eq(first)
+      expect(result.to_a[1]).to eq(second)
+    end
+  end
+
+  describe "#method_missing" do
+    it "creates a :send node for method calls without arguments" do
+      receiver = described_class.new(:lit, ["obj"])
+      result = receiver.foo
+
+      expect(result.type).to eq(:send)
+      expect(result.to_a[0]).to eq(receiver)
+      expect(result.to_a[1]).to eq("foo")
+    end
+
+    it "creates a :send node for method calls with arguments" do
+      receiver = described_class.new(:lit, ["obj"])
+      arg1 = described_class.new(:lit, ["a"])
+      arg2 = described_class.new(:lit, ["b"])
+
+      result = receiver.bar(arg1, arg2)
+
+      expect(result.type).to eq(:send)
+      expect(result.to_a[0]).to eq(receiver)
+      expect(result.to_a[1]).to eq("bar")
+      expect(result.to_a[2]).to eq(arg1)
+      expect(result.to_a[3]).to eq(arg2)
+    end
+
+    it "handles various method names" do
+      receiver = described_class.new(:lit, ["obj"])
+
+      # Test different method names
+      expect(receiver.length.to_a[1]).to eq("length")
+      expect(receiver.upcase.to_a[1]).to eq("upcase")
+      expect(receiver.custom_method.to_a[1]).to eq("custom_method")
+    end
+  end
+
+  describe "#inspect" do
+    it "returns a string representation of the node" do
+      node = described_class.new(:lit, ["10"])
+      expect(node.inspect).to eq('(lit "10")')
+    end
+
+    it "includes nested nodes in the representation" do
+      child1 = described_class.new(:lit, ["a"])
+      child2 = described_class.new(:lit, ["b"])
+      node = described_class.new(:eq, [child1, child2])
+
+      expect(node.inspect).to eq('(eq (lit "a") (lit "b"))')
+    end
+  end
+end