synvert-core 0.63.1 → 1.0.1

data/spec/synvert/core/node_query/parser_spec.rb

@@ -0,0 +1,270 @@
+require 'spec_helper'
+
+module Synvert::Core::NodeQuery
+  RSpec.describe Parser do
+    let(:parser) { described_class.new }
+
+    def assert_parser(source)
+      expect(parser.parse(source).to_s).to eq source
+    end
+
+    it 'parses one selector' do
+      source = '.send[message=:create]'
+      assert_parser(source)
+    end
+
+    it 'parses two selectors' do
+      source = '.class[name=Synvert] .def[name="foobar"]'
+      assert_parser(source)
+    end
+
+    it 'parses three selectors' do
+      source = '.class[name=Synvert] .def[name="foobar"] .send[message=create]'
+      assert_parser(source)
+    end
+
+    it 'parses child selector' do
+      source = '.class[name=Synvert] > .def[name="foobar"]'
+      assert_parser(source)
+    end
+
+    it 'parses :first-child' do
+      source = '.class .def:first-child'
+      assert_parser(source)
+    end
+
+    it 'parses :last-child' do
+      source = '.class .def:last-child'
+      assert_parser(source)
+    end
+
+    it 'parses :nth-child(n)' do
+      source = '.class .def:nth-child(2)'
+      assert_parser(source)
+    end
+
+    it 'parses :nth-last-child(n)' do
+      source = '.class .def:nth-last-child(2)'
+      assert_parser(source)
+    end
+
+    it 'parses :has selector' do
+      source = '.class:has(> .def)'
+      assert_parser(source)
+    end
+
+    it 'parses multiple attributes' do
+      source = '.send[receiver=nil][message=:create]'
+      assert_parser(source)
+    end
+
+    it 'parses nested attributes' do
+      source = '.send[receiver.message=:create]'
+      assert_parser(source)
+    end
+
+    it 'parses selector value' do
+      source = '.send[receiver=.send[message=:create]]'
+      assert_parser(source)
+    end
+
+    it 'parses not equal operator' do
+      source = '.send[receiver=.send[message!=:create]]'
+      assert_parser(source)
+    end
+
+    it 'parses greater than operator' do
+      source = '.send[receiver=.send[arguments.size>1]]'
+      assert_parser(source)
+    end
+
+    it 'parses greater than or equal operator' do
+      source = '.send[receiver=.send[arguments.size>=1]]'
+      assert_parser(source)
+    end
+
+    it 'parses less than operator' do
+      source = '.send[receiver=.send[arguments.size<1]]'
+      assert_parser(source)
+    end
+
+    it 'parses less than or equal operator' do
+      source = '.send[receiver=.send[arguments.size<=1]]'
+      assert_parser(source)
+    end
+
+    it 'parses in operator' do
+      source = '.def[name in (foo, bar)]'
+      assert_parser(source)
+    end
+
+    it 'parses not_in operator' do
+      source = '.def[name not in (foo, bar)]'
+      assert_parser(source)
+    end
+
+    it 'parses includes operator' do
+      source = '.def[arguments includes &block]'
+      assert_parser(source)
+    end
+
+    describe '#query_nodes' do
+      let(:node) {
+        parse(<<~EOS)
+          class Synvert
+            def foo
+              FactoryBot.create(:user, name: 'foo')
+            end
+
+            def bar
+              FactoryBot.create(:user, name: 'bar')
+            end
+
+            def foobar(a, b)
+              { a: a, b: b }
+              foo.merge(bar)
+              arr[index]
+            end
+          end
+        EOS
+      }
+
+      it 'matches class node' do
+        expression = parser.parse('.class[name=Synvert]')
+        expect(expression.query_nodes(node)).to eq [node]
+      end
+
+      it 'matches def node' do
+        expression = parser.parse('.def')
+        expect(expression.query_nodes(node)).to eq node.body
+      end
+
+      it 'matches first def node' do
+        expression = parser.parse('.def:first-child')
+        expect(expression.query_nodes(node)).to eq [node.body.first]
+      end
+
+      it 'matches nested first node' do
+        expression = parser.parse('.def[arguments.size=0] .send:first-child')
+        expect(expression.query_nodes(node)).to eq [node.body.first.body.first, node.body.second.body.first]
+      end
+
+      it 'matches last def node' do
+        expression = parser.parse('.def:last-child')
+        expect(expression.query_nodes(node)).to eq [node.body.last]
+      end
+
+      it 'matches nth-child node' do
+        expression = parser.parse('.def:nth-child(2)')
+        expect(expression.query_nodes(node)).to eq [node.body.second]
+      end
+
+      it 'matches nth-last-child node' do
+        expression = parser.parse('.def:nth-last-child(2)')
+        expect(expression.query_nodes(node)).to eq [node.body[-2]]
+      end
+
+      it 'matches not equal' do
+        expression = parser.parse('.def[name!=foobar]')
+        expect(expression.query_nodes(node)).to eq [node.body.first, node.body.second]
+      end
+
+      it 'matches in' do
+        expression = parser.parse('.def[name IN (foo, bar)]')
+        expect(expression.query_nodes(node)).to eq [node.body.first, node.body.second]
+      end
+
+      it 'matches not in' do
+        expression = parser.parse('.def[name NOT IN (foo, bar)]')
+        expect(expression.query_nodes(node)).to eq [node.body.last]
+      end
+
+      it 'matches includes' do
+        expression = parser.parse('.def[arguments INCLUDES a]')
+        expect(expression.query_nodes(node)).to eq [node.body.last]
+      end
+
+      it 'matches equal array' do
+        expression = parser.parse('.def[arguments=(a, b)]')
+        expect(expression.query_nodes(node)).to eq [node.body.last]
+
+        expression = parser.parse('.def[arguments=(b, a)]')
+        expect(expression.query_nodes(node)).to eq []
+      end
+
+      it 'matches not equal array' do
+        expression = parser.parse('.def[arguments!=(a, b)]')
+        expect(expression.query_nodes(node)).to eq [node.body.first, node.body.second]
+
+        expression = parser.parse('.def[arguments!=(b, a)]')
+        expect(expression.query_nodes(node)).to eq [node.body.first, node.body.second, node.body.last]
+      end
+
+      it 'matches descendant node' do
+        expression = parser.parse('.class .send[message=:create]')
+        expect(expression.query_nodes(node)).to eq [node.body.first.children.last, node.body.second.children.last]
+      end
+
+      it 'matches three level descendant node' do
+        expression = parser.parse('.class .def .send[message=:create]')
+        expect(expression.query_nodes(node)).to eq [node.body.first.children.last, node.body.second.children.last]
+      end
+
+      it 'matches child node' do
+        expression = parser.parse('.def > .send[message=:create]')
+        expect(expression.query_nodes(node)).to eq [node.body.first.children.last, node.body.second.children.last]
+      end
+
+      it 'matches next sibling node' do
+        expression = parser.parse('.def[name=foo] + .def[name=bar]')
+        expect(expression.query_nodes(node)).to eq [node.body.second]
+      end
+
+      it 'matches sebsequent sibling node' do
+        expression = parser.parse('.def[name=foo] ~ .def[name=foobar]')
+        expect(expression.query_nodes(node)).to eq [node.body.last]
+      end
+
+      it 'matches has selector' do
+        expression = parser.parse('.def:has(> .send[receiver=FactoryBot])')
+        expect(expression.query_nodes(node)).to eq [node.body.first, node.body.second]
+      end
+
+      it 'matches arguments.size' do
+        expression = parser.parse('.send[arguments.size=2]')
+        expect(expression.query_nodes(node)).to eq [node.body.first.children.last, node.body.second.children.last]
+        expression = parser.parse('.send[arguments.size>2]')
+        expect(expression.query_nodes(node)).to eq []
+        expression = parser.parse('.send[arguments.size>=2]')
+        expect(expression.query_nodes(node)).to eq [node.body.first.children.last, node.body.second.children.last]
+      end
+
+      it 'matches arguments' do
+        expression = parser.parse('.send[arguments=[size=2][first=.sym][last=.hash]]')
+        expect(expression.query_nodes(node)).to eq [node.body.first.children.last, node.body.second.children.last]
+      end
+
+      it 'matches regexp value' do
+        expression = parser.parse('.def[name=~/foo/]')
+        expect(expression.query_nodes(node)).to eq [node.body.first, node.body.last]
+        expression = parser.parse('.def[name!~/bar/]')
+        expect(expression.query_nodes(node)).to eq [node.body.first]
+      end
+
+      it 'matches attribute value' do
+        expression = parser.parse('.pair[key={{value}}]')
+        expect(expression.query_nodes(node)).to eq node.body.last.body.first.children
+      end
+
+      it 'matches identifier' do
+        expression = parser.parse('.send[receiver=foo][message=merge]')
+        expect(expression.query_nodes(node)).to eq [node.body.last.body.second]
+      end
+
+      it 'matches []' do
+        expression = parser.parse('.send[message="[]"]')
+        expect(expression.query_nodes(node)).to eq [node.body.last.body.third]
+      end
+    end
+  end
+end

