metamorpher 0.1.0

data/spec/support/matchers/have_substitution_matcher.rb

@@ -0,0 +1,15 @@
+require "rspec/expectations"
+
+RSpec::Matchers.define :have_substitution do |expected|
+  match do |actual|
+    actual.substitution == expected
+  end
+
+  failure_message_for_should do |actual|
+    "expected the substitution #{actual.substitution}, but got #{expected}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "expected to not receive the substitution #{actual.substitution}"
+  end
+end

data/spec/support/shared_examples/shared_examples_for_derivation_builders.rb

@@ -0,0 +1,53 @@
+require "metamorpher/terms/literal"
+
+module Metamorpher
+  module Terms
+    shared_examples "a derivation builder" do
+      describe "derivation!" do
+        it "should create an instance of Derivation" do
+          built = subject.derivation!(:method) do |method|
+            Literal.new(name: (method.name.to_s + "s").to_sym)
+          end
+
+          expect(built.base).to eq([:method])
+          expect(built.derivation.call(Literal.new(name: :dog))).to eq(Literal.new(name: :dogs))
+        end
+
+        it "should capture all arguments as the base" do
+          built = subject.derivation!(:key, :value) {}
+
+          expect(built.base).to eq([:key, :value])
+        end
+
+        it "should provide a builder for use in the block" do
+          built = subject.derivation!(:key, :value) do |key, value, builder|
+            builder.pair(key, value)
+          end
+
+          derived = built.derivation.call(
+            Literal.new(name: :dog),
+            Literal.new(name: :lassie)
+          )
+
+          paired = Literal.new(
+            name: :pair,
+            children: [
+              Literal.new(name: :dog),
+              Literal.new(name: :lassie)
+            ]
+          )
+
+          expect(derived).to eq(paired)
+        end
+
+        it "should raise if no arguments are passed" do
+          expect { subject.derivation! { nil } }.to raise_error(ArgumentError)
+        end
+
+        it "should raise if no block is passed" do
+          expect { subject.derivation!(:method) }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end

data/spec/support/shared_examples/shared_examples_for_greedy_variable_builders.rb

@@ -0,0 +1,49 @@
+require "metamorpher/terms/variable"
+
+module Metamorpher
+  module Terms
+    shared_examples "a greedy variable builder" do
+      describe "greedy_variable!" do
+        it "should create an instance of Variable with greedy? set to true" do
+          actual = subject.greedy_variable!(:a)
+          expected = Variable.new(name: :a, greedy?: true)
+
+          expect(actual).to eq(expected)
+        end
+
+        it "should create condition from block" do
+          built = subject.greedy_variable!(:a) { |term| term > 0 }
+
+          expect(built.name).to eq(:a)
+          expect(built.condition.call(1)).to be_true
+          expect(built.condition.call(-1)).to be_false
+        end
+
+        it "should not allow children" do
+          expect { subject.greedy_variable!(:a, 1) }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe "greedy variable shorthand" do
+        it "should create an instance of Variable with greedy? set to true" do
+          actual = subject.A_
+          expected = Variable.new(name: :a, greedy?: true)
+
+          expect(actual).to eq(expected)
+        end
+
+        it "should create condition from block" do
+          built = subject.A_ { |term| term > 0 }
+
+          expect(built.name).to eq(:a)
+          expect(built.condition.call(1)).to be_true
+          expect(built.condition.call(-1)).to be_false
+        end
+
+        it "should not allow children" do
+          expect { subject.A_(1) }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end

data/spec/support/shared_examples/shared_examples_for_literal_builders.rb

