synvert-core 1.1.0 → 1.2.1

data/lib/synvert/core/node_query/parser.y

@@ -1,31 +1,26 @@
 class Synvert::Core::NodeQuery::Parser
 options no_result_var
-token tNODE_TYPE tATTRIBUTE tKEY tIDENTIFIER tIDENTIFIER_VALUE tINDEX tPSEUDO_CLASS tCOMMA
+token tNODE_TYPE tATTRIBUTE tKEY tIDENTIFIER tIDENTIFIER_VALUE tINDEX tPSEUDO_CLASS
       tCHILD tSUBSEQUENT_SIBLING tNEXT_SIBLING
-      tOPEN_ATTRIBUTE tCLOSE_ATTRIBUTE tOPEN_DYNAMIC_ATTRIBUTE tCLOSE_DYNAMIC_ATTRIBUTE tOPEN_ARRAY tCLOSE_ARRAY tOPEN_SELECTOR tCLOSE_SELECTOR
+      tOPEN_ATTRIBUTE tCLOSE_ATTRIBUTE tOPEN_DYNAMIC_ATTRIBUTE tCLOSE_DYNAMIC_ATTRIBUTE
+      tOPEN_ARRAY tCLOSE_ARRAY tOPEN_SELECTOR tCLOSE_SELECTOR tOPEN_GOTO_SCOPE tCLOSE_GOTO_SCOPE
       tEQUAL tNOT_EQUAL tMATCH tNOT_MATCH tGREATER_THAN tGREATER_THAN_OR_EQUAL tLESS_THAN tLESS_THAN_OR_EQUAL tIN tNOT_IN tINCLUDES
       tARRAY_VALUE tDYNAMIC_ATTRIBUTE tBOOLEAN tFLOAT tINTEGER tNIL tREGEXP tSTRING tSYMBOL
 rule
   expression
-    : selector tCHILD expression { Compiler::Expression.new(selector: val[0], rest: val[2], relationship: :child) }
-    | selector tSUBSEQUENT_SIBLING expression { Compiler::Expression.new(selector: val[0], rest: val[2], relationship: :subsequent_sibling) }
-    | selector tNEXT_SIBLING expression { Compiler::Expression.new(selector: val[0], rest: val[2], relationship: :next_sibling) }
-    | selector expression { Compiler::Expression.new(selector: val[0], rest: val[1], relationship: :descendant) }
-    | selector { Compiler::Expression.new(selector: val[0]) }
-    | tCHILD expression { Compiler::Expression.new(rest: val[1], relationship: :child) }
+    : tCHILD expression { Compiler::Expression.new(rest: val[1], relationship: :child) }
     | tSUBSEQUENT_SIBLING expression { Compiler::Expression.new(rest: val[1], relationship: :subsequent_sibling) }
     | tNEXT_SIBLING expression { Compiler::Expression.new(rest: val[1], relationship: :next_sibling) }
+    | tOPEN_GOTO_SCOPE tIDENTIFIER tCLOSE_GOTO_SCOPE expression { Compiler::Expression.new(goto_scope: val[1], rest: val[3]) }
+    | tPSEUDO_CLASS tOPEN_SELECTOR expression tCLOSE_SELECTOR { Compiler::Expression.new(relationship: val[0].to_sym, rest: val[2]) }
+    | selector expression { Compiler::Expression.new(selector: val[0], rest: val[1]) }
+    | selector { Compiler::Expression.new(selector: val[0]) }
 
   selector
     : tNODE_TYPE attribute_list tINDEX { Compiler::Selector.new(node_type: val[0], attribute_list: val[1], index: val[2]) }
     | tNODE_TYPE tINDEX { Compiler::Selector.new(node_type: val[0], index: val[1]) }
