metamorpher 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07d706738851b486c6fc3a58140b5046a1569a6e
-  data.tar.gz: 77e1d643b5816016c0d054954af1d9f7f9e6bbae
+  metadata.gz: d8979355b8d41bbbc8c4f0a547f68e92cef86b17
+  data.tar.gz: bc38d9940581f4172e381617cd127d8e2e862994
 SHA512:
-  metadata.gz: 6a15ddbe30e40c36ec9d4ea427d6e5558650b00d6aabb907d2954cd5327abe5effc232355fc249fe0faa59191fe9546dadb2846ae4ef7e7f56796b52446ed3fe
-  data.tar.gz: 063d0829bb4dbc7de52d3a50b78599d752d395a94f0b3e5cb9dd9067dfb3f8eae389ec6d3380db1a6b865f9b13f2fb9fc75c0bf1fa7606c427de4cfb4ed3d115
+  metadata.gz: 0f78c4e7669975915d24d7a75bcdfb1481745a01c8fbad1f0264137d55b5630d1e87173000cb86f3c2f70869dfdb5ad880a65dc5cefeea1db1d5d6895ee9ff84
+  data.tar.gz: da8af5b60c5f6ce8ce759838668d57127b29e9f1277f99ca90c11f45ed6169517bc6853b1f5e47d3d74958c2c112aefa8a747507f36056e69d30ad99f17e29bd

data/.codeclimate.yml