@@ -0,0 +1,93 @@
+require "metamorpher/terms/literal"
+require "metamorpher/terms/variable"
+
+module Metamorpher
+  module Terms
+    shared_examples_for "a literal builder" do
+      describe "literal!" do
+        it "should create an instance of Literal" do
+          actual = subject.literal!(:a)
+          expected = Literal.new(name: :a)
+
+          expect(actual).to eq(expected)
+        end
+
+        it "should work with numeric names" do
+          actual = subject.literal!(4)
+          expected = Literal.new(name: 4)
+
+          expect(actual).to eq(expected)
+        end
+
+        it "should capture single children" do
+          actual = subject.literal!(:inc, subject.literal!(1))
+          expected = Literal.new(name: :inc, children: [Literal.new(name: 1)])
+
+          expect(actual).to eq(expected)
+        end
+
+        it "should capture several children" do
+          actual = subject.literal!(:add, subject.literal!(1), subject.literal!(2))
+          expected = Literal.new(
+            name: :add,
+            children: [
+              Literal.new(name: 1),
+              Literal.new(name: 2)
+            ]
+          )
+
+          expect(actual).to eq(expected)
+        end
+
+        it "should automatically convert children to literals" do
+          actual = subject.literal!(:add, 1, 2)
+          expected = Literal.new(
+            name: :add,
+            children: [
+              Literal.new(name: 1),
+              Literal.new(name: 2)
+            ]
+          )
+
+          expect(actual).to eq(expected)
+        end
+
+        it "should not automatically convert children that are already terms" do
+          actual = subject.literal!(:inc, Variable.new(name: :a))
+          expected = Literal.new(name: :inc, children: [Variable.new(name: :a)])
+
+          expect(actual).to eq(expected)
+        end
+      end
+
+      describe "literal shorthand" do
+        it "should create an instance of Literal" do
+          actual = subject.a
+          expected = Literal.new(name: :a)
+
+          expect(actual).to eq(expected)
+        end
+
+        it "should work for longer names" do
+          actual = subject.this_is_a_longer_name
+          expected = Literal.new(name: :this_is_a_longer_name)
+
+          expect(actual).to eq(expected)
+        end
+
+        it "should capture children" do
+          actual = subject.add(1, 2)
+          expected = Literal.new(
+            name: :add,
+            children: [
+              Literal.new(name: 1),
+              Literal.new(name: 2)
+            ]
+          )
+
+          expect(actual).to eq(expected)
+        end
+      end
+    end
+  end
+end

data/spec/support/shared_examples/shared_examples_for_variable_builders.rb

@@ -0,0 +1,49 @@
+require "metamorpher/terms/variable"
+
+module Metamorpher
+  module Terms
+    shared_examples "a variable builder" do
+      describe "variable!" do
+        it "should create an instance of Variable" do
+          actual = subject.variable!(:a)
+          expected = Variable.new(name: :a)
+
+          expect(actual).to eq(expected)
+        end
+
+        it "should create condition from block" do
+          built = subject.variable!(:a) { |term| term > 0 }
+
+          expect(built.name).to eq(:a)
+          expect(built.condition.call(1)).to be_true
+          expect(built.condition.call(-1)).to be_false
+        end
+
+        it "should not allow children" do
+          expect { subject.variable!(:a, 1) }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe "variable shorthand" do
+        it "should create an instance of Variable" do
+          actual = subject.A
+          expected = Variable.new(name: :a)
+
+          expect(actual).to eq(expected)
+        end
+
+        it "should create condition from block" do
+          built = subject.A { |term| term > 0 }
+
+          expect(built.name).to eq(:a)
+          expect(built.condition.call(1)).to be_true
+          expect(built.condition.call(-1)).to be_false
+        end
+
+        it "should not allow children" do
+          expect { subject.A(1) }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end

data/spec/unit/builders/ast/derivation_builder_spec.rb

@@ -0,0 +1,5 @@
+require "metamorpher/builders/ast/derivation_builder"
+
+describe Metamorpher::Builders::AST::DerivationBuilder do
+  it_behaves_like "a derivation builder"
+end

data/spec/unit/builders/ast/greedy_variable_builder_spec.rb

@@ -0,0 +1,9 @@
+require "metamorpher/builders/ast/greedy_variable_builder"
+
+describe Metamorpher::Builders::AST::GreedyVariableBuilder do
+  it_behaves_like "a greedy variable builder"
+
+  it "should raise when incorrect shorthand is used" do
+    expect { subject.inc }.to raise_error(NoMethodError)
+  end
+end

data/spec/unit/builders/ast/literal_builder_spec.rb

@@ -0,0 +1,9 @@
+require "metamorpher/builders/ast/literal_builder"
+
+describe Metamorpher::Builders::AST::LiteralBuilder do
+  it_behaves_like "a literal builder"
+
+  it "should raise when variable shorthand is used" do
+    expect { subject.INC }.to raise_error(NoMethodError)
+  end
+end

data/spec/unit/builders/ast/variable_builder_spec.rb

@@ -0,0 +1,9 @@
+require "metamorpher/builders/ast/variable_builder"
+
+describe Metamorpher::Builders::AST::VariableBuilder do
+  it_behaves_like "a variable builder"
+
+  it "should raise when incorrect shorthand is used" do
+    expect { subject.inc }.to raise_error(NoMethodError)
+  end
+end

data/spec/unit/builders/ruby/variable_replacement_visitor_spec.rb

@@ -0,0 +1,48 @@
+require "metamorpher/builders/ruby/variable_replacement_visitor"
+
+module Metamorpher
+  module Builders
+    module Ruby
+      describe VariableReplacementVisitor do
+        let(:builder) { Metamorpher::Builders::AST::Builder.new }
+        let(:replacement) { builder.literal!(:bar) }
+        subject { VariableReplacementVisitor.new(:foo, replacement) }
+
+        it "should replace a variable with the correct name" do
+          original = builder.variable!(:foo)
+          replaced = subject.visit(original)
+
+          expect(replaced).to eq(replacement)
+        end
+
+        it "should replace a nested variable" do
+          original = builder.literal!(:+, 2, builder.variable!(:foo))
+          replaced = subject.visit(original)
+
+          expect(replaced).to eq(original.replace(original.children.last.path, replacement))
+        end
+
+        it "should not replace a variable with a different name" do
+          original = builder.variable!(:bar)
+          replaced = subject.visit(original)
+
+          expect(replaced).to eq(original)
+        end
+
+        it "should not replace a literal" do
+          original = builder.literal!(:foo)
+          replaced = subject.visit(original)
+
+          expect(replaced).to eq(original)
+        end
+
+        it "should not replace a derived" do
+          original = builder.derivation!(:foo) {}
+          replaced = subject.visit(original)
+
+          expect(replaced).to eq(original)
+        end
+      end
+    end
+  end
+end

data/spec/unit/drivers/ruby_spec.rb

@@ -0,0 +1,91 @@
+require "metamorpher/drivers/ruby"
+require "metamorpher/builders/ast/builder"
+
+module Metamorpher
+  module Drivers
+    describe Ruby do
+      let(:builder) { Builders::AST::Builder.new }
+
+      describe "for a simple program" do
+        let(:source)  { "1 + 2" }
+        let(:literal) { builder.literal!(:send, builder.int(1), :+, builder.int(2)) }
+
+        it "should parse a simple program to literals" do
+          expect(subject.parse(source)).to eq(literal)
+        end
+
+        it "should unparse valid literals to source" do
+          expect(subject.unparse(literal)).to eq(source)
+        end
+
+        it "should provide source location of literals" do
+          subject.parse(source)
+
+          expect(subject.source_location_for(literal)).to eq(0..4)
+          expect(subject.source_location_for(literal.children.first)).to eq(0..0)
+          expect(subject.source_location_for(literal.children.last)).to eq(4..4)
+        end
+      end
+
+      describe "for program containing identical statements" do
+        let(:source)  { "1 + 1" }
+        let(:literal) { builder.literal!(:send, builder.int(1), :+, builder.int(1)) }
+
+        it "should provide different source locations for syntactically equal literals" do
+          subject.parse(source)
+
+          expect(subject.source_location_for(literal.children.first)).to eq(0..0)
+          expect(subject.source_location_for(literal.children.last)).to eq(4..4)
+        end
+      end
+
+      describe "for program that parses to an AST containing nils" do
+        let(:source)  { "LEFT + RIGHT" }
+        let(:literal) do
+          builder.literal!(
+           :send,
+           builder.const(nil, :LEFT),
+           :+,
+           builder.const(nil, :RIGHT)
+          )
+        end
+
+        it "should parse a simple program to literals" do
+          expect(subject.parse(source)).to eq(literal)
+        end
+
+        it "should unparse valid literals to source" do
+          expect(subject.unparse(literal)).to eq(source)
+        end
+      end
+
+      %w(nil true false self).each do |keyword|
+        describe "for a program containing the '#{keyword}' keyword" do
+          let(:source)  { "a = #{keyword}" }
+          let(:literal) { builder.lvasgn(:a, keyword.to_sym) }
+
+          it "should parse to the correct literal" do
+            expect(subject.parse(source)).to eq(literal)
+          end
+
+          it "should unparse to the correct source" do
+            expect(subject.unparse(literal)).to eq(source)
+          end
+        end
+
+        describe "for a program that is the '#{keyword}' keyword" do
+          let(:source)  { keyword }
+          let(:literal) { builder.literal! keyword.to_sym }
+
+          it "should parse to the correct literal" do
+            expect(subject.parse(source)).to eq(literal)
+          end
+
+          it "should unparse to the correct source" do
+            expect(subject.unparse(literal)).to eq(source)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/matcher/matching_spec.rb