-    | attribute_list tINDEX { Compiler::Selector.new(attribute_list: val[0], index: val[1]) }
-    | tNODE_TYPE attribute_list tPSEUDO_CLASS tOPEN_SELECTOR expression tCLOSE_SELECTOR { Compiler::Selector.new(node_type: val[0], attribute_list: val[1], pseudo_class: val[2], pseudo_expression: val[4]) }
-    | tNODE_TYPE tPSEUDO_CLASS tOPEN_SELECTOR expression tCLOSE_SELECTOR { Compiler::Selector.new(node_type: val[0], pseudo_class: val[1], pseudo_expression: val[3]) }
-    | attribute_list tPSEUDO_CLASS tOPEN_SELECTOR expression tCLOSE_SELECTOR { Compiler::Selector.new(attribute_list: val[0], pseudo_class: val[1], pseudo_expression: val[3]) }
     | tNODE_TYPE attribute_list { Compiler::Selector.new(node_type: val[0], attribute_list: val[1]) }
     | tNODE_TYPE { Compiler::Selector.new(node_type: val[0]) }
-    | attribute_list { Compiler::Selector.new(attribute_list: val[0]) }
     ;
 
   attribute_list
@@ -53,7 +48,7 @@ rule
     | tKEY tIN tOPEN_ARRAY array_value tCLOSE_ARRAY { Compiler::Attribute.new(key: val[0], value: val[3], operator: :in) }
 
   array_value
-    : value tCOMMA array_value { Compiler::Array.new(value: val[0], rest: val[2]) }
+    : value array_value { Compiler::Array.new(value: val[0], rest: val[1]) }
     | value { Compiler::Array.new(value: val[0]) }
 
   value

data/lib/synvert/core/node_query.rb

@@ -5,10 +5,10 @@
 # It supports the following selectors:
 #
 # * AST node type: +.class+, +.send+
-# * attribute value: +[receiver = nil]+, +[message = create]+
-# * attribute regex: <code>[key=~/\A:([^'"]+)\z/]</code>, <code>[key!~/\A:([^'"]+)\z/]</code>
-# * attribute conditions: +[message != nil]+, +[value > 1]+, +[value >= 1]+, +[value < 1]+, +[value <= 1]+
-# * nested attribute: +[caller.message = map]+, +[arguments.size = 2]+
+# * attribute value: +.send[receiver = nil]+, +.send[message = create]+
+# * attribute regex: <code>.send[key=~/\A:([^'"]+)\z/]</code>, <code>.send[key!~/\A:([^'"]+)\z/]</code>
+# * attribute conditions: +.send[message != nil]+, +.send[value > 1]+, +.send[value >= 1]+, +.send[value < 1]+, +.send[value <= 1]+
+# * nested attribute: +.send[caller.message = map]+, +.send[arguments.size = 2]+
 # * first or last child: +.def:first-child+, +.send:last-child+
 # * nth-child or nth-last-child: +.def:nth-child(2)+, +.send:nth-last-child(2)+
 # * descendant: +.class .send+
@@ -21,9 +21,9 @@
 #
 # * not_has: +.class:not_has(.def)+, it's same as +:not(:has())+ in css, just to make implementation easy.
 # * nested selector: +.send[arguments = [size = 2][first = .sym][last = .hash]]+
-# * array value: +.send[arguments = (a, b)]+
-# * IN operator: +.send[message IN (try, try!)]+
-# * NOT IN operator: +.send[message NOT IN (create, build)]+
+# * array value: +.send[arguments = (a b)]+
+# * IN operator: +.send[message IN (try try!)]+
+# * NOT IN operator: +.send[message NOT IN (create build)]+
 # * INCLUDES operator: +.send[arguments INCLUDES &block]+
 # * dynamic attribute value: +.hash > .pair[key={{value}}]+
 #

data/lib/synvert/core/version.rb

@@ -2,6 +2,6 @@
 
 module Synvert
   module Core
-    VERSION = '1.1.0'
+    VERSION = '1.2.1'
   end
 end

data/spec/synvert/core/node_ext_spec.rb

