metamorpher 0.1.0

data/metamorpher.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'metamorpher/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "metamorpher"
+  spec.version       = Metamorpher::VERSION
+  spec.authors       = ["Louis Rose"]
+  spec.email         = ["louis.rose@york.ac.uk"]
+  spec.description   = %q{Provides structures that support program transformations, such as refactoring or program mutation.}
+  spec.summary       = %q{A term rewriting library for transforming (Ruby) programs}
+  spec.homepage      = "https://github.com/mutiny/metamorpher"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "attributable", "~> 0.1.0"
+  spec.add_runtime_dependency "parser", "~> 2.1.4"
+  spec.add_runtime_dependency "unparser", "~> 0.1.9"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.1.1"
+  spec.add_development_dependency "rspec", "~> 2.14.1"
+  spec.add_development_dependency "coveralls", "~> 0.7.0"
+  spec.add_development_dependency "rubocop", "~> 0.19.1"
+end

data/spec/integration/ast/builder_spec.rb

@@ -0,0 +1,13 @@
+require "metamorpher"
+
+describe Metamorpher do
+  subject { Metamorpher.builder }
+
+  before { Metamorpher.configure(builder: :ast)  }
+  after  { Metamorpher.configure(builder: :ruby) }
+
+  it_behaves_like "a literal builder"
+  it_behaves_like "a variable builder"
+  it_behaves_like "a greedy variable builder"
+  it_behaves_like "a derivation builder"
+end

data/spec/integration/ast/matcher_spec.rb

@@ -0,0 +1,132 @@
+require "metamorpher"
+require "metamorpher/builders/ast"
+
+describe "Matching" do
+  let(:builder) { Metamorpher::Builders::AST::Builder.new }
+
+  describe "literals" do
+    class SuccZeroMatcher
+      include Metamorpher::Matcher
+      include Metamorpher::Builders::AST
+
+      def pattern
+        builder.succ(0)
+      end
+    end
+
+    subject { SuccZeroMatcher.new }
+
+    it "should return a match for a matching expression" do
+      expression = builder.succ(0)
+
+      expect(subject.run(expression)).to have_matched(expression)
+    end
+
+    it "should return no match for a non-matching expression" do
+      expression = builder.succ(1)
+
+      expect(subject.run(expression)).not_to have_matched
+    end
+  end
+
+  describe "variables" do
+    class SuccMatcher
+      include Metamorpher::Matcher
+      include Metamorpher::Builders::AST
+
+      def pattern
+        builder.succ(builder.X)
+      end
+    end
+
+    subject { SuccMatcher.new }
+
+    it "should return a match for matching expressions" do
+      expressions = [
+        builder.succ(0),
+        builder.succ(1),
+        builder.succ(:n),
+        builder.succ(builder.succ(:n))
+      ]
+
+      expressions.each do |expression|
+        expect(subject.run(expression)).to have_matched(expression)
+      end
+    end
+
+    it "should return no match for a non-matching expression" do
+      expression = builder.pred(1)
+
+      expect(subject.run(expression)).not_to have_matched
+    end
+  end
+
+  describe "conditional variables" do
+    class DynamicFinderMatcher
+      include Metamorpher::Matcher
+      include Metamorpher::Builders::AST
+
+      def pattern
+        builder.literal!(
+          :".",
+          :User,
+          builder.METHOD { |literal| literal.name =~ /^find_by_/ }
+        )
+      end
+    end
+
+    subject { DynamicFinderMatcher.new }
+
+    it "should return a match for matching expression" do
+      expression = builder.literal!(:".", :User, :find_by_name)
+
+      expect(subject.run(expression)).to have_matched(expression)
+    end
+
+    it "should return no match when the condition is not satisfied" do
+      expression = builder.literal!(:".", :User, :find)
+
+      expect(subject.run(expression)).not_to have_matched
+    end
+  end
+
+  describe "greedy variables" do
+    class MultiAddMatcher
+      include Metamorpher::Matcher
+      include Metamorpher::Builders::AST
+
+      def pattern
+        builder.add(
+          builder.ARGS_
+        )
+      end
+    end
+
+    subject { MultiAddMatcher.new }
+
+    it "should return a match for matching expressions" do
+      expressions = [
+        builder.add(1),
+        builder.add(1, 2),
+        builder.add(1, 2, 3),
+        builder.add(1, builder.succ(:n), 2)
+      ]
+
+      expressions.each do |expression|
+        expect(subject.run(expression)).to have_matched(expression)
+      end
+    end
+
+    it "should return no match when there are no arguments" do
+      expression = builder.add
+
+      expect(subject.run(expression)).not_to have_matched
+    end
+
+    it "should return no match when names do not match" do
+      expression = builder.multiply(1, 2, 3)
+
+      expect(subject.run(expression)).not_to have_matched
+    end
+  end
+end

