parser_node_ext 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0d6b0cc2e9e72c692cbc566acb7ef8cd180f428b5f473ce82457e26bdffc661
-  data.tar.gz: 37de56dc2293bb387ca423291bf7a6fa84be97ebf21c1652aba095b76cc9817d
+  metadata.gz: 54f47aa3cbd58cec27d151340e935bf687be7c9cb63c523cdd8174869aebaf7e
+  data.tar.gz: e3e940453872b9bd0abd24a2b11b8d07c59e35613717b365b9810b0461cd1f28
 SHA512:
-  metadata.gz: 998948687de1e0555ae1f8d2e69452c382a4320d69f5106d75ba6855a5ef0b3718bf3a28acf36a3f1a1f0e4fc86f19ed7f5d8c9e482719ddf32d26fdf3887b82
-  data.tar.gz: f339dfc3553d68ddffa96ffd4903832346cc1d29cb679eb1ec21dbe94a64551af9535de1f0d1548b90ef8e49df017cf8efa3a2f0503268cb4a9dcbdc49ed109a
+  metadata.gz: 573b0ae05b18d25c04bc1efeac3f763c3872eee302d1b23fa11c054d32a1ea84afc86e7984e3ae6892f55bc39c4b0c8faadf133da1d53af6b387b8a57f55f685
+  data.tar.gz: b8b718a0dec190ce6b563fa9edd842d38869a58f7bc43799297e6ed88268f2fd5427315791c5b4cec62046d510056165b60683d36709d86790675eb19b14b655

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# CHANGELOG
+
+## 0.4.0 (2022-07-07)
+
+* raise `MethodNotSupported` error
+
+## 0.3.0 (2022-07-04)
+
+* Add `Node#to_hash`
+
+## 0.2.0 (2022-06-27)
+
+* Add `Node#to_value`
+* Add `Node#to_source`
+* Support `xxx_value` and `xxx_source` for `hash` node
+
+## 0.1.0 (2022-06-26)
+
+* Abstract from synvert-core

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    parser_node_ext (0.1.0)
+    parser_node_ext (0.4.0)
       parser
 
 GEM
@@ -28,6 +28,7 @@ GEM
 
 PLATFORMS
   x86_64-darwin-21
+  x86_64-linux
 
 DEPENDENCIES
   parser_node_ext!

data/lib/parser_node_ext/version.rb

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

data/lib/parser_node_ext.rb

@@ -5,8 +5,6 @@ require_relative "parser_node_ext/version"
 require 'parser'
 
 module ParserNodeExt
-  class Error < StandardError; end
-
   class MethodNotSupported < StandardError; end
   # Your code goes here...
 
@@ -95,7 +93,7 @@ module ParserNodeExt
           index = TYPE_CHILDREN[type]&.index(method_name)
           return children[index] if index
 
-          raise Synvert::Core::MethodNotSupported, "#{method_name} is not handled for #{debug_info}"
+          raise MethodNotSupported, "#{method_name} is not handled for #{debug_info}"
         end
       end
 
@@ -105,14 +103,14 @@ module ParserNodeExt
       #   node # s(:or_asgn, s(:lvasgn, :a), s(:int, 1))
       #   node.left_value # :a
       # @return [Parser::AST::Node] left value of node.
-      # @raise [Synvert::Core::MethodNotSupported] if calls on other 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 Synvert::Core::MethodNotSupported, "#{left_value} is not handled for #{debug_info}"
+        raise MethodNotSupported, "#{left_value} is not handled for #{debug_info}"
       end
 
       # Get arguments of node.
@@ -121,7 +119,7 @@ module ParserNodeExt
       #   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")))]
       # @return [Array<Parser::AST::Node>] arguments of node.
-      # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+      # @raise [MethodNotSupported] if calls on other node.
       def arguments
         case type
         when :def, :block
@@ -133,7 +131,7 @@ module ParserNodeExt
         when :defined?
           children
         else
-          raise Synvert::Core::MethodNotSupported, "arguments is not handled for #{debug_info}"
+          raise MethodNotSupported, "arguments is not handled for #{debug_info}"
         end
       end
 
@@ -143,7 +141,7 @@ module ParserNodeExt
       #   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))]
       # @return [Array<Parser::AST::Node>] body of node.
-      # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+      # @raise [MethodNotSupported] if calls on other node.
       def body
         case type
         when :begin
@@ -157,7 +155,7 @@ module ParserNodeExt
 
           :begin == children[3].type ? children[3].body : children[3..-1]
         else
-          raise Synvert::Core::MethodNotSupported, "body is not handled for #{debug_info}"
+          raise MethodNotSupported, "body is not handled for #{debug_info}"
         end
       end
 
@@ -167,12 +165,12 @@ module ParserNodeExt
       #   node # s(:if, s(:defined?, s(:const, nil, :Bundler)), nil, nil)
       #   node.condition # s(:defined?, s(:const, nil, :Bundler))
       # @return [Parser::AST::Node] condition of node.
-      # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+      # @raise [MethodNotSupported] if calls on other node.
       def condition
         if :if == type
           children[0]
         else
-          raise Synvert::Core::MethodNotSupported, "condition is not handled for #{debug_info}"
+          raise MethodNotSupported, "condition is not handled for #{debug_info}"
         end
       end
 
@@ -181,12 +179,12 @@ module ParserNodeExt
       #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)), s(:pair, s(:str, "foo"), s(:str, "bar")))
       #   node.keys # [s(:sym, :foo), s(:str, "foo")]
       # @return [Array<Parser::AST::Node>] keys of node.
