parser_node_ext 0.11.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 935089d050b6cfa37cb4b2b73aa2f2b29fc82b6e355354a46184f20434a331e2
-  data.tar.gz: d1667479f06fb825d9abe9479dbc4eacc64a234e72c792709f6735fab02e56c2
+  metadata.gz: 9c326faea53723b13d4a991011fb260e874a0d86788308c4c4a919ede8d5680b
+  data.tar.gz: 1892e4c21ec1e1c8d4f2fc8c8b4cc78f502a8d20bcf4ee3cd823aa717415122e
 SHA512:
-  metadata.gz: fcdf61c369ee2486b3eb276714f38ad53a75e022732fdfcbd9d38f0d05615efd4268813d675e9548e5ba27c8b020f8a5c88e472b48ad317c558c23c2e566f824
-  data.tar.gz: b98d563672fab7af70592839603b7ac7a3d0315710d11b2a071a9b66a84f9d5744df3682277ed9a997f172f84031c4417112ca38e7be267f1383b6a21e8bbaf9
+  metadata.gz: 810a25e6c68cfc13791501a5bf1d7a3264a31a90b4af25ba4d109373bd18240fa88c577a194540ebb7835da756e0f1ad584ad19d6318165e802c68e49167b6eb
+  data.tar.gz: cba51e45acbf600057a22ac27fd21fe1a980fc6d7b8278312815c4b8c87dd89ab7b9b2b67af81994078f4dd4cf8f34e0755ef59357ee090cc0852a87740b1b26

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # CHANGELOG
 
+## 1.1.0 (2023-05-15)
+
+* hash `xxx_value` returns the node rather than the value
+* Support `xxx_pair` for `hash` node
+
+## 1.0.0 (2023-02-12)
+
+* Support almost all of nodes
+
 ## 0.11.0 (2023-02-12)
 
 * Support `self` node

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    parser_node_ext (0.11.0)
+    parser_node_ext (1.1.0)
       parser
 
 GEM
@@ -9,7 +9,7 @@ GEM
   specs:
     ast (2.4.2)
     diff-lcs (1.5.0)
-    parser (3.2.1.0)
+    parser (3.2.2.1)
       ast (~> 2.4.1)
     rake (13.0.6)
     rspec (3.11.0)

data/README.md