@@ -0,0 +1,230 @@
+require "metamorpher/terms/variable"
+require "metamorpher/terms/literal"
+require "metamorpher/terms/derived"
+
+module Metamorpher
+  module Terms
+    describe Variable do
+      let(:root) do
+        Literal.new(
+          name: :root,
+          children: [
+            Literal.new(name: :first_child),
+            Literal.new(name: :second_child),
+            Literal.new(name: :third_child)
+          ]
+        )
+      end
+
+      let(:first_child)  { root.children[0] }
+      let(:second_child) { root.children[1] }
+      let(:third_child)  { root.children[2] }
+
+      describe "unconditional, non-greedy variable" do
+        subject { Variable.new(name: :type) }
+
+        it "should match any literal" do
+          expect(subject.match(root)).to have_matched(root)
+        end
+
+        it "should include the match in the substitution" do
+          expect(subject.match(root)).to have_substitution(type: root)
+        end
+
+        it "shouldn't match nil" do
+          expect(subject.match(nil)).not_to have_matched
+        end
+      end
+
+      describe "conditional, non-greedy variable" do
+        subject { Variable.new(name: :type, condition: -> (l) { l.name == :third_child }) }
+
+        it "should match when literal matches condition" do
+          expect(subject.match(third_child)).to have_matched(third_child)
+        end
+
+        it "shouldn't match when literal doesn't match condition" do
+          expect(subject.match(second_child)).not_to have_matched
+        end
+
+        it "shouldn't match nil" do
+          expect(subject.match(nil)).not_to have_matched
+        end
+      end
+
+      describe "unconditional, greedy variable" do
+        subject { Variable.new(name: :type, greedy?: true) }
+
+        it "should match against literal and all younger siblings" do
+          result = subject.match(second_child)
+
+          expect(result).to have_matched([second_child, third_child])
+          expect(result).to have_substitution(type: [second_child, third_child])
+        end
+
+        it "should match against literal when there is no parent" do
+          result = subject.match(root)
+
+          expect(result).to have_matched([root])
+          expect(result).to have_substitution(type: [root])
+        end
+
+        it "should allow parent to match when there are a different number of children" do
+          wrapped_subject = Literal.new(name: :root, children: [subject])
+          result = wrapped_subject.match(root)
+
+          expect(result).to have_matched(root)
+          expect(result).to have_substitution(type: root.children)
+        end
+
+        it "shouldn't match nil" do
+          expect(subject.match(nil)).not_to have_matched
+        end
+      end
+
+      describe "conditional, greedy variable" do
+        subject { Variable.new(name: :type, greedy?: true, condition: -> (ls) { ls.size == 2 }) }
+
+        it "should match when literal matches condition" do
+          result = subject.match(second_child)
+
+          expect(result).to have_matched([second_child, third_child])
+          expect(result).to have_substitution(type: [second_child, third_child])
+        end
+
+        it "should not match when literal doesn't match condition" do
+          expect(subject.match(third_child)).not_to have_matched
+        end
+
+        it "shouldn't match nil" do
+          expect(subject.match(nil)).not_to have_matched
+        end
+      end
+
+      describe Literal do
+        describe "with no children" do
+          let(:literal) { Literal.new(name: :root) }
+
+          it "should match when names match" do
+            matchee = Literal.new(name: :root)
+
+            expect(literal.match(matchee)).to have_matched(matchee)
+          end
+
+          it "shouldn't match when names don't match" do
+            matchee = Literal.new(name: :not_found)
+
+            expect(literal.match(matchee)).not_to have_matched
+          end
+
+          it "should be able to match nils" do
+            literal = Literal.new(name: nil)
+            matchee = Literal.new(name: nil)
+
+            expect(literal.match(matchee)).to have_matched(matchee)
+          end
+        end
+
+        describe "with children" do
+          let(:root) do
+            Literal.new(
+              name: :root,
+              children: [
+                Literal.new(name: :first_child),
+                Literal.new(name: :second_child),
+                Literal.new(name: :third_child)
+              ]
+            )
+          end
+
+          let(:first_child)  { root.children[0] }
+          let(:second_child) { root.children[1] }
+          let(:third_child)  { root.children[2] }
+
+          it "should match when children match" do
+            matchee = Literal.new(
+              name: :root,
+              children: [
+                Literal.new(name: :first_child),
+                Literal.new(name: :second_child),
+                Literal.new(name: :third_child)
+              ]
+            )
+
+            expect(root.match(matchee)).to have_matched(matchee)
+          end
+
+          it "should not match when children don't match" do
+            matchee = Literal.new(
+              name: :root,
+              children: [
+                Literal.new(name: :primer_hijo),
+                Literal.new(name: :segundo_hijo),
+                Literal.new(name: :tercero_hijo)
+              ]
+            )
+
+            expect(root.match(matchee)).not_to have_matched
+          end
+
+          it "should not match when there are too few children" do
+            matchee = Literal.new(
+              name: :root,
+              children: [
+                Literal.new(name: :first_child),
+                Literal.new(name: :second_child)
+              ]
+            )
+
+            expect(root.match(matchee)).not_to have_matched
+          end
+
+          it "should not match when there are too many children" do
+            matchee = Literal.new(
+              name: :root,
+              children: [
+                Literal.new(name: :first_child),
+                Literal.new(name: :second_child),
+                Literal.new(name: :third_child),
+                Literal.new(name: :fourth_child)
+              ]
+            )
+
+            expect(root.match(matchee)).not_to have_matched
+          end
+
+          it "builds substitution from children" do
+            root = Literal.new(
+              name: :root,
+              children: [
+                Variable.new(name: :first),
+                Literal.new(name: :second_child),
+                Variable.new(name: :last)
+              ]
+            )
+
+            matchee = Literal.new(
+              name: :root,
+              children: [
+                Literal.new(name: :first_child),
+                Literal.new(name: :second_child),
+                Literal.new(name: :third_child)
+              ]
+            )
+
+            expect(root.match(matchee)).to have_substitution(first: first_child, last: third_child)
+          end
+        end
+      end
+
+      describe Derived do
+        it "should raise" do
+          root = Derived.new
+          matchee = Literal.new(name: :root)
+
+          expect { root.match(matchee) }.to raise_error(Matcher::MatchingError)
+        end
+      end
+    end
+  end
+end

data/spec/unit/metamorpher_spec.rb

@@ -0,0 +1,22 @@
+require "metamorpher"
+
+module Metamorpher
+  describe Metamorpher do
+    it "should provide a Ruby builder by default" do
+      expect(subject.builder).to be_kind_of(Builders::Ruby::Builder)
+    end
+
+    describe "configure" do
+      it "should be possible to change to an AST builder" do
+        subject.configure(builder: :ast)
+        expect(subject.builder).to be_kind_of(Builders::AST::Builder)
+      end
+
+      it "should be possible to change back to the Ruby builder" do
+        subject.configure(builder: :ast)
+        subject.configure(builder: :ruby)
+        expect(subject.builder).to be_kind_of(Builders::Ruby::Builder)
+      end
+    end
+  end
+end