synvert-core 0.1.0

data/lib/synvert/core/rewriter.rb

@@ -0,0 +1,200 @@
+# encoding: utf-8
+
+module Synvert::Core
+  # Rewriter is the top level namespace in a snippet.
+  #
+  # One Rewriter can contain one or many [Synvert::Core::Rewriter::Instance],
+  # which define the behavior what files and what codes to detect and rewrite to what code.
+  #
+  #   Synvert::Rewriter.new 'factory_girl_short_syntax', 'use FactoryGirl short syntax' do
+  #     if_gem 'factory_girl', {gte: '2.0.0'}
+  #
+  #     within_files 'spec/**/*.rb' do
+  #       with_node type: 'send', receiver: 'FactoryGirl', message: 'create' do
+  #         replace_with "create({{arguments}})"
+  #       end
+  #     end
+  #   end
+  class Rewriter
+    autoload :Action, 'synvert/core/rewriter/action'
+    autoload :AppendAction, 'synvert/core/rewriter/action'
+    autoload :InsertAction, 'synvert/core/rewriter/action'
+    autoload :InsertAfterAction, 'synvert/core/rewriter/action'
+    autoload :ReplaceWithAction, 'synvert/core/rewriter/action'
+    autoload :RemoveAction, 'synvert/core/rewriter/action'
+
+    autoload :Instance, 'synvert/core/rewriter/instance'
+
+    autoload :Scope, 'synvert/core/rewriter/scope'
+
+    autoload :Condition, 'synvert/core/rewriter/condition'
+    autoload :IfExistCondition, 'synvert/core/rewriter/condition'
+    autoload :UnlessExistCondition, 'synvert/core/rewriter/condition'
+    autoload :IfOnlyExistCondition, 'synvert/core/rewriter/condition'
+
+    autoload :GemSpec, 'synvert/core/rewriter/gem_spec'
+
+    class <<self
+      # Register a rewriter with its name.
+      #
+      # @param name [String] the unique rewriter name.
+      # @param rewriter [Synvert::Core::Rewriter] the rewriter to register.
+      def register(name, rewriter)
+        @rewriters ||= {}
+        @rewriters[name] = rewriter
+      end
+
+      # Fetch a rewriter by name.
+      #
+      # @param name [String] rewrtier name.
+      # @return [Synvert::Core::Rewriter] the matching rewriter.
+      def fetch(name)
+        @rewriters[name]
+      end
+
+      # Get a registered rewriter by name and process that rewriter.
+      #
+      # @param name [String] the rewriter name.
+      # @return [Synvert::Core::Rewriter] the registered rewriter.
+      # @raise [Synvert::Core::RewriterNotFound] if the registered rewriter is not found.
+      def call(name)
+        if (rewriter = @rewriters[name])
+          rewriter.process
+          rewriter
+        else
+          raise RewriterNotFound.new "Rewriter #{name} not found"
+        end
+      end
+
+      # Get all available rewriters
+      #
+      # @return [Array<Synvert::Core::Rewriter>]
+      def availables
+        @rewriters.values
+      end
+
+      # Clear all registered rewriters.
+      def clear
+        @rewriters.clear
+      end
+    end
+
+    # @!attribute [r] name
+    #   @return [String] the unique name of rewriter
+    # @!attribute [r] sub_snippets
+    #   @return [Array<Synvert::Core::Rewriter>] all rewriters this rewiter calls.
+    attr_reader :name, :sub_snippets
+
+    # Initialize a rewriter.
+    # When a rewriter is initialized, it is also registered.
+    #
+    # @param name [String] name of the rewriter.
+    # @param block [Block] a block defines the behaviors of the rewriter, block code won't be called when initialization.
+    # @return [Synvert::Core::Rewriter]
+    def initialize(name, &block)
+      @name = name.to_s
+      @block = block
+      @helpers = []
+      @sub_snippets = []
+      self.class.register(@name, self)
+    end
+
+    # Process the rewriter.
+    # It will call the block.
+    def process
+      self.instance_eval &@block
+    end
+
+    # Process rewriter with sandbox mode.
+    # It will call the block but doesn't change any file.
+    def process_with_sandbox
+      @sandbox = true
+      self.process
+      @sandbox = false
+    end
+
+    #######
+    # DSL #
+    #######
+
+    # Parse description dsl, it sets description of the rewrite.
+    # Or get description.
+    #
+    # @param description [String] rewriter description.
+    # @return rewriter description.
+    def description(description=nil)
+      if description
+        @description = description
+      else
+        @description
+      end
+    end
+
+    # Parse if_gem dsl, it compares version of the specified gem.
+    #
+    # @param name [String] gem name.
+    # @param comparator [Hash] equal, less than or greater than specified version, e.g. {gte: '2.0.0'},
+    #   key can be eq, lt, gt, lte, gte or ne.
+    def if_gem(name, comparator)
+      @gem_spec = Rewriter::GemSpec.new(name, comparator)
+    end
+
+    # Parse within_files dsl, it finds specified files.
+    # It creates a [Synvert::Core::Rewriter::Instance] to rewrite code.
+    #
+    # @param file_pattern [String] pattern to find files, e.g. spec/**/*_spec.rb
+    # @param block [Block] the block to rewrite code in the matching files.
+    def within_files(file_pattern, &block)
+      return if @sandbox
+
+      if !@gem_spec || @gem_spec.match?
+        instance = Rewriter::Instance.new(file_pattern, &block)
+        @helpers.each { |helper| instance.singleton_class.send(:define_method, helper[:name], &helper[:block]) }
+        instance.process
+      end
+    end
+
+    # Parse within_file dsl, it finds a specifiled file.
+    alias within_file within_files
+
+    # Parses add_file dsl, it adds a new file.
+    #
+    # @param filename [String] file name of newly created file.
+    # @param content [String] file body of newly created file.
+    def add_file(filename, content)
+      return if @sandbox
+
+      File.open filename, 'w' do |file|
+        file.write content
+      end
+    end
+
+    # Parse add_snippet dsl, it calls anther rewriter.
+    #
+    # @param name [String] name of another rewriter.
+    def add_snippet(name)
+      @sub_snippets << self.class.call(name.to_s)
+    end
+
+    # Parse helper_method dsl, it defines helper method for [Synvert::Core::Rewriter::Instance].
+    #
+    # @param name [String] helper method name.
+    # @param block [Block] helper method block.
+    def helper_method(name, &block)
+      @helpers << {name: name, block: block}
+    end
+
+    # Parse todo dsl, it sets todo of the rewriter.
+    # Or get todo.
+    #
+    # @param todo_list [String] rewriter todo.
+    # @return [String] rewriter todo.
+    def todo(todo=nil)
+      if todo
+        @todo = todo
+      else
+        @todo
+      end
+    end
+  end
+end

