masamune-ast 1.1.2 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cafe74abe55158e29178163ef544558f8e8d042d8adae0668a8625e1883c843
-  data.tar.gz: f0068f9e6783403ba0d17f65902c0ecfded0806424383c8d325168ce0b4c7a58
+  metadata.gz: 34d1bcf1f5fc587393f5ded22b65afb26d64217253dcea0d83ea483574988326
+  data.tar.gz: 21f726e99d53494fb50c08012962156245a37920425fae2ab338946d463f2721
 SHA512:
-  metadata.gz: b6647c5ea9745d2e1f842a0d0eea3de05e795c7afa9a3241cf9d6a87dd802c4c62e7c9fdb266afcbc8e54ffe51af25d9bacc32830d4f28009f9c34b2a4f733a8
-  data.tar.gz: d7781f44d57a0bca23d7a61eaed10cdb687431a66540433ac0e01f43c6a625cd05aea2cd06168b1ea980d2fffaa827634ba3633ca8a94950df2110a60d4f9f5c
+  metadata.gz: 2cca246c5770392976a5b9b9a577ac90a7363c8972bbf954f76493b13dfebbc16e3c3eeb3230238e348fa77f11accadf326fb774d11a40d03aaf172e15f9a946
+  data.tar.gz: 9da6db975cdd75e0a3fc57056bcb2908054a54f90da996660d4fca46e967e64aa5431a78e118b8a264ca4749f421fc7dc667626da5b6e28b7d724656d7bca241

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    masamune-ast (1.1.2)
+    masamune-ast (1.1.4)
       activesupport
 
 GEM

data/README.md

@@ -33,7 +33,7 @@ code = <<~CODE
 CODE
 
 msmn = Masamune::AbstractSyntaxTree.new(code)
-msmn.replace(type: :variables, old_token: "n", new_token: "foo")
+msmn.replace(type: :variable, old_token: "n", new_token: "foo")
 
 # This will produce the following code in string form.
 10.times do |foo|
@@ -88,9 +88,9 @@ CODE
 msmn = Masamune::AbstractSyntaxTree.new(code)
 
 msmn.all_methods
-#=> [{:position=>[6, 4], :token=>"foo"},
-#=> {:position=>[2, 4], :token=>"sum"},
+#=> [{:position=>[2, 4], :token=>"sum"},
 #=> {:position=>[2, 8], :token=>"times"},
+#=> {:position=>[6, 4], :token=>"foo"},
 #=> {:position=>[8, 0], :token=>"foo"},
 #=> {:position=>[9, 0], :token=>"foo"}]
 
@@ -104,6 +104,39 @@ msmn.method_definitions
 #=> [{:position=>[6, 4], :token=>"foo"}]
 ```
 
+You can also return the node classes themselves and get the data from there:
+```ruby
+code = <<~CODE
+  "ruby"
+  "rails"
+CODE
+
+msmn = Masamune::AbstractSyntaxTree.new(code)
+msmn.strings(result_type: :nodes)
+#=> [#<Masamune::AbstractSyntaxTree::StringContent:0x00007f6f7c9a6850
+#=>  @ast_id=1440,
+#=>  @contents=[:string_content, [:@tstring_content, "ruby", [1, 1]]],
+#=>  @data_nodes=
+#=>   [#<Masamune::AbstractSyntaxTree::DataNode:0x00007f6f7c9a6828
+#=>     @ast_id=1440,
+#=>     @contents=[:@tstring_content, "ruby", [1, 1]],
+#=>     @data_nodes=nil,
+#=>     @line_position=[1, 1],
+#=>     @token="ruby",
+#=>     @type=:@tstring_content>]>,
+#=> #<Masamune::AbstractSyntaxTree::StringContent:0x00007f6f7c9a5630
+#=>  @ast_id=1440,
+#=>  @contents=[:string_content, [:@tstring_content, "rails", [2, 1]]],
+#=>  @data_nodes=
+#=>   [#<Masamune::AbstractSyntaxTree::DataNode:0x00007f6f7c9a5608
+#=>     @ast_id=1440,
+#=>     @contents=[:@tstring_content, "rails", [2, 1]],
+#=>     @data_nodes=nil,
+#=>     @line_position=[2, 1],
+#=>     @token="rails",
+#=>     @type=:@tstring_content>]>]
+```
+
 In some cases, it can be easier to look at the given lex nodes to analyze your source code since you can easily see the index and the line position it's on:
 ```ruby
 msmn.lex_nodes