data/spec/synvert/core/rewriter/action_spec.rb

@@ -10,9 +10,5 @@ module Synvert::Core
       instance = double(current_node: block_node)
       Rewriter::Action.new(instance, source)
     }
-
-    it 'gets line' do
-      expect(subject.line).to eq 2
-    end
   end
 end

data/spec/synvert/core/rewriter/condition/if_only_exist_condition_spec.rb

@@ -17,12 +17,7 @@ module Synvert::Core
 
     describe '#process' do
       it 'gets matching nodes' do
-        source =
-          '
-          RSpec.configure do |config|
-            config.include EmailSpec::Helpers
-          end
-        '
+        source = ' RSpec.configure do |config| config.include EmailSpec::Helpers end '
         node = Parser::CurrentRuby.parse(source)
         instance = double(current_node: node)
         run = false

data/spec/synvert/core/rewriter/gem_spec_spec.rb

@@ -46,7 +46,7 @@ module Synvert::Core
       expect(gem_spec).not_to be_match
     end
 
-    it 'raise Synvert::Core::GemfileLockNotFound if Gemfile.lock does not exist' do
+    it 'returns true if Gemfile.lock does not exist' do
       expect(File).to receive(:exist?).with(lock_path).and_return(false)
       gem_spec = Rewriter::GemSpec.new('ast', '1.1.0')
       expect(gem_spec).to be_match

