synvert-core 0.1.0

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Synvert::Core
+  # GemSpec checks and compares gem version.
+  class Rewriter::GemSpec
+    OPERATORS = {eq: '==', lt: '<', gt: '>', lte: '<=', gte: '>=', ne: '!='}
+
+    # Initialize a gem_spec.
+    #
+    # @param name [String] gem name
+    # @param comparator [Hash] comparator to gem version, e.g. {eg: '2.0.0'},
+    #   comparator key can be eq, lt, gt, lte, gte or ne.
+    def initialize(name, comparator)
+      @name = name
+      if Hash === comparator
+        @operator = comparator.keys.first
+        @version = Gem::Version.new comparator.values.first
+      else
+        @operator = :eq
+        @version = Gem::Version.new comparator
+      end
+    end
+
+    # Check if the specified gem version in Gemfile.lock matches gem_spec comparator.
+    #
+    # @return [Boolean] true if matches, otherwise false.
+    # @raise [Synvert::Core::GemfileLockNotFound] raise if Gemfile.lock does not exist.
+    def match?
+      gemfile_lock_path = File.join(Configuration.instance.get(:path), 'Gemfile.lock')
+      if File.exists? gemfile_lock_path
+        parser = Bundler::LockfileParser.new(File.read(gemfile_lock_path))
+        if spec = parser.specs.find { |spec| spec.name == @name }
+          Gem::Version.new(spec.version).send(OPERATORS[@operator], @version)
+        else
+          false
+        end
+      else
+        raise GemfileLockNotFound.new 'Gemfile.lock does not exist'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,185 @@
+# encoding: utf-8
+
+module Synvert::Core
+  # 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::Core::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::Core::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::Core::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::Core::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::Core::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::Core::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::Core::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::Core::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::Core::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::Core::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::Core::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/core/rewriter/scope.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+module Synvert::Core
+  # Scope finds the child nodes which match rules.
+  class Rewriter::Scope
+    # Initialize a scope
+    #
+    # @param instance [Synvert::Core::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/core/version.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+
+module Synvert
+  module Core
+    VERSION = "0.1.0"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'synvert/core'
+
+require 'coveralls'
+Coveralls.wear!
+
+Dir[File.join(File.dirname(__FILE__), 'support', '*')].each do |path|
+  require path
+end
+
+RSpec.configure do |config|
+  config.include ParserHelper
+
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+
+  config.before do
+    Synvert::Core::Configuration.instance.set :skip_files, []
+  end
+end

data/spec/support/parser_helper.rb

@@ -0,0 +1,5 @@
+module ParserHelper
+  def parse(code)
+    Parser::CurrentRuby.parse code
+  end
+end