data/lib/masamune/abstract_syntax_tree/nodes/blocks/brace_block.rb

@@ -0,0 +1,13 @@
+# TODO: Add description.
+
+module Masamune
+  class AbstractSyntaxTree
+    class BraceBlock < Block
+      attr_accessor :ast_id
+
+      def initialize(contents, ast_id)
+        super
+      end
+    end
+  end
+end

data/lib/masamune/abstract_syntax_tree/nodes/blocks/do_block.rb

@@ -0,0 +1,13 @@
+# TODO: Add description.
+
+module Masamune
+  class AbstractSyntaxTree
+    class DoBlock < Block
+      attr_accessor :ast_id
+
+      def initialize(contents, ast_id)
+        super
+      end
+    end
+  end
+end

data/lib/masamune/abstract_syntax_tree/{program.rb → nodes/program.rb}

@@ -1,4 +1,4 @@
-# Program represents the top layer of the AST,
+# Program represents the top layer of the abstract syntax tree,
 # and the second element of the array houses the entire program.
 
 module Masamune

data/lib/masamune/abstract_syntax_tree/{do_block.rb → nodes/support_nodes/block.rb}

@@ -1,10 +1,9 @@
-# TODO: Add description.
+# DoBlock and BraceBlock share some of
+# the same logic, so we share that here.
 
 module Masamune
   class AbstractSyntaxTree
-    class DoBlock < Node
-      attr_accessor :ast_id
-
+    class Block < Node
       def initialize(contents, ast_id)
         super
       end

data/lib/masamune/abstract_syntax_tree/nodes/support_nodes/comment.rb

@@ -0,0 +1,25 @@
+# In the abstract syntax tree created by Ripper.sexp,
+# the type for comments is :void_stmt, and it doesn't have
+# a data node within it either. This means that the text
+# for the comment doesn't exist in the ast. It DOES exist
+# in LexNode though, so we grab from them there instead.
+
+module Masamune
+  class AbstractSyntaxTree
+    class Comment < Node
+      def initialize(contents, ast_id)
+        super
+
+        # Since this is techincally supposed to be a :void_stmt
+        # in this ast, we just leave this as nil.
+        @contents = nil
+      end
+
+      def extract_data_nodes
+        [
+          DataNode.new([contents.type, contents.token, contents.position], @ast_id)
+        ]
+      end
+    end
+  end
+end

data/lib/masamune/abstract_syntax_tree/nodes/symbol.rb

@@ -0,0 +1,17 @@
+# TODO: Add description.
+
+module Masamune
+  class AbstractSyntaxTree
+    class Symbol < Node
+      def initialize(contents, ast_id)
+        super
+      end
+
+      def extract_data_nodes
+        [
+          DataNode.new(@contents[1], @ast_id)
+        ]
+      end
+    end
+  end
+end

data/lib/masamune/abstract_syntax_tree/nodes/symbols/dyna_symbol.rb

@@ -0,0 +1,20 @@
+# TODO: Add description.
+
+module Masamune
+  class AbstractSyntaxTree
+    class DynaSymbol < Node
+      def initialize(contents, ast_id)
+        super
+      end
+
+      # Dyna Symbols are symbols created from strings, i.e. - :"project".
+      # Since they have :@tstring_content inside of them, the data node
+      # is technically for a String, so instead of duplicating it here,
+      # we just use a method specifically for getting the symbol.
+      # This should be the same as the :symbol_literal type.
+      def get_symbol_data
+        DataNode.new(@contents[1][1], @ast_id)
+      end
+    end
+  end
+end

data/lib/masamune/abstract_syntax_tree/nodes/symbols/symbol_literal.rb

@@ -0,0 +1,21 @@
+# TODO: Add description.
+
+module Masamune
+  class AbstractSyntaxTree
+    class SymbolLiteral < Node
+      def initialize(contents, ast_id)
+        super
+      end
+
+      # Symbol Literals are a node type of :symbol_literal,
+      # but have a node type of :symbol nested within them.
+      # For the reason, the data node is technically for :symbol
+      # and not :symbol_literal, so instead of duplicating it here,
+      # we just use a method specifically for getting the symbol.
+      # This should be the same as the :dyna_symbol type.
+      def get_symbol_data
+        DataNode.new(@contents[1][1], @ast_id)
+      end
+    end
+  end
+end

data/lib/masamune/abstract_syntax_tree/{block_var.rb → nodes/variables/block_var.rb}