data/lib/synvert/core/rewriter/action.rb

@@ -0,0 +1,224 @@
+# encoding: utf-8
+
+module Synvert::Core
+  # Action defines rewriter action, add, replace or remove code.
+  class Rewriter::Action
+    # Initialize an action.
+    #
+    # @param instance [Synvert::Core::Rewriter::Instance]
+    # @param code {String] new code to add, replace or remove.
+    def initialize(instance, code)
+      @instance = instance
+      @code = code
+      @node = @instance.current_node
+    end
+
+    # Line number of the node.
+    #
+    # @return [Integer] line number.
+    def line
+      @node.loc.expression.line
+    end
+
+    # The rewritten source code with proper indent.
+    #
+    # @return [String] rewritten code.
+    def rewritten_code
+      if rewritten_source.split("\n").length > 1
+        "\n\n" + rewritten_source.split("\n").map { |line|
+          indent(@node) + line
+        }.join("\n")
+      else
+        "\n" + indent(@node) + rewritten_source
+      end
+    end
+
+    # The rewritten source code.
+    #
+    # @return [String] rewritten source code.
+    def rewritten_source
+      @rewritten_source ||= @node.rewritten_source(@code)
+    end
+
+    # Compare actions by begin position.
+    #
+    # @param action [Synvert::Core::Rewriter::Action]
+    # @return [Integer] -1, 0 or 1
+    def <=>(action)
+      self.begin_pos <=> action.begin_pos
+    end
+  end
+
+  # ReplaceWithAction to replace code.
+  class Rewriter::ReplaceWithAction < Rewriter::Action
+    # Begin position of code to replace.
+    #
+    # @return [Integer] begin position.
+    def begin_pos
+      @node.loc.expression.begin_pos
+    end
+
+    # End position of code to replace.
+    #
+    # @return [Integer] end position.
+    def end_pos
+      @node.loc.expression.end_pos
+    end
+
+    # The rewritten source code with proper indent.
+    #
+    # @return [String] rewritten code.
+    def rewritten_code
+      if rewritten_source.split("\n").length > 1
+        "\n\n" + rewritten_source.split("\n").map { |line|
+          indent(@node) + line
+        }.join("\n")
+      else
+        rewritten_source
+      end
+    end
+
+  private
+
+    # Indent of the node
+    #
+    # @param node [Parser::AST::Node]
+    # @return [String] n times whitesphace
+    def indent(node)
+      ' ' * node.indent
+    end
+  end
+
+  # AppendWithAction to append code to the bottom of node body.
+  class Rewriter::AppendAction < Rewriter::Action
+    # Begin position to append code.
+    #
+    # @return [Integer] begin position.
+    def begin_pos
+      if :begin == @node.type
+        @node.loc.expression.end_pos
+      else
+        @node.loc.expression.end_pos - 4
+      end
+    end
+
+    # End position, always same to begin position.
+    #
+    # @return [Integer] end position.
+    def end_pos
+      begin_pos
+    end
+
+  private
+
+    # Indent of the node.
+    #
+    # @param node [Parser::AST::Node]
+    # @return [String] n times whitesphace
+    def indent(node)
+      if [:block, :class].include? node.type
+        ' ' * (node.indent + 2)
+      else
+        ' ' * node.indent
+      end
+    end
+  end
+
+  # InsertAction to insert code to the top of node body.
+  class Rewriter::InsertAction < Rewriter::Action
+    # Begin position to insert code.
+    #
+    # @return [Integer] begin position.
+    def begin_pos
+      insert_position(@node)
+    end
+
+    # End position, always same to begin position.
+    #
+    # @return [Integer] end position.
+    def end_pos
+      begin_pos
+    end
+
+  private
+
+    # Insert position.
+    #
+    # @return [Integer] insert position.
+    def insert_position(node)
+      case node.type
+      when :block
+        node.children[1].children.empty? ? node.children[0].loc.expression.end_pos + 3 : node.children[1].loc.expression.end_pos
+      when :class
+        node.children[1] ? node.children[1].loc.expression.end_pos : node.children[0].loc.expression.end_pos
+      else
+        node.children.last.loc.expression.end_pos
+      end
+    end
+
+    # Indent of the node.
+    #
+    # @param node [Parser::AST::Node]
+    # @return [String] n times whitesphace
+    def indent(node)
+      if [:block, :class].include? node.type
+        ' ' * (node.indent + 2)
+      else
+        ' ' * node.indent
+      end
+    end
+  end
+
+  # InsertAfterAction to insert code next to the node.
+  class Rewriter::InsertAfterAction < Rewriter::Action
+    # Begin position to insert code.
+    #
+    # @return [Integer] begin position.
+    def begin_pos
+      @node.loc.expression.end_pos
+    end
+
+    # End position, always same to begin position.
+    #
+    # @return [Integer] end position.
+    def end_pos
+      begin_pos
+    end
+
+  private
+
+    # Indent of the node.
+    #
+    # @param node [Parser::AST::Node]
+    # @return [String] n times whitesphace
+    def indent(node)
+      ' ' * node.indent
+    end
+  end
+
+  # RemoveAction to remove code.
+  class Rewriter::RemoveAction < Rewriter::Action
+    def initialize(instance, code=nil)
+      super
+    end
+
+    # Begin position of code to replace.
+    #
+    # @return [Integer] begin position.
+    def begin_pos
+      @node.loc.expression.begin_pos
+    end
+
+    # End position of code to replace.
+    #
+    # @return [Integer] end position.
+    def end_pos
+      @node.loc.expression.end_pos
+    end
+
+    # The rewritten code, always empty string.
+    def rewritten_code
+      ''
+    end
+  end
+end

