parser_node_ext 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c0d6b0cc2e9e72c692cbc566acb7ef8cd180f428b5f473ce82457e26bdffc661
+  data.tar.gz: 37de56dc2293bb387ca423291bf7a6fa84be97ebf21c1652aba095b76cc9817d
+SHA512:
+  metadata.gz: 998948687de1e0555ae1f8d2e69452c382a4320d69f5106d75ba6855a5ef0b3718bf3a28acf36a3f1a1f0e4fc86f19ed7f5d8c9e482719ddf32d26fdf3887b82
+  data.tar.gz: f339dfc3553d68ddffa96ffd4903832346cc1d29cb679eb1ec21dbe94a64551af9535de1f0d1548b90ef8e49df017cf8efa3a2f0503268cb4a9dcbdc49ed109a

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in parser_node_ext.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -0,0 +1,38 @@
+PATH
+  remote: .
+  specs:
+    parser_node_ext (0.1.0)
+      parser
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    diff-lcs (1.5.0)
+    parser (3.1.2.0)
+      ast (~> 2.4.1)
+    rake (13.0.6)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+
+PLATFORMS
+  x86_64-darwin-21
+
+DEPENDENCIES
+  parser_node_ext!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.3.7

data/README.md

@@ -0,0 +1,35 @@
+# 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.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'parser_node_ext'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install parser_node_ext
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/parser_node_ext.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/parser_node_ext/version.rb

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