@@ -11,7 +11,7 @@ module Masamune
 
       # :block_var has a lot of nil values within in.
       # I'm not sure what this represents, but it would be
-      # nice to find out and implement it document/implement it somewhere.
+      # nice to find out and document/implement it somewhere.
       def extract_data_nodes
         @contents[1][1].map do |content|
           DataNode.new(content, @ast_id)

data/lib/masamune/abstract_syntax_tree.rb

@@ -1,6 +1,6 @@
 module Masamune
   class AbstractSyntaxTree
-    attr_reader :code, :tree
+    attr_reader :code, :tree, :comment_list
     attr_accessor :node_list, :data_node_list, :lex_nodes
 
     def initialize(code)
@@ -13,7 +13,12 @@ module Masamune
 
       @node_list = []
       @data_node_list = []
+      @comment_list = []
       register_nodes(@tree)
+
+      # Refer to Masamune::AbstractSyntaxTree::Comment
+      # to see why we register these separately.
+      register_comments
     end
 
     def register_nodes(tree_node = self.tree)
@@ -36,30 +41,43 @@ module Masamune
       end
     end
 
+    def register_comments
+      comment_lex_nodes = @lex_nodes.select {|node| node.type == :comment}.flatten
+      @comment_list << comment_lex_nodes.map {|node| Comment.new(node, self.__id__)}
+      @comment_list.flatten!
+    end
+
+    # TODO: A lot of these methods have the same content,
+    # so I want to come up with a way to refactor these.
+
     # TODO: Add block_params: true to the arguments.
-    def variables(name: nil)
+    def variables(name: nil, result_type: Hash)
       var_classes = [
         :var_field,
         :var_ref,
         :params
       ].map {|type| get_node_class(type)}
-      find_nodes(var_classes, token: name)
+      results = find_nodes(var_classes, token: name, result_type: result_type)
+      order_results(results)
     end
 
-    def strings(content: nil)
-      find_nodes(get_node_class(:string_content), token: content)
+    def strings(content: nil, result_type: Hash)
+      results = find_nodes(get_node_class(:string_content), token: content, result_type: result_type)
+      order_results(results)
     end
 
-    def method_definitions(name: nil)
-      find_nodes(get_node_class(:def), token: name)
+    def method_definitions(name: nil, result_type: Hash)
+      results = find_nodes(get_node_class(:def), token: name, result_type: result_type)
+      order_results(results)
     end
 
-    def method_calls(name: nil)
+    def method_calls(name: nil, result_type: Hash)
       method_classes = [
         :vcall,
         :call
       ].map {|type| get_node_class(type)}
-      find_nodes(method_classes, token: name)
+      results = find_nodes(method_classes, token: name, result_type: result_type)
+      order_results(results)
     end
 
     # TODO
@@ -70,37 +88,56 @@ module Masamune
     def brace_block_params
     end
 
-    # @tree only shows comments as a type of `:void_stmt` and
-    # doesn't have a data node, so we get comments from @lex_nodes.
-    def comments(content: nil)
-      comments = @lex_nodes.select {|node| node.type == :comment}
-      comments.select {|comment| comment.token == content} if content
-      comments.map {|comment| {position: comment.position, token: comment.token}}
+    def symbols(content: nil, result_type: Hash)
+      results = symbol_literals(content: content, result_type: result_type) + string_symbols(content: content, result_type: result_type)
+      order_results(results)
+    end
+
+    def symbol_literals(content: nil, result_type: Hash)
+      results = find_nodes(get_node_class(:symbol_literal), token: content, result_type: result_type)
+      order_results(results)
+    end
+
+    def string_symbols(content: nil, result_type: Hash)
+      results = find_nodes(get_node_class(:dyna_symbol), token: content, result_type: result_type)
+      order_results(results)
     end
 
-    def all_methods
-      method_definitions + method_calls
+    def comments(content: nil, result_type: Hash)
+      results = find_nodes(get_node_class(:comment), token: content, result_type: result_type)
+      order_results(results)
     end
 
-    def block_params
+    def all_methods(name: nil, result_type: Hash)
+      results = method_definitions(name: name, result_type: result_type) + method_calls(name: name, result_type: result_type)
+      order_results(results)
+    end
+
+    def block_params(content: nil, result_type: Hash)
       # TODO: do_block_params + brace_block_params
