synvert-core 1.1.1 → 1.2.0

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

@@ -1,28 +1,25 @@
 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]) }
@@ -53,7 +50,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/version.rb

@@ -2,6 +2,6 @@
 
 module Synvert
   module Core
-    VERSION = '1.1.1'
+    VERSION = '1.2.0'
   end
 end

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

@@ -226,6 +226,19 @@ module Synvert::Core::NodeQuery
         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 = [
@@ -429,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, "["],
@@ -437,7 +450,6 @@ module Synvert::Core::NodeQuery
           [:tIN, "IN"],
           [:tOPEN_ARRAY, "("],
           [:tIDENTIFIER_VALUE, "create"],
-          [:tCOMMA, ","],
           [:tIDENTIFIER_VALUE, "build"],
           [:tCLOSE_ARRAY, ")"],
           [:tCLOSE_ATTRIBUTE, "]"]
@@ -446,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, "["],
@@ -454,7 +466,6 @@ module Synvert::Core::NodeQuery
           [:tNOT_IN, "NOT IN"],
           [:tOPEN_ARRAY, "("],
           [:tIDENTIFIER_VALUE, "create"],
-          [:tCOMMA, ","],
           [:tIDENTIFIER_VALUE, "build"],
           [:tCLOSE_ARRAY, ")"],
           [:tCLOSE_ATTRIBUTE, "]"]
@@ -610,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
 
@@ -142,15 +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]
@@ -192,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
 
@@ -207,18 +224,18 @@ 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
 
@@ -247,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]
@@ -257,12 +287,17 @@ 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('.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.fourth
+          node.body.third.body.third
         ]
         expression = parser.parse('.def .send[arguments.size>2]')
         expect(expression.query_nodes(node)).to eq []
@@ -270,7 +305,7 @@ module Synvert::Core::NodeQuery
         expect(expression.query_nodes(node)).to eq [
           node.body.first.body.last,
           node.body.second.body.last,
-          node.body.third.body.fourth
+          node.body.third.body.third
         ]
       end
 
@@ -291,18 +326,18 @@ 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]')
-        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]
+        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
+
+      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
 

metadata

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