synvert-core 0.64.0 → 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/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/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,6 +11,14 @@ module Synvert::Core
       Rewriter::Instance.new(rewriter, ['file pattern'])
     }
 
+    it 'parses find_node' do
+      scope = double
+      block = proc {}
+      expect(Rewriter::QueryScope).to receive(:new).with(instance, '.send[message=create]', &block).and_return(scope)
+      expect(scope).to receive(:process)
+      instance.find_node('.send[message=create]', &block)
+    end
+
     it 'parses within_node' do
       scope = double
       block = proc {}
@@ -91,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
@@ -108,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,9 @@ 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", "3.10.0"
   spec.add_development_dependency "rspec-mocks", "3.10.2" # rspec-mocks 3.10.3 breaks tests

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: synvert-core
 version: !ruby/object:Gem::Version
-  version: 0.64.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-02 00:00:00.000000000 Z
+date: 2022-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -94,6 +94,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: oedipus_lex
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: racc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -153,11 +195,35 @@ files:
 - README.md
 - Rakefile
 - lib/synvert/core.rb
+- lib/synvert/core/array_ext.rb
 - lib/synvert/core/configuration.rb
 - lib/synvert/core/engine.rb
 - lib/synvert/core/engine/erb.rb
 - lib/synvert/core/exceptions.rb
 - lib/synvert/core/node_ext.rb
+- lib/synvert/core/node_query.rb
+- lib/synvert/core/node_query/compiler.rb
+- lib/synvert/core/node_query/compiler/array.rb
+- lib/synvert/core/node_query/compiler/attribute.rb
+- lib/synvert/core/node_query/compiler/attribute_list.rb
+- lib/synvert/core/node_query/compiler/boolean.rb
+- lib/synvert/core/node_query/compiler/comparable.rb
+- lib/synvert/core/node_query/compiler/dynamic_attribute.rb
+- lib/synvert/core/node_query/compiler/expression.rb
+- lib/synvert/core/node_query/compiler/float.rb
+- lib/synvert/core/node_query/compiler/identifier.rb
+- lib/synvert/core/node_query/compiler/integer.rb
+- lib/synvert/core/node_query/compiler/invalid_operator_error.rb
+- lib/synvert/core/node_query/compiler/nil.rb
+- lib/synvert/core/node_query/compiler/parse_error.rb
+- lib/synvert/core/node_query/compiler/regexp.rb
+- lib/synvert/core/node_query/compiler/selector.rb
+- lib/synvert/core/node_query/compiler/string.rb
+- lib/synvert/core/node_query/compiler/symbol.rb
+- lib/synvert/core/node_query/lexer.rex
+- lib/synvert/core/node_query/lexer.rex.rb
+- lib/synvert/core/node_query/parser.racc.rb
+- lib/synvert/core/node_query/parser.y
 - lib/synvert/core/rewriter.rb
 - lib/synvert/core/rewriter/action.rb
 - lib/synvert/core/rewriter/action/append_action.rb
@@ -181,6 +247,7 @@ files:
 - lib/synvert/core/rewriter/ruby_version.rb
 - lib/synvert/core/rewriter/scope.rb
 - lib/synvert/core/rewriter/scope/goto_scope.rb
+- lib/synvert/core/rewriter/scope/query_scope.rb
 - lib/synvert/core/rewriter/scope/within_scope.rb
 - lib/synvert/core/rewriter/warning.rb
 - lib/synvert/core/version.rb
@@ -188,6 +255,8 @@ files:
 - spec/support/parser_helper.rb
 - spec/synvert/core/engine/erb_spec.rb
 - spec/synvert/core/node_ext_spec.rb
+- spec/synvert/core/node_query/lexer_spec.rb
+- spec/synvert/core/node_query/parser_spec.rb
 - spec/synvert/core/rewriter/action/append_action_spec.rb
 - spec/synvert/core/rewriter/action/delete_action_spec.rb
 - spec/synvert/core/rewriter/action/insert_action_spec.rb
@@ -208,6 +277,7 @@ files:
 - spec/synvert/core/rewriter/instance_spec.rb
 - spec/synvert/core/rewriter/ruby_version_spec.rb
 - spec/synvert/core/rewriter/scope/goto_scope_spec.rb
+- spec/synvert/core/rewriter/scope/query_scope_spec.rb
 - spec/synvert/core/rewriter/scope/within_scope_spec.rb
 - spec/synvert/core/rewriter/scope_spec.rb
 - spec/synvert/core/rewriter/warning_spec.rb
@@ -241,6 +311,8 @@ test_files:
 - spec/support/parser_helper.rb
 - spec/synvert/core/engine/erb_spec.rb
 - spec/synvert/core/node_ext_spec.rb
+- spec/synvert/core/node_query/lexer_spec.rb
+- spec/synvert/core/node_query/parser_spec.rb
 - spec/synvert/core/rewriter/action/append_action_spec.rb
 - spec/synvert/core/rewriter/action/delete_action_spec.rb
 - spec/synvert/core/rewriter/action/insert_action_spec.rb
@@ -261,6 +333,7 @@ test_files:
 - spec/synvert/core/rewriter/instance_spec.rb
 - spec/synvert/core/rewriter/ruby_version_spec.rb
 - spec/synvert/core/rewriter/scope/goto_scope_spec.rb
+- spec/synvert/core/rewriter/scope/query_scope_spec.rb
 - spec/synvert/core/rewriter/scope/within_scope_spec.rb
 - spec/synvert/core/rewriter/scope_spec.rb
 - spec/synvert/core/rewriter/warning_spec.rb