metamorpher 0.1.0

data/spec/unit/refactorer/merger_spec.rb

@@ -0,0 +1,84 @@
+require "metamorpher/refactorer/merger"
+require "metamorpher/refactorer/site"
+
+module Metamorpher
+  module Refactorer
+    describe Merger do
+      let(:original) { "The quick brown fox jumps over the lazy dog." }
+      subject { Merger.new(original) }
+
+      describe "for a single replacement" do
+        it "should be able to rewrite at the start of the string" do
+          merged = merge(Site.new(0..2, "The", "A"))
+
+          expect(merged).to eq("A quick brown fox jumps over the lazy dog.")
+        end
+
+        it "should be able to rewrite in the middle of the string" do
+          merged = merge(Site.new(4..8, "quick", "swift"))
+
+          expect(merged).to eq("The swift brown fox jumps over the lazy dog.")
+        end
+
+        it "should be able to rewrite at the end of the string" do
+          merged = merge(Site.new(43..43, ".", "!"))
+
+          expect(merged).to eq("The quick brown fox jumps over the lazy dog!")
+        end
+
+        it "should not alter the original string" do
+          merge(Site.new(0..2, "The", "A"))
+
+          expect(original).to eq("The quick brown fox jumps over the lazy dog.")
+        end
+
+        it "should yield before performing the replacement" do
+          replacement = Site.new(0..2, "The", "A")
+
+          expect { |b| merge(replacement, &b) }.to yield_with_args(replacement)
+        end
+      end
+
+      describe "for multiple replacements" do
+        it "should merge all replacements" do
+          merged = merge(
+            Site.new(4..8, "quick", "swift"),
+            Site.new(20..24, "jumps", "walks"),
+            Site.new(40..42, "dog", "cat")
+          )
+
+          expect(merged).to eq("The swift brown fox walks over the lazy cat.")
+        end
+
+        it "should determine position of all replacements based on the original string" do
+          merged = merge(
+            Site.new(4..8, "quick", "fast"),
+            Site.new(20..24, "jumps", "springs"),
+            Site.new(40..42, "dog", "cat")
+          )
+
+          # note that "fast" is 1 char shorter than its replacee "quick"
+          # and hence the second substring has to be repositioned by -1 char
+          # and that "springs" is 2 chars longer than its replacee "jumps"
+          # and hence the third substring has to be repositioned by +1 char (as -1 + +2 = +1)
+
+          expect(merged).to eq("The fast brown fox springs over the lazy cat.")
+        end
+
+        it "should yield before performing each replacement" do
+          replacements = [
+            Site.new(4..8, "quick", "fast"),
+            Site.new(20..24, "jumps", "springs"),
+            Site.new(40..42, "dog", "cat")
+          ]
+
+          expect { |b| merge(*replacements, &b) }.to yield_successive_args(*replacements)
+        end
+      end
+
+      def merge(*replacements, &block)
+        subject.merge(*replacements, &block)
+      end
+    end
+  end
+end

data/spec/unit/refactorer/site_spec.rb

@@ -0,0 +1,52 @@
+require "metamorpher/refactorer/site"
+
+module Metamorpher
+  module Refactorer
+    describe Site do
+      subject { Site.new(4..6, "foo", "bar") }
+
+      describe "slide" do
+        it "should return a replacement with the new position" do
+          expect(subject.slide(2).original_position).to eq(6..8)
+        end
+
+        it "should not alter the code" do
+          expect(subject.slide(2).original_code).to eq("foo")
+          expect(subject.slide(2).refactored_code).to eq("bar")
+        end
+
+        it "should be chainable" do
+          expect(subject.slide(2).slide(10).original_position).to eq(16..18)
+        end
+      end
+
+      describe "merge_into" do
+        it "should apply change to argument" do
+          expect(subject.merge_into("foo foo")).to eq("foo bar")
+        end
+
+        it "should raise error when mergee is shorter than start of position" do
+          expect { subject.merge_into("foo") }.to raise_error(ArgumentError)
+        end
+
+        it "should not raise error when mergee is same length as start of position" do
+          expect { subject.merge_into("foo ") }.to_not raise_error
+        end
+      end
+
+      describe "offset" do
+        it "should be 0 when position and value are the same size" do
+          expect(subject.offset).to eq(0)
+        end
+
+        it "should be -ve when position's size is larger than value's size" do
+          expect(Site.new(4..6, "foo", "b").offset).to eq(-2)
+        end
+
+        it "should be +ve when position's size is smaller than value's size" do
+          expect(Site.new(4..6, "foo", "baaz").offset).to eq(1)
+        end
+      end
+    end
+  end
+end

