synvert 0.0.17 → 0.1.0

data/lib/synvert/rewriter/instance.rb

@@ -1,185 +0,0 @@
-# encoding: utf-8
-
-module Synvert
-  # Instance is an execution unit, it finds specified ast nodes,
-  # checks if the nodes match some conditions, then add, replace or remove code.
-  #
-  # One instance can contains one or many [Synvert::Rewriter::Scope] and [Synvert::Rewriter::Condition].
-  class Rewriter::Instance
-    # @!attribute [rw] current_node
-    #   @return current parsing node
-    # @!attribute [rw] current_source
-    #   @return current source code of file
-    # @!attribute [rw] current_file
-    #   @return current filename
-    attr_accessor :current_node, :current_source, :current_file
-
-    # Initialize an instance.
-    #
-    # @param file_pattern [String] pattern to find files, e.g. spec/**/*_spec.rb
-    # @param block [Block] block code to find nodes, match conditions and rewrite code.
-    # @return [Synvert::Rewriter::Instance]
-    def initialize(file_pattern, &block)
-      @actions = []
-      @file_pattern = file_pattern
-      @block = block
-    end
-
-    # Process the instance.
-    # It finds all files, for each file, it executes the block code, gets all rewrite actions,
-    # and rewrite source code back to original file.
-    def process
-      parser = Parser::CurrentRuby.new
-      file_pattern = File.join(Configuration.instance.get(:path), @file_pattern)
-      Dir.glob(file_pattern).each do |file_path|
-        unless Configuration.instance.get(:skip_files).include? file_path
-          begin
-            source = File.read(file_path)
-            buffer = Parser::Source::Buffer.new file_path
-            buffer.source = source
-
-            parser.reset
-            ast = parser.parse buffer
-
-            @current_file = file_path
-            @current_source = source
-            @current_node = ast
-            instance_eval &@block
-            @current_node = ast
-
-            @actions.sort!
-            check_conflict_actions
-            @actions.reverse.each do |action|
-              source[action.begin_pos...action.end_pos] = action.rewritten_code
-              source = remove_code_or_whole_line(source, action.line)
-            end
-            @actions = []
-
-            File.write file_path, source
-          end while !@conflict_actions.empty?
-        end
-      end
-    end
-
-    # Gets current node, it allows to get current node in block code.
-    #
-    # @return [Parser::AST::Node]
-    def node
-      @current_node
-    end
-
-    #######
-    # DSL #
-    #######
-
-    # Parse within_node dsl, it creates a [Synvert::Rewriter::Scope] to find matching ast nodes,
-    # then continue operating on each matching ast node.
-    #
-    # @param rules [Hash] rules to find mathing ast nodes.
-    # @param block [Block] block code to continue operating on the matching nodes.
-    def within_node(rules, &block)
-      Rewriter::Scope.new(self, rules, &block).process
-    end
-
-    alias with_node within_node
-
-    # Parse if_exist_node dsl, it creates a [Synvert::Rewriter::IfExistCondition] to check
-    # if matching nodes exist in the child nodes, if so, then continue operating on each matching ast node.
-    #
-    # @param rules [Hash] rules to check mathing ast nodes.
-    # @param block [Block] block code to continue operating on the matching nodes.
-    def if_exist_node(rules, &block)
-      Rewriter::IfExistCondition.new(self, rules, &block).process
-    end
-
-    # Parse unless_exist_node dsl, it creates a [Synvert::Rewriter::UnlessExistCondition] to check
-    # if matching nodes doesn't exist in the child nodes, if so, then continue operating on each matching ast node.
-    #
-    # @param rules [Hash] rules to check mathing ast nodes.
-    # @param block [Block] block code to continue operating on the matching nodes.
-    def unless_exist_node(rules, &block)
-      Rewriter::UnlessExistCondition.new(self, rules, &block).process
-    end
-
-    # Parse if_only_exist_node dsl, it creates a [Synvert::Rewriter::IfOnlyExistCondition] to check
-    # if current node has only one child node and the child node matches rules,
-    # if so, then continue operating on each matching ast node.
-    #
-    # @param rules [Hash] rules to check mathing ast nodes.
-    # @param block [Block] block code to continue operating on the matching nodes.
-    def if_only_exist_node(rules, &block)
-      Rewriter::IfOnlyExistCondition.new(self, rules, &block).process
-    end
-
-    # Parse append dsl, it creates a [Synvert::Rewriter::AppendAction] to
-    # append the code to the bottom of current node body.
-    #
-    # @param code [String] code need to be appended.
-    def append(code)
-      @actions << Rewriter::AppendAction.new(self, code)
-    end
-
-    # Parse insert dsl, it creates a [Synvert::Rewriter::InsertAction] to
-    # insert the code to the top of current node body.
-    #
-    # @param code [String] code need to be inserted.
-    def insert(code)
-      @actions << Rewriter::InsertAction.new(self, code)
-    end
-
-    # Parse insert_after dsl, it creates a [Synvert::Rewriter::InsertAfterAction] to
-    # insert the code next to the current node.
-    #
-    # @param code [String] code need to be inserted.
-    def insert_after(node)
-      @actions << Rewriter::InsertAfterAction.new(self, node)
-    end
-
-    # Parse replace_with dsl, it creates a [Synvert::Rewriter::ReplaceWithAction] to
-    # replace current node with code.
-    #
-    # @param code [String] code need to be replaced with.
-    def replace_with(code)
-      @actions << Rewriter::ReplaceWithAction.new(self, code)
-    end
-
-    # Parse remove dsl, it creates a [Synvert::Rewriter::RemoveAction] to current node.
-    def remove
-      @actions << Rewriter::RemoveAction.new(self)
-    end
-
-  private
-
-    # It changes source code from bottom to top, and it can change source code twice at the same time.
-    # So if there is an overlap between two actions, it removes the conflict actions and operate them in the next loop.
-    def check_conflict_actions
-      i = @actions.length - 1
-      @conflict_actions = []
-      while i > 0
-        if @actions[i].begin_pos <= @actions[i - 1].end_pos
-          @conflict_actions << @actions.delete_at(i)
-        end
-        i -= 1
-      end
-      @conflict_actions
-    end
-
-    # It checks if code is removed and that line is empty.
-    #
-    # @param source [String] source code of file
-    # @param line [String] the line number
-    def remove_code_or_whole_line(source, line)
-      newline_at_end_of_line = source[-1] == "\n"
-      source_arr = source.split("\n")
-      if source_arr[line - 1] && source_arr[line - 1].strip.empty?
-        source_arr.delete_at(line - 1)
-        if source_arr[line - 2] && source_arr[line - 2].strip.empty? && source_arr[line - 1] && source_arr[line - 1].strip.empty?
-          source_arr.delete_at(line - 1)
-        end
-        source_arr.join("\n") + (newline_at_end_of_line ? "\n" : '')
-      else
-        source
-      end
-    end
-  end
-end