@@ -0,0 +1,2 @@
+exclude_paths:
+- examples/*

data/README.md

@@ -53,6 +53,7 @@ The primary data structure used for [rewriting](#rewriters) and for [matching](#
 * Variable - a named node, which is bound to a subterm (subtree) during [matching](#matchers).
 * 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).
+* Term Set - a collection of terms (potentially of mixed types).
 
 To simplify the construction of terms, metamorpher provides the `Metamorpher::Builders::AST::Builder` class, which is demonstrated below.
 
@@ -76,6 +77,9 @@ builder.derivation! :key, :value do |key, value, builder|
   builder.pair(key, value)
 end
  # [KEY, VALUE] -> ...
+
+ builder.either! builder.literal!(:succ), builder.variable!(:n)
+ # TermSet[succ, N]
 ```
 
 Variables can be conditional, in which case they are specified by passing a block:
@@ -104,11 +108,12 @@ builder.PAIRS_ { |literal| literal.name =~ /^find_by_/ } #=> PAIRS+?
 
 #### Coercion of non-terms to literals
 
-When constructing a literal, the builder ensures that any children are converted to literals if they are not already a term:
+When constructing a literal or a term set, the builder ensures that any children are converted to literals if they are not already a term:
 
 ```ruby
 builder.literal!(:add, :x, :y) # => add(x, y)
 builder.add(:x, :y) # => add(x, y)
+builder.either!(:add, :subtract) # => TermSet[add, subtract]
 ```
 
 Without automatic coercion, the statements above would be written as follows. Note that they are more verbose:
@@ -116,6 +121,7 @@ Without automatic coercion, the statements above would be written as follows. No
 ```ruby
 builder.literal!(:add, builder.literal!(:x), builder.literal!(:y)) # => add(x, y)
 builder.add(builder.x, builder.y) # => add(x, y)
+builder.either!(builder.add, builder.subtract) # => TermSet[add, subtract]
 ```
 
 Note that coercion isn't necessary (and isn't applied) when the children of a literal are already terms:
@@ -123,6 +129,7 @@ Note that coercion isn't necessary (and isn't applied) when the children of a li
 ```ruby
 builder.literal!(:add, builder.variable!(:n), builder.variable!(:m)) # => add(N, M)
 builder.add(builder.N, builder.M) # => add(N, M)
+builder.either!(builder.N, builder.M) # => TermSet[N, M]
 ```
 
 ### Matchers
@@ -134,6 +141,9 @@ Metamorpher provides the `Metamorpher::Matcher` module for specifying matchers.
 ```ruby
 require "metamorpher"
 
+# Use the AST builder
+Metamorpher.configure(:ast)
+
 class SuccZeroMatcher
   include Metamorpher::Matcher
   include Metamorpher::Builders::AST
@@ -154,6 +164,33 @@ result = SuccZeroMatcher.new.run(expression)
 result.matches? # => false
 ```
 
+#### Alternatives
+
+Matching can search for several expressions to match at a time. Metamorpher provides TermSets for this purpose. Recall that TermSets are built using `builder.either!`
+
+For example, we can extend our previous matcher to search for the expressions `succ(0)` and `pred(2)` at the same time.
+
+```ruby
+class VerboseOneMatcher
+  include Metamorpher::Matcher
+  include Metamorpher::Builders::AST
+
+  def pattern
+    builder.either!(builder.succ(0), builder.pred(2))
+  end
+end
+
+expression = Metamorpher.builder.succ(0) # => succ(0)
+result = VerboseOneMatcher.new.run(expression)
+ # => <Metamorpher::Matcher::Match root=succ(0), substitution={}>
+result.matches? # => true
+
+expression = Metamorpher.builder.pred(2) # => pred(2)
+result = VerboseOneMatcher.new.run(expression)
+ # => <Metamorpher::Matcher::Match root=pred(2), substitution={}>
+result.matches? # => true
+```
+
 #### Variables
 
 Matching is more powerful when we can allow for some variability in the expressions that we wish to match. Metamorpher provides variables for this purpose.
@@ -352,6 +389,7 @@ Recall that term is a tree (i.e., an acyclic graph), whose nodes are either a:
 * Variable - a named node, which is bound to a subterm (subtree) during [matching](#matchers).
 * 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).
+* Term Set - a collection of terms (potentially of mixed types).
 
 The following examples demonstrate the way in which terms can built from strings that resemble Ruby programs:
 
@@ -398,6 +436,12 @@ builder
  # [KEY, VALUE] -> ...
 ```
 
+To build a term sets, provide several arguments:
+
+```ruby
+builder.build("true", "false") # => TermSet[true, false]
+```
+
 ### 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.
@@ -452,7 +496,7 @@ class LessThanMutator
   end
 
   def replacements
-    builder.build_all("A > B", "A == B")
+    builder.build("A > B", "A == B")
   end
 end
 

data/RELEASES.md

@@ -1,7 +1,10 @@
 # Release History
 
+## v0.2.1 (12 May 2015)
+* Provide support for term sets, which make it possible to match (or rewrite to) multiple expressions at once
+
 ## v0.2.0 (9 May 2015)
-* Provide support for mutators which are similar to refactorers but produce multiple transformed programs
+* Provide support for mutators, which are similar to refactorers but produce multiple transformed programs
 
 ## v0.1.1 (8 May 2015)
 * Update dependencies

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

@@ -1,7 +1,9 @@
+require "metamorpher/terms/term_set"
 require "metamorpher/builders/ast/literal_builder"
 require "metamorpher/builders/ast/variable_builder"
 require "metamorpher/builders/ast/greedy_variable_builder"
 require "metamorpher/builders/ast/derivation_builder"
+require "metamorpher/builders/ast/term_set_builder"
 require "forwardable"
 
 module Metamorpher
@@ -13,6 +15,7 @@ module Metamorpher
         def_delegator :variable_builder, :variable!
         def_delegator :greedy_variable_builder, :greedy_variable!
         def_delegator :derivation_builder, :derivation!
+        def_delegator :term_set_builder, :either!
 
         def method_missing(method, *arguments, &block)
           builders_with_shorthand
@@ -45,6 +48,10 @@ module Metamorpher
         def derivation_builder
           @derivation_builder ||= DerivationBuilder.new
         end
+
+        def term_set_builder
+          @term_set_builder ||= TermSetBuilder.new
+        end
       end
     end
   end

data/lib/metamorpher/builders/ast/literal_builder.rb

@@ -5,7 +5,7 @@ module Metamorpher
     module AST
       class LiteralBuilder
         def literal!(name, *children)
-          Terms::Literal.new(name: name, children: children.map { |c| termify(c) })
+          Terms::Literal.new(name: name, children: children.map(&method(:termify)))
         end
 
         def shorthand?(method, *_arguments, &_block)

data/lib/metamorpher/builders/ast/term_set_builder.rb

@@ -0,0 +1,20 @@
+require "metamorpher/terms/term_set"
+require "metamorpher/terms/literal"
+
+module Metamorpher
+  module Builders
+    module AST
+      class TermSetBuilder
+        def either!(*terms)
+          Terms::TermSet.new(terms: terms.map(&method(:termify)))
+        end
+
+        private
+
+        def termify(item)
+          item.is_a?(Terms::Term) ? item : Terms::Literal.new(name: item)
+        end
+      end
+    end
+  end
+end

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

@@ -2,17 +2,15 @@ require "metamorpher/drivers/ruby"
 require "metamorpher/builders/ruby/term"
 require "metamorpher/builders/ruby/uppercase_constant_rewriter"
 require "metamorpher/builders/ruby/uppercase_rewriter"
+require "metamorpher/terms/term_set"
 
 module Metamorpher
   module Builders
     module Ruby
       class Builder
-        def build(source)
-          decorate(rewrite(parse(source)))
-        end
-
-        def build_all(*sources)
-          sources.map(&method(:build))
+        def build(*sources)
+          terms = sources.map { |source| decorate(rewrite(parse(source))) }
+          terms.size == 1 ? terms.first : Metamorpher::Terms::TermSet.new(terms: terms)
         end
 
         private

data/lib/metamorpher/matcher/matching.rb

@@ -41,6 +41,15 @@ module Metamorpher
         end
       end
 
+      def visit_termset(termset)
+        matches = termset.terms.map { |term| term.match(other) }.select(&:matches?)
+        if matches.any?
+          matches.first
+        else
+          Matcher::NoMatch.new
+        end
+      end
+
       def visit_derived(_derived)
         fail MatchingError, "Cannot match against a derived variable."
       end

data/lib/metamorpher/refactorer.rb

@@ -11,11 +11,5 @@ module Metamorpher
     def merge(src, replacements, &block)
       Transformer::Merger.new(src).merge(*replacements, &block)
     end
-
-    private
-
-    def replacements
-      @replacements ||= [replacement]
-    end
   end
 end

data/lib/metamorpher/rewriter/substitution.rb

@@ -31,6 +31,12 @@ module Metamorpher
         derived.derivation.call(*substitutes)
       end
 
+      def visit_termset(termset)
+        Terms::TermSet.new(
+          terms: termset.terms.map { |term| visit(term) }
+        )
+      end
+
       private
 
       def substitution_for_variable(name)

data/lib/metamorpher/terms/term.rb

@@ -20,6 +20,10 @@ module Metamorpher
         name
       end
 
+      def alternatives
+        [self]
+      end
+
       def path
         if parent
           parent.path << parent.children.index { |c| c.equal?(self) }

data/lib/metamorpher/terms/term_set.rb

@@ -0,0 +1,17 @@
+require "metamorpher/terms/term"
+
+module Metamorpher
+  module Terms
+    class TermSet < Term
+      attributes terms: []
+
+      def inspect
+        "TermSet" + terms.inspect
+      end
+
+      def alternatives
+        terms
+      end
+    end
+  end
+end

data/lib/metamorpher/transformer/base.rb

@@ -32,19 +32,19 @@ module Metamorpher
 
       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)
+          rule.reduce(literal) do |original, rewritings|
+            original_position = driver.source_location_for(original)
+            original_code = src[original_position]
+
+            rewritings.alternatives.each do |rewriting|
+              replacements << Site.new(original_position, original_code, driver.unparse(rewriting))
             end
           end
         end
       end
 
-      def rules
-        @rules ||= replacements.map { |r| Rewriter::Rule.new(pattern: pattern, replacement: r) }
+      def rule
+        @rule ||= Rewriter::Rule.new(pattern: pattern, replacement: replacement)
       end
     end
   end

data/lib/metamorpher/version.rb

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

data/spec/integration/ast/builder_spec.rb

@@ -1,4 +1,5 @@
 require "metamorpher"
+require "metamorpher/terms/term_set"
 
 describe Metamorpher do
   subject { Metamorpher.builder }
@@ -10,4 +11,5 @@ describe Metamorpher do
   it_behaves_like "a variable builder"
   it_behaves_like "a greedy variable builder"
   it_behaves_like "a derivation builder"
+  it_behaves_like "a term set builder"
 end

data/spec/integration/ast/matcher_spec.rb

@@ -129,4 +129,64 @@ describe "Matching" do
       expect(subject.run(expression)).not_to have_matched
     end
   end
+
+  describe "alternatives" do
+    class CalculatorOperatorMatcher
+      include Metamorpher::Matcher
+      include Metamorpher::Builders::AST
+
+      def pattern
+        builder.either!(
+          builder.add(builder.ARGS_),
+          builder.subtract(builder.ARGS_),
+          builder.clear
+        )
+      end
+    end
+
+    subject { CalculatorOperatorMatcher.new }
+
+    it "should return a match for matching add 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 a match for matching subtract expressions" do
+      expressions = [
+        builder.subtract(1),
+        builder.subtract(1, 2),
+        builder.subtract(1, 2, 3),
+        builder.subtract(1, builder.succ(:n), 2)
+      ]
+
+      expressions.each do |expression|
+        expect(subject.run(expression)).to have_matched(expression)
+      end
+    end
+
+    it "should return a match for matching clear expression" do
+      expect(subject.run(builder.clear)).to have_matched(builder.clear)
+    end
+
+    it "should return no match for near misses" do
+      expressions = [
+        builder.add,
+        builder.subtract,
+        builder.empty,
+        builder.multiply(1, 2, 3)
+      ]
+
+      expressions.each do |expression|
+        expect(subject.run(expression)).not_to have_matched(expression)
+      end
+    end
+  end
 end

data/spec/integration/ast/rewriter_spec.rb

@@ -82,6 +82,33 @@ describe "Rewriting" do
     end
   end
 
+  describe "multiple rewritings via termset" do
+    class FlexiblePluraliseRewriter
+      include Metamorpher::Rewriter
+      include Metamorpher::Builders::AST
+
+      def pattern
+        builder.SINGULAR
+      end
+
+      def replacement
+        builder.either!(
+          builder.derivation!(:singular) { |singular| builder.literal!(singular.name + "s") },
+          builder.derivation!(:singular) { |singular| builder.literal!(singular.name + "es") }
+        )
+      end
+    end
+
+    subject { FlexiblePluraliseRewriter.new }
+
+    it "should rewrite using each derivation" do
+      expression = builder.literal! "virus"
+      reduced = builder.either!(builder.literal!("viruss"), builder.literal!("viruses"))
+
+      expect(subject.reduce(expression)).to eq(reduced)
+    end
+  end
+
   describe "derivations" do
     describe "from a single variable" do
       class PluraliseRewriter
@@ -134,5 +161,34 @@ describe "Rewriting" do
         expect(subject.reduce(expression)).to eq(reduced)
       end
     end
+
+    describe "to several alternatives" do
+      class FlexiblePluraliseRewriterInner
+        include Metamorpher::Rewriter
+        include Metamorpher::Builders::AST
+
+        def pattern
+          builder.SINGULAR
+        end
+
+        def replacement
+          builder.derivation!(:singular) do |singular|
+            builder.either!(
+              builder.literal!(singular.name + "s"),
+              builder.literal!(singular.name + "es")
+            )
+          end
+        end
+      end
+
+      subject { FlexiblePluraliseRewriterInner.new }
+
+      it "should rewrite using each derivation" do
+        expression = builder.literal! "virus"
+        reduced = builder.either!(builder.literal!("viruss"), builder.literal!("viruses"))
+
+        expect(subject.reduce(expression)).to eq(reduced)
+      end
+    end
   end
 end

data/spec/integration/ruby/builder_spec.rb

@@ -122,4 +122,22 @@ describe Metamorpher.builder do
       expect(last_derived.base).to eq([:last])
     end
   end
+
+  describe "when building with alternatives" do
+    it "should produce a termset" do
+      actual = subject.build("1 + 1", "LEFT + RIGHT")
+
+      expected_literals = ast_builder.literal!(:send, ast_builder.int(1), :+, ast_builder.int(1))
+      expected_variables = ast_builder.literal!(:send, ast_builder.LEFT, :+, ast_builder.RIGHT)
+      expected = ast_builder.either!(expected_literals, expected_variables)
+
+      expect(actual).to eq(expected)
+    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
 end

data/spec/integration/ruby/mutator_spec.rb

@@ -11,8 +11,8 @@ describe "Mutator" do
         builder.build("A < B")
       end
 
-      def replacements
-        builder.build_all("A > B", "A == B")
+      def replacement
+        builder.build("A > B", "A == B")
       end
     end
 
@@ -33,13 +33,13 @@ describe "Mutator" do
         "end",
 
         "def compare\n" \
-        "  foo < bar\n" \
-        "  bar > baz\n" \
+        "  foo == bar\n" \
+        "  bar < baz\n" \
         "end",
 
         "def compare\n" \
-        "  foo == bar\n" \
-        "  bar < baz\n" \
+        "  foo < bar\n" \
+        "  bar > baz\n" \
         "end",
 
         "def compare\n" \
@@ -52,7 +52,7 @@ describe "Mutator" do
     let(:not_mutatable) { "foo == bar" }
 
     describe "by calling mutate" do
-      describe "for code that can be mutated"do
+      describe "for code that can be mutated" do
         it "should return the mutated code" do
           expect(subject.mutate(mutatable)).to eq(mutated)
         end
@@ -60,8 +60,8 @@ describe "Mutator" do
         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"),
             site_for(26..34, "bar < baz", "bar == baz")
           )
         end
@@ -89,8 +89,8 @@ describe "Mutator" do
         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"),
             site_for(26..34, "bar < baz", "bar == baz")
           )
         end
@@ -155,8 +155,8 @@ describe "Mutator" do
           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"),
             site_for(26..34, "bar < baz", "bar == baz")
           ]
         ]
@@ -166,8 +166,8 @@ describe "Mutator" do
           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"),
             site_for(26..34, "bar < baz", "bar == baz")
           ]
         ]

data/spec/support/shared_examples/shared_examples_for_term_set_builder.rb

@@ -0,0 +1,39 @@
+require "metamorpher/terms/term_set"
+require "metamorpher/terms/literal"
+require "metamorpher/terms/variable"
+
+module Metamorpher
+  module Terms
+    shared_examples_for "a term set builder" do
+      describe "either!" do
+        it "should create an instance of TermSet" do
+          actual = subject.either!(Literal.new(name: :a), Variable.new(name: :b))
+          expected = TermSet.new(terms: [Literal.new(name: :a), Variable.new(name: :b)])
+
+          expect(actual).to eq(expected)
+        end
+
+        it "should return an empty TermSet when given no arguments" do
+          actual = subject.either!
+          expected = Metamorpher::Terms::TermSet.new
+
+          expect(actual).to eq(expected)
+        end
+
+        it "should automatically convert arguments to literals" do
+          actual = subject.either!(:add, :subtract)
+          expected = TermSet.new(terms: [Literal.new(name: :add), Literal.new(name: :subtract)])
+
+          expect(actual).to eq(expected)
+        end
+
+        it "should not automatically convert arguments that are already terms" do
+          actual = subject.either!(:add, Variable.new(name: :operator))
+          expected = TermSet.new(terms: [Literal.new(name: :add), Variable.new(name: :operator)])
+
+          expect(actual).to eq(expected)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+require "metamorpher/builders/ast/term_set_builder"
+
+describe Metamorpher::Builders::AST::TermSetBuilder do
+  it_behaves_like "a term set builder"
+end

data/spec/unit/matcher/matching_spec.rb

@@ -217,6 +217,25 @@ module Metamorpher
         end
       end
 
+      describe TermSet do
+        let(:first) { Literal.new(name: :first) }
+        let(:second) { Literal.new(name: :second) }
+
+        subject { TermSet.new(terms: [first, second]) }
+
+        it "should match when a child matches" do
+          matchee = Literal.new(name: :second)
+
+          expect(subject.match(matchee)).to have_matched(matchee)
+        end
+
+        it "should not match when no child matches" do
+          matchee = Literal.new(name: :third)
+
+          expect(subject.match(matchee)).not_to have_matched
+        end
+      end
+
       describe Derived do
         it "should raise" do
           root = Derived.new

data/spec/unit/rewriter/substitution_spec.rb

@@ -93,5 +93,25 @@ module Metamorpher
         end
       end
     end
+
+    describe TermSet do
+      let(:first_child) { Variable.new(name: :type) }
+
+      let(:second_child) do
+        Derived.new(
+          base: [:type],
+          derivation: -> (type) { Literal.new(name: type.name.reverse) }
+        )
+      end
+
+      subject { TermSet.new(terms: [first_child, second_child]) }
+
+      it "should perform substitution on each child" do
+        substitution = { type: Literal.new(name: "sub") }
+        expected = TermSet.new(terms: [Literal.new(name: "sub"), Literal.new(name: "sub".reverse)])
+
+        expect(subject.substitute(substitution)).to eq(expected)
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metamorpher
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Louis Rose
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-08 00:00:00.000000000 Z
+date: 2015-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: attributable
@@ -130,6 +130,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -152,6 +153,7 @@ files:
 - lib/metamorpher/builders/ast/derivation_builder.rb
 - lib/metamorpher/builders/ast/greedy_variable_builder.rb
 - lib/metamorpher/builders/ast/literal_builder.rb
+- lib/metamorpher/builders/ast/term_set_builder.rb
 - lib/metamorpher/builders/ast/variable_builder.rb
 - lib/metamorpher/builders/ruby.rb
 - lib/metamorpher/builders/ruby/builder.rb
@@ -178,6 +180,7 @@ files:
 - lib/metamorpher/terms/derived.rb
 - lib/metamorpher/terms/literal.rb
 - lib/metamorpher/terms/term.rb
+- lib/metamorpher/terms/term_set.rb
 - lib/metamorpher/terms/variable.rb
 - lib/metamorpher/transformer/base.rb
 - lib/metamorpher/transformer/merger.rb
@@ -199,10 +202,12 @@ files:
 - spec/support/shared_examples/shared_examples_for_derivation_builders.rb
 - spec/support/shared_examples/shared_examples_for_greedy_variable_builders.rb
 - spec/support/shared_examples/shared_examples_for_literal_builders.rb
+- spec/support/shared_examples/shared_examples_for_term_set_builder.rb
 - spec/support/shared_examples/shared_examples_for_variable_builders.rb
 - spec/unit/builders/ast/derivation_builder_spec.rb
 - spec/unit/builders/ast/greedy_variable_builder_spec.rb
 - spec/unit/builders/ast/literal_builder_spec.rb
+- spec/unit/builders/ast/term_set_builder_spec.rb
 - spec/unit/builders/ast/variable_builder_spec.rb
 - spec/unit/builders/ruby/variable_replacement_visitor_spec.rb
 - spec/unit/drivers/ruby_spec.rb
@@ -255,10 +260,12 @@ test_files:
 - spec/support/shared_examples/shared_examples_for_derivation_builders.rb
 - spec/support/shared_examples/shared_examples_for_greedy_variable_builders.rb
 - spec/support/shared_examples/shared_examples_for_literal_builders.rb
+- spec/support/shared_examples/shared_examples_for_term_set_builder.rb
 - spec/support/shared_examples/shared_examples_for_variable_builders.rb
 - spec/unit/builders/ast/derivation_builder_spec.rb
 - spec/unit/builders/ast/greedy_variable_builder_spec.rb
 - spec/unit/builders/ast/literal_builder_spec.rb
+- spec/unit/builders/ast/term_set_builder_spec.rb
 - spec/unit/builders/ast/variable_builder_spec.rb
 - spec/unit/builders/ruby/variable_replacement_visitor_spec.rb
 - spec/unit/drivers/ruby_spec.rb