@@ -1,8 +1,15 @@
 # ParserNodeExt
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/parser_node_ext`. To experiment with that code, run `bin/console` for an interactive prompt.
+It assigns names to the child nodes of the [parser](https://rubygems.org/gems/parser).
 
-TODO: Delete this and the text above, and describe your gem
+It also adds some helpers
+
+```ruby
+# node is a hash node
+node.foo_pair # get the pair node of hash foo key
+node.foo_value # get the value node of the hash foo key
+node.foo_source # get the source of the value node of the hash foo key
+```
 
 ## Installation
 
@@ -22,7 +29,10 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+```ruby
+require 'parser/current'
+require 'parser_node_ext'
+```
 
 ## Development
 

data/lib/parser_node_ext/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ParserNodeExt
-  VERSION = "0.11.0"
+  VERSION = "1.1.0"
 end

data/lib/parser_node_ext.rb

@@ -9,60 +9,111 @@ module ParserNodeExt
   # Your code goes here...
 
   TYPE_CHILDREN = {
+    alias: %i[new_name old_name],
     and: %i[left_value right_value],
+    and_asgn: %i[variable value],
     arg: %i[name],
     array: %i[elements],
     array_pattern: %i[elements],
+    array_pattern_with_tail: %i[elements],
+    back_ref: %i[name],
     begin: %i[body],
     block: %i[caller arguments body],
     blockarg: %i[name],
+    block_pass: %i[name],
+    break: %i[expression],
     case: %i[expression when_statements else_statement],
     case_match: %i[expression in_statements else_statement],
+    casgn: %i[parent_const name value],
+    cbase: %i[],
+    complex: %i[value],
     const: %i[parent_const name],
     class: %i[name parent_class body],
     csend: %i[receiver message arguments],
-    cvasgn: %i[left_value right_value],
+    cvasgn: %i[variable value],
     cvar: %i[name],
     def: %i[name arguments body],
     defined?: %i[arguments],
     defs: %i[self name arguments body],
+    dstr: %i[elements],
+    dsym: %i[elements],
+    eflipflop: %i[begin end],
+    ensure: %i[body ensure_body],
     erange: %i[begin end],
     false: [],
     find_pattern: %i[elements],
     float: %i[value],
+    for: %i[variable expression body],
+    forward_args: [],
+    gvar: %i[name],
+    gvasgn: %i[variable value],
     hash: %i[pairs],
     hash_pattern: %i[pairs],
     if: %i[expression if_statement else_statement],
+    iflipflop: %i[begin end],
     if_guard: %i[expression],
     int: %i[value],
     in_pattern: %i[expression guard body],
     irange: %i[begin end],
-    ivasgn: %i[left_value right_value],
+    ivasgn: %i[variable value],
     ivar: %i[name],
+    kwarg: %i[name],
+    kwbody: %i[body],
+    kwnilarg: [],
+    kwoptarg: %i[name value],
+    kwrestarg: %i[name],
+    kwsplat: %i[name],
     lvar: %i[name],
-    lvasgn: %i[left_value right_value],
-    masgn: %i[left_value right_value],
+    lvasgn: %i[variable value],
+    masgn: %i[variable value],
     match_as: %i[key value],
+    match_nil_pattern: [],
     match_pattern: %i[left_value right_value],
     match_pattern_p: %i[left_value right_value],
     match_rest: %i[variable],
     match_var: %i[name],
+    match_with_lvasgn: %i[left_value right_value],
+    mlhs: %i[elements],
     module: %i[name body],
+    next: %i[expression],
     nil: [],
+    nth_ref: %i[name],
     numblock: %i[caller arguments_count body],
+    optarg: %i[name value],
+    op_asgn: %i[variable operator value],
     or: %i[left_value right_value],
-    or_asgn: %i[left_value right_value],
+    or_asgn: %i[variable value],
     pair: %i[key value],
-    pin: %i[variable],
+    pin: %i[expression],
+    postexe: %i[body],
+    preexe: %i[body],
+    rational: %i[value],
+    redo: [],
+    regexp: %i[elements options],
+    regopt: %i[elements],
+    resbody: %i[exceptions variable body],
+    rescue: %i[body rescue_bodies else_statement],
     restarg: %i[name],
+    retry: [],
+    return: %i[expression],
+    sclass: %i[name body],
     self: [],
+    shadowarg: %i[name],
     send: %i[receiver message arguments],
+    splat: %i[name],
     str: %i[value],
     super: %i[arguments],
     sym: %i[value],
     true: [],
+    undef: %i[elements],
     unless_guard: %i[expression],
+    until: %i[expression body],
+    until_post: %i[expression body],
     when: %i[expression body],
+    while: %i[expression body],
+    while_post: %i[expression body],
+    xstr: %i[elements],
+    yield: %i[arguments],
     zsuper: []
   }
 
@@ -111,24 +162,8 @@ module ParserNodeExt
         end
       end
 
-      # Return the left value of node.
-      # It supports :and, :cvagn, :lvasgn, :masgn, :or and :or_asgn nodes.
-      # @example
-      #   node # s(:or_asgn, s(:lvasgn, :a), s(:int, 1))
-      #   node.left_value # :a
-      # @return [Parser::AST::Node] left value of node.
-      # @raise [MethodNotSupported] if calls on other node.
-      def left_value
-        return children[0].children[0] if type == :or_asgn
-
-        index = TYPE_CHILDREN[type]&.index(:left_value)
-        return children[index] if index
-
-        raise MethodNotSupported, "#{left_value} is not supported for #{self}"
-      end
-
       # Get arguments of node.
-      # It supports :block, :csend, :def, :defined?, :defs and :send nodes.
+      # It supports :block, :csend, :def, :defined?, :defs, :send, :yeild nodes.
       # @example
       #   node # s(:send, s(:const, nil, :FactoryGirl), :create, s(:sym, :post), s(:hash, s(:pair, s(:sym, :title), s(:str, "post"))))
       #   node.arguments # [s(:sym, :post), s(:hash, s(:pair, s(:sym, :title), s(:str, "post")))]
@@ -144,7 +179,7 @@ module ParserNodeExt
           children[1].children
         when :send, :csend
           children[2..-1]
-        when :defined?
+        when :defined?, :yield
           children
         else
           raise MethodNotSupported, "arguments is not supported for #{self}"
@@ -152,7 +187,7 @@ module ParserNodeExt
       end
 
       # Get body of node.
-      # It supports :begin, :block, :class, :def, :defs, :module, :numblock node.
+      # It supports :begin, :block, :class, :def, :defs, :ensure, :for, :module, :numblock, resbody, :sclass, :until, :until_post, :while and :while_post node.
       # @example
       #   node # s(:block, s(:send, s(:const, nil, :RSpec), :configure), s(:args, s(:arg, :config)), s(:send, nil, :include, s(:const, s(:const, nil, :EmailSpec), :Helpers)))
       #   node.body # [s(:send, nil, :include, s(:const, s(:const, nil, :EmailSpec), :Helpers))]
@@ -160,20 +195,24 @@ module ParserNodeExt
       # @raise [MethodNotSupported] if calls on other node.
       def body
         case type
-        when :begin
+        when :begin, :kwbegin
           children
-        when :when, :module
+        when :rescue, :ensure, :preexe, :postexe
+          return [] if children[0].nil?
+
+          [:begin, :kwbegin].include?(children[0].type) ? children[0].body : [children[0]]
+        when :when, :module, :sclass, :until, :until_post, :while, :while_post
           return [] if children[1].nil?
 
-          :begin == children[1].type ? children[1].body : children[1..-1]
-        when :def, :block, :class, :numblock, :in_pattern
+          [:begin, :kwbegin].include?(children[1].type) ? children[1].body : children[1..-1]
+        when :def, :block, :class, :for, :in_pattern, :numblock, :resbody
           return [] if children[2].nil?
 
-          :begin == children[2].type ? children[2].body : children[2..-1]
+          [:begin, :kwbegin].include?(children[2].type) ? children[2].body : children[2..-1]
         when :defs
           return [] if children[3].nil?
 
-          :begin == children[3].type ? children[3].body : children[3..-1]
+          [:begin, :kwbegin].include?(children[3].type) ? children[3].body : children[3..-1]
         else
           raise MethodNotSupported, "body is not supported for #{self}"
         end
@@ -190,6 +229,28 @@ module ParserNodeExt
         end
       end
 
+      # Get rescue bodies of resuce node.
+      # @return [Array<Parser::AST::Node>] rescue statements of rescue node.
+      # @raise [MethodNotSupported] if calls on other node.
+      def rescue_bodies
+        if :rescue == type
+          children[1...-1]
+        else
+          raise MethodNotSupported, "rescue_bodies is not supported for #{self}"
+        end
+      end
+
+      # Get ensure body of ensure node.
+      # @return [Array<Parser::AST::Node>] ensure body of ensure node.
+      # @raise [MethodNotSupported] if calls on other node.
+      def ensure_body
+        if :ensure == type
+          children[1..-1]
+        else
+          raise MethodNotSupported, "ensure_body is not supported for #{self}"
+        end
+      end
+
       # Get in statements of case_match node.
       # @return [Array<Parser::AST::Node>] in statements of case node.
       # @raise [MethodNotSupported] if calls on other node.
@@ -201,24 +262,54 @@ module ParserNodeExt
         end
       end
 
-      # Get else statement of case node.
-      # @return [Parser::AST::Node] else statement of case node.
+      # Get else statement of node.
+      # @return [Parser::AST::Node] else statement of node.
       # @raise [MethodNotSupported] if calls on other node.
       def else_statement
         children[-1]
       end
 
-      # Get elements of :array and :array_pattern node.
+      # Get elements of :array, :array_pattern, :array_pattern_with_tail, :find_pattern, :dstr, :dsym, :xstr, :regopt, :mlhs and :undef node.
       # @return [Array<Parser::AST::Node>] elements of array node.
       # @raise [MethodNotSupported] if calls on other node.
       def elements
-        if %i[array array_pattern find_pattern].include?(type)
+        if %i[array array_pattern array_pattern_with_tail find_pattern dstr dsym xstr regopt mlhs undef].include?(type)
           children
+        elsif type == :regexp
+          children[0...-1]
         else
           raise MethodNotSupported, "elements is not supported for #{self}"
         end
       end
 
+      # Get options of :regexp node.
+      # @example
+      #   node # s(:regexp, s(:str, "foo"), s(:regopt, :i, :m))
+      #   node.options # s(:regopt, :i, :m)
+      # @return [Parser::AST::Node] options of regexp node.
+      # @raise [MethodNotSupported] if calls on other node.
+      def options
+        if :regexp == type
+          children[-1]
+        else
+          raise MethodNotSupported, "options is not supported for #{self}"
+        end
+      end
+
+      # Get exceptions of :resbody node.
+      # @example
+      #   node # s(:resbody, s(:array, (:const nil :Exception), (:const nil :A)), s(:lvasgn :bar), s(:int 1))
+      #   node.exceptions # s(:array, (:const nil :Exception), (:const nil :A))
+      # @return [Parser::AST::Node] exceptions of resbody node.
+      # @raise [MethodNotSupported] if calls on other node.
+      def exceptions
+        if :resbody == type
+          children[0]
+        else
+          raise MethodNotSupported, "exceptions is not supported for #{self}"
+        end
+      end
+
       # Get pairs of :hash and :hash_pattern node.
       # @example
       #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)), s(:pair, s(:str, "foo"), s(:str, "bar")))
@@ -276,12 +367,27 @@ module ParserNodeExt
         end
       end
 
+      # Get :hash pair node according to specified key.
+      # @example
+      #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)))
+      #   node.hash_pair(:foo) # s(:pair, s(:sym, :foo), s(:sym, :bar))
+      # @param [Symbol, String] key value.
+      # @return [Parser::AST::Node] hash pair node.
+      # @raise [MethodNotSupported] if calls on other node.
+      def hash_pair(key)
+        if :hash == type
+          children.find { |pair_node| pair_node.key.to_value == key }
+        else
+          raise MethodNotSupported, "hash_pair is not supported for #{self}"
+        end
+      end
+
       # Get :hash value node according to specified key.
       # @example
       #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)))
       #   node.hash_value(:foo) # s(:sym, :bar)
       # @param [Symbol, String] key value.
-      # @return [Parser::AST::Node] hash value of node.
+      # @return [Parser::AST::Node] hash value node.
       # @raise [MethodNotSupported] if calls on other node.
       def hash_value(key)
         if :hash == type
@@ -315,7 +421,7 @@ module ParserNodeExt
           (children.first.to_value..children.last.to_value)
         when :erange
           (children.first.to_value...children.last.to_value)
-        when :begin
+        when :begin, :kwbegin
           children.first.to_value
         else
           self
@@ -359,18 +465,24 @@ module ParserNodeExt
       def method_missing(method_name, *args, &block)
         if :args == type && children.respond_to?(method_name)
           return children.send(method_name, *args, &block)
-        elsif :hash == type && method_name.to_s.include?('_value')
-          key = method_name.to_s.sub('_value', '')
-          return hash_value(key.to_sym)&.to_value if key?(key.to_sym)
-          return hash_value(key.to_s)&.to_value if key?(key.to_s)
+        elsif :hash == type && method_name.to_s.end_with?('_pair')
+          key = method_name.to_s[0..-6]
+          return hash_pair(key.to_sym) if key?(key.to_sym)
+          return hash_pair(key.to_s) if key?(key.to_s)
 
           return nil
-        elsif :hash == type && method_name.to_s.include?('_source')
-          key = method_name.to_s.sub('_source', '')
+        elsif :hash == type && method_name.to_s.end_with?('_value')
+          key = method_name.to_s[0..-7]
+          return hash_value(key.to_sym) if key?(key.to_sym)
+          return hash_value(key.to_s) if key?(key.to_s)
+
+          return nil
+        elsif :hash == type && method_name.to_s.end_with?('_source')
+          key = method_name.to_s[0..-8]
           return hash_value(key.to_sym)&.to_source if key?(key.to_sym)
           return hash_value(key.to_s)&.to_source if key?(key.to_s)
 
-          return nil
+          return ''
         end
 
         super
@@ -379,12 +491,15 @@ module ParserNodeExt
       def respond_to_missing?(method_name, *args)
         if :args == type && children.respond_to?(method_name)
           return true
-        elsif :hash == type && method_name.to_s.include?('_value')
-          key = method_name.to_s.sub('_value', '')
-          return true if key?(key.to_sym) || key?(key.to_s)
-        elsif :hash == type && method_name.to_s.include?('_source')
-          key = method_name.to_s.sub('_source', '')
-          return true if key?(key.to_sym) || key?(key.to_s)
+        elsif :hash == type && method_name.to_s.end_with?('_pair')
+          key = method_name.to_s[0..-6]
+          return key?(key.to_sym) || key?(key.to_s)
+        elsif :hash == type && method_name.to_s.end_with?('_value')
+          key = method_name.to_s[0..-7]
+          return key?(key.to_sym) || key?(key.to_s)
+        elsif :hash == type && method_name.to_s.end_with?('_source')
+          key = method_name.to_s[0..-8]
+          return key?(key.to_sym) || key?(key.to_s)
         end
 
         super

data/sig/parser_node_ext.rbs

@@ -9,8 +9,13 @@ module ParserNodeExt
   def caller: () -> Parser::AST::Node
   def elements: () -> Array[Parser::AST::Node]
   def else_statement: () -> Parser::AST::Node
+  def exceptions: () -> Array[Parser::AST::Node]
   def end: () -> Parser::AST::Node
+  def ensure_body: () -> Array[Parser::AST::Node]
   def expression: () -> Parser::AST::Node
+  def old_name: () -> Symbol
+  def options: () -> Parser::AST::Node
+  def operator: () -> Symbol
   def if_statement: () -> Parser::AST::Node
   def in_statements: () -> Array[Parser::AST::Node]
   def key: () -> Parser::AST::Node
@@ -18,9 +23,11 @@ module ParserNodeExt
   def left_value: () -> Parser::AST::Node | Symbol
   def message: () -> Symbol
   def name: () -> Parser::AST::Node | Symbol
+  def new_name: () -> Symbol
   def pairs: () -> Array[Parser::AST::Node]
   def parent_class: () -> Parser::AST::Node
   def receiver: () -> Parser::AST::Node
+  def rescue_bodies: () -> Array[Parser::AST::Node]
   def right_value: () -> Parser::AST::Node
   def self: () -> Parser::AST::Node
   def value: () -> Parser::AST::Node

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parser_node_ext
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-02-11 00:00:00.000000000 Z
+date: 2023-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -63,7 +63,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: extend parser node