data/spec/synvert/core/node_ext_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+describe Parser::AST::Node do
+  describe '#name' do
+    it 'gets for class node' do
+      node = parse('class Synvert; end')
+      expect(node.name).to eq parse('Synvert')
+
+      node = parse('class Synvert::Core::Rewriter::Instance; end')
+      expect(node.name).to eq parse('Synvert::Core::Rewriter::Instance')
+    end
+
+    it 'gets for module node' do
+      node = parse('module Synvert; end')
+      expect(node.name).to eq parse('Synvert')
+    end
+
+    it 'gets for def node' do
+      node = parse('def current_node; end')
+      expect(node.name).to eq :current_node
+    end
+
+    it 'gets for defs node' do
+      node = parse('def self.current_node; end')
+      expect(node.name).to eq :current_node
+    end
+  end
+
+  describe '#receiver' do
+    it 'gets for send node' do
+      node = parse('FactoryGirl.create :post')
+      expect(node.receiver).to eq parse('FactoryGirl')
+    end
+  end
+
+  describe '#message' do
+    it 'gets for send node' do
+      node = parse('FactoryGirl.create :post')
+      expect(node.message).to eq :create
+    end
+  end
+
+  describe '#arguments' do
+    it 'gets for send node' do
+      node = parse("FactoryGirl.create :post, title: 'post'")
+      expect(node.arguments).to eq parse("[:post, title: 'post']").children
+    end
+
+    it 'gets for block node' do
+      source = 'RSpec.configure do |config|; end'
+      node = parse(source)
+      instance = double(current_source: source)
+      expect(node.arguments.map { |argument| argument.source(instance) }).to eq ['config']
+    end
+
+    it 'gets for defined? node' do
+      node = parse('defined?(Bundler)')
+      expect(node.arguments).to eq [parse('Bundler')]
+    end
+  end
+
+  describe '#caller' do
+    it 'gets for block node' do
+      node = parse('RSpec.configure do |config|; end')
+      expect(node.caller).to eq parse('RSpec.configure')
+    end
+  end
+
+  describe '#body' do
+    it 'gets one line for block node' do
+      node = parse('RSpec.configure do |config|; include EmailSpec::Helpers; end')
+      expect(node.body).to eq [parse('include EmailSpec::Helpers')]
+    end
+
+    it 'gets multiple lines for block node' do
+      node = parse('RSpec.configure do |config|; include EmailSpec::Helpers; include EmailSpec::Matchers; end')
+      expect(node.body).to eq [parse('include EmailSpec::Helpers'), parse('include EmailSpec::Matchers')]
+    end
+
+    it 'gets for begin node' do
+      node = parse('foo; bar')
+      expect(node.body).to eq [parse('foo'), parse('bar')]
+    end
+  end
+
+  describe "#keys" do
+    it 'gets for hash node' do
+      node = parse("{:foo => :bar, 'foo' => 'bar'}")
+      expect(node.keys).to eq [Parser::CurrentRuby.parse(':foo'), Parser::CurrentRuby.parse("'foo'")]
+    end
+  end
+
+  describe "#values" do
+    it 'gets for hash node' do
+      node = parse("{:foo => :bar, 'foo' => 'bar'}")
+      expect(node.values).to eq [Parser::CurrentRuby.parse(':bar'), Parser::CurrentRuby.parse("'bar'")]
+    end
+  end
+
+  describe "#key" do
+    it 'gets for pair node' do
+      node = parse("{:foo => 'bar'}").children[0]
+      expect(node.key).to eq Parser::CurrentRuby.parse(':foo')
+    end
+  end
+
+  describe "#value" do
+    it 'gets for hash node' do
+      node = parse("{:foo => 'bar'}").children[0]
+      expect(node.value).to eq Parser::CurrentRuby.parse("'bar'")
+    end
+  end
+
+  describe "#condition" do
+    it 'gets for if node' do
+      node = parse('if defined?(Bundler); end')
+      expect(node.condition).to eq parse('defined?(Bundler)')
+    end
+  end
+
+  describe '#source' do
+    it 'gets for node' do
+      source = 'params[:user][:email]'
+      instance = double(current_source: source)
+      node = parse(source)
+      expect(node.source(instance)).to eq 'params[:user][:email]'
+    end
+  end
+
+  describe '#indent' do
+    it 'gets column number' do
+      node = parse('  FactoryGirl.create :post')
+      expect(node.indent).to eq 2
+    end
+  end
+
+  describe '#recursive_children' do
+    it 'iterates all children recursively' do
+      node = parse('class Synvert; def current_node; @node; end; end')
+      children = []
+      node.recursive_children { |child| children << child.type }
+      expect(children).to be_include :const
+      expect(children).to be_include :def
+      expect(children).to be_include :args
+      expect(children).to be_include :ivar
+    end
+  end
+
+  describe '#match?' do
+    let(:instance) { Synvert::Core::Rewriter::Instance.new('file pattern') }
+
+    it 'matches class name' do
+      source = 'class Synvert; end'
+      instance.current_source = source
+      node = parse(source)
+      expect(node).to be_match(instance, type: 'class', name: 'Synvert')
+    end
+
+    it 'matches message with regexp' do
+      source = 'User.find_by_login(login)'
+      instance.current_source = source
+      node = parse(source)
+      expect(node).to be_match(instance, type: 'send', message: /^find_by_/)
+    end
+
+    it 'matches arguments with symbol' do
+      source = 'params[:user]'
+      instance.current_source = source
+      node = parse(source)
+      expect(node).to be_match(instance, type: 'send', receiver: 'params', message: '[]', arguments: [:user])
+    end
+
+    it 'matches assign number' do
+      source = 'at_least(0)'
+      instance.current_source = source
+      node = parse(source)
+      expect(node).to be_match(instance, type: 'send', arguments: [0])
+    end
+
+    it 'matches arguments with string' do
+      source = 'params["user"]'
+      instance.current_source = source
+      node = parse(source)
+      expect(node).to be_match(instance, type: 'send', receiver: 'params', message: '[]', arguments: ['user'])
+    end
+
+    it 'matches arguments any' do
+      source = 'config.middleware.insert_after ActiveRecord::QueryCache, Lifo::Cache, page_cache: false'
+      instance.current_source = source
+      node = parse(source)
+      expect(node).to be_match(instance, type: 'send', arguments: {any: 'Lifo::Cache'})
+    end
+
+    it 'matches not' do
+      source = 'class Synvert; end'
+      instance.current_source = source
+      node = parse(source)
+      expect(node).not_to be_match(instance, type: 'class', name: {not: 'Synvert'})
+    end
+  end
+end