metamorpher 0.1.0

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

@@ -0,0 +1,32 @@
+module Metamorpher
+  module Builders
+    module Ruby
+      class VariableReplacementVisitor < Visitable::Visitor
+        attr_accessor :variable_name, :replacement
+
+        def initialize(variable_name, replacement)
+          @variable_name, @replacement = variable_name, replacement
+        end
+
+        def visit_literal(literal)
+          Terms::Literal.new(
+            name: literal.name,
+            children: literal.children.map { |child| visit(child) }
+          )
+        end
+
+        def visit_variable(variable)
+          if variable.name == variable_name
+            replacement
+          else
+            variable
+          end
+        end
+
+        def visit_term(term)
+          term
+        end
+      end
+    end
+  end
+end

data/lib/metamorpher/builders/ruby.rb

@@ -0,0 +1,11 @@
+require "metamorpher/builders/ruby/builder"
+
+module Metamorpher
+  module Builders
+    module Ruby
+      def builder
+        @builder ||= Builder.new
+      end
+    end
+  end
+end

data/lib/metamorpher/drivers/parse_error.rb

@@ -0,0 +1,5 @@
+module Metamorpher
+  module Drivers
+    class ParseError < ArgumentError; end
+  end
+end

data/lib/metamorpher/drivers/ruby.rb

@@ -0,0 +1,78 @@
+require "metamorpher/drivers/parse_error"
+require "metamorpher/terms/literal"
+require "parser/current"
+require "unparser"
+
+module Metamorpher
+  module Drivers
+    class Ruby
+      def parse(src)
+        import(@root = parser.parse(src))
+      rescue Parser::SyntaxError
+        raise ParseError
+      end
+
+      def unparse(literal)
+        unparser.unparse(export(literal))
+      end
+
+      def source_location_for(literal)
+        ast = ast_for(literal)
+        (ast.loc.expression.begin_pos..(ast.loc.expression.end_pos - 1))
+      end
+
+      private
+
+      def import(ast)
+        create_literal_for(ast)
+      end
+
+      def create_literal_for(ast)
+        if ast.respond_to? :type
+          Terms::Literal.new(name: ast.type, children: ast.children.map { |c| import(c) })
+        else
+          Terms::Literal.new(name: ast)
+        end
+      end
+
+      def export(literal)
+        if literal.branch?
+          Parser::AST::Node.new(literal.name, literal.children.map { |c| export(c) })
+
+        elsif keyword?(literal)
+          # Unparser requires leaf nodes containing keywords to be represented as nodes.
+          Parser::AST::Node.new(literal.name)
+
+        else
+          # Unparser requires all other leaf nodes to be represented as primitives.
+          literal.name
+        end
+      end
+
+      def keyword?(literal)
+        literal.leaf? && !literal.child_of?(:sym) && keywords.include?(literal.name)
+      end
+
+      def keywords
+        # The symbols used by Parser for Ruby keywords. The current implementation
+        # is not a definitive list. If unparsing fails, it might be due to this list
+        # omitting a necessary keyword. Note that these are the symbols produced
+        # by Parser which are not necessarily the same as Ruby keywords (e.g.,
+        # Parser sometimes produces a :zsuper node for a program of the form "super")
+        @keywords ||= %i(nil false true self)
+      end
+
+      def ast_for(literal)
+        literal.path.reduce(@root) { |a, e| a.children[e] }
+      end
+
+      def parser
+        @parser ||= Parser::CurrentRuby
+      end
+
+      def unparser
+        @unparser ||= Unparser
+      end
+    end
+  end
+end

data/lib/metamorpher/matcher/match.rb

@@ -0,0 +1,26 @@
+require "attributable"
+
+module Metamorpher
+  module Matcher
+    class Match
+      extend Attributable
+      attributes :root, substitution: {}
+
+      def matches?
+        true
+      end
+
+      def match_for(variable)
+        substitution[variable.name]
+      end
+
+      def combine(combinee)
+        if combinee.matches?
+          Match.new(root: root, substitution: combinee.substitution.merge(substitution))
+        else
+          NoMatch.new
+        end
+      end
+    end
+  end
+end

data/lib/metamorpher/matcher/matching.rb