data/spec/synvert/core/rewriter/helper_spec.rb

@@ -4,7 +4,10 @@ require 'spec_helper'
 
 module Synvert::Core
   describe Rewriter::Helper do
-    let(:dummy_instance) { Class.new { include Rewriter::Helper }.new }
+    let(:dummy_instance) {
+      Class.new { include Rewriter::Helper }
+           .new
+    }
     let(:instance) do
       rewriter = Rewriter.new('foo', 'bar')
       Rewriter::Instance.new rewriter, 'spec/**/*_spec.rb' do

data/spec/synvert/core/rewriter/instance_spec.rb

@@ -11,54 +11,52 @@ module Synvert::Core
       Rewriter::Instance.new(rewriter, ['file pattern'])
     }
 
-    it 'parses within_node' do
+    it 'parses find_node' do
       scope = double
       block = proc {}
-      expect(Rewriter::WithinScope).to receive(:new)
-        .with(instance, { type: 'send', message: 'create' }, { stop_when_match: false }, &block)
-        .and_return(scope)
+      expect(Rewriter::QueryScope).to receive(:new).with(instance, '.send[message=create]', &block).and_return(scope)
       expect(scope).to receive(:process)
-      instance.within_node(type: 'send', message: 'create', &block)
+      instance.find_node('.send[message=create]', &block)
     end
 
-    it 'parses with_node' do
+    it 'parses within_node' do
       scope = double
       block = proc {}
       expect(Rewriter::WithinScope).to receive(:new)
-        .with(instance, { type: 'send', message: 'create' }, { stop_when_match: false }, &block)
+        .with(instance, { type: 'send', message: 'create' }, { stop_when_match: false, direct: false }, &block)
         .and_return(scope)
       expect(scope).to receive(:process)