-      find_nodes(get_node_class(:params))
+      results = find_nodes(get_node_class(:params), token: content, result_type: result_type)
+      order_results(results)
     end
 
-    # TODO: Create an option to return a list of DataNode class instances.
-    def find_nodes(token_classes, token: nil)
+    def find_nodes(token_classes, token: nil, result_type: Hash)
       # Ensure the classes are in an array
       token_classes = [token_classes].flatten
 
       nodes = []
       token_classes.each do |klass|
-        nodes << @node_list.select {|node| node.class == klass}
+        if klass == Masamune::AbstractSyntaxTree::Comment
+          nodes = @comment_list.dup
+        else
+          nodes << @node_list.select {|node| node.class == klass}
+        end
       end
 
       # Searching for multiple classes will yield multi-dimensional arrays,
       # so we ensure everything is flattened out before moving forward.
       nodes.flatten!
 
+      return nodes if result_type == :nodes
+
       if token
         # TODO: This most likely shouldn't be `node.data_nodes.first`.
         # There are probably more data_nodes we need to check depending on the node class.
@@ -109,10 +146,19 @@ module Masamune
 
       final_result = []
       nodes.each do |node|
-        node.data_nodes.each {|dn| final_result << dn.position_and_token} if node.data_nodes
+        # Data for symbols are housed within a nested node, so we handle those differently here.
+        # Read the comments for `get_symbol_data` in the symbol node classes for details.
+        if node.class == Masamune::AbstractSyntaxTree::SymbolLiteral || node.class == Masamune::AbstractSyntaxTree::DynaSymbol
+          final_result << node.get_symbol_data.position_and_token
+        else
+          node.data_nodes.each {|dn| final_result << dn.position_and_token} if node.data_nodes
+        end
       end
 
-      DataNode.order_results_by_position(final_result)
+      # Only order the information if we're returning hashes.
+      # TODO: We might want to change the placement of order_results_by_position
+      # if the operation is being done against hashes and not data nodes.
+      nodes.first.class.is_a?(Hash) ? DataNode.order_results_by_position(final_result) : final_result
     end
 
     def replace(type:, old_token:, new_token:)
@@ -136,5 +182,16 @@ module Masamune
         Node
       end
     end
+
+    # We only order results when they are a Hash.
+    # The contents from the Hash are pulled from data nodes.
+    # i.e. - {position: [4, 7], token: "project"}
+    def order_results(results)
+      if results.first.is_a?(Hash)
+        DataNode.order_results_by_position(results)
+      else
+        results
+      end
+    end
   end
 end

data/lib/masamune/slasher.rb

@@ -3,8 +3,9 @@ module Masamune
     def self.replace(type:, old_token:, new_token:, code:, ast:)
       # `type` can either be a method from the ast like `method_definitions`,
       # or it can be a list of Masamune::AbstractSyntaxTree node classes.
-      position_and_token_ary = if type.is_a?(Symbol) && ast.respond_to?(type)
-        ast.send(type)
+      position_and_token_ary = if type.is_a?(Symbol)
+        type_to_method = type.to_s.pluralize.to_sym
+        ast.send(type_to_method)
       elsif type.is_a?(Array)
         type.map {|klass| ast.find_nodes(klass)}.flatten
       end

data/lib/masamune/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Masamune
-  VERSION = "1.1.2"
+  VERSION = "1.1.4"
 end

data/lib/masamune.rb

@@ -9,19 +9,24 @@ require "masamune/abstract_syntax_tree"
 require "masamune/abstract_syntax_tree/node"
 require "masamune/abstract_syntax_tree/data_node"
 