data/lib/synvert/core/rewriter/condition.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+module Synvert::Core
+  # Condition checks if rules matches.
+  class Rewriter::Condition
+    # Initialize a condition.
+    #
+    # @param instance [Synvert::Core::Rewriter::Instance]
+    # @param rules [Hash]
+    # @param block [Block]
+    # @return [Synvert::Core::Rewriter::Condition]
+    def initialize(instance, rules, &block)
+      @instance = instance
+      @rules = rules
+      @block = block
+    end
+
+    # If condition matches, run the block code.
+    def process
+      @instance.instance_eval &@block if match?
+    end
+  end
+
+  # IfExistCondition checks if matching node exists in the node children.
+  class Rewriter::IfExistCondition < Rewriter::Condition
+    # check if any child node matches the rules.
+    def match?
+      match = false
+      @instance.current_node.recursive_children do |child_node|
+        match = match || (child_node && child_node.match?(@instance, @rules))
+      end
+      match
+    end
+  end
+
+  # UnlessExistCondition checks if matching node doesn't exist in the node children.
+  class Rewriter::UnlessExistCondition < Rewriter::Condition
+    # check if none of child node matches the rules.
+    def match?
+      match = false
+      @instance.current_node.recursive_children do |child_node|
+        match = match || (child_node && child_node.match?(@instance, @rules))
+      end
+      !match
+    end
+  end
+
+  # IfExistCondition checks if node has only one child node and the child node matches rules.
+  class Rewriter::IfOnlyExistCondition < Rewriter::Condition
+    # check if only have one child node and the child node matches rules.
+    def match?
+      @instance.current_node.body.size == 1 &&
+        @instance.current_node.body.first.match?(@instance, @rules)
+    end
+  end
+end