masamune-ast 1.1.3 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccb2d3e2f9229836db093e7d6e164a30a37302610835973bcba1bf63781d4869
-  data.tar.gz: afeba57c0b354caa8bb753c4dffdafc1aeca92b96997ec0345bd309c3c0cc33a
+  metadata.gz: cde8e5ad304fc141ebf9a19a2b14ca11bdb5a582f37946e7190888a142cbf800
+  data.tar.gz: 79cfd7151f94c22f78efd3fcfda3be6321b68a76ea5d5175b73ecd96b2ae2331
 SHA512:
-  metadata.gz: 63c3961e42d7ae3264eac44d6d7c6b43f572f95daa2d4c56077eace0baf2fb1a7259f6f149ce0ab0dc11a00d463f463ae246ba1a563e5a4ef83405e3d5910641
-  data.tar.gz: c130f31c0d73a54af8775f538c928ae71d55a456b8f2d715b690ef9cf2b1de906fd808e47d3ad668630817d038d255feefd2cc309c221e5b4de5e693bc844f5c
+  metadata.gz: 071e318a82a6c9df04ca33746f2f1e97ff2a49362e054621d7ff490bf727574bcd55648c6fcdd63ec6f49c5962eea009fbdce1acd6bc98d0f5d9bc35f3336d9e
+  data.tar.gz: 7bfd78af1aa7e621f343ef77521a2895921b449f944487518746b201ff3d925fe9e22645b17d7bd8fd83fcaf89463870f339bb2fa0a654c9bc9c9cf194bb2183

data/Gemfile.lock

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

data/README.md

@@ -1,6 +1,6 @@
 # Masamune
 
-## A Ruby source code analyzer based on Ripper’s Abstract Syntax Tree generator (`Ripper#sexp`).
+## A Ruby source code analyzer based on Ripper’s Abstract Syntax Tree generator.
 
 ## Installation
 
@@ -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,15 +88,17 @@ 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=>[3, 2], :token=>"puts"},
+#=> {:position=>[6, 4], :token=>"foo"},
 #=> {:position=>[8, 0], :token=>"foo"},
 #=> {:position=>[9, 0], :token=>"foo"}]
 
 msmn.method_calls
 #=> [{:position=>[2, 4], :token=>"sum"},
 #=> {:position=>[2, 8], :token=>"times"},
+#=> {:position=>[3, 2], :token=>"puts"},
 #=> {:position=>[8, 0], :token=>"foo"},
 #=> {:position=>[9, 0], :token=>"foo"}]
 
@@ -104,6 +106,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/data_node.rb

@@ -11,8 +11,9 @@ module Masamune
     class DataNode < Node
       attr_reader :type, :token, :line_position
 
-      def initialize(contents, ast_id)
+      def initialize(contents, ast_id, parent)
         @type, @token, @line_position = contents
+        @parent = parent
         super(contents, ast_id)
       end
 
@@ -26,7 +27,7 @@ module Masamune
       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
+          position_and_token[:position].first
         end.uniq.sort
 
         final_result = []

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/{call.rb → nodes/call.rb}

@@ -9,7 +9,7 @@ module Masamune
 
       def extract_data_nodes
         [
-          DataNode.new(@contents.last, @ast_id)
+          DataNode.new(@contents.last, @ast_id, self)
         ]
       end
     end

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

@@ -0,0 +1,64 @@
+# Code example:
+# puts "hello"
+#
+# syntax_tree output:
+# SyntaxTree::Command[
+#   message: SyntaxTree::Ident[value: "puts"],
+#   arguments: SyntaxTree::Args[
+#     parts: [
+#       SyntaxTree::StringLiteral[
+#         parts: [SyntaxTree::TStringContent[value: "greetings"]]
+#       ]
+#     ]
+#   ]
+# ]
+
+# Code example:
+# namespace :project
+#   resources :pages
+# end
+#
+# syntax_tree output:
+# SyntaxTree::Command[
+#   message: SyntaxTree::Ident[value: "namespace"],
+#   arguments: SyntaxTree::Args[
+#     parts: [SyntaxTree::SymbolLiteral[value: SyntaxTree::Ident[value: "project"]]]
+#   ],
+#   block: SyntaxTree::BlockNode[
+#     bodystmt: SyntaxTree::BodyStmt[
+#       statements: SyntaxTree::Statements[
+#         body: [
+#           SyntaxTree::Command[
+#             message: SyntaxTree::Ident[value: "resources"],
+#             arguments: SyntaxTree::Args[
+#               parts: [
+#                 SyntaxTree::SymbolLiteral[
+#                   value: SyntaxTree::Ident[value: "pages"]
+#                 ]
+#               ]
+#             ]
+#           ]
+#         ]
+#       ]
+#     ]
+#   ]
+# ]
+
+
+# TODO: As you can see in the second example above, `command` can receive a
+# block, so we might want to have a way to access the block node in the future.
+module Masamune
+  class AbstractSyntaxTree
+    class Command < Node
+      def initialize(contents, ast_id)
+        super
+      end
+
+      def extract_data_nodes
+        [
+          DataNode.new(@contents[1], @ast_id, self)
+        ]
+      end
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ module Masamune
 
       def extract_data_nodes
         [
-          DataNode.new(@contents[1], @ast_id)
+          DataNode.new(@contents[1], @ast_id, self)
         ]
       end
     end

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

