metamorpher 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d16003d62069703538fe00d09537221c30a8b50
-  data.tar.gz: 2be984b2778ce18e4085795895d23df4d5407f9d
+  metadata.gz: 07d706738851b486c6fc3a58140b5046a1569a6e
+  data.tar.gz: 77e1d643b5816016c0d054954af1d9f7f9e6bbae
 SHA512:
-  metadata.gz: 2a9745cbf4788895da970497de3b8f15e28c9866b74c899e468a36a13f86bf804400be34db79e20f0ae35437fcd0487e0f4ffd032c2744bb3193050897595e32
-  data.tar.gz: bf3e827ea391a666826a816d4338b8bd4afbebd426f53e7977ded9bf3238f5371c41dac6e950440d066269244c5677e54fb98ae14fe664d14b82728ebbbc7753
+  metadata.gz: 6a15ddbe30e40c36ec9d4ea427d6e5558650b00d6aabb907d2954cd5327abe5effc232355fc249fe0faa59191fe9546dadb2846ae4ef7e7f56796b52446ed3fe
+  data.tar.gz: 063d0829bb4dbc7de52d3a50b78599d752d395a94f0b3e5cb9dd9067dfb3f8eae389ec6d3380db1a6b865f9b13f2fb9fc75c0bf1fa7606c427de4cfb4ed3d115

data/.gitignore

@@ -1,3 +1,4 @@
+.DS_Store
 *.gem
 *.rbc
 .bundle

data/README.md