@@ -0,0 +1,61 @@
+require "metamorpher/visitable/visitor"
+require "metamorpher/matcher/match"
+require "metamorpher/matcher/no_match"
+
+module Metamorpher
+  module Matcher
+    module Matching
+      def match(other)
+        if other.nil?
+          Matcher::NoMatch.new
+        else
+          accept MatchingVisitor.new(other)
+        end
+      end
+    end
+
+    class MatchingVisitor < Visitable::Visitor
+      attr_accessor :other
+
+      def initialize(other)
+        @other = other
+      end
+
+      def visit_variable(variable)
+        captured = variable.greedy? ? other.with_younger_siblings : other
+        if variable.condition.call(captured)
+          Matcher::Match.new(root: captured, substitution: { variable.name => captured })
+        else
+          Matcher::NoMatch.new
+        end
+      end
+
+      def visit_literal(literal)
+        if other.name == literal.name && expected_number_of_children?(literal)
+          literal.children
+            .zip(other.children)
+            .map { |child, other_child| child.match(other_child) }
+            .reduce(Matcher::Match.new(root: other), :combine)
+        else
+          Matcher::NoMatch.new
+        end
+      end
+
+      def visit_derived(derived)
+        fail MatchingError, "Cannot match against a derived variable."
+      end
+
+      private
+
+      def expected_number_of_children?(literal)
+        other.children.size == literal.children.size || greedy_child?(literal)
+      end
+
+      def greedy_child?(literal)
+        literal.children.any? { |c| c.is_a?(Terms::Variable) && c.greedy? }
+      end
+    end
+
+    class MatchingError < ArgumentError; end
+  end
+end

data/lib/metamorpher/matcher/no_match.rb

@@ -0,0 +1,18 @@
+require "attributable"
+
+module Metamorpher
+  module Matcher
+    class NoMatch
+      extend Attributable
+      attributes
+
+      def matches?
+        false
+      end
+
+      def combine(_)
+        NoMatch.new
+      end
+    end
+  end
+end

data/lib/metamorpher/matcher.rb

@@ -0,0 +1,6 @@
+module Metamorpher
+  module Matcher
+    extend Forwardable
+    def_delegator :pattern, :match, :run
+  end
+end

data/lib/metamorpher/refactorer/merger.rb

@@ -0,0 +1,18 @@
+require "attributable"
+
+module Metamorpher
+  module Refactorer
+    Merger = Struct.new(:original) do
+      def merge(*replacements, &block)
+        original.dup.tap do |merged|
+          replacements.sort.reduce(0) do |offset, replacement|
+            yield replacement if block
+            replacement = replacement.slide(offset)
+            replacement.merge_into(merged)
+            offset + replacement.offset
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metamorpher/refactorer/site.rb

@@ -0,0 +1,29 @@
+require "attributable"
+
+module Metamorpher
+  module Refactorer
+    Site = Struct.new(:original_position, :original_code, :refactored_code) do
+      def slide(offset)
+        new_position = (original_position.begin + offset)..(original_position.end + offset)
+        Site.new(new_position, original_code, refactored_code)
+      end
+
+      def merge_into(destination)
+        if original_position.begin > destination.size
+          fail ArgumentError, "Position #{original_position} does not exist in: #{destination}"
+        end
+
+        destination[original_position] = refactored_code
+        destination
+      end
+
+      def offset
+        refactored_code.size - original_code.size
+      end
+
+      def <=>(other)
+        original_position.begin <=> other.original_position.begin
+      end
+    end
+  end
+end

data/lib/metamorpher/refactorer.rb

@@ -0,0 +1,48 @@
+require "metamorpher/refactorer/merger"
+require "metamorpher/refactorer/site"
+require "metamorpher/rewriter/rule"
+require "metamorpher/drivers/ruby"
+
+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
+
+    def refactor_files(paths, &block)
+      paths.reduce({}) do |result, path|
+        changes = []
+        result[path] = refactor_file(path) { |change| changes << change }
+        block.call(path, result[path], changes) if block
+        result
+      end
+    end
+
+    def driver
+      @driver ||= Metamorpher::Drivers::Ruby.new
+    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)
+    end
+  end
+end

data/lib/metamorpher/rewriter/replacement.rb

@@ -0,0 +1,18 @@
+module Metamorpher
+  module Rewriter
+    module Replacement
+      def replace(path, replacement)
+        if path.empty?
+          replacement
+        else
+          Terms::Literal.new(
+            name: name,
+            children: children.map_at(path.first) { |e| e.replace(path.drop(1), replacement) }
+          )
+        end
+      end
+    end
+
+    class ReplacementError < ArgumentError; end
+  end
+end