@@ -1033,33 +1033,41 @@ describe Parser::AST::Node do
       node = parse(<<~EOS)
         class Synvert
           def foobar(foo, bar)
-            foo + bar
+            { foo => bar }
           end
         end
       EOS
-      expect(node.to_hash).to eq({
-        type: :class,
-        parent_class: nil,
-        name: {
-          type: :const,
-          parent_const: nil,
-          name: :Synvert
-        },
-        body: [{
-          type: :def,
-          name: :foobar,
-          arguments: [
-            { type: :arg, name: :foo},
-            { type: :arg, name: :bar}
-          ],
-          body: [{
-            type: :send,
-            receiver: { name: :foo, type: :lvar },
-            message: :+,
-            arguments: [{ name: :bar, type: :lvar }]
-          }]
-        }]
-      })
+      expect(node.to_hash).to eq(
+        {
+          type: :class,
+          parent_class: nil,
+          name: {
+            type: :const,
+            parent_const: nil,
+            name: :Synvert
+          },
+          body: [
+            {
+              type: :def,
+              name: :foobar,
+              arguments: [
+                { type: :arg, name: :foo },
+                { type: :arg, name: :bar }
+              ],
+              body: [
+                {
+                  type: :hash,
+                  pairs: {
+                    type: :pair,
+                    key: { type: :lvar, name: :foo },
+                    value: { type: :lvar, name: :bar }
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      )
     end
   end
 end

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

@@ -200,6 +200,45 @@ module Synvert::Core::NodeQuery
         assert_tokens source, expected_tokens
       end
 
+      it 'matches :[] message' do
+        source = ".send[message=[]]"
+        expected_tokens = [
+          [:tNODE_TYPE, "send"],
+          [:tOPEN_ATTRIBUTE, "["],
+          [:tKEY, "message"],
+          [:tEQUAL, "="],
+          [:tIDENTIFIER_VALUE, "[]"],
+          [:tCLOSE_ATTRIBUTE, "]"]
+        ]
+        assert_tokens source, expected_tokens
+      end
+
+      it 'matches :[] message' do
+        source = ".send[message=:[]=]"
+        expected_tokens = [
+          [:tNODE_TYPE, "send"],
+          [:tOPEN_ATTRIBUTE, "["],
+          [:tKEY, "message"],
+          [:tEQUAL, "="],
+          [:tSYMBOL, :[]=],
+          [:tCLOSE_ATTRIBUTE, "]"]
+        ]
+        assert_tokens source, expected_tokens
+      end
+
+      it 'matches nil?' do
+        source = ".send[message=nil?]"
+        expected_tokens = [
+          [:tNODE_TYPE, "send"],
+          [:tOPEN_ATTRIBUTE, "["],
+          [:tKEY, "message"],
+          [:tEQUAL, "="],
+          [:tIDENTIFIER_VALUE, "nil?"],
+          [:tCLOSE_ATTRIBUTE, "]"]
+        ]
+        assert_tokens source, expected_tokens
+      end
+
       it 'matches attribute value' do
         source = '.pair[key={{value}}]'
         expected_tokens = [
@@ -403,7 +442,7 @@ module Synvert::Core::NodeQuery
       end
 
       it 'matches IN' do
-        source = '.send[message IN (create, build)]'
+        source = '.send[message IN (create build)]'
         expected_tokens = [
           [:tNODE_TYPE, "send"],
           [:tOPEN_ATTRIBUTE, "["],
@@ -411,7 +450,6 @@ module Synvert::Core::NodeQuery
           [:tIN, "IN"],
           [:tOPEN_ARRAY, "("],
           [:tIDENTIFIER_VALUE, "create"],
-          [:tCOMMA, ","],
           [:tIDENTIFIER_VALUE, "build"],
           [:tCLOSE_ARRAY, ")"],
           [:tCLOSE_ATTRIBUTE, "]"]
@@ -420,7 +458,7 @@ module Synvert::Core::NodeQuery
       end
 
       it 'matches NOT IN' do
-        source = '.send[message NOT IN (create, build)]'
+        source = '.send[message NOT IN (create build)]'
         expected_tokens = [
           [:tNODE_TYPE, "send"],
           [:tOPEN_ATTRIBUTE, "["],
@@ -428,7 +466,6 @@ module Synvert::Core::NodeQuery
           [:tNOT_IN, "NOT IN"],
           [:tOPEN_ARRAY, "("],
           [:tIDENTIFIER_VALUE, "create"],
-          [:tCOMMA, ","],
           [:tIDENTIFIER_VALUE, "build"],
           [:tCLOSE_ARRAY, ")"],
           [:tCLOSE_ATTRIBUTE, "]"]
@@ -584,5 +621,20 @@ module Synvert::Core::NodeQuery
         assert_tokens source, expected_tokens
       end
     end
+
+    context 'goto_scope' do
+      it 'matches' do
+        source = '.block <body> > .def'
+        expected_tokens = [
+          [:tNODE_TYPE, "block"],
+          [:tOPEN_GOTO_SCOPE, "<"],
+          [:tIDENTIFIER, "body"],
+          [:tCLOSE_GOTO_SCOPE, ">"],
+          [:tCHILD, ">"],
+          [:tNODE_TYPE, "def"]
+        ]
+        assert_tokens source, expected_tokens
+      end
+    end
   end
 end

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

@@ -28,6 +28,11 @@ module Synvert::Core::NodeQuery
       assert_parser(source)
     end
 
+    it 'parses scope' do
+      source = '.block <body> > .send'
+      assert_parser(source)
+    end
+
     it 'parses :first-child' do
       source = '.class .def:first-child'
       assert_parser(source)
@@ -49,12 +54,17 @@ module Synvert::Core::NodeQuery
     end
 
     it 'parses :has selector' do
-      source = '.class:has(> .def)'
+      source = '.class :has(> .def)'
       assert_parser(source)
     end
 
     it 'parses :not_has selector' do
-      source = '.class:not_has(> .def)'
+      source = '.class :not_has(> .def)'
+      assert_parser(source)
+    end
+
+    it 'parses root :has selector' do
+      source = ':has(.def)'
       assert_parser(source)
     end
 
@@ -99,12 +109,12 @@ module Synvert::Core::NodeQuery
     end
 
     it 'parses in operator' do
-      source = '.def[name in (foo, bar)]'
+      source = '.def[name in (foo bar)]'
       assert_parser(source)
     end
 
     it 'parses not_in operator' do
-      source = '.def[name not in (foo, bar)]'
+      source = '.def[name not in (foo bar)]'
       assert_parser(source)
     end
 
@@ -118,6 +128,16 @@ module Synvert::Core::NodeQuery
       assert_parser(source)
     end
 
+    it 'parses []=' do
+      source = '.send[message=[]=]'
+      assert_parser(source)
+    end
+
+    it 'parses :[]' do
+      source = '.send[message=:[]]'
+      assert_parser(source)
+    end
+
     describe '#query_nodes' do
       let(:node) {
         parse(<<~EOS)
@@ -132,13 +152,22 @@ module Synvert::Core::NodeQuery
 
             def foobar(a, b)
               { a: a, b: b }
-              foo.merge(bar)
               arr[index]
+              arr[index] = value
+              nil?
+              call('')
             end
           end
         EOS
       }
 
+      let(:test_node) {
+        parse(<<~EOS)
+          RSpec.describe Synvert do
+          end
+        EOS
+      }
+
       it 'matches class node' do
         expression = parser.parse('.class[name=Synvert]')
         expect(expression.query_nodes(node)).to eq [node]
@@ -180,12 +209,12 @@ module Synvert::Core::NodeQuery
       end
 
       it 'matches in' do
-        expression = parser.parse('.def[name IN (foo, bar)]')
+        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)]')
+        expression = parser.parse('.def[name NOT IN (foo bar)]')
         expect(expression.query_nodes(node)).to eq [node.body.last]
       end
 
@@ -195,34 +224,34 @@ module Synvert::Core::NodeQuery
       end
 
       it 'matches equal array' do
-        expression = parser.parse('.def[arguments=(a, b)]')
+        expression = parser.parse('.def[arguments=(a b)]')
         expect(expression.query_nodes(node)).to eq [node.body.last]
 
-        expression = parser.parse('.def[arguments=(b, a)]')
+        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)]')
+        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)]')
+        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]
+        expect(expression.query_nodes(node)).to eq [node.body.first.body.last, node.body.second.body.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]
+        expect(expression.query_nodes(node)).to eq [node.body.first.body.last, node.body.second.body.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]
+        expect(expression.query_nodes(node)).to eq [node.body.first.body.last, node.body.second.body.last]
       end
 
       it 'matches next sibling node' do
@@ -235,6 +264,19 @@ module Synvert::Core::NodeQuery
         expect(expression.query_nodes(node)).to eq [node.body.last]
       end
 
+      it 'matches goto scope' do
+        expression = parser.parse('.def <body> > .send[message=:create]')
+        expect(expression.query_nodes(node)).to eq [node.body.first.body.last, node.body.second.body.last]
+
+        expression = parser.parse('.def <body> .send[message=:create]')
+        expect(expression.query_nodes(node)).to eq [node.body.first.body.last, node.body.second.body.last]
+      end
+
+      it 'matches multiple goto scope' do
+        expression = parser.parse('.block <caller.arguments> .const[name=Synvert]')
+        expect(expression.query_nodes(test_node)).to eq [test_node.caller.arguments.first]
+      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]
@@ -245,18 +287,31 @@ module Synvert::Core::NodeQuery
         expect(expression.query_nodes(node)).to eq [node.body.last]
       end
 
+      it 'matches root has selector' do
+        expression = parser.parse(':has(.def[name=foobar])')
+        expect(expression.query_nodes(node)).to eq [node]
+      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]')
+        expression = parser.parse('.def .send[arguments.size=2]')
+        expect(expression.query_nodes(node)).to eq [
+          node.body.first.body.last,
+          node.body.second.body.last,
+          node.body.third.body.third
+        ]
+        expression = parser.parse('.def .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]
+        expression = parser.parse('.def .send[arguments.size>=2]')
+        expect(expression.query_nodes(node)).to eq [
+          node.body.first.body.last,
+          node.body.second.body.last,
+          node.body.third.body.third
+        ]
       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]
+        expression = parser.parse('.send[arguments.size=2][arguments.first=.sym][arguments.last=.hash]')
+        expect(expression.query_nodes(node)).to eq [node.body.first.body.last, node.body.second.body.last]
       end
 
       it 'matches regexp value' do
@@ -271,15 +326,25 @@ module Synvert::Core::NodeQuery
         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]')
+      it 'matches []' do
+        expression = parser.parse('.send[message=[]]')
         expect(expression.query_nodes(node)).to eq [node.body.last.body.second]
       end
 
-      it 'matches []' do
-        expression = parser.parse('.send[message="[]"]')
+      it 'matches []=' do
+        expression = parser.parse('.send[message=:[]=]')
         expect(expression.query_nodes(node)).to eq [node.body.last.body.third]
       end
+
+      it 'matches nil and nil?' do
+        expression = parser.parse('.send[receiver=nil][message=nil?]')
+        expect(expression.query_nodes(node)).to eq [node.body.last.body.fourth]
+      end
+
+      it 'matches empty string' do
+        expression = parser.parse('.send[message=call][arguments.first=""]')
+        expect(expression.query_nodes(node)).to eq [node.body.last.body.last]
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: synvert-core
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-26 00:00:00.000000000 Z
+date: 2022-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport