masamune-ast 1.0.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 418c2c9ca6e229ff03320d7057ff12f19cdbb60d3da8b9f1d03db901b6971b43
-  data.tar.gz: 3dda8f6d319d4ce961a8f9b3421d73bea5a8462c8c740b0c1f6e37e25e3020a1
+  metadata.gz: a00f60e535cf2096a37cd6efd639aa7c132c70e58c3b422a23538128368b5c85
+  data.tar.gz: 5d548fc4b9d5cf25c1099a2b446542f57342694d7b414052df004dcd2cf311c2
 SHA512:
-  metadata.gz: 165fb67094e4e12730106dd7262d4d8be67db9d7994ca96c5d94a46d2334c0c62d1aa9fab64637e9290e3aff6f7a8c8b913580b4ae3e2ed4584b52f40a82d55a
-  data.tar.gz: '006920de6a9409d6a08f6cfe955f918e8411c267665559aec9847fddffb6c514ca9283db8efbe73d8098f687c274d06439ffd681a817172ac5e7216fd61ef774'
+  metadata.gz: c80bcefac510bfd4103d56fd13f39a46d1e4531eceb678d620709b97fe0c941f20f1e7ffddc6058e77aab46ab093d1d4ba768b6860649c5a57197e36f89bf109
+  data.tar.gz: 731a46f94d655a820acdd949d7d7fa03f3fc37277858b5b5daea3c0c13444720b3b1ca829d0f304d5aecb3f390e3055168503ce6655653268cb89fcf19ab28e3

data/Gemfile.lock

@@ -1,18 +1,29 @@
 PATH
   remote: .
   specs:
-    masamune-ast (1.0.0)
+    masamune-ast (1.1.1)
+      activesupport
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (7.0.4.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
     coderay (1.1.3)
+    concurrent-ruby (1.2.2)
+    i18n (1.13.0)
+      concurrent-ruby (~> 1.0)
     method_source (1.0.0)
     minitest (5.18.0)
     pry (0.14.2)
       coderay (~> 1.1)
       method_source (~> 1.0)
     rake (13.0.6)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
 
 PLATFORMS
   x86_64-linux

data/README.md

@@ -13,8 +13,38 @@ Or add the following to your Gemfile and run `bundle install`
 gem "masamune-ast"
 ```
 
+Then require the gem in a file like this:
+```ruby
+require "masamune"
+```
+
 ## Usage
 
+Isolate and replace variables, methods, or strings in your Ruby source code according to the specific tokens allotted when the code is intially parsed:
+```ruby
+code = <<~CODE
+  10.times do |n|
+    puts n
+  end
+
+  def n
+    "n"
+  end
+CODE
+
+msmn = Masamune::AbstractSyntaxTree.new(code)
+msmn.replace(type: :variables, old_token: "n", new_token: "foo")
+
+# This will produce the following code in string form.
+10.times do |foo|
+  puts foo
+end
+
+def n
+  "n"
+end
+```
+
 Pinpoint variables and methods in your source code even when other tokens have the same or similar spelling:
 ```ruby
 code = <<CODE
@@ -26,12 +56,22 @@ CODE
 
 msmn = Masamune::AbstractSyntaxTree.new(code)
 
-# Searching the tree returns the specific node and the line number it's on.
 msmn.variables
-#=> [[[1, 0], "java"], [[2, 0], "javascript"], [[2, 13], "java"]]
-
-msmn.search(:variable, "java")
-#=> [[[1, 0], "java"], [[2, 13], "java"]]
+#=> [{:position=>[1, 0], :token=>"java"},
+#=> {:position=>[2, 0], :token=>"javascript"},
+#=> {:position=>[2, 13], :token=>"java"},
+#=> {:position=>[3, 5], :token=>"java"},
+#=> {:position=>[3, 25], :token=>"javascript"}]
+
+msmn.strings
+#=> [{:position=>[1, 8], :token=>"java"},
+#=> {:position=>[2, 21], :token=>"script"},
+#=> {:position=>[3, 13], :token=>" is not "}]
+
+msmn.variables(name: "java")
+#=> [{position: [1, 0], token: "java"},
+#=> {position: [2, 13], token: "java"},
+#=> {position: [3, 5], token: "java"}]
 
 code = <<CODE
 ary = [1, 2, 3]
@@ -47,43 +87,42 @@ CODE
 
 msmn = Masamune::AbstractSyntaxTree.new(code)
 
-msmn.search(:method_call, "sum")
-#=> [[[2, 4], "sum"]]
-
-msmn.search(:def, "foo")
-#=> [[[6, 4], "foo"]]
-
-msmn.search(:method_call, "foo")
-#=> [[[8, 0], "foo"], [[9, 0], "foo"]]
+msmn.all_methods
+#=> [{:position=>[6, 4], :token=>"foo"},
+#=> {:position=>[2, 4], :token=>"sum"},
+#=> {:position=>[2, 8], :token=>"times"},
+#=> {:position=>[8, 0], :token=>"foo"},
+#=> {:position=>[9, 0], :token=>"foo"}]
+
+msmn.method_calls
+#=> [{:position=>[2, 4], :token=>"sum"},
+#=> {:position=>[2, 8], :token=>"times"},
+#=> {:position=>[8, 0], :token=>"foo"},
+#=> {:position=>[9, 0], :token=>"foo"}]
+
+msmn.method_definitions
+#=> [{:position=>[6, 4], :token=>"foo"}]
 ```
 
-In some cases, it can be easier to look at the given lex nodes to analyze your source code:
+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
 => [#<Masamune::LexNode:0x00007fd61810cac0 @ast_id=1200, @index=0, @position=[1, 0], @state=CMDARG, @token="java", @type=:ident>,
  #<Masamune::LexNode:0x00007fd61810c930 @ast_id=1200, @index=1, @position=[1, 4], @state=CMDARG, @token=" ", @type=:sp>,
  #<Masamune::LexNode:0x00007fd61810c7c8 @ast_id=1200, @index=2, @position=[1, 5], @state=BEG, @token="=", @type=:op>,
- #<Masamune::LexNode:0x00007fd61810c638 @ast_id=1200, @index=3, @position=[1, 6], @state=BEG, @token=" ", @type=:sp>,
- #<Masamune::LexNode:0x00007fd61810c480 @ast_id=1200, @index=4, @position=[1, 7], @state=BEG, @token="\"", @type=:tstring_beg>,
- #<Masamune::LexNode:0x00007fd61810c318 @ast_id=1200, @index=5, @position=[1, 8], @state=BEG, @token="java", @type=:tstring_content>,
- #<Masamune::LexNode:0x00007fd61810c188 @ast_id=1200, @index=6, @position=[1, 12], @state=END, @token="\"", @type=:tstring_end>,
- #<Masamune::LexNode:0x00007fd61810c020 @ast_id=1200, @index=7, @position=[1, 13], @state=BEG, @token="\n", @type=:nl>,
- #<Masamune::LexNode:0x00007fd618113e88 @ast_id=1200, @index=8, @position=[2, 0], @state=CMDARG, @token="javascript", @type=:ident>,
- #<Masamune::LexNode:0x00007fd618113cf8 @ast_id=1200, @index=9, @position=[2, 10], @state=CMDARG, @token=" ", @type=:sp>,
- #<Masamune::LexNode:0x00007fd618113b68 @ast_id=1200, @index=10, @position=[2, 11], @state=BEG, @token="=", @type=:op>,
 …
 ]
 
-msmn.lex_nodes[8].is_variable?
+lex_node = msmn.lex_nodes.first
+
+lex_node.variable?
 #=> true
 
-msmn.lex_nodes[8].is_string?
+lex_node.string?
 #=> false
 
-msmn.lex_nodes[8].is_method_definition?
+lex_node.method_definition?
 #=> false
-
-# etc...
 ```
 
 ## Contributing

data/lib/masamune/abstract_syntax_tree/assign.rb

@@ -0,0 +1,11 @@
+# TODO: Add description.
+
+module Masamune
+  class AbstractSyntaxTree
+    class Assign < Node
+      def initialize(contents, ast_id)
+        super
+      end
+    end
+  end
+end

data/lib/masamune/abstract_syntax_tree/block_var.rb

@@ -0,0 +1,22 @@
+# TODO: Add description.
+
+module Masamune
+  class AbstractSyntaxTree
+    class BlockVar < Node
+      attr_accessor :ast_id
+
+      def initialize(contents, ast_id)
+        super
+      end
+
+      # :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.
+      def extract_data_nodes
+        @contents[1][1].map do |content|
+          DataNode.new(content, @ast_id)
+        end
+      end
+    end
+  end
+end

data/lib/masamune/abstract_syntax_tree/brace_block.rb

@@ -0,0 +1,19 @@
+# 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

data/lib/masamune/abstract_syntax_tree/call.rb

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

data/lib/masamune/abstract_syntax_tree/data_node.rb

@@ -0,0 +1,62 @@
+# A data node represents an abstraction in the AST which has details about a specific type.
+# i.e. - [:@ident, "variable_name", [4, 7]]
+# These values are the `type`, `token`, and `position`, respectively.
+# It is simliar to what you see in `Ripper.lex(code)` and `Masamune::AbstractSyntaxTree's @lex_nodes`.
+
+# We break this down into a simpler structure, `position_and_token`,
+# which looks like this: {position: [4, 7], token: "ruby"}
+
+module Masamune
+  class AbstractSyntaxTree
+    class DataNode < Node
+      attr_reader :type, :token, :line_position
+
+      def initialize(contents, ast_id)
+        @type, @token, @line_position = contents
+        super(contents, ast_id)
+      end
+
+      # Results here represent the position and token of the
+      # data we're searching in the form of a Hash like the following:
+      # [
+      #   {position: [4, 7], token: "ruby"},
+      #   {position: [7, 7], token: "rails"}
+      # ]
+      # TODO: Worry about using a faster sorting algorithm later.
+      def self.order_results_by_position(position_and_token_ary)
+        # Extract the line numbers first, i.e - 4 from [4, 7]
+        line_numbers = position_and_token_ary.map do |position_and_token|
+          line_number = position_and_token[:position].first
+        end.uniq.sort
+
+        final_result = []
+        line_numbers.each do |line_number|
+          # Group data together in an array if they're on the same line.
+          shared_line_data = position_and_token_ary.select do |position_and_token|
+            position_and_token[:position].first == line_number
+          end
+
+          # Sort the positions on each line number respectively.
+          positions_on_line = shared_line_data.map do |position_and_token|
+            position_and_token[:position].last
+          end.sort
+
+          # Apply to the final result.
+          positions_on_line.each do |position_on_line|
+            shared_line_data.each do |position_and_token|
+              if position_and_token[:position].last == position_on_line
+                final_result << position_and_token
+              end
+            end
+          end
+        end
+
+        final_result
+      end
+
+      def position_and_token
+        {position: @line_position, token: @token}
+      end
+    end
+  end
+end

data/lib/masamune/abstract_syntax_tree/def.rb

@@ -0,0 +1,17 @@
+# TODO: Add description.
+
+module Masamune
+  class AbstractSyntaxTree
+    class Def < 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/do_block.rb

@@ -0,0 +1,19 @@
+# TODO: Add description.
+
+module Masamune
+  class AbstractSyntaxTree
+    class DoBlock < 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

data/lib/masamune/abstract_syntax_tree/node.rb

@@ -0,0 +1,41 @@
+# TODO: Add description
+
+module Masamune
+  class AbstractSyntaxTree
+    class Node
+      attr_reader :ast_id, :contents, :index_stack, :data_nodes
+
+      def initialize(contents, ast_id)
+        @ast_id = ast_id
+        @contents = contents
+        @data_nodes = extract_data_nodes
+      end
+
+      def ast
+        ObjectSpace._id2ref(@ast_id)
+      end
+
+      # TODO: Consider removing the :type and :typeless methods.
+
+      # Ripper's abstract syntax tree nodes are either typed or typeless.
+      # Types consist of values such as :def, :do_block, :var_ref, etc.
+      # Typed nodes house one of these types as its first element,
+      # whereas typeless nodes simply have arrays as top-level elements.
+      # Example of a typed node: [:@tstring_content, "ruby", [4, 7]]
+      def typed?
+        @contents.is_a?(Array) && @contents.first.is_a?(Symbol)
+      end
+
+      def typeless?
+        !typed?
+      end
+
+      # By default, we assume a node has no data nodes to extract.
+      # Because the structure for each node is different, we handle
+      # extraction separately for each node within its respective class.
+      def extract_data_nodes
+        # TODO: Might want to make this [] instead of nil.
+      end
+    end
+  end
+end

data/lib/masamune/abstract_syntax_tree/params.rb

@@ -0,0 +1,23 @@
+# TODO: Add description.
+
+module Masamune
+  class AbstractSyntaxTree
+    class Params < Node
+      def initialize(contents, ast_id)
+        super
+      end
+
+      def extract_data_nodes
+        # TODO: Sometimes the params node looks like this:
+        # [:params, nil, nil, nil, nil, nil, nil, nil]
+        # Add a description for this, and review this portion
+        # to ensure that it's being handled properly.
+        unless @contents[1].nil?
+          @contents[1].map do |content|
+            DataNode.new(content, @ast_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/masamune/abstract_syntax_tree/program.rb

@@ -0,0 +1,16 @@
+# Program represents the top layer of the AST,
+# and the second element of the array houses the entire program.
+
+module Masamune
+  class AbstractSyntaxTree
+    class Program < Node
+      def initialize(contents, ast_id)
+        super
+      end
+
+      def extract_data_nodes
+        # No data nodes to extract.
+      end
+    end
+  end
+end

data/lib/masamune/abstract_syntax_tree/string_content.rb

@@ -0,0 +1,17 @@
+# TODO: Add description.
+
+module Masamune
+  class AbstractSyntaxTree
+    class StringContent < 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/var_field.rb

@@ -0,0 +1,17 @@
+# TODO: Add description.
+
+module Masamune
+  class AbstractSyntaxTree
+    class VarField < 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/var_ref.rb

@@ -0,0 +1,19 @@
+# TODO: Add description.
+
+module Masamune
+  class AbstractSyntaxTree
+    class VarRef < Node
+      attr_accessor :ast_id
+
+      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/vcall.rb

@@ -0,0 +1,17 @@
+# TODO: Add description.
+
+module Masamune
+  class AbstractSyntaxTree
+    class Vcall < 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.rb

@@ -0,0 +1,132 @@
+module Masamune
+  class AbstractSyntaxTree
+    attr_reader :code, :tree
+    attr_accessor :node_list, :data_node_list, :lex_nodes
+
+    def initialize(code)
+      @code = code
+      @tree = Ripper.sexp(code)
+      raw_lex_nodes = Ripper.lex(code)
+      @lex_nodes = raw_lex_nodes.map do |lex_node|
+        LexNode.new(raw_lex_nodes.index(lex_node), lex_node, self.__id__)
+      end
+
+      @node_list = []
+      @data_node_list = []
+      register_nodes(@tree)
+    end
+
+    def register_nodes(tree_node = self.tree)
+      if tree_node.is_a?(Array)
+        klass = get_node_class(tree_node.first)
+        msmn_node = klass.new(tree_node, self.__id__)
+      else
+        # Create a general node if the node is a single value.
+        msmn_node = Node.new(tree_node, self.__id__)
+      end
+
+      # Register nodes and any data nodes housed within it.
+      # See Masamune::AbstractSyntaxTree::DataNode for more details on what a data node is.
+      @node_list << msmn_node
+      msmn_node.data_nodes.each { |dn| @data_node_list << dn } if msmn_node.data_nodes
+
+      # Continue down the tree until base case is reached.
+      if !msmn_node.nil? && msmn_node.contents.is_a?(Array)
+        msmn_node.contents.each { |node| register_nodes(node) }
+      end
+    end
+
+    # TODO: Add block_params: true to the arguments.
+    def variables(name: nil)
+      var_classes = [
+        :var_field,
+        :var_ref,
+        :params
+      ].map {|type| get_node_class(type)}
+      find_nodes(var_classes, token: name)
+    end
+
+    def strings(content: nil)
+      find_nodes(get_node_class(:string_content), token: content)
+    end
+
+    def method_definitions(name: nil)
+      find_nodes(get_node_class(:def), token: name)
+    end
+
+    def method_calls(name: nil)
+      method_classes = [
+        :vcall,
+        :call
+      ].map {|type| get_node_class(type)}
+      find_nodes(method_classes, token: name)
+    end
+
+    # TODO
+    def do_block_params
+    end
+
+    # TODO
+    def brace_block_params
+    end
+
+    def all_methods
+      method_definitions + method_calls
+    end
+
+    def block_params
+      # TODO: do_block_params + brace_block_params
+      find_nodes(get_node_class(:params))
+    end
+
+    # TODO: Create an option to return a list of DataNode class instances.
+    def find_nodes(token_classes, token: nil)
+      # 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}
+      end
+
+      # Searching for multiple classes will yield multi-dimensional arrays,
+      # so we ensure everything is flattened out before moving forward.
+      nodes.flatten!
+
+      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.
+        nodes = nodes.select {|node| node.data_nodes.first.token == token}.flatten
+      end
+
+      final_result = []
+      nodes.each do |node|
+        node.data_nodes.each {|dn| final_result << dn.position_and_token} if node.data_nodes
+      end
+
+      DataNode.order_results_by_position(final_result)
+    end
+
+    def replace(type:, old_token:, new_token:)
+      Slasher.replace(
+        type: type,
+        old_token: old_token,
+        new_token: new_token,
+        code: @code,
+        ast: self
+      )
+    end
+
+    private
+
+    def get_node_class(type)
+      begin
+        "Masamune::AbstractSyntaxTree::#{type.to_s.camelize}".constantize
+      rescue NameError
+        # For all other nodes that we haven't covered yet, we just make a general class.
+        # We can worry about adding the classes for other nodes as we go.
+        Node
+      end
+    end
+  end
+end

data/lib/{masamune-ast → masamune}/lex_node.rb

@@ -23,30 +23,31 @@ module Masamune
       ObjectSpace._id2ref(@ast_id)
     end
 
-    def is_variable?
-      return false unless is_identifier?
-      ast.search(:variable, @token).any?
+    def variable?
+      return false unless identifier?
+      ast.variables(name: @token).any?
     end
 
-    def is_method?
-      return false unless is_identifier?
-      is_method_definition? || is_method_call?
+    def method_definition?
+      ast.method_definitions(name: @token).any?
     end
 
-    def is_method_definition?
-      ast.search(:def, @token).any?
+    def method_call?
+      ast.method_calls(name: @token).any?
     end
 
-    def is_method_call?
-      ast.search(:method_call, @token).any?
+    def method?
+      return false unless identifier?
+      method_definition? || method_call?
     end
 
-    def is_identifier?
-      type == :ident
+    # TODO: I'm not sure how I feel about checking @type against the symbol directly.
+    def identifier?
+      @type == :ident
     end
 
-    def is_string?
-      type == :tstring_content
+    def string?
+      @type == :tstring_content
     end
   end
 end

data/lib/masamune/slasher.rb

@@ -0,0 +1,32 @@
+module Masamune
+  module Slasher
+    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)
+      elsif type.is_a?(Array)
+        type.map {|klass| ast.find_nodes(klass)}.flatten
+      end
+
+      tokens_to_replace = position_and_token_ary.select do |pos_and_tok|
+        pos_and_tok[:token] == old_token
+      end
+
+      # Build from lex nodes
+      result = ast.lex_nodes.map do |lex_node|
+        match_found = false
+        tokens_to_replace.each do |position_and_token|
+          if position_and_token[:position] == lex_node.position
+            match_found = true
+            break
+          end
+        end
+
+        match_found ? new_token : lex_node.token
+      end
+
+      result.join
+    end
+  end
+end

data/lib/{masamune-ast → masamune}/version.rb

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

data/lib/masamune.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "masamune/version"
+require "ripper"
+require "active_support/core_ext/string/inflections"
+require "masamune/lex_node"
+require "masamune/slasher"
+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 "pp"
+require "pry"
+
+module Masamune
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: masamune-ast
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Gabriel Zayas
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-05-01 00:00:00.000000000 Z
-dependencies: []
+date: 2023-06-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: A layer of abstraction on top of Ripper for handling Abstract Syntax
   Trees in Ruby.
 email:
@@ -24,13 +38,25 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- lib/masamune-ast.rb
-- lib/masamune-ast/abstract_syntax_tree.rb
-- lib/masamune-ast/abstract_syntax_tree/data_node.rb
-- lib/masamune-ast/abstract_syntax_tree/node.rb
-- lib/masamune-ast/lex_node.rb
-- lib/masamune-ast/slicer.rb
-- lib/masamune-ast/version.rb
+- 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/lex_node.rb
+- lib/masamune/slasher.rb
+- lib/masamune/version.rb
 - sig/masamune.rbs
 homepage: https://www.github.com/gazayas/masamune-ast
 licenses:

data/lib/masamune-ast/abstract_syntax_tree/data_node.rb

@@ -1,11 +0,0 @@
-# TODO: Not sure if I'll implement this yet.
-
-module Masamune
-  class AbstractSyntaxTree
-    class DataNode << Masamune::AbstractSyntaxTree::Node
-      def initialize(tree_node)
-        @parent, @contents, _ = tree_node
-      end
-    end
-  end
-end

data/lib/masamune-ast/abstract_syntax_tree/node.rb

@@ -1,16 +0,0 @@
-# TODO: Not sure if I'll implement this yet.
-
-module Masamune
-  class AbstractSyntaxTree
-    class Node
-      def initialize(tree_node)
-        @contents = tree_node
-      end
-
-      # i.e. - [:@ident, "variable_name", [4, 7]]
-      def is_data_node?
-        @contents[0].is_a?(Symbol) && @contents[1].is_a?(String) && (@contents[2][0].is_a?(Integer) && @contents[2][1].is_a?(Integer))
-      end
-    end
-  end
-end

data/lib/masamune-ast/abstract_syntax_tree.rb

@@ -1,121 +0,0 @@
-module Masamune
-  class AbstractSyntaxTree
-    attr_reader :data
-    attr_accessor :lex_nodes, :debug
-
-    def initialize(code)
-      @data = Ripper.sexp(code)
-      raw_lex_nodes = Ripper.lex(code)
-      @lex_nodes = raw_lex_nodes.map do |lex_node|
-        Masamune::LexNode.new(raw_lex_nodes.index(lex_node), lex_node, self.__id__)
-      end
-      @debug = false
-    end
-
-    def tree_nodes
-      raise "Set `debug` to `true` to display the tree nodes" unless @debug
-      search # Perform search with no conditions.
-    end
-
-    def variables
-      search(:variable)
-    end
-
-    def all_methods
-      method_definitions + method_calls
-    end
-
-    def method_definitions
-      search(:def)
-    end
-
-    def method_calls
-      search(:method_call)
-    end
-
-    def strings
-      search(:string)
-    end
-
-    def data_nodes
-      search(:data_node)
-    end
-
-    def search(type = nil, token = nil, tree_node = self.data, result = [])
-      return unless tree_node.is_a?(Array) || (tree_node.is_a?(Array) && tree_node.empty?)
-      debug_output(tree_node) if @debug
-
-      # If the first element is an array, then we're getting all arrays so we just continue the search.
-      if tree_node.first.is_a?(Array)
-        tree_node.each { |node| search(type, token, node, result) }
-      elsif tree_node.first.is_a?(Symbol)
-        # TODO: These two if statements bother me a lot.
-        # There should be a more effiecient/smart way to do this.
-        if has_data_node?(tree_node)
-          if (type == :variable && (tree_node.first == :var_field || tree_node.first == :var_ref)) ||
-             (type == :string && tree_node.first == :string_content) ||
-             (type == :def && tree_node.first == :def) ||
-             (type == :method_call && tree_node.first == :vcall)
-
-            # TODO: AbstractSyntaxTree::DataNode.new(tree_node)
-            # For most tree nodes, the data_node is housed in the second element.
-            position, data_node_token = data_node_parts(tree_node[1])
-
-            # Gather all results if token isn't specified.
-            result << [position, data_node_token] if token == data_node_token || token.nil?
-          end
-
-          # Continue search for all necessary elements.
-          case tree_node.first
-          when :def, :command
-            tree_node.each { |node| search(type, token, node, result) }
-          end
-
-        # The data nodes in :call nodes are in a different place within the array, so we handle that here.
-        # These :call nodes represent methods and chained methods like `[1, 2, 3].sum.times`.
-        elsif (type == :method_call && tree_node.first == :call)
-          # The method inside the [:call, ...] data node is the last element in the array.
-          position, data_node_token = data_node_parts(tree_node.last)
-          result << [position, data_node_token] if token == data_node_token || token.nil?
-          # The second element is where more :call nodes are nested, so we search it.
-          search(type, token, tree_node[1], result)
-        else
-          # Simply continue the search for all other nodes.
-          tree_node.each { |node| search(type, token, node, result) }
-        end
-      end
-
-      result
-    end
-
-    private
-
-    # A data node represents an abstraction in the AST which has details about a specific command.
-    # i.e. - [:@ident, "variable_name", [4, 7]]
-    # These values are the `type`, `token`, and `position`, respectively.
-    # It is simliar to what you see in `Ripper.lex(code)` and `Masamune::Base's @lex_nodes`.
-    # Data nodes serve as a base case when recursively searching the AST.
-    #
-    # The parent node's first element houses the type of action being performed:
-    # i.e. - [:assign, [:@ident, "variable_name", [4, 7]]]
-    # `has_data_node?` is performed on a parent node.
-    def has_data_node?(node)
-      node[1].is_a?(Array) && node[1][1].is_a?(String)
-    end
-
-    def data_node_parts(tree_node)
-      _, token, position = tree_node
-      [position, token]
-    end
-
-    def is_line_position?(tree_node)
-      tree_node.size == 2 && tree_node.first.is_a?(Integer) && tree_node.last.is_a?(Integer)
-    end
-
-    def debug_output(tree_node)
-      puts "==================================" # TODO: Track the array depth and output the number here.
-      puts "=================================="
-      p tree_node
-    end
-  end
-end

data/lib/masamune-ast/slicer.rb

@@ -1,19 +0,0 @@
-module Masamune
-  module Slicer
-    def initialize(ast)
-      @ast = ast
-    end
-
-    # TODO
-
-    # def replace(type, token)
-    #   @ast.search(type, token)
-    # end
-
-    # def insert_inside_block
-    # end
-
-    # def append_to_block
-    # end
-  end
-end

data/lib/masamune-ast.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "masamune-ast/version"
-require "ripper"
-require "masamune-ast/lex_node"
-require "masamune-ast/abstract_syntax_tree"
-
-require "pp"
-require "pry"
-
-module Masamune
-end