data/spec/unit/rewriter/replacement_spec.rb

@@ -0,0 +1,73 @@
+require "metamorpher/terms/variable"
+require "metamorpher/terms/derived"
+require "metamorpher/terms/literal"
+
+module Metamorpher
+  module Terms
+    describe "replace" do
+      describe "with no children" do
+        subject { Literal.new(name: :top) }
+
+        it "should be possible to replace at the top" do
+          replacement = Literal.new(name: :root)
+
+          expect(subject.replace(subject.path, replacement)).to eq(replacement)
+        end
+      end
+
+      describe "with children" do
+        subject do
+          Literal.new(
+            name: :root,
+            children: [
+              Literal.new(name: :first_child),
+              Variable.new(name: :second_child),
+              Derived.new(name: :third_child)
+            ]
+          )
+        end
+
+        let(:replacement) { Literal.new(name: :root) }
+
+        it "should be possible to replace literal child" do
+          expect(subject.replace(subject.children[0].path, replacement)).to eq(
+            Literal.new(
+              name: :root,
+              children: [
+                replacement,
+                Variable.new(name: :second_child),
+                Derived.new(name: :third_child)
+              ]
+            )
+          )
+        end
+
+        it "should be possible to replace literal child" do
+          expect(subject.replace(subject.children[1].path, replacement)).to eq(
+            Literal.new(
+              name: :root,
+              children: [
+                Literal.new(name: :first_child),
+                replacement,
+                Derived.new(name: :third_child)
+              ]
+            )
+          )
+        end
+
+        it "should be possible to replace derived child" do
+          expect(subject.replace(subject.children[2].path, replacement)).to eq(
+            Literal.new(
+              name: :root,
+              children: [
+                Literal.new(name: :first_child),
+                Variable.new(name: :second_child),
+                replacement
+              ]
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/spec/unit/rewriter/substitution_spec.rb

@@ -0,0 +1,97 @@
+require "metamorpher/terms/variable"
+require "metamorpher/terms/derived"
+require "metamorpher/terms/literal"
+
+module Metamorpher
+  module Terms
+    describe Variable do
+      subject { Variable.new(name: :type) }
+
+      it "should return the element of the substitution with the correct name" do
+        substitution = { type: Literal.new(name: :sub) }
+        expect(subject.substitute(substitution)).to eq(substitution[:type])
+      end
+
+      it "should raise if the substitution contains no value for variable's name" do
+        expect { subject.substitute({}) }.to raise_error(Rewriter::SubstitutionError)
+      end
+    end
+
+    describe Derived do
+      subject do
+        Derived.new(
+          base: [:type],
+          derivation: -> (type) { Literal.new(name: type.name.reverse) }
+        )
+      end
+
+      it "should return the element of the substitution after calling derivation" do
+        substitution = { type: Literal.new(name: "reverse_me") }
+
+        expect(subject.substitute(substitution)).to eq(
+          Literal.new(name: "reverse_me".reverse)
+        )
+      end
+
+      it "should raise if the substitution contains no value for variable's name" do
+        expect { subject.substitute({}) }.to raise_error(Rewriter::SubstitutionError)
+      end
+    end
+
+    describe Literal do
+      describe "with no children" do
+        subject { Literal.new(name: :root) }
+
+        it "should return the original literal" do
+          expect(subject.substitute({})).to eq(subject)
+        end
+      end
+
+      describe "with children" do
+        subject do
+          Literal.new(
+            name: :root,
+            children: [
+              Literal.new(name: :child, children: [Variable.new(name: :foo)])
+            ]
+          )
+        end
+
+        let(:child) { literal.children.first }
+        let(:grandchild) { child.children.first }
+
+        it "should return the original literal with substituted descendants" do
+          substitution = { foo: Literal.new(name: :bar) }
+
+          expect(subject.substitute(substitution)).to eq(
+            Literal.new(
+              name: :root,
+              children: [
+                Literal.new(
+                  name: :child,
+                  children: [Literal.new(name: :bar)]
+                )
+              ]
+            )
+          )
+        end
+
+        it "should contain all elements if the substituted value is an array" do
+          substitution = { foo: [Literal.new(name: :bar), Literal.new(name: :baz)] }
+
+          expect(subject.substitute(substitution)).to eq(
+            Literal.new(
+              name: :root,
+              children: [
+                Literal.new(
+                  name: :child,
+                  children: [Literal.new(name: :bar), Literal.new(name: :baz)]
+                )
+              ]
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/spec/unit/rewriter/traverser_spec.rb

@@ -0,0 +1,51 @@
+require "metamorpher/rewriter/traverser"
+
+module Metamorpher
+  module Rewriter
+    describe Traverser do
+      describe "traversing a flat tree" do
+        let(:tree) { t(1, 2, 3, 4) }
+
+        it "correctly reports number of nodes" do
+          expect(subject.traverse(tree).size).to eq(5)
+        end
+
+        it "returns nodes in left-to-right order" do
+          expect(subject.traverse(tree).take(5)).to eq([tree, 1, 2, 3, 4])
+        end
+      end
+
+      describe "traversing a skinny tree" do
+        let(:tree) { t(1, t(2, t(3))) }
+
+        it "correctly reports number of nodes" do
+          expect(subject.traverse(tree).size).to eq(6)
+        end
+
+        it "returns nodes in outermost (root-to-leaves) order" do
+          expect(subject.traverse(tree).take(6)).to eq(
+            [tree, 1, tree.children.last, 2, tree.children.last.children.last, 3]
+          )
+        end
+      end
+
+      describe "traversing the empty tree" do
+        let(:tree) { t }
+
+        it "correctly reports number of nodes" do
+          expect(subject.traverse(tree).size).to eq(1)
+        end
+
+        it "returns only the original tree" do
+          expect(subject.traverse(tree).take(1)).to eq([tree])
+        end
+      end
+
+      def t(*children)
+        Tree.new(children)
+      end
+
+      class Tree < Struct.new(:children); end
+    end
+  end
+end

data/spec/unit/support/map_at_spec.rb

@@ -0,0 +1,18 @@
+require "metamorpher/support/map_at"
+
+describe Enumerable do
+  subject { %w(foo bar baz) }
+
+  describe "map_at" do
+    it "should return a new array with the specified replacement" do
+      expect(subject.map_at(0) { |w| w.reverse }).to eq(%w(oof bar baz))
+      expect(subject.map_at(1) { |w| w.reverse }).to eq(%w(foo rab baz))
+      expect(subject.map_at(2) { |w| w.reverse }).to eq(%w(foo bar zab))
+    end
+
+    it "should raise when index is out of range" do
+      expect { subject.map_at(-1) }.to raise_error(IndexError)
+      expect { subject.map_at(3) }.to raise_error(IndexError)
+    end
+  end
+end

data/spec/unit/terms/literal_spec.rb

@@ -0,0 +1,60 @@
+require "metamorpher/terms/literal"
+
+module Metamorpher
+  module Terms
+    describe Literal do
+      describe "leaf? and branch?" do
+        let(:parent) { Literal.new(name: :parent, children: [Literal.new(name: :child)]) }
+        let(:child)  { parent.children.first }
+
+        it "should correctly identify childless literals as leaves not branches" do
+          expect(child).to be_leaf
+          expect(child).not_to be_branch
+        end
+
+        it "should correctly identify literals with children as branches not leaves" do
+          expect(parent).to be_branch
+          expect(parent).not_to be_leaf
+        end
+      end
+
+      describe "child_of?" do
+        let(:parent) { Literal.new(name: :parent, children: [Literal.new(name: :child)]) }
+        let(:child)  { parent.children.first }
+
+        it "should return true when parent's name is parameter" do
+          expect(child).to be_child_of(:parent)
+        end
+
+        it "should return false when parent's name is not parameter" do
+          expect(child).not_to be_child_of(:root)
+        end
+
+        it "should false when literal has no parent" do
+          expect(parent).not_to be_child_of(:root)
+        end
+      end
+
+      describe "children younger than or equal to" do
+        let(:eldest)   { Term.new(name: :eldest) }
+        let(:middle)   { Term.new(name: :middle) }
+        let(:youngest) { Term.new(name: :youngest) }
+
+        subject { Literal.new(name: :parent, children: [eldest, middle, youngest]) }
+
+        it "should return all children not to the 'left' of argument" do
+          expect(subject.children_younger_than_or_equal_to(middle)).to eq([middle, youngest])
+        end
+
+        it "should return an only argument when argument is the youngest" do
+          expect(subject.children_younger_than_or_equal_to(youngest)).to eq([youngest])
+        end
+
+        it "should raise when argument is not a child" do
+          expect { subject.children_younger_than_or_equal_to(Term.new(name: :unknown)) }
+            .to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end

data/spec/unit/terms/term_spec.rb

@@ -0,0 +1,59 @@
+require "metamorpher/terms/term"
+require "metamorpher/terms/literal"
+
+module Metamorpher
+  module Terms
+    describe Term do
+      describe "path" do
+        let(:root) do
+          Literal.new(
+            name: :root,
+            children: [
+              Literal.new(
+                name: :child,
+                children: [
+                  Term.new(name: :grandchild),
+                  Term.new(name: :grandchild)
+                ]
+              ),
+              Literal.new(
+                name: :child,
+                children: [
+                  Term.new(name: :grandchild),
+                  Term.new(name: :grandchild),
+                  Term.new(name: :grandchild)
+                ]
+              )
+            ]
+          )
+        end
+
+        let(:first_child)   { root.children.first }
+        let(:second_child)  { root.children.last }
+
+        let(:leftmost_grandchild)   { first_child.children.first }
+        let(:rightmost_grandchild)  { second_child.children.last }
+
+        it "should return [] for root" do
+          expect(root.path).to eq([])
+        end
+
+        it "should return [0] for first child" do
+          expect(first_child.path).to eq([0])
+        end
+
+        it "should return [1] for second child" do
+          expect(second_child.path).to eq([1])
+        end
+
+        it "should return [0, 0] for leftmost grandchild" do
+          expect(leftmost_grandchild.path).to eq([0, 0])
+        end
+
+        it "should return [1, 2] for rightmost grandchild" do
+          expect(rightmost_grandchild.path).to eq([1, 2])
+        end
+      end
+    end
+  end
+end

data/spec/unit/visitable/visitor_spec.rb

@@ -0,0 +1,35 @@
+require "metamorpher/visitable/visitor"
+
+module Metamorpher
+  module Visitable
+    describe Visitor do
+      it "should call visitor based on the type of the visitee" do
+        subject = Visitor.new
+        subject.stub(visit_string: true)
+        subject.visit("foo")
+        expect(subject).to have_received(:visit_string)
+      end
+
+      it "should call visitor on ancestor of visitee if necessary" do
+        subject = Visitor.new
+        subject.stub(visit_numeric: true)
+        subject.visit(3) # Fixnum < Integer < Numeric
+        expect(subject).to have_received(:visit_numeric)
+      end
+
+      it "should call visitor based on unqualified type of the visitee" do
+        subject = Visitor.new
+        subject.stub(visit_dummy: true)
+        subject.visit(Dummy.new)
+        expect(subject).to have_received(:visit_dummy)
+      end
+
+      it "should raise if no appropriate visit method is defined" do
+        subject = Visitor.new
+        expect { subject.visit("foo") }.to raise_error(ArgumentError)
+      end
+    end
+
+    class Dummy; end
+  end
+end