-      # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+      # @raise [MethodNotSupported] if calls on other node.
       def keys
         if :hash == type
           children.map { |child| child.children[0] }
         else
-          raise Synvert::Core::MethodNotSupported, "keys is not handled for #{debug_info}"
+          raise MethodNotSupported, "keys is not handled for #{debug_info}"
         end
       end
 
@@ -195,13 +193,155 @@ module ParserNodeExt
       #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)), s(:pair, s(:str, "foo"), s(:str, "bar")))
       #   node.values # [s(:sym, :bar), s(:str, "bar")]
       # @return [Array<Parser::AST::Node>] values of node.
-      # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+      # @raise [MethodNotSupported] if calls on other node.
       def values
         if :hash == type
           children.map { |child| child.children[1] }
         else
-          raise Synvert::Core::MethodNotSupported, "keys is not handled for #{debug_info}"
+          raise MethodNotSupported, "keys is not handled for #{debug_info}"
+        end
+      end
+
+      # Check if :hash node contains specified key.
+      # @example
+      #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)))
+      #   node.key?(:foo) # true
+      # @param [Symbol, String] key value.
+      # @return [Boolean] true if specified key exists.
+      # @raise [MethodNotSupported] if calls on other node.
+      def key?(key)
+        if :hash == type
+          children.any? { |pair_node| pair_node.key.to_value == key }
+        else
+          raise MethodNotSupported, "key? is not handled for #{debug_info}"
+        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.
+      # @raise [MethodNotSupported] if calls on other node.
+      def hash_value(key)
+        if :hash == type
+          value_node = children.find { |pair_node| pair_node.key.to_value == key }
+          value_node&.value
+        else
+          raise MethodNotSupported, "hash_value is not handled for #{debug_info}"
+        end
+      end
+
+      # Return the exact value of node.
+      # It supports :array, :begin, :erange, :false, :float, :irange, :int, :str, :sym and :true nodes.
+      # @example
+      #   node # s(:array, s(:str, "str"), s(:sym, :str))
+      #   node.to_value # ['str', :str]
+      # @return [Object] exact value.
+      # @raise [MethodNotSupported] if calls on other node.
+      def to_value
+        case type
+        when :int, :float, :str, :sym
+          children.last
+        when :true
+          true
+        when :false
+          false
+        when :nil
+          nil
+        when :array
+          children.map(&:to_value)
+        when :irange
+          (children.first.to_value..children.last.to_value)
+        when :erange
+          (children.first.to_value...children.last.to_value)
+        when :begin
+          children.first.to_value
+        else
+          self
+        end
+      end
+
+      # Get the source code of node.
+      #
+      # @return [String] source code.
+      def to_source
+        loc.expression&.source
+      end
+
+      # Convert node to a hash, so that it can be converted to a json.
+      def to_hash
+        result = { type: type }
+        if TYPE_CHILDREN[type]
+          TYPE_CHILDREN[type].each do |key|
+            value = send(key)
+            result[key] =
+              case value
+              when Array
+                value.map { |v| v.respond_to?(:to_hash) ? v.to_hash : v }
+              when Parser::AST::Node
+                value.to_hash
+              else
+                value
+              end
+          end
+        else
+          result[:children] = children.map { |c| c.respond_to?(:to_hash) ? c.to_hash : c }
+        end
+        result
+      end
+
+      # Respond key value and source for hash node, e.g.
+      # @example
+      #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)))
+      #   node.foo_value # :bar
+      #   node.foo_source # ":bar"
+      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)
+
+          return nil
+        elsif :hash == type && method_name.to_s.include?('_source')
+          key = method_name.to_s.sub('_source', '')
+          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
+        end
+
+        super
+      end
+
+      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)
         end
+
+        super
+      end
+
+      # Return the debug info.
+      #
+      # @return [String] file, line, source and node.
+      def debug_info
+        "\n" +
+          [
+            "file: #{loc.expression.source_buffer.name}",
+            "line: #{loc.expression.line}",
+            "source: #{to_source}",
+            "node: #{inspect}"
+          ].join("\n")
       end
     end
   end

data/sig/parser_node_ext.rbs

@@ -2,17 +2,19 @@ module ParserNodeExt
   VERSION: String
   # See the writing guide of rbs: https://github.com/ruby/rbs#guides
 
-  def arguments: Array[Parser::AST::Node]
-  def body: Array[Parser::AST::Node]
-  def caller: Parser::AST::Node
-  def key: Parser::AST::Node
-  def left_value: Parser::AST::Node | Symbol
-  def message: Symbol
-  def name: Parser::AST::Node | Symbol
-  def pairs: Array[Parser::AST::Node]
-  def parent_class: Parser::AST::Node
-  def receiver: Parser::AST::Node
-  def right_value: Parser::AST::Node
-  def self: Parser::AST::Node
-  def value: Parser::AST::Node
+  def arguments: () -> Array[Parser::AST::Node]
+  def body: () -> Array[Parser::AST::Node]
+  def caller: () -> Parser::AST::Node
+  def key: () -> Parser::AST::Node
+  def left_value: () -> Parser::AST::Node | Symbol
+  def message: () -> Symbol
+  def name: () -> Parser::AST::Node | Symbol
+  def pairs: () -> Array[Parser::AST::Node]
+  def parent_class: () -> Parser::AST::Node
+  def receiver: () -> Parser::AST::Node
+  def right_value: () -> Parser::AST::Node
+  def self: () -> Parser::AST::Node
+  def value: () -> Parser::AST::Node
+
+  def to_hash: () -> Hash
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parser_node_ext
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-26 00:00:00.000000000 Z
+date: 2022-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -33,6 +33,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - README.md