data/lib/synvert/rewriter/scope.rb

@@ -1,46 +0,0 @@
-# encoding: utf-8
-
-module Synvert
-  # Scope finds the child nodes which match rules.
-  class Rewriter::Scope
-    # Initialize a scope
-    #
-    # @param instance [Synvert::Rewriter::Instance]
-    # @param rules [Hash]
-    # @param block [Block]
-    def initialize(instance, rules, &block)
-      @instance = instance
-      @rules = rules
-      @block = block
-    end
-
-    # Find the matching nodes. It checks the current node and iterates all child nodes,
-    # then run the block code for each matching node.
-    def process
-      current_node = @instance.current_node
-      return unless current_node
-      process_with_node current_node do
-        matching_nodes = []
-        matching_nodes << current_node if current_node.match? @instance, @rules
-        current_node.recursive_children do |child_node|
-          matching_nodes << child_node if child_node.match? @instance, @rules
-        end
-        matching_nodes.each do |matching_node|
-          process_with_node matching_node do
-            @instance.instance_eval &@block
-          end
-        end
-      end
-    end
-
-  private
-
-    # Set instance current node properly and process.
-    # @param node [Parser::AST::Node]
-    def process_with_node(node)
-      @instance.current_node = node
-      yield
-      @instance.current_node = node
-    end
-  end
-end

data/lib/synvert/rewriter.rb