data/lib/metamorpher/rewriter/rule.rb

@@ -0,0 +1,38 @@
+require "attributable"
+require "metamorpher/rewriter/traverser"
+
+module Metamorpher
+  module Rewriter
+    class Rule
+      extend Attributable
+      attributes :pattern, :replacement, traverser: Traverser.new
+
+      def apply(ast, &block)
+        rewrite_all(ast, matches_for(ast).take(1), &block)
+      end
+
+      def reduce(ast, &block)
+        rewrite_all(ast, matches_for(ast), &block)
+      end
+
+      private
+
+      def rewrite_all(ast, matches, &block)
+        matches.reduce(ast) { |a, e| rewrite(a, e, &block) }
+      end
+
+      def rewrite(ast, match, &block)
+        original, rewritten = match.root, replacement.substitute(match.substitution)
+        block.call(original, rewritten) if block
+        ast.replace(original.path, rewritten)
+      end
+
+      def matches_for(ast)
+        traverser.traverse(ast)
+          .lazy # only compute the next match when needed
+          .map { |current| pattern.match(current) }
+          .select { |result| result.matches? }
+      end
+    end
+  end
+end

data/lib/metamorpher/rewriter/substitution.rb

@@ -0,0 +1,45 @@
+require "metamorpher/visitable/visitor"
+
+module Metamorpher
+  module Rewriter
+    module Substitution
+      def substitute(substitution)
+        accept SubstitutionVisitor.new(substitution)
+      end
+    end
+
+    class SubstitutionVisitor < Visitable::Visitor
+      attr_accessor :substitution
+
+      def initialize(substitution)
+        @substitution = substitution
+      end
+
+      def visit_variable(variable)
+        substitution_for_variable(variable.name)
+      end
+
+      def visit_literal(literal)
+        Terms::Literal.new(
+          name: literal.name,
+          children: literal.children.flat_map { |child| visit(child) }
+        )
+      end
+
+      def visit_derived(derived)
+        substitutes = derived.base.map { |v| substitution_for_variable(v) }
+        derived.derivation.call(*substitutes)
+      end
+
+      private
+
+      def substitution_for_variable(name)
+        substitution.fetch(name) do
+          fail SubstitutionError, "No substitution found for variable '#{name}'"
+        end
+      end
+    end
+
+    class SubstitutionError < ArgumentError; end
+  end
+end

data/lib/metamorpher/rewriter/traverser.rb

@@ -0,0 +1,26 @@
+module Metamorpher
+  module Rewriter
+    class Traverser
+      def traverse(tree)
+        Enumerator.new(count(tree)) do |yielder|
+          waiting = [tree]
+          until waiting.empty?
+            current = waiting.shift
+            yielder << current
+            waiting.concat(children(current))
+          end
+        end
+      end
+
+      private
+
+      def count(tree)
+        children(tree).flat_map { |child| count(child) }.inject(1, :+)
+      end
+
+      def children(node)
+        node.respond_to?(:children) ? node.children : []
+      end
+    end
+  end
+end

data/lib/metamorpher/rewriter.rb

@@ -0,0 +1,12 @@
+require "metamorpher/rewriter/rule"
+
+module Metamorpher
+  module Rewriter
+    extend Forwardable
+    def_delegators :rule, :apply, :reduce
+
+    def rule
+      @rule ||= Rewriter::Rule.new(pattern: pattern, replacement: replacement)
+    end
+  end
+end

data/lib/metamorpher/support/map_at.rb

@@ -0,0 +1,8 @@
+module Enumerable
+  # Returns a new array with the element at _index_ replaced by the result of
+  # running _block_ on that element.
+  def map_at(index, &block)
+    fail IndexError if index < 0 || index >= size
+    each_with_index.map { |e, i| i == index ? block.call(e) : e }
+  end
+end

data/lib/metamorpher/terms/derived.rb

@@ -0,0 +1,13 @@
+require "metamorpher/terms/term"
+
+module Metamorpher
+  module Terms
+    class Derived < Term
+      attributes :base, :derivation
+
+      def inspect
+        "[#{base.map(&:upcase).join(", ")}] -> ..."
+      end
+    end
+  end
+end

data/lib/metamorpher/terms/literal.rb