-      instance.with_node(type: 'send', message: 'create', &block)
+      instance.within_node(type: 'send', message: 'create', &block)
     end
 
-    it 'parses within_node with recursive false' do
+    it 'parses with_node' do
       scope = double
       block = proc {}
       expect(Rewriter::WithinScope).to receive(:new)
-        .with(instance, { type: 'send', message: 'create' }, { stop_when_match: true }, &block)
+        .with(instance, { type: 'send', message: 'create' }, { stop_when_match: false, direct: false }, &block)
         .and_return(scope)
       expect(scope).to receive(:process)
-      instance.within_node({ type: 'send', message: 'create' }, { stop_when_match: true }, &block)
+      instance.with_node(type: 'send', message: 'create', &block)
     end
 
-    it 'parses within_direct_node' do
+    it 'parses within_node with stop_when_match true' do
       scope = double
       block = proc {}
       expect(Rewriter::WithinScope).to receive(:new)
-        .with(instance, { type: 'send', message: 'create' }, { direct: true }, &block)
+        .with(instance, { type: 'send', message: 'create' }, { stop_when_match: true, direct: false }, &block)
         .and_return(scope)
       expect(scope).to receive(:process)
-      instance.within_direct_node(type: 'send', message: 'create', &block)
+      instance.within_node({ type: 'send', message: 'create' }, { stop_when_match: true }, &block)
     end
 
-    it 'parses with_direct_node' do
+    it 'parses within_node with direct true' do
       scope = double
       block = proc {}
       expect(Rewriter::WithinScope).to receive(:new)
-        .with(instance, { type: 'send', message: 'create' }, { direct: true }, &block)
+        .with(instance, { type: 'send', message: 'create' }, { stop_when_match: false, direct: true }, &block)
         .and_return(scope)
       expect(scope).to receive(:process)
-      instance.with_direct_node(type: 'send', message: 'create', &block)
+      instance.within_node({ type: 'send', message: 'create' }, { direct: true }, &block)
     end
 
     it 'parses goto_node' do
@@ -101,7 +99,10 @@ module Synvert::Core
 
     it 'parses append' do
       action = double
-      expect(Rewriter::AppendAction).to receive(:new).with(instance, 'include FactoryGirl::Syntax::Methods').and_return(action)
+      expect(Rewriter::AppendAction).to receive(:new).with(
+        instance,
+        'include FactoryGirl::Syntax::Methods'
+      ).and_return(action)
       expect(action).to receive(:process)
       instance.append 'include FactoryGirl::Syntax::Methods'
     end
@@ -118,14 +119,24 @@ module Synvert::Core
 
     it 'parses insert at end' do
       action = double
-      expect(Rewriter::InsertAction).to receive(:new).with(instance, '.first', at: 'end', to: 'receiver').and_return(action)
+      expect(Rewriter::InsertAction).to receive(:new).with(
+        instance,
+        '.first',
+        at: 'end',
+        to: 'receiver'
+      ).and_return(action)
       expect(action).to receive(:process)
       instance.insert '.first', to: 'receiver'
     end
 
     it 'parses insert at beginning' do
       action = double
-      expect(Rewriter::InsertAction).to receive(:new).with(instance, 'URI.', at: 'beginning', to: nil).and_return(action)
+      expect(Rewriter::InsertAction).to receive(:new).with(
+        instance,
+        'URI.',
+        at: 'beginning',
+        to: nil
+      ).and_return(action)
       expect(action).to receive(:process)
       instance.insert 'URI.', at: 'beginning'
     end