@@ -1,200 +0,0 @@
-# encoding: utf-8
-
-module Synvert
-  # Rewriter is the top level namespace in a snippet.
-  #
-  # One Rewriter can contain one or many [Synvert::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/rewriter/action'
-    autoload :AppendAction, 'synvert/rewriter/action'
-    autoload :InsertAction, 'synvert/rewriter/action'
-    autoload :InsertAfterAction, 'synvert/rewriter/action'
-    autoload :ReplaceWithAction, 'synvert/rewriter/action'
-    autoload :RemoveAction, 'synvert/rewriter/action'
-
-    autoload :Instance, 'synvert/rewriter/instance'
-
-    autoload :Scope, 'synvert/rewriter/scope'
-
-    autoload :Condition, 'synvert/rewriter/condition'
-    autoload :IfExistCondition, 'synvert/rewriter/condition'
-    autoload :UnlessExistCondition, 'synvert/rewriter/condition'
-    autoload :IfOnlyExistCondition, 'synvert/rewriter/condition'
-
-    autoload :GemSpec, 'synvert/rewriter/gem_spec'
-
-    class <<self
-      # Register a rewriter with its name.
-      #
-      # @param name [String] the unique rewriter name.
-      # @param rewriter [Synvert::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::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::Rewriter] the registered rewriter.
-      # @raise [Synvert::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::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::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::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::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::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/snippets/check_syntax.rb

@@ -1,5 +0,0 @@
-Synvert::Rewriter.new :check_syntax do
-  description "just used to check if there are syntax errors."
-
-  within_files "**/*.rb" do; end
-end

data/lib/synvert/snippets/factory_girl/syntax_methods.rb

@@ -1,98 +0,0 @@
-Synvert::Rewriter.new "factory_girl_short_syntax" do
-  description <<-EOF
-Uses FactoryGirl short syntax.
-
-1. it adds FactoryGirl::Syntax::methods module to RSpec, Test::Unit, Cucumber, Spainach, MiniTest, MiniTest::Spec, minitest-rails.
-
-    # rspec
-    RSpec.configure do |config|
-      config.include FactoryGirl::Syntax::Methods
-    end
-
-    # Test::Unit
-    class Test::Unit::TestCase
-      include FactoryGirl::Syntax::Methods
-    end
-
-    # Cucumber
-    World(FactoryGirl::Syntax::Methods)
-
-    # Spinach
-    class Spinach::FeatureSteps
-      include FactoryGirl::Syntax::Methods
-    end
-
-    # MiniTest
-    class MiniTest::Unit::TestCase
-      include FactoryGirl::Syntax::Methods
-    end
-
-    # MiniTest::Spec
-    class MiniTest::Spec
-      include FactoryGirl::Syntax::Methods
-    end
-
-    # minitest-rails
-    class MiniTest::Rails::ActiveSupport::TestCase
-      include FactoryGirl::Syntax::Methods
-    end
-
-2. it converts to short syntax.
-
-    FactoryGirl.create(...) => create(...)
-    FactoryGirl.build(...) => build(...)
-    FactoryGirl.attributes_for(...) => attributes_for(...)
-    FactoryGirl.build_stubbed(...) => build_stubbed(...)
-    FactoryGirl.create_list(...) => create_list(...)
-    FactoryGirl.build_list(...) => build_list(...)
-    FactoryGirl.create_pair(...) => create_pair(...)
-    FactoryGirl.build_pair(...) => build_pair(...)
-  EOF
-
-  if_gem 'factory_girl', {gte: '2.0.0'}
-
-  # insert include FactoryGirl::Syntax::Methods
-  within_file 'spec/spec_helper.rb' do
-    within_node type: 'block', caller: {receiver: 'RSpec', message: 'configure'} do
-      unless_exist_node type: 'send', message: 'include', arguments: ['FactoryGirl::Syntax::Methods'] do
-        insert "{{arguments.first}}.include FactoryGirl::Syntax::Methods"
-      end
-    end
-  end
-
-  # insert include FactoryGirl::Syntax::Methods
-  within_file 'test/test_helper.rb' do
-    %w(Test::Unit::TestCase ActiveSupport::TestCase MiniTest::Unit::TestCase MiniTest::Spec MiniTest::Rails::ActiveSupport::TestCase).each do |class_name|
-      within_node type: 'class', name: class_name do
-        unless_exist_node type: 'send', message: 'include', arguments: ['FactoryGirl::Syntax::Methods'] do
-          insert "include FactoryGirl::Syntax::Methods"
-        end
-      end
-    end
-  end
-
-  # insert World(FactoryGirl::Syntax::Methods)
-  within_file 'features/support/env.rb' do
-    unless_exist_node type: 'send', message: 'World', arguments: ['FactoryGirl::Syntax::Methods'] do
-      insert "World(FactoryGirl::Syntax::Methods)"
-    end
-  end
-
-  # FactoryGirl.create(...) => create(...)
-  # FactoryGirl.build(...) => build(...)
-  # FactoryGirl.attributes_for(...) => attributes_for(...)
-  # FactoryGirl.build_stubbed(...) => build_stubbed(...)
-  # FactoryGirl.create_list(...) => create_list(...)
-  # FactoryGirl.build_list(...) => build_list(...)
-  # FactoryGirl.create_pair(...) => create_pair(...)
-  # FactoryGirl.build_pair(...) => build_pair(...)
-  %w(test/**/*.rb spec/**/*.rb features/**/*.rb).each do |file_pattern|
-    within_files file_pattern do
-      %w(create build attributes_for build_stubbed create_list build_list create_pair build_pair).each do |message|
-        with_node type: 'send', receiver: 'FactoryGirl', message: message do
-          replace_with "#{message}({{arguments}})"
-        end
-      end
-    end
-  end
-end