data/lib/parser_node_ext.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require_relative "parser_node_ext/version"
+
+require 'parser'
+
+module ParserNodeExt
+  class Error < StandardError; end
+
+  class MethodNotSupported < StandardError; end
+  # Your code goes here...
+
+  TYPE_CHILDREN = {
+    and: %i[left_value right_value],
+    arg: %i[name],
+    begin: %i[body],
+    block: %i[caller arguments body],
+    blockarg: %i[name],
+    const: %i[parent_const name],
+    class: %i[name parent_class body],
+    csend: %i[receiver message arguments],
+    cvasgn: %i[left_value right_value],
+    cvar: %i[name],
+    def: %i[name arguments body],
+    definded?: %i[arguments],
+    defs: %i[self name arguments body],
+    hash: %i[pairs],
+    ivasgn: %i[left_value right_value],
+    ivar: %i[name],
+    lvar: %i[name],
+    lvasgn: %i[left_value right_value],
+    masgn: %i[left_value right_value],
+    module: %i[name body],
+    or: %i[left_value right_value],
+    or_asgn: %i[left_value right_value],
+    pair: %i[key value],
+    restarg: %i[name],
+    send: %i[receiver message arguments],
+    super: %i[arguments],
+    zsuper: %i[]
+  }
+
+  def self.included(base)
+    base.class_eval do
+      # Initialize a Node.
+      #
+      # It extends {Parser::AST::Node} and set parent for its child nodes.
+      def initialize(type, children = [], properties = {})
+        @mutable_attributes = {}
+        super
+        # children could be nil for s(:array)
+        Array(children).each do |child_node|
+          if child_node.is_a?(Parser::AST::Node)
+            child_node.parent = self
+          end
+        end
+      end
+
+      # Get the parent node.
+      # @return [Parser::AST::Node] parent node.
+      def parent
+        @mutable_attributes[:parent]
+      end
+
+      # Set the parent node.
+      # @param node [Parser::AST::Node] parent node.
+      def parent=(node)
+        @mutable_attributes[:parent] = node
+      end
+
+      # Get the sibling nodes.
+      # @return [Array<Parser::AST::Node>] sibling nodes.
+      def siblings
+        index = parent.children.index(self)
+        parent.children[index + 1..]
+      end
+
+      # Dyamically defined method
+      # caller, key, left_value, message, name, pairs, parent_class, parent_const, receivr, rgith_value and value.
+      # based on const TYPE_CHILDREN.
+      %i[
+        caller
+        key
+        left_value
+        message
+        name
+        pairs
+        parent_class
+        parent_const
+        receiver
+        right_value
+        value
+      ].each do |method_name|
+        define_method(method_name) do
+          index = TYPE_CHILDREN[type]&.index(method_name)
+          return children[index] if index
+
+          raise Synvert::Core::MethodNotSupported, "#{method_name} is not handled for #{debug_info}"
+        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 [Synvert::Core::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}"
+      end
+
+      # Get arguments of node.
+      # It supports :block, :csend, :def, :defined?, :defs and :send 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")))]
+      # @return [Array<Parser::AST::Node>] arguments of node.
+      # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+      def arguments
+        case type
+        when :def, :block
+          children[1].children
+        when :defs
+          children[2].children
+        when :send, :csend
+          children[2..-1]
+        when :defined?
+          children
+        else
+          raise Synvert::Core::MethodNotSupported, "arguments is not handled for #{debug_info}"
+        end
+      end
+
+      # Get body of node.
+      # It supports :begin, :block, :class, :def, :defs and :module 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))]
+      # @return [Array<Parser::AST::Node>] body of node.
+      # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
+      def body
+        case type
+        when :begin
+          children
+        when :def, :block, :class, :module
+          return [] if children[2].nil?
+
+          :begin == 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]
+        else
+          raise Synvert::Core::MethodNotSupported, "body is not handled for #{debug_info}"
+        end
+      end
+
+      # Get condition of node.
+      # It supports :if node.
+      # @example
+      #   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.
+      def condition
+        if :if == type
+          children[0]
+        else
+          raise Synvert::Core::MethodNotSupported, "condition is not handled for #{debug_info}"
+        end
+      end
+
+      # Get keys of :hash node.
+      # @example
+      #   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.
+      def keys
+        if :hash == type
+          children.map { |child| child.children[0] }
+        else
+          raise Synvert::Core::MethodNotSupported, "keys is not handled for #{debug_info}"
+        end
+      end
+
+      # Get values of :hash node.
+      # @example
+      #   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.
+      def values
+        if :hash == type
+          children.map { |child| child.children[1] }
+        else
+          raise Synvert::Core::MethodNotSupported, "keys is not handled for #{debug_info}"
+        end
+      end
+    end
+  end
+end
+
+# Extend Parser::AST::Node.
+# {https://github.com/whitequark/parser/blob/master/lib/parser/ast/node.rb}
+#
+# Rules
+#
+# Synvert compares ast nodes with key / value pairs, each ast node has
+# multiple attributes, e.g. +receiver+, +message+ and +arguments+, it
+# matches only when all of key / value pairs match.
+#
+# +type: 'send', message: :include, arguments: ['FactoryGirl::Syntax::Methods']+
+#
+# Synvert does comparison based on the value type
+#
+# 1. if value is a symbol, then compares ast node value as symbol, e.g. +message: :include+
+# 2. if value is a string, then compares ast node original source code, e.g. +name: 'Synvert::Application'+
+# 3. if value is a regexp, then compares ast node original source code, e.g. +message: /find_all_by_/+
+# 4. if value is an array, then compares each ast node, e.g. +arguments: ['FactoryGirl::Syntax::Methods']+
+# 5. if value is nil, then check if ast node is nil, e.g. +arguments: [nil]+
+# 6. if value is true or false, then check if ast node is :true or :false, e.g. +arguments: [false]+
+# 7. if value is ast, then compare ast node directly, e.g. +to_ast: Parser::CurrentRuby.parse("self.class.serialized_attributes")+
+#
+# It can also compare nested key / value pairs, like
+#
+# +type: 'send', receiver: { type: 'send', receiver: { type: 'send', message: 'config' }, message: 'active_record' }, message: 'identity_map='+
+#
+# Source Code to Ast Node
+# {https://synvert-playground.xinminlabs.com/ruby}
+class Parser::AST::Node
+  include ParserNodeExt
+end

data/parser_node_ext.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "lib/parser_node_ext/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "parser_node_ext"
+  spec.version = ParserNodeExt::VERSION
+  spec.authors = ["Richard Huang"]
+  spec.email = ["flyerhzm@gmail.com"]
+
+  spec.summary = "extend parser node"
+  spec.description = "extend parser node, add parent and sibling, use meaning properties to get child node"
+  spec.homepage = "https://github.com/xinminlabs/parser_node_ext"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/xinminlabs/parser_node_ext"
+  spec.metadata["changelog_uri"] = "https://github.com/xinminlabs/parser_node_ext/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "parser"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/sig/parser_node_ext.rbs

@@ -0,0 +1,18 @@
+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
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: parser_node_ext
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Richard Huang
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: extend parser node, add parent and sibling, use meaning properties to
+  get child node
+email:
+- flyerhzm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/parser_node_ext.rb
+- lib/parser_node_ext/version.rb
+- parser_node_ext.gemspec
+- sig/parser_node_ext.rbs
+homepage: https://github.com/xinminlabs/parser_node_ext
+licenses: []
+metadata:
+  homepage_uri: https://github.com/xinminlabs/parser_node_ext
+  source_code_uri: https://github.com/xinminlabs/parser_node_ext
+  changelog_uri: https://github.com/xinminlabs/parser_node_ext/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: extend parser node
+test_files: []