data/spec/synvert/core/rewriter/scope/query_scope_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module Synvert::Core
+  describe Rewriter::QueryScope do
+    let(:instance) {
+      rewriter = Rewriter.new('foo', 'bar')
+      Rewriter::Instance.new(rewriter, 'file pattern')
+    }
+    let(:source) { <<~EOS }
+      describe Post do
+        it 'gets post' do
+          FactoryGirl.create :post
+        end
+      end
+    EOS
+
+    let(:node) { Parser::CurrentRuby.parse(source) }
+
+    before do
+      Rewriter::Instance.reset
+      instance.current_node = node
+    end
+
+    describe '#process' do
+      it 'not call block if no matching node' do
+        run = false
+        scope =
+          described_class.new instance, '.send[message=missing]' do
+            run = true
+          end
+        scope.process
+        expect(run).to be_falsey
+      end
+
+      it 'call block if there is matching node' do
+        run = false
+        type_in_scope = nil
+        scope =
+          described_class.new instance, '.send[receiver=FactoryGirl][message=create][arguments=(:post)]' do
+            run = true
+            type_in_scope = node.type
+          end
+        scope.process
+        expect(run).to be_truthy
+        expect(type_in_scope).to eq :send
+        expect(instance.current_node.type).to eq :block
+      end
+
+      it 'matches multiple block nodes' do
+        block_nodes = []
+        scope =
+          described_class.new(instance, '.block') do
+            block_nodes << node
+          end
+        scope.process
+        expect(block_nodes.size).to eq 2
+      end
+
+      it 'raises ParseError' do
+        scope = described_class.new(instance, 'hello world') {}
+        expect {
+          scope.process
+        }.to raise_error(NodeQuery::Compiler::ParseError)
+
+        scope = described_class.new(instance, '.type[key IN value]') {}
+        expect {
+          scope.process
+        }.to raise_error(NodeQuery::Compiler::ParseError)
+      end
+    end
+  end
+end

data/spec/synvert/core/rewriter/scope/within_scope_spec.rb

@@ -54,27 +54,30 @@ module Synvert::Core
 
       it 'matches multiple block nodes' do
         block_nodes = []
-        scope = Rewriter::WithinScope.new(instance, { type: 'block' }, { stop_when_match: false }) do
-          block_nodes << node
-        end
+        scope =
+          Rewriter::WithinScope.new(instance, { type: 'block' }, { stop_when_match: false }) do
+            block_nodes << node
+          end
         scope.process
         expect(block_nodes.size).to eq 2
       end
 
       it 'matches only one block node if no recursive' do
         block_nodes = []
-        scope = Rewriter::WithinScope.new(instance, { type: 'block' } , { stop_when_match: true }) do
-          block_nodes << node
-        end
+        scope =
+          Rewriter::WithinScope.new(instance, { type: 'block' }, { stop_when_match: true }) do
+            block_nodes << node
+          end
         scope.process
         expect(block_nodes.size).to eq 1
       end
 
       it 'matches only one direct node' do
         block_nodes = []
-        scope = Rewriter::WithinScope.new(instance, { type: 'block' } , { direct: true }) do
-          block_nodes << node
-        end
+        scope =
+          Rewriter::WithinScope.new(instance, { type: 'block' }, { direct: true }) do
+            block_nodes << node
+          end
         scope.process
         expect(block_nodes.size).to eq 1
       end

data/spec/synvert/core/rewriter_spec.rb

@@ -191,7 +191,8 @@ module Synvert::Core
           Rewriter.new 'group', 'name' do
             add_snippet :group, :not_exist
           end
-        expect { rewriter.process }.to raise_error(RewriterNotFound)
+        expect { rewriter.process }
+          .to raise_error(RewriterNotFound)
       end
     end
 
@@ -248,7 +249,8 @@ module Synvert::Core
       end
 
       it 'raises RewriterNotFound if rewriter not found' do
-        expect { Rewriter.call 'group', 'rewriter' }.to raise_error(RewriterNotFound)
+        expect { Rewriter.call 'group', 'rewriter' }
+          .to raise_error(RewriterNotFound)
       end
 
       context 'available' do

data/synvert-core-ruby.gemspec

@@ -14,7 +14,8 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/xinminlabs/synvert-core-ruby"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0")
+  spec.files         = `git ls-files -z`.split("\x0") +
+                       %w[lib/synvert/core/node_query/lexer.rex.rb lib/synvert/core/node_query/parser.racc.rb]
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
@@ -26,6 +27,10 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "guard"
   spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "guard-rake"
+  spec.add_development_dependency "oedipus_lex"
+  spec.add_development_dependency "racc"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec", "3.10.0"
+  spec.add_development_dependency "rspec-mocks", "3.10.2" # rspec-mocks 3.10.3 breaks tests
 end