-# Node Types
-require "masamune/abstract_syntax_tree/assign"
-require "masamune/abstract_syntax_tree/block_var"
-require "masamune/abstract_syntax_tree/brace_block"
-require "masamune/abstract_syntax_tree/call"
-require "masamune/abstract_syntax_tree/def"
-require "masamune/abstract_syntax_tree/do_block"
-require "masamune/abstract_syntax_tree/params"
-require "masamune/abstract_syntax_tree/program"
-require "masamune/abstract_syntax_tree/string_content"
-require "masamune/abstract_syntax_tree/var_field"
-require "masamune/abstract_syntax_tree/var_ref"
-require "masamune/abstract_syntax_tree/vcall"
+require "masamune/abstract_syntax_tree/nodes/support_nodes/block"
+require "masamune/abstract_syntax_tree/nodes/support_nodes/comment"
+
+require "masamune/abstract_syntax_tree/nodes/blocks/brace_block"
+require "masamune/abstract_syntax_tree/nodes/blocks/do_block"
+require "masamune/abstract_syntax_tree/nodes/symbols/dyna_symbol"
+require "masamune/abstract_syntax_tree/nodes/symbols/symbol_literal"
+require "masamune/abstract_syntax_tree/nodes/variables/block_var"
+require "masamune/abstract_syntax_tree/nodes/variables/var_field"
+require "masamune/abstract_syntax_tree/nodes/variables/var_ref"
+require "masamune/abstract_syntax_tree/nodes/assign"
+require "masamune/abstract_syntax_tree/nodes/call"
+require "masamune/abstract_syntax_tree/nodes/def"
+require "masamune/abstract_syntax_tree/nodes/params"
+require "masamune/abstract_syntax_tree/nodes/program"
+require "masamune/abstract_syntax_tree/nodes/string_content"
+require "masamune/abstract_syntax_tree/nodes/symbol"
+require "masamune/abstract_syntax_tree/nodes/vcall"
 
 require "pp"
 require "pry"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: masamune-ast
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.4
 platform: ruby
 authors:
 - Gabriel Zayas
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-06-03 00:00:00.000000000 Z
+date: 2023-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -40,20 +40,25 @@ files:
 - Rakefile
 - lib/masamune.rb
 - lib/masamune/abstract_syntax_tree.rb
-- lib/masamune/abstract_syntax_tree/assign.rb
-- lib/masamune/abstract_syntax_tree/block_var.rb
-- lib/masamune/abstract_syntax_tree/brace_block.rb
-- lib/masamune/abstract_syntax_tree/call.rb
 - lib/masamune/abstract_syntax_tree/data_node.rb
-- lib/masamune/abstract_syntax_tree/def.rb
-- lib/masamune/abstract_syntax_tree/do_block.rb
 - lib/masamune/abstract_syntax_tree/node.rb
-- lib/masamune/abstract_syntax_tree/params.rb
-- lib/masamune/abstract_syntax_tree/program.rb
-- lib/masamune/abstract_syntax_tree/string_content.rb
-- lib/masamune/abstract_syntax_tree/var_field.rb
-- lib/masamune/abstract_syntax_tree/var_ref.rb
-- lib/masamune/abstract_syntax_tree/vcall.rb
+- lib/masamune/abstract_syntax_tree/nodes/assign.rb
+- lib/masamune/abstract_syntax_tree/nodes/blocks/brace_block.rb
+- lib/masamune/abstract_syntax_tree/nodes/blocks/do_block.rb
+- lib/masamune/abstract_syntax_tree/nodes/call.rb
+- lib/masamune/abstract_syntax_tree/nodes/def.rb
+- lib/masamune/abstract_syntax_tree/nodes/params.rb
+- lib/masamune/abstract_syntax_tree/nodes/program.rb
+- lib/masamune/abstract_syntax_tree/nodes/string_content.rb
+- lib/masamune/abstract_syntax_tree/nodes/support_nodes/block.rb
+- lib/masamune/abstract_syntax_tree/nodes/support_nodes/comment.rb
+- lib/masamune/abstract_syntax_tree/nodes/symbol.rb
+- lib/masamune/abstract_syntax_tree/nodes/symbols/dyna_symbol.rb
+- lib/masamune/abstract_syntax_tree/nodes/symbols/symbol_literal.rb
+- lib/masamune/abstract_syntax_tree/nodes/variables/block_var.rb
+- lib/masamune/abstract_syntax_tree/nodes/variables/var_field.rb
+- lib/masamune/abstract_syntax_tree/nodes/variables/var_ref.rb
+- lib/masamune/abstract_syntax_tree/nodes/vcall.rb
 - lib/masamune/lex_node.rb
 - lib/masamune/slasher.rb
 - lib/masamune/version.rb

data/lib/masamune/abstract_syntax_tree/brace_block.rb

@@ -1,19 +0,0 @@
-# TODO: Add description.
-
-module Masamune
-  class AbstractSyntaxTree
-    class BraceBlock < Node
-      attr_accessor :ast_id
-
-      def initialize(contents, ast_id)
-        super
-      end
-
-      def params
-        # This node should exist already, so we search for it in the ast object.
-        block_var = BlockVar.new(contents[1], ast_id)
-        ast.node_list.find {|node| node.contents == block_var.contents}
-      end
-    end
-  end
-end