data/lib/synvert/snippets/rails/convert_dynamic_finders.rb

@@ -1,93 +0,0 @@
-Synvert::Rewriter.new "convert_rails_dynamic_finders" do
-  description <<-EOF
-It converts rails dynamic finders to arel syntax.
-
-    find_all_by_... => where(...)
-    find_by_... => where(...).first
-    find_last_by_... => where(...).last
-    scoped_by_... => where(...)
-    find_or_initialize_by_... => find_or_initialize_by(...)
-    find_or_create_by_... => find_or_create_by(...)
-  EOF
-
-  helper_method 'dynamic_finder_to_hash' do |prefix|
-    fields = node.message.to_s[prefix.length..-1].split("_and_")
-    if fields.length == node.arguments.length && :hash != node.arguments.first.type
-      fields.length.times.map { |i|
-        fields[i] + ": " + node.arguments[i].source(self)
-      }.join(", ")
-    else
-      "{{arguments}}"
-    end
-  end
-
-  within_files '**/*.rb' do
-    # find_all_by_... => where(...)
-    with_node type: 'send', message: /^find_all_by_/ do
-      hash_params = dynamic_finder_to_hash("find_all_by_")
-      if node.receiver
-        replace_with "{{receiver}}.where(#{hash_params})"
-      else
-        replace_with "where(#{hash_params})"
-      end
-    end
-
-    # find_by_... => where(...).first
-    with_node type: 'send', message: /^find_by_/ do
-      if :find_by_id == node.message
-        if node.receiver
-          replace_with "{{receiver}}.find({{arguments}})"
-        else
-          replace_with "find({{arguments}}"
-        end
-      elsif :find_by_sql != node.message
-        hash_params = dynamic_finder_to_hash("find_by_")
-        if node.receiver
-          replace_with "{{receiver}}.where(#{hash_params}).first"
-        else
-          replace_with "where(#{hash_params}).first"
-        end
-      end
-    end
-
-    # find_last_by_... => where(...).last
-    with_node type: 'send', message: /^find_last_by_/ do
-      hash_params = dynamic_finder_to_hash("find_last_by_")
-      if node.receiver
-        replace_with "{{receiver}}.where(#{hash_params}).last"
-      else
-        replace_with "where(#{hash_params}).last"
-      end
-    end
-
-    # scoped_by_... => where(...)
-    with_node type: 'send', message: /^scoped_by_/ do
-      hash_params = dynamic_finder_to_hash("scoped_by_")
-      if node.receiver
-        replace_with "{{receiver}}.where(#{hash_params})"
-      else
-        replace_with "where(#{hash_params})"
-      end
-    end
-
-    # find_or_initialize_by_... => find_or_initialize_by(...)
-    with_node type: 'send', message: /^find_or_initialize_by_/ do
-      hash_params = dynamic_finder_to_hash("find_or_initialize_by_")
-      if node.receiver
-        replace_with "{{receiver}}.find_or_initialize_by(#{hash_params})"
-      else
-        replace_with "find_or_initialize_by(#{hash_params})"
-      end
-    end
-
-    # find_or_create_by_... => find_or_create_by(...)
-    with_node type: 'send', message: /^find_or_create_by_/ do
-      hash_params = dynamic_finder_to_hash("find_or_create_by_")
-      if node.receiver
-        replace_with "{{receiver}}.find_or_create_by(#{hash_params})"
-      else
-        replace_with "find_or_create_by(#{hash_params})"
-      end
-    end
-  end
-end