data/spec/integration/ast/rewriter_spec.rb

@@ -0,0 +1,138 @@
+require "metamorpher"
+require "metamorpher/builders/ast"
+
+describe "Rewriting" do
+  let(:builder) { Metamorpher::Builders::AST::Builder.new }
+
+  describe "literals" do
+    class SuccZeroRewriter
+      include Metamorpher::Rewriter
+      include Metamorpher::Builders::AST
+
+      def pattern
+        builder.literal! :succ, 0
+      end
+
+      def replacement
+        builder.literal! 1
+      end
+    end
+
+    subject { SuccZeroRewriter.new }
+
+    describe "with reduce" do
+      it "should rewrite a matching expression" do
+        expression = builder.succ(0)
+        reduced = builder.literal!(1)
+
+        expect(subject.reduce(expression)).to eq(reduced)
+      end
+
+      it "should completely rewrite all matching expressions" do
+        expression = builder.add(builder.succ(0), builder.succ(0))
+        reduced = builder.add(builder.literal!(1), builder.literal!(1))
+
+        expect(subject.reduce(expression)).to eq(reduced)
+      end
+
+      it "should yield the original and replacement literals" do
+        expression = builder.add(builder.succ(0), builder.succ(0))
+        reduced = builder.add(builder.literal!(1), builder.literal!(1))
+
+        expect { |b| subject.reduce(expression, &b) }.to yield_successive_args(
+          [expression.children.first, reduced.children.first],
+          [expression.children.last, reduced.children.last]
+        )
+      end
+
+      it "should not change a non-matching expression" do
+        expression = builder.succ(1)
+
+        expect(subject.reduce(expression)).to eq(expression)
+      end
+    end
+
+    describe "with apply" do
+      it "should rewrite a matching expression" do
+        expression = builder.succ(0)
+        reduced = builder.literal!(1)
+
+        expect(subject.apply(expression)).to eq(reduced)
+      end
+
+      it "should yield the original and replacement literal" do
+        expression = builder.succ(0)
+        reduced = builder.literal!(1)
+
+        expect { |b| subject.apply(expression, &b) }.to yield_with_args(expression, reduced)
+      end
+
+      it "should rewrite only the first matching expressions" do
+        expression = builder.add(builder.succ(0), builder.succ(0))
+        reduced = builder.add(builder.literal!(1), builder.succ(0))
+
+        expect(subject.apply(expression)).to eq(reduced)
+      end
+
+      it "should not change a non-matching expression" do
+        expression = builder.succ(1)
+
+        expect(subject.apply(expression)).to eq(expression)
+      end
+    end
+  end
+
+  describe "derivations" do
+    describe "from a single variable" do
+      class PluraliseRewriter
+        include Metamorpher::Rewriter
+        include Metamorpher::Builders::AST
+
+        def pattern
+          builder.SINGULAR
+        end
+
+        def replacement
+          builder.derivation! :singular do |singular|
+            builder.literal!(singular.name + "s")
+          end
+        end
+      end
+
+      subject { PluraliseRewriter.new }
+
+      it "should rewrite using the derivation logic" do
+        expression = builder.literal! "dog"
+        reduced = builder.literal! "dogs"
+
+        expect(subject.reduce(expression)).to eq(reduced)
+      end
+    end
+
+    describe "from multiple variables" do
+      class RocketRewriter
+        include Metamorpher::Rewriter
+        include Metamorpher::Builders::AST
+
+        def pattern
+          builder.literal!(:"=>", builder.KEY, builder.VALUE)
+        end
+
+        def replacement
+          builder.derivation!(:key, :value) do |key, value|
+            builder.pair(key, value)
+          end
+        end
+      end
+
+      subject { RocketRewriter.new }
+
+      it "should rewrite using the derivation logic" do
+        expression = builder.literal! :"=>", :foo, :bar
+        reduced = builder.pair(:foo, :bar)
+
+        expect(subject.reduce(expression)).to eq(reduced)
+      end
+    end
+  end
+end