@@ -36,7 +36,7 @@ This simple example is short, but terse! To fully understand it, you might now w
 
 * [Practicalities](#practicalities) - Information on how to use metamorpher to manipulate (Ruby) programs:
     * [Building Ruby terms](#building-ruby-terms) - how to concisely create terms that represent Ruby programs.
-    * [Refactorers](#refactorers) - how to use rewriters to refactor Ruby programs.
+    * [Transformers](#transformers) - how to use rewriters to transform Ruby programs.
 
 
 ## Fundamentals
@@ -54,7 +54,7 @@ The primary data structure used for [rewriting](#rewriters) and for [matching](#
 * Greedy variable - a variable that is bound to a set of subterms during [matching](#matchers).
 * Derivation - a placeholder node, which is replaced during [rewriting](#rewriters).
 
-To simplify the construction of terms, metamorpher provides the `Metamorpher::Builders::AST::Builder` class, which is demonstrated below. 
+To simplify the construction of terms, metamorpher provides the `Metamorpher::Builders::AST::Builder` class, which is demonstrated below.
 
 ```ruby
 require "metamorpher"
@@ -71,7 +71,7 @@ builder.derivation! :singular do |singular, builder|
   builder.literal!(singular.name + "s")
 end
  # [SINGULAR] -> ...
- 
+
 builder.derivation! :key, :value do |key, value, builder|
   builder.pair(key, value)
 end
@@ -91,7 +91,7 @@ The builder provides a method missing shorthand for constructing literals, varia
 
 ```ruby
 builder.succ # => succ
-builder.N # => N 
+builder.N # => N
 builder.N_ # => N+
 ```
 
@@ -137,7 +137,7 @@ require "metamorpher"
 class SuccZeroMatcher
   include Metamorpher::Matcher
   include Metamorpher::Builders::AST
-  
+
   def pattern
     builder.succ(0)
   end
@@ -145,7 +145,7 @@ end
 
 expression = Metamorpher.builder.succ(0) # => succ(0)
 result = SuccZeroMatcher.new.run(expression)
- # => <Metamorpher::Matcher::Match root=succ(0), substitution={}> 
+ # => <Metamorpher::Matcher::Match root=succ(0), substitution={}>
 result.matches? # => true
 
 expression = Metamorpher.builder.succ(1) # => succ(1)
@@ -164,7 +164,7 @@ For example, suppose we wish to match expressions of the form `succ(X)` where X
 class SuccMatcher
   include Metamorpher::Matcher
   include Metamorpher::Builders::AST
-  
+
   def pattern
     builder.succ(builder.X)
   end
@@ -172,21 +172,21 @@ end
 
 expression = Metamorpher.builder.succ(0) # => succ(0)
 SuccMatcher.new.run(expression)
- # => <Metamorpher::Matcher::Match root=succ(0), substitution={:x=>0}> 
+ # => <Metamorpher::Matcher::Match root=succ(0), substitution={:x=>0}>
 
 expression = Metamorpher.builder.succ(1) # => succ(1)
 SuccMatcher.new.run(expression)
  # => <Metamorpher::Matcher::Match root=succ(0), substitution={:x=>1}>
- 
+
 expression = Metamorpher.builder.succ(:n) # => succ(n)
 SuccMatcher.new.run(expression)
  # => <Metamorpher::Matcher::Match root=succ(n), substitution={:x=>n}>
 
 expression = Metamorpher.builder.succ(Metamorpher.builder.succ(:n)) # => succ(succ(n))
 SuccMatcher.new.run(expression)
- # => <Metamorpher::Matcher::Match root=succ(succ(n)), substitution={:x=>succ(n)}> 
+ # => <Metamorpher::Matcher::Match root=succ(succ(n)), substitution={:x=>succ(n)}>
 ```
-    
+
 #### Conditional variables
 
 By default, a variable matches any literal. Matching is more powerful when variables are able to match only those literals that satisfy some condition. Metamorpher provides conditional variables for this purpose.
@@ -197,7 +197,7 @@ For example, suppose that we wish to create a matcher that only matches method c
 class DynamicFinderMatcher
   include Metamorpher::Matcher
   include Metamorpher::Builders::AST
-  
+
   def pattern
     builder.literal!(
       :".",
@@ -209,7 +209,7 @@ end
 
 expression = Metamorpher.builder.literal!(:".", :User, :find_by_name) # => .(User, find_by_name)
 DynamicFinderMatcher.new.run(expression)
- # => #<Metamorpher::Matcher::Match root=.(User, find_by_name), substitution={:method=>find_by_name}> 
+ # => #<Metamorpher::Matcher::Match root=.(User, find_by_name), substitution={:method=>find_by_name}>
 
 expression = Metamorpher.builder.literal!(:".", :User, :find) # => .(User, find)
 DynamicFinderMatcher.new.run(expression)
@@ -226,7 +226,7 @@ For example, suppose that we wish to create a matcher that works for an expressi
 class MultiAddMatcher
   include Metamorpher::Matcher
   include Metamorpher::Builders::AST
-  
+
   def pattern
     builder.add(
       builder.ARGS_
@@ -235,10 +235,10 @@ class MultiAddMatcher
 end
 
 MultiAddMatcher.new.run(Metamorpher.builder.add(1,2))
- # => #<Metamorpher::Matcher::Match root=add(1,2), substitution={:args=>[1, 2]}> 
+ # => #<Metamorpher::Matcher::Match root=add(1,2), substitution={:args=>[1, 2]}>
 
 MultiAddMatcher.new.run(Metamorpher.builder.add(1,2,3))
- # => #<Metamorpher::Matcher::Match root=add(1,2,3), substitution={:args=>[1, 2, 3]}> 
+ # => #<Metamorpher::Matcher::Match root=add(1,2,3), substitution={:args=>[1, 2, 3]}>
 ```
 
 ### Rewriters
@@ -253,11 +253,11 @@ require "metamorpher"
 class SuccZeroRewriter
   include Metamorpher::Rewriter
   include Metamorpher::Builders::AST
-  
+
   def pattern
     builder.literal! :succ, 0
   end
-  
+
   def replacement
     builder.literal! 1
   end
@@ -300,7 +300,7 @@ SuccZeroRewriter.new.reduce(expression) do |matching, rewritten|
 end
  # About to replace 'succ(0)' at position [0] with '1'
  # About to replace 'succ(0)' at position [1] with '1'
- # => 
+ # =>
 ```
 
 #### Derivations
@@ -313,11 +313,11 @@ For example, suppose that we wish to create a rewriter that pluralises any liter
 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")
@@ -398,11 +398,23 @@ builder
  # [KEY, VALUE] -> ...
 ```
 
-### Refactorers 
+### Transformers
+
+Transformers are [rewriters](#rewriters) that are specialised for rewriting program source code. A transformer parses a program's source code, rewrites the source code, and returns the unparsed, rewritten source code.
+
+Metamorpher provides two types of transformers:
+
+* Refactorer - produces a single transformed program that contains all rewritings together
+* Mutator - produces a set of transformed programs where each program contains a single rewriting
+
+For example, for the pattern `1 + 1`, the replacement `2` and the input program `(1 + 1) * (1 + 1)`:
 
-Refactorers are [rewriters](#rewriters) that are specialised for rewriting program source code. A refactorer parses a program's source code, rewrites the source code, and returns the unparsed, rewritten source code. 
+* A refactorer will produce `(2) * (2)`
+* A mutator will produce `[(2) * (1 + 1), (1 + 1) * (2)].`
 
-Metamorpher provides the `Metamorpher::Refactorer` module for constructing classes that perform refactorings. Include it, specify a `pattern` and a `replacement`, and then call `refactor(src)`:
+Metamorpher provides the `Metamorpher::Refactorer` and `Metamorpher::Mutator` modules for constructing classes that perform refactorings or mutations.
+
+To construct a refactorer, include the relevant module, specify a `pattern` and a `replacement`, and then call `refactor(src)`:
 
 ```ruby
 require "metamorpher"
@@ -420,11 +432,42 @@ class UnnecessaryConditionalRefactorer
   end
 end
 
-program = "a = if some_predicate then true else false end"
+program = "a = if some_predicate then true else false end; " \
+          "b = if another_predicate then true else false end"
 UnnecessaryConditionalRefactorer.new.refactor(program)
- # => "a = some_predicate"
+ # => "a = some_predicate; b = another_predicate"
 ```
 
+Similarly to construct a mutator, include the relevant module, specify a `pattern` and an array of `replacements`, and then call `mutate(src)`:
+
+```ruby
+require "metamorpher"
+
+class LessThanMutator
+  include Metamorpher::Mutator
+  include Metamorpher::Builders::Ruby
+
+  def pattern
+    builder.build("A < B")
+  end
+
+  def replacements
+    builder.build_all("A > B", "A == B")
+  end
+end
+
+program = "a = foo < bar; b = bar < baz"
+LessThanMutator.new.mutate(program)
+ # => [
+ #       "a = foo > bar; b = bar < baz",
+ #       "a = foo == bar; b = bar < baz",
+ #       "a = foo < bar; b = bar > baz",
+ #      "a = foo < bar; b = bar == baz"
+ #    ]
+```
+
+The remainder of this section discusses only refactorers, but note that mutators have all of the same functionality as refactorers (but provides methods prefixed with `mutate` rather than `refactor`).
+
 The `refactor` method can optionally take a block, which is called immediately before the matching code is replaced with the refactored code:
 
 ```ruby
@@ -445,11 +488,11 @@ The `Metamorpher::Refactorer` module also defines a `refactor_file(path)` method
 
 ```ruby
 path = File.expand_path("refactorable.rb", "/Users/louis/code/mutiny")
- # => "/Users/louis/code/mutiny/refactorable.rb" 
+ # => "/Users/louis/code/mutiny/refactorable.rb"
 
 UnnecessaryConditionalRefactorer.new.refactor_file(path)
  # => ... (refactored code)
- 
+
 UnnecessaryConditionalRefactorer.new.refactor_file(path) do |refactoring|
   # works just like the block passed to refactor
 end
@@ -460,7 +503,7 @@ You might prefer the `refactor_files(paths)` method, if you'd like to refactor s
 
 ```ruby
 paths = Dir.glob(File.expand_path(File.join("**", "*.rb"), "/Users/louis/code/mutiny"))
- # => ["/Users/louis/code/mutiny/lib/mutiny.rb", ...] 
+ # => ["/Users/louis/code/mutiny/lib/mutiny.rb", ...]
 
  # Note that refactor_files returns a Hash rather than a String
 UnnecessaryConditionalRefactorer.new.refactor_files(paths)
@@ -489,22 +532,22 @@ By default, `Metamorpher::Refactorer` assumes that you wish to refactor Ruby pro
 ```ruby
 class JavaRefactorer
   include Metamorpher::Refactorer
-  
+
   def driver
     YourTool::MetamorpherDrivers::Java.new
   end
-  
+
   def pattern
     ...
   end
-  
+
   def replacement
     ...
   end
 end
 ```
 
-#### Examples 
+#### Examples
 
 Below are a few examples of using metamorpher to perform refactorings on Ruby code.
 
@@ -558,21 +601,21 @@ class RefactorWhereFirstToFindBy
        builder.build(create_hash_string(keys, values))
      end
   end
-  
+
   private
-  
+
   # Extracts an array of attributes from the name of a dynamic
   # finder, such as find_by_asset_id_and_object_path.
   def attributes_from_dynamic_finder(dynamic_finder)
     dynamic_finder["find_by_".length..-1].split("_and_")
   end
-  
+
   # Builds a string representation of a hash from a set of keys
   # and a corresponding set of values
   def create_hash_string(keys, values)
     "{" + create_pairs_string(keys, values) + "}"
   end
-  
+
   def create_pairs_string(keys, values)
     keys
      .zip(values)

data/RELEASES.md

@@ -0,0 +1,14 @@
+# Release History
+
+## v0.2.0 (9 May 2015)
+* Provide support for mutators which are similar to refactorers but produce multiple transformed programs
+
+## v0.1.1 (8 May 2015)
+* Update dependencies
+
+## v0.1.0 (6 May 2014)
+Provide support for:
+* A generic mechanism for specifying terms
+* Language-independent term matching and rewriting
+* Language-specific refactoring
+* A Ruby builder that enables program matching, rewriting and refactoring of Ruby programs.

data/lib/metamorpher.rb

@@ -6,6 +6,7 @@ require "metamorpher/support/map_at"
 require "metamorpher/matcher"
 require "metamorpher/rewriter"
 require "metamorpher/refactorer"
+require "metamorpher/mutator"
 
 module Metamorpher
   def self.builder

data/lib/metamorpher/builders/ruby/builder.rb

@@ -11,6 +11,10 @@ module Metamorpher
           decorate(rewrite(parse(source)))
         end
 
+        def build_all(*sources)
+          sources.map(&method(:build))
+        end
+
         private
 
         def decorate(term)

data/lib/metamorpher/builders/ruby/uppercase_constant_rewriter.rb

@@ -1,29 +1,15 @@
 require "metamorpher/builders/ast"
+require "metamorpher/builders/ruby/uppercase_rewriter"
 
 module Metamorpher
   module Builders
     module Ruby
-      class UppercaseConstantRewriter
+      class UppercaseConstantRewriter < UppercaseRewriter
         include Metamorpher::Rewriter
         include Metamorpher::Builders::AST
 
         def pattern
-          builder.const(
-            builder.literal!(nil),
-            builder.VARIABLE_TO_BE { |v| v.name && v.name.to_s[/^[A-Z_]*$/] }
-          )
-        end
-
-        def replacement
-          builder.derivation!(:variable_to_be) do |variable_to_be, builder|
-            name = variable_to_be.name.to_s
-
-            if name.end_with?("_")
-              builder.greedy_variable! name.chomp("_").downcase.to_sym
-            else
-              builder.variable! name.downcase.to_sym
-            end
-          end
+          builder.const(builder.literal!(nil), super)
         end
       end
     end

data/lib/metamorpher/mutator.rb

@@ -0,0 +1,15 @@
+require "metamorpher/transformer/base"
+require "metamorpher/transformer/merger"
+
+module Metamorpher
+  module Mutator
+    include Transformer::Base
+    alias_method :mutate, :transform
+    alias_method :mutate_file, :transform_file
+    alias_method :mutate_files, :transform_files
+
+    def merge(src, replacements, &block)
+      replacements.map { |replacement| Transformer::Merger.new(src).merge(replacement, &block) }
+    end
+  end
+end

data/lib/metamorpher/refactorer.rb

@@ -1,47 +1,21 @@
-require "metamorpher/refactorer/merger"
-require "metamorpher/refactorer/site"
-require "metamorpher/rewriter/rule"
-require "metamorpher/drivers/ruby"
+require "metamorpher/transformer/base"
+require "metamorpher/transformer/merger"
 
 module Metamorpher
   module Refactorer
-    def refactor(src, &block)
-      literal = driver.parse(src)
-      replacements = reduce_to_replacements(src, literal)
-      Merger.new(src).merge(*replacements, &block)
-    end
-
-    def refactor_file(path, &block)
-      refactor(File.read(path), &block)
-    end
+    include Transformer::Base
+    alias_method :refactor, :transform
+    alias_method :refactor_file, :transform_file
+    alias_method :refactor_files, :transform_files
 
-    def refactor_files(paths, &block)
-      paths.each_with_object({}) do |path, result|
-        changes = []
-        result[path] = refactor_file(path) { |change| changes << change }
-        block.call(path, result[path], changes) if block
-      end
-    end
-
-    def driver
-      @driver ||= Metamorpher::Drivers::Ruby.new
+    def merge(src, replacements, &block)
+      Transformer::Merger.new(src).merge(*replacements, &block)
     end
 
     private
 
-    def reduce_to_replacements(src, literal)
-      [].tap do |replacements|
-        rule.reduce(literal) do |original, rewritten|
-          original_position = driver.source_location_for(original)
-          original_code = src[original_position]
-          refactored_code = driver.unparse(rewritten)
-          replacements << Site.new(original_position, original_code, refactored_code)
-        end
-      end
-    end
-
-    def rule
-      @rule ||= Rewriter::Rule.new(pattern: pattern, replacement: replacement)
+    def replacements
+      @replacements ||= [replacement]
     end
   end
 end

data/lib/metamorpher/transformer/base.rb

@@ -0,0 +1,51 @@
+require "metamorpher/transformer/merger"
+require "metamorpher/transformer/site"
+require "metamorpher/rewriter/rule"
+require "metamorpher/drivers/ruby"
+
+module Metamorpher
+  module Transformer
+    module Base
+      def transform(src, &block)
+        literal = driver.parse(src)
+        replacements = reduce_to_replacements(src, literal)
+        merge(src, replacements, &block)
+      end
+
+      def transform_file(path, &block)
+        transform(File.read(path), &block)
+      end
+
+      def transform_files(paths, &block)
+        paths.each_with_object({}) do |path, result|
+          changes = []
+          result[path] = transform_file(path) { |change| changes << change }
+          block.call(path, result[path], changes) if block
+        end
+      end
+
+      def driver
+        @driver ||= Metamorpher::Drivers::Ruby.new
+      end
+
+      private
+
+      def reduce_to_replacements(src, literal)
+        [].tap do |replacements|
+          rules.each do |rule| # FIXME : change to inject?
+            rule.reduce(literal) do |original, rewritten|
+              original_position = driver.source_location_for(original)
+              original_code = src[original_position]
+              transformed_code = driver.unparse(rewritten)
+              replacements << Site.new(original_position, original_code, transformed_code)
+            end
+          end
+        end
+      end
+
+      def rules
+        @rules ||= replacements.map { |r| Rewriter::Rule.new(pattern: pattern, replacement: r) }
+      end
+    end
+  end
+end

data/lib/metamorpher/{refactorer → transformer}/merger.rb

@@ -1,7 +1,7 @@
 require "attributable"
 
 module Metamorpher
-  module Refactorer
+  module Transformer
     Merger = Struct.new(:original) do
       def merge(*replacements, &block)
         original.dup.tap do |merged|

data/lib/metamorpher/{refactorer → transformer}/site.rb

@@ -1,7 +1,7 @@
 require "attributable"
 
 module Metamorpher
-  module Refactorer
+  module Transformer
     Site = Struct.new(:original_position, :original_code, :refactored_code) do
       def slide(offset)
         new_position = (original_position.begin + offset)..(original_position.end + offset)

data/lib/metamorpher/version.rb

@@ -1,3 +1,3 @@
 module Metamorpher
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/spec/integration/ruby/mutator_spec.rb

@@ -0,0 +1,215 @@
+require "metamorpher"
+require "tempfile"
+
+describe "Mutator" do
+  describe "for Ruby" do
+    class LessThanMutator
+      include Metamorpher::Mutator
+      include Metamorpher::Builders::Ruby
+
+      def pattern
+        builder.build("A < B")
+      end
+
+      def replacements
+        builder.build_all("A > B", "A == B")
+      end
+    end
+
+    subject { LessThanMutator.new }
+
+    let(:mutatable) do
+      "def compare\n" \
+      "  foo < bar\n" \
+      "  bar < baz\n" \
+      "end"
+    end
+
+    let(:mutated) do
+      [
+        "def compare\n" \
+        "  foo > bar\n" \
+        "  bar < baz\n" \
+        "end",
+
+        "def compare\n" \
+        "  foo < bar\n" \
+        "  bar > baz\n" \
+        "end",
+
+        "def compare\n" \
+        "  foo == bar\n" \
+        "  bar < baz\n" \
+        "end",
+
+        "def compare\n" \
+        "  foo < bar\n" \
+        "  bar == baz\n" \
+        "end"
+      ]
+    end
+
+    let(:not_mutatable) { "foo == bar" }
+
+    describe "by calling mutate" do
+      describe "for code that can be mutated"do
+        it "should return the mutated code" do
+          expect(subject.mutate(mutatable)).to eq(mutated)
+        end
+
+        it "should yield for each mutation site" do
+          expect { |b| subject.mutate(mutatable, &b) }.to yield_successive_args(
+            site_for(14..22, "foo < bar", "foo > bar"),
+            site_for(26..34, "bar < baz", "bar > baz"),
+            site_for(14..22, "foo < bar", "foo == bar"),
+            site_for(26..34, "bar < baz", "bar == baz")
+          )
+        end
+      end
+
+      describe "for code that cannot be mutated" do
+        it "should return no mutants" do
+          expect(subject.mutate(not_mutatable)).to eq([])
+        end
+
+        it "should not yield when there are no mutants" do
+          expect { |b| subject.mutate(not_mutatable, &b) }.not_to yield_control
+        end
+      end
+    end
+
+    describe "mutate_file" do
+      describe "for code that can be mutated" do
+        let(:mutatable_file) { create_temporary_ruby_file("mutatable", mutatable) }
+
+        it "should return the mutated code" do
+          expect(subject.mutate_file(mutatable_file)).to eq(mutated)
+        end
+
+        it "should yield for each mutating site" do
+          expect { |b| subject.mutate_file(mutatable_file, &b) }.to yield_successive_args(
+            site_for(14..22, "foo < bar", "foo > bar"),
+            site_for(26..34, "bar < baz", "bar > baz"),
+            site_for(14..22, "foo < bar", "foo == bar"),
+            site_for(26..34, "bar < baz", "bar == baz")
+          )
+        end
+      end
+
+      describe "for code that cannot be mutated" do
+        let(:not_mutatable_file) do
+          create_temporary_ruby_file("not_mutatable", not_mutatable)
+        end
+
+        it "should return no mutants" do
+          expect(subject.mutate_file(not_mutatable_file)).to eq([])
+        end
+
+        it "should not yield when there are no mutating site" do
+          expect { |b| subject.mutate_file(not_mutatable_file, &b) }.not_to yield_control
+        end
+      end
+    end
+
+    describe "mutate_files" do
+      let(:mutatable_file) { create_temporary_ruby_file("mutatable", mutatable) }
+      let(:clone_of_mutatable_file) { create_temporary_ruby_file("mutatable", mutatable) }
+
+      let(:different_mutating_sites_file) do
+        create_temporary_ruby_file(
+          "differently_mutatable",
+          "result = foo < bar"
+        )
+      end
+
+      let(:not_mutatable_file) do
+        create_temporary_ruby_file(
+          "not_mutatable",
+          "nothing_to_see_here = 42"
+        )
+      end
+
+      let(:files) do
+        [
+          mutatable_file,
+          clone_of_mutatable_file,
+          different_mutating_sites_file,
+          not_mutatable_file
+        ]
+      end
+
+      it "should return a map of the paths and mutated code" do
+        mutated_files = {
+          mutatable_file => mutated,
+          clone_of_mutatable_file => mutated,
+          different_mutating_sites_file => ["result = foo > bar", "result = foo == bar"],
+          not_mutatable_file => []
+        }
+
+        expect(subject.mutate_files(files)).to eq(mutated_files)
+      end
+
+      it "should yield for each file" do
+        mutatable_file_details = [
+          mutatable_file,
+          mutated,
+          [
+            site_for(14..22, "foo < bar", "foo > bar"),
+            site_for(26..34, "bar < baz", "bar > baz"),
+            site_for(14..22, "foo < bar", "foo == bar"),
+            site_for(26..34, "bar < baz", "bar == baz")
+          ]
+        ]
+
+        clone_of_mutatable_file_details = [
+          clone_of_mutatable_file,
+          mutated,
+          [
+            site_for(14..22, "foo < bar", "foo > bar"),
+            site_for(26..34, "bar < baz", "bar > baz"),
+            site_for(14..22, "foo < bar", "foo == bar"),
+            site_for(26..34, "bar < baz", "bar == baz")
+          ]
+        ]
+
+        different_mutating_sites_file_details = [
+          different_mutating_sites_file,
+          ["result = foo > bar", "result = foo == bar"],
+          [
+            site_for(9..17, "foo < bar", "foo > bar"),
+            site_for(9..17, "foo < bar", "foo == bar")
+          ]
+        ]
+
+        not_mutatable_file_details = [
+          not_mutatable_file,
+          [],
+          []
+        ]
+
+        summary = []
+        subject.mutate_files(files) { |*args| summary << args }
+
+        expect(summary[0]).to eq(mutatable_file_details)
+        expect(summary[1]).to eq(clone_of_mutatable_file_details)
+        expect(summary[2]).to eq(different_mutating_sites_file_details)
+        expect(summary[3]).to eq(not_mutatable_file_details)
+      end
+    end
+
+    def site_for(original_position, original_code, mutated_code)
+      Metamorpher::Transformer::Site.new(
+        original_position,
+        original_code,
+        mutated_code
+      )
+    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/integration/ruby/refactorer_spec.rb

@@ -176,7 +176,7 @@ describe "Refactorer" do
     end
 
     def site_for(original_position, predicate)
-      Metamorpher::Refactorer::Site.new(
+      Metamorpher::Transformer::Site.new(
         original_position,
         refactorable_code_for(predicate),
         predicate

data/spec/unit/{refactorer → transformer}/merger_spec.rb

@@ -1,8 +1,8 @@
-require "metamorpher/refactorer/merger"
-require "metamorpher/refactorer/site"
+require "metamorpher/transformer/merger"
+require "metamorpher/transformer/site"
 
 module Metamorpher
-  module Refactorer
+  module Transformer
     describe Merger do
       let(:original) { "The quick brown fox jumps over the lazy dog." }
       subject { Merger.new(original) }

data/spec/unit/{refactorer → transformer}/site_spec.rb

@@ -1,7 +1,7 @@
-require "metamorpher/refactorer/site"
+require "metamorpher/transformer/site"
 
 module Metamorpher
-  module Refactorer
+  module Transformer
     describe Site do
       subject { Site.new(4..6, "foo", "bar") }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: metamorpher
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Louis Rose
@@ -138,6 +138,7 @@ files:
 - Gemfile
 - LICENSE.txt
 - README.md
+- RELEASES.md
 - Rakefile
 - examples/refactorings/rails/where_first/app.rb
 - examples/refactorings/rails/where_first/refactorers/refactor_where_first_mocks.rb
@@ -166,9 +167,8 @@ files:
 - lib/metamorpher/matcher/match.rb
 - lib/metamorpher/matcher/matching.rb
 - lib/metamorpher/matcher/no_match.rb
+- lib/metamorpher/mutator.rb
 - lib/metamorpher/refactorer.rb
-- lib/metamorpher/refactorer/merger.rb
-- lib/metamorpher/refactorer/site.rb
 - lib/metamorpher/rewriter.rb
 - lib/metamorpher/rewriter/replacement.rb
 - lib/metamorpher/rewriter/rule.rb
@@ -179,6 +179,9 @@ files:
 - lib/metamorpher/terms/literal.rb
 - lib/metamorpher/terms/term.rb
 - lib/metamorpher/terms/variable.rb
+- lib/metamorpher/transformer/base.rb
+- lib/metamorpher/transformer/merger.rb
+- lib/metamorpher/transformer/site.rb
 - lib/metamorpher/version.rb
 - lib/metamorpher/visitable/visitable.rb
 - lib/metamorpher/visitable/visitor.rb
@@ -187,6 +190,7 @@ files:
 - spec/integration/ast/matcher_spec.rb
 - spec/integration/ast/rewriter_spec.rb
 - spec/integration/ruby/builder_spec.rb
+- spec/integration/ruby/mutator_spec.rb
 - spec/integration/ruby/refactorer_spec.rb
 - spec/spec_helper.rb
 - spec/support/helpers/silence_stream.rb
@@ -204,14 +208,14 @@ files:
 - spec/unit/drivers/ruby_spec.rb
 - spec/unit/matcher/matching_spec.rb
 - spec/unit/metamorpher_spec.rb
-- spec/unit/refactorer/merger_spec.rb
-- spec/unit/refactorer/site_spec.rb
 - spec/unit/rewriter/replacement_spec.rb
 - spec/unit/rewriter/substitution_spec.rb
 - spec/unit/rewriter/traverser_spec.rb
 - spec/unit/support/map_at_spec.rb
 - spec/unit/terms/literal_spec.rb
 - spec/unit/terms/term_spec.rb
+- spec/unit/transformer/merger_spec.rb
+- spec/unit/transformer/site_spec.rb
 - spec/unit/visitable/visitor_spec.rb
 homepage: https://github.com/mutiny/metamorpher
 licenses:
@@ -242,6 +246,7 @@ test_files:
 - spec/integration/ast/matcher_spec.rb
 - spec/integration/ast/rewriter_spec.rb
 - spec/integration/ruby/builder_spec.rb
+- spec/integration/ruby/mutator_spec.rb
 - spec/integration/ruby/refactorer_spec.rb
 - spec/spec_helper.rb
 - spec/support/helpers/silence_stream.rb
@@ -259,12 +264,12 @@ test_files:
 - spec/unit/drivers/ruby_spec.rb
 - spec/unit/matcher/matching_spec.rb
 - spec/unit/metamorpher_spec.rb
-- spec/unit/refactorer/merger_spec.rb
-- spec/unit/refactorer/site_spec.rb
 - spec/unit/rewriter/replacement_spec.rb
 - spec/unit/rewriter/substitution_spec.rb
 - spec/unit/rewriter/traverser_spec.rb
 - spec/unit/support/map_at_spec.rb
 - spec/unit/terms/literal_spec.rb
 - spec/unit/terms/term_spec.rb
+- spec/unit/transformer/merger_spec.rb
+- spec/unit/transformer/site_spec.rb
 - spec/unit/visitable/visitor_spec.rb