@@ -14,7 +14,7 @@ module Masamune
         # to ensure that it's being handled properly.
         unless @contents[1].nil?
           @contents[1].map do |content|
-            DataNode.new(content, @ast_id)
+            DataNode.new(content, @ast_id, self)
           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/{string_content.rb → nodes/string_content.rb}

@@ -9,7 +9,7 @@ module Masamune
 
       def extract_data_nodes
         [
-          DataNode.new(@contents[1], @ast_id)
+          DataNode.new(@contents[1], @ast_id, self)
         ]
       end
     end

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, self)
+        ]
+      end
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ module Masamune
 
       def extract_data_nodes
         [
-          DataNode.new(@contents[1], @ast_id)
+          DataNode.new(@contents[1], @ast_id, self)
         ]
       end
     end

data/lib/masamune/abstract_syntax_tree/{dyna_symbol.rb → nodes/symbols/dyna_symbol.rb}

@@ -13,7 +13,7 @@ module Masamune
       # 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)
+        DataNode.new(@contents[1][1], @ast_id, self)
       end
     end
   end

data/lib/masamune/abstract_syntax_tree/{symbol_literal.rb → nodes/symbols/symbol_literal.rb}

@@ -14,7 +14,7 @@ module Masamune
       # 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)
+        DataNode.new(@contents[1][1], @ast_id, self)
       end
     end
   end

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

@@ -14,7 +14,7 @@ module Masamune
       # nice to find out and document/implement it somewhere.
       def extract_data_nodes
         @contents[1][1].map do |content|
-          DataNode.new(content, @ast_id)
+          DataNode.new(content, @ast_id, self)
         end
       end
     end

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

@@ -9,7 +9,7 @@ module Masamune
 
       def extract_data_nodes
         [
-          DataNode.new(@contents[1], @ast_id)
+          DataNode.new(@contents[1], @ast_id, self)
         ]
       end
     end

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

@@ -11,7 +11,7 @@ module Masamune
 
       def extract_data_nodes
         [
-          DataNode.new(@contents[1], @ast_id)
+          DataNode.new(@contents[1], @ast_id, self)
         ]
       end
     end

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

@@ -9,7 +9,7 @@ module Masamune
 
       def extract_data_nodes
         [
-          DataNode.new(@contents[1], @ast_id)
+          DataNode.new(@contents[1], @ast_id, self)
         ]
       end
     end

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,44 @@ 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
+        :call,
+        :command
       ].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,49 +89,56 @@ module Masamune
     def brace_block_params
     end
 
-    def symbols(content: nil)
-      symbol_literals + string_symbols
+    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)
-      find_nodes(get_node_class(:symbol_literal), token: content)
+    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)
-      find_nodes(get_node_class(:dyna_symbol), token: content)
+    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
 
-    # @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 comments(content: nil, result_type: Hash)
+      results = find_nodes(get_node_class(:comment), token: content, result_type: result_type)
+      order_results(results)
     end
 
-    def all_methods
-      method_definitions + method_calls
+    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
+    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.
@@ -130,7 +156,10 @@ module Masamune
         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:)
@@ -154,5 +183,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.3"
+  VERSION = "1.1.5"
 end

data/lib/masamune.rb

@@ -9,22 +9,25 @@ 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/dyna_symbol"
-require "masamune/abstract_syntax_tree/params"
-require "masamune/abstract_syntax_tree/program"
-require "masamune/abstract_syntax_tree/string_content"
-require "masamune/abstract_syntax_tree/symbol_literal"
-require "masamune/abstract_syntax_tree/symbol"
-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/command"
+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.3
+  version: 1.1.5
 platform: ruby
 authors:
 - Gabriel Zayas
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-06-05 00:00:00.000000000 Z
+date: 2023-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -40,23 +40,26 @@ 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/dyna_symbol.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/symbol.rb
-- lib/masamune/abstract_syntax_tree/symbol_literal.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/command.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