data/spec/integration/ruby/builder_spec.rb

@@ -0,0 +1,125 @@
+require "metamorpher"
+
+describe Metamorpher.builder do
+  let(:ast_builder) { Metamorpher::Builders::AST::Builder.new }
+
+  describe "when building literals" do
+    it "should produce literals from source" do
+      expect(subject.build("1 + 1")).to eq(
+        ast_builder.literal!(
+          :send,
+          ast_builder.int(1),
+          :+,
+          ast_builder.int(1)
+        )
+      )
+    end
+
+    it "should raise for invalid source" do
+      silence_stream(STDERR) do
+        expect { subject.build("1 + ") }.to raise_error(Metamorpher::Drivers::ParseError)
+      end
+    end
+  end
+
+  describe "when building programs containing constants" do
+    it "should convert uppercase constants to variables" do
+      expect(subject.build("LEFT + RIGHT")).to eq(
+        ast_builder.literal!(
+          :send,
+          ast_builder.LEFT,
+          :+,
+          ast_builder.RIGHT
+        )
+      )
+    end
+
+    it "should convert uppercase messages to variables" do
+      expect(subject.build("User.METHOD")).to eq(
+        ast_builder.literal!(
+          :send,
+          ast_builder.literal!(:const, nil, :User),
+          ast_builder.METHOD
+        )
+      )
+    end
+
+    it "should convert uppercase constants ending with underscore to greedy variables" do
+      expect(subject.build("LEFT_ + RIGHT_")).to eq(
+        ast_builder.literal!(
+          :send,
+          ast_builder.LEFT_,
+          :+,
+          ast_builder.RIGHT_
+        )
+      )
+    end
+
+    it "should not convert non-uppercase constants to variables" do
+      expect(subject.build("Left + RIGHt")).to eq(
+        ast_builder.literal!(
+          :send,
+          ast_builder.const(nil, :Left),
+          :+,
+          ast_builder.const(nil, :RIGHt)
+        )
+      )
+    end
+  end
+
+  describe "when building programs with conditional variables" do
+    it "should create a conditional variable from a call to ensuring" do
+      built = subject.build("A").ensuring("A") { |n| n > 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 create several conditional variables from several calls to ensuring" do
+      built = subject
+        .build("A + B")
+        .ensuring("A") { |n| n > 0 }
+        .ensuring("B") { |n| n < 0 }
+
+      first_variable, _operator, last_variable = built.children
+
+      expect(first_variable.name).to eq(:a)
+      expect(first_variable.condition.call(1)).to be_true
+      expect(first_variable.condition.call(-1)).to be_false
+
+      expect(last_variable.name).to eq(:b)
+      expect(last_variable.condition.call(-1)).to be_true
+      expect(last_variable.condition.call(1)).to be_false
+    end
+  end
+
+  describe "when building programs with derivations" do
+    it "should create a derivation from a call to deriving" do
+      built = subject.build("PLURAL").deriving("PLURAL", "SINGULAR") do |constant|
+        subject.build(constant.children.last.name.to_s + "s")
+      end
+
+      expect(built.base).to eq([:singular])
+      expect(built.derivation.call(subject.build("dog"))).to eq(subject.build("dogs"))
+    end
+
+    it "should create a derivation with multiple bases from a call to deriving" do
+      built = subject.build("HASH").deriving("HASH", "KEY", "VALUE") {}
+
+      expect(built.base).to eq([:key, :value])
+    end
+
+    it "should create several derivations from several calls to deriving" do
+      built = subject
+        .build("NEW_FIRST; NEW_LAST")
+        .deriving("NEW_FIRST", "FIRST") {}
+        .deriving("NEW_LAST", "LAST") {}
+
+      first_derived, last_derived = built.children
+
+      expect(first_derived.base).to eq([:first])
+      expect(last_derived.base).to eq([:last])
+    end
+  end
+end

data/spec/integration/ruby/refactorer_spec.rb

@@ -0,0 +1,192 @@
+require "metamorpher"
+
+describe "Refactorer" do
+  describe "for Ruby" do
+    class UnnecessaryConditionalRefactorer
+      include Metamorpher::Refactorer
+      include Metamorpher::Builders::Ruby
+
+      def pattern
+        builder.build("if CONDITION then true else false end")
+      end
+
+      def replacement
+        builder.build("CONDITION")
+      end
+    end
+
+    subject { UnnecessaryConditionalRefactorer.new }
+
+    let(:refactorable) do
+      "def run\n" \
+      "  a = #{refactorable_code_for("some_predicate")}\n" \
+      "  b = #{refactorable_code_for("some_other_predicate")}\n" \
+      "end"
+    end
+
+    let(:refactored) do
+      "def run\n" \
+      "  a = some_predicate\n" \
+      "  b = some_other_predicate\n" \
+      "end"
+    end
+
+    let(:not_refactorable) { "nothing_to_see_here = 42" }
+
+    describe "by calling refactor" do
+      describe "for code that can be refactored"do
+        it "should return the refactored code" do
+          expect(subject.refactor(refactorable)).to eq(refactored)
+        end
+
+        it "should yield for each refactoring site" do
+          expect { |b| subject.refactor(refactorable, &b) }.to yield_successive_args(
+            site_for(14..55, "some_predicate"),
+            site_for(63.. 110, "some_other_predicate")
+          )
+        end
+      end
+
+      describe "for code that cannot be refactored" do
+        it "should return the original code" do
+          expect(subject.refactor(not_refactorable)).to eq(not_refactorable)
+        end
+
+        it "should not yield when there are no refactoring site" do
+          expect { |b| subject.refactor(not_refactorable, &b) }.not_to yield_control
+        end
+      end
+    end
+
+    describe "refactor_file" do
+      describe "for code that can be refactored" do
+        let(:refactorable_file) { create_temporary_ruby_file("refactorable", refactorable) }
+
+        it "should return the refactored code" do
+          expect(subject.refactor_file(refactorable_file)).to eq(refactored)
+        end
+
+        it "should yield for each refactoring site" do
+          expect { |b| subject.refactor_file(refactorable_file, &b) }.to yield_successive_args(
+            site_for(14..55, "some_predicate"),
+            site_for(63.. 110, "some_other_predicate")
+          )
+        end
+      end
+
+      describe "for code that cannot be refactored" do
+        let(:not_refactorable_file) do
+          create_temporary_ruby_file("not_refactorable", not_refactorable)
+        end
+
+        it "should return the original code" do
+          expect(subject.refactor_file(not_refactorable_file)).to eq(not_refactorable)
+        end
+
+        it "should not yield when there are no refactoring site" do
+          expect { |b| subject.refactor_file(not_refactorable_file, &b) }.not_to yield_control
+        end
+      end
+    end
+
+    describe "refactor_files" do
+      let(:refactorable_file) { create_temporary_ruby_file("refactorable", refactorable) }
+      let(:clone_of_refactorable_file) { create_temporary_ruby_file("refactorable", refactorable) }
+
+      let(:different_refactoring_sites_file) do
+        create_temporary_ruby_file(
+          "differently_refactorable",
+          "c = if yet_another_predicate then true else false end"
+        )
+      end
+
+      let(:not_refactorable_file) do
+        create_temporary_ruby_file(
+          "not_refactorable",
+          "nothing_to_see_here = 42"
+        )
+      end
+
+      let(:files) do
+        [
+          refactorable_file,
+          clone_of_refactorable_file,
+          different_refactoring_sites_file,
+          not_refactorable_file
+        ]
+      end
+
+      it "should return a map of the paths and refactored code" do
+        refactored_files = {
+          refactorable_file => refactored,
+          clone_of_refactorable_file => refactored,
+          different_refactoring_sites_file => "c = yet_another_predicate",
+          not_refactorable_file => "nothing_to_see_here = 42"
+        }
+
+        expect(subject.refactor_files(files)).to eq(refactored_files)
+      end
+
+      it "should yield for each file" do
+        refactorable_file_details = [
+          refactorable_file,
+          refactored,
+          [
+            site_for(14..55, "some_predicate"),
+            site_for(63.. 110, "some_other_predicate")
+          ]
+        ]
+
+        clone_of_refactorable_file_details = [
+          clone_of_refactorable_file,
+          refactored,
+          [
+            site_for(14..55, "some_predicate"),
+            site_for(63.. 110, "some_other_predicate")
+          ]
+        ]
+
+        different_refactoring_sites_file_details = [
+          different_refactoring_sites_file,
+          "c = yet_another_predicate",
+          [
+            site_for(4..52, "yet_another_predicate")
+          ]
+        ]
+
+        not_refactorable_file_details = [
+          not_refactorable_file,
+          "nothing_to_see_here = 42",
+          []
+        ]
+
+        summary = []
+        subject.refactor_files(files) { |*args| summary << args }
+
+        expect(summary[0]).to eq(refactorable_file_details)
+        expect(summary[1]).to eq(clone_of_refactorable_file_details)
+        expect(summary[2]).to eq(different_refactoring_sites_file_details)
+        expect(summary[3]).to eq(not_refactorable_file_details)
+      end
+    end
+
+    def refactorable_code_for(predicate)
+      "if #{predicate} then true else false end"
+    end
+
+    def site_for(original_position, predicate)
+      Metamorpher::Refactorer::Site.new(
+        original_position,
+        refactorable_code_for(predicate),
+        predicate
+      )
+    end
+
+    def create_temporary_ruby_file(filename, contents)
+      Tempfile.new([filename, ".rb"]).tap do |tempfile|
+        tempfile.write(contents)
+        tempfile.close
+      end.path
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require "coveralls"
+Coveralls.wear!
+
+Dir["./spec/support/**/*.rb"].each { |f| require f }
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = "random"
+
+  config.expect_with :rspec do |c|
+    # Disable old "should" syntax for expressions
+    c.syntax = :expect
+  end
+
+  config.treat_symbols_as_metadata_keys_with_true_values = true # Prepare for RSpec 3
+end

data/spec/support/helpers/silence_stream.rb

@@ -0,0 +1,10 @@
+# Taken from ActiveSupport: http://api.rubyonrails.org/classes/Kernel.html#method-i-silence_stream
+def silence_stream(stream)
+  old_stream = stream.dup
+  stream.reopen(RbConfig::CONFIG["host_os"] =~ /mswin|mingw/ ? "NUL:" : "/dev/null")
+  stream.sync = true
+  yield
+ensure
+  stream.reopen(old_stream)
+  old_stream.close
+end

data/spec/support/matchers/have_matched_matcher.rb

@@ -0,0 +1,22 @@
+require "rspec/expectations"
+
+RSpec::Matchers.define :have_matched do |expected_root|
+  match do |actual|
+    actual.matches? && (expected_root.nil? || actual.root == expected_root)
+  end
+
+  failure_message_for_should do |actual|
+    if actual.matches?
+      "expected a match against '#{expected_root.inspect}', " \
+      "but got a match against '#{actual.root.inspect}'"
+    else
+      "expected a match, but got none"
+    end
+  end
+
+  failure_message_for_should_not do |actual|
+    if actual.matches?
+      "expected no match, but got a match against #{actual.root.inspect}"
+    end
+  end
+end