@@ -0,0 +1,47 @@
+require "metamorpher/terms/term"
+require "metamorpher/matcher/match"
+require "metamorpher/matcher/no_match"
+
+module Metamorpher
+  module Terms
+    class Literal < Term
+      attributes children: []
+
+      def initialize(attributes = {})
+        initialize_attributes(attributes)
+        children.each { |child| child.parent = self }
+      end
+
+      def inspect
+        if leaf?
+          "#{name}"
+        else
+          "#{name}(#{children.map(&:inspect).join(', ')})"
+        end
+      end
+
+      def leaf?
+        children.empty?
+      end
+
+      def branch?
+        !leaf?
+      end
+
+      def child_of?(parent_name)
+        parent && parent.name == parent_name
+      end
+
+      def children_younger_than_or_equal_to(child)
+        children[(index(child))..-1]
+      end
+
+      private
+
+      def index(child)
+        children.index(child) ||
+        fail(ArgumentError, "#{child.inspect} is not a child of #{inspect}")
+      end
+    end
+  end
+end

data/lib/metamorpher/terms/term.rb

@@ -0,0 +1,40 @@
+require "attributable"
+require "metamorpher/visitable/visitable"
+require "metamorpher/matcher/matching"
+require "metamorpher/rewriter/replacement"
+require "metamorpher/rewriter/substitution"
+
+module Metamorpher
+  module Terms
+    class Term
+      extend Attributable
+      attributes :name
+      attr_accessor :parent
+
+      include Visitable
+      include Matcher::Matching
+      include Rewriter::Replacement
+      include Rewriter::Substitution
+
+      def inspect
+        name
+      end
+
+      def path
+        if parent
+          parent.path << parent.children.index { |c| c.equal?(self) }
+        else
+          []
+        end
+      end
+
+      def with_younger_siblings
+        if parent
+          parent.children_younger_than_or_equal_to(self)
+        else
+          [self]
+        end
+      end
+    end
+  end
+end

data/lib/metamorpher/terms/variable.rb

@@ -0,0 +1,17 @@
+require "metamorpher/terms/term"
+require "metamorpher/matcher/match"
+
+module Metamorpher
+  module Terms
+    class Variable < Term
+      DEFAULT_CONDITION = ->(_) { true }
+      attributes greedy?: false, condition: DEFAULT_CONDITION
+
+      def inspect
+        name.to_s.upcase +
+        (greedy? ? "+" : "") +
+        (condition != DEFAULT_CONDITION ? "?" : "")
+      end
+    end
+  end
+end

data/lib/metamorpher/version.rb

@@ -0,0 +1,3 @@
+module Metamorpher
+  VERSION = "0.1.0"
+end

data/lib/metamorpher/visitable/visitable.rb

@@ -0,0 +1,7 @@
+module Metamorpher
+  module Visitable
+    def accept(visitor)
+      visitor.visit(self)
+    end
+  end
+end

data/lib/metamorpher/visitable/visitor.rb

@@ -0,0 +1,21 @@
+# Based on http://blog.rubybestpractices.com/posts/aaronp/001_double_dispatch_dance.html
+
+module Metamorpher
+  module Visitable
+    class Visitor
+      ###
+      # This method will examine the class and ancestors of +thing+. For each
+      # class in the "ancestors" list, it will check to see if the visitor knows
+      # how to handle that particular class. If it can't find a handler for the
+      # +thing+ it will raise an exception.
+      def visit(thing)
+        thing.class.ancestors.each do |ancestor|
+          method_name = :"visit_#{ancestor.name.split("::").last.downcase}"
+          return send(method_name, thing) if respond_to?(method_name)
+        end
+
+        fail ArgumentError, "Can't visit #{thing.class}"
+      end
+    end
+  end
+end

data/lib/metamorpher.rb

@@ -0,0 +1,30 @@
+require "metamorpher/version"
+require "metamorpher/builders/ruby"
+
+require "metamorpher/support/map_at"
+
+require "metamorpher/matcher"
+require "metamorpher/rewriter"
+require "metamorpher/refactorer"
+
+module Metamorpher
+  def self.builder
+    @builder ||= Builders::Ruby::Builder.new
+  end
+
+  def self.configure(builder: :ast)
+    configure_builder(builder)
+  end
+
+  private
+
+  def self.configure_builder(builder)
+    require "metamorpher/builders/#{builder}/builder"
+    @builder = builder_class_for(builder).new
+  end
+
+  def self.builder_class_for(name)
+    namespace = name == :ast ? "AST" : name.to_s.capitalize
+    Builders.const_get(namespace).const_get("Builder")
+  end
+end