parser_node_ext 0.11.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 935089d050b6cfa37cb4b2b73aa2f2b29fc82b6e355354a46184f20434a331e2
-  data.tar.gz: d1667479f06fb825d9abe9479dbc4eacc64a234e72c792709f6735fab02e56c2
+  metadata.gz: 9650ac2c4cec4440ffc72ee28d8904f0583c6d9dfef3890060f5b52adeb28553
+  data.tar.gz: e3b0dc597dfeca91c977646ced5398673483de2161311bb3f7b9077d29802d9e
 SHA512:
-  metadata.gz: fcdf61c369ee2486b3eb276714f38ad53a75e022732fdfcbd9d38f0d05615efd4268813d675e9548e5ba27c8b020f8a5c88e472b48ad317c558c23c2e566f824
-  data.tar.gz: b98d563672fab7af70592839603b7ac7a3d0315710d11b2a071a9b66a84f9d5744df3682277ed9a997f172f84031c4417112ca38e7be267f1383b6a21e8bbaf9
+  metadata.gz: 9bd6453cfbe47d33bd9326368d6ff8741178980aaa15e34ed9f5cccbfbd900fa70b007b825802ee36de49ba324ac22d13f38138f4639653d236af4b7347138c3
+  data.tar.gz: 8c477d4181a64b667a317c8d12924bd504604465f32381a9265f9604c4759b73b2fbffff70c8db5de9cabc27a93f54c5a94d212daa9d79cc3bf9f66b4784eda9

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## 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.0.0)
       parser
 
 GEM

data/lib/parser_node_ext/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ParserNodeExt
-  VERSION = "0.11.0"
+  VERSION = "1.0.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")))
@@ -315,7 +406,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

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.0.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-02-11 00:00:00.000000000 Z
+date: 2023-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser