masamune-ast 1.2.0 → 2.0.0

data/lib/masamune/abstract_syntax_tree.rb

@@ -1,173 +1,91 @@
+require_relative "abstract_syntax_tree/prism/node_extensions"
+
 module Masamune
   class AbstractSyntaxTree
-    attr_reader :code, :tree, :comment_list
-    attr_accessor :node_list, :data_node_list, :lex_nodes
+    attr_reader :code, :prism, :ripper
+    attr_accessor :lex_nodes
 
     def initialize(code)
       @code = code
-      @tree = Ripper.sexp(code)
+      @prism = Prism.parse(code)
+      @ripper = 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 = []
-      @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)
-      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
 
-    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!
+    def variables(token_value: nil)
+      visitor = VariablesVisitor.new(token_value)
+      @prism.value.accept(visitor)
+      visitor.results
     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, result_type: Hash)
-      var_classes = [
-        :var_field,
-        :var_ref,
-        :params
-      ].map {|type| get_node_class(type)}
-      results = find_nodes(var_classes, token: name, result_type: result_type)
-      order_results(results)
+    def strings(token_value: nil)
+      visitor = StringsVisitor.new(token_value)
+      @prism.value.accept(visitor)
+      visitor.results
     end
 
-    def strings(content: nil, result_type: Hash)
-      results = find_nodes(get_node_class(:string_content), token: content, result_type: result_type)
-      order_results(results)
+    def all_methods(token_value: nil)
+      order_nodes(method_definitions(token_value: token_value) + method_calls(token_value: token_value))
     end
 
-    def method_definitions(name: nil, result_type: Hash)
-      results = find_nodes(get_node_class(:def), token: name, result_type: result_type)
-      order_results(results)
+    def method_definitions(token_value: nil)
+      visitor = MethodDefinitionsVisitor.new(token_value)
+      @prism.value.accept(visitor)
+      visitor.results
     end
 
-    def method_calls(name: nil, result_type: Hash)
-      method_classes = [
-        :vcall,
-        :call,
-        :command
-      ].map {|type| get_node_class(type)}
-      results = find_nodes(method_classes, token: name, result_type: result_type)
-      order_results(results)
+    def method_calls(token_value: nil)
+      visitor = MethodCallsVisitor.new(token_value)
+      @prism.value.accept(visitor)
+      visitor.results
     end
 
-    # TODO
-    def do_block_params
+    def symbols(token_value: nil)
+      visitor = SymbolsVisitor.new(token_value)
+      @prism.value.accept(visitor)
+      visitor.results
     end
 
-    # TODO
-    def brace_block_params
-    end
-
-    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(token_value: nil)
+      result = symbols(token_value: token_value)
 
-    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)
+      # TODO: Describe why closing_loc has to happen.
+      result.select{|node| node.closing_loc.nil?}
     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 string_symbols(token_value: nil)
+      result = symbols(token_value: token_value)
 
-    def comments(content: nil, result_type: Hash)
-      results = find_nodes(get_node_class(:comment), token: content, result_type: result_type)
-      order_results(results)
+      # TODO: Describe why closing_loc has to happen.
+      result.reject{|node| node.closing_loc.nil?}
     end
 
-    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)
+    # Retrieves all parameters within pipes (i.e. - |x, y, z|).
+    def block_parameters
+      visitor = BlockParametersVisitor.new
+      @prism.value.accept(visitor)
+      visitor.results
     end
 
-    def block_params(content: nil, result_type: Hash)
-      # TODO: do_block_params + brace_block_params
-      results = find_nodes(get_node_class(:params), token: content, result_type: result_type)
-      order_results(results)
+    def parameters(token_value: nil)
+      visitor = ParametersVisitor.new(token_value)
+      @prism.value.accept(visitor)
+      visitor.results
     end
 
-    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|
-        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.
-        nodes = nodes.select {|node| node.data_nodes.first.token == token}.flatten
-      end
-
-      final_result = []
-      nodes.each do |node|
-        # 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.line_data_and_token
-        else
-          node.data_nodes.each {|dn| final_result << dn.line_data_and_token} if node.data_nodes
-        end
-      end
-
-      # 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
-      final_result
+    # TODO: Search by token_value if necessary.
+    def comments
+      @prism.comments
     end
 
-    def replace(type:, old_token:, new_token:)
+    def replace(type:, old_token_value:, new_token_value:)
       Slasher.replace(
         type: type,
-        old_token: old_token,
-        new_token: new_token,
+        old_token_value: old_token_value,
+        new_token_value: new_token_value,
         code: @code,
         ast: self
       )
@@ -175,24 +93,12 @@ module Masamune
 
     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
-
-    # 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
+    # Order results according to their token location.
+    def order_nodes(nodes)
+      nodes.sort do |a, b|
+        by_line = a.token_location.start_line <=> b.token_location.start_line
+        # If we're on the same line, refer to the inner index for order.
+        by_line.zero? ? a.token_location.start_column <=> b.token_location.start_column : by_line
       end
     end
   end

data/lib/masamune/lex_node.rb

@@ -1,17 +1,17 @@
 module Masamune
   # https://docs.ruby-lang.org/en/3.0/Ripper.html#method-c-lex
   #
-  # @position: Line number and starting point on the line. i.e. - [4, 7].
+  # @location: Line number and starting point on the line. i.e. - [4, 7].
   # @type: The type of token. i.e. - :kw (is a keyword).
   # @token: The raw string which represents the actual ruby code. i.e. - "do".
   # @state: Ripper::Lexer::State. i.e. - CMDARG.
   class LexNode
-    attr_accessor :position, :type, :token, :state, :ast_id
+    attr_accessor :location, :type, :token, :state, :ast_id
     attr_reader :index
 
     def initialize(index, raw_lex_node, ast_id)
       @index = index
-      @position, @type, @token, @state = raw_lex_node
+      @location, @type, @token, @state = raw_lex_node
       @type = @type.to_s.gsub(/^[a-z]*_/, "").to_sym
 
       # Since the Abstract Syntax Tree can get very large,
@@ -25,15 +25,15 @@ module Masamune
 
     def variable?
       return false unless identifier?
-      ast.variables(name: @token).any?
+      ast.variables(token_value: @token).any?
     end
 
     def method_definition?
-      ast.method_definitions(name: @token).any?
+      ast.method_definitions(token_value: @token).any?
     end
 
     def method_call?
-      ast.method_calls(name: @token).any?
+      ast.method_calls(token_value: @token).any?
     end
 
     def method?

data/lib/masamune/slasher.rb

@@ -1,34 +1,28 @@
 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.
-      line_data_and_token_ary = if type.is_a?(Symbol)
+    def self.replace(type:, old_token_value:, new_token_value:, code:, ast:)
+      # `type` refers to the singluar form of a method name from the ast like `method_definitions`.
+      nodes = 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
 
-      tokens_to_replace = line_data_and_token_ary.select do |line_data_and_token|
-        line_data_and_token[:token] == old_token
+      nodes_of_tokens_to_replace = nodes.select do |node|
+        node.token_value == old_token_value
       end
 
       # Build from lex nodes
       result = ast.lex_nodes.map do |lex_node|
         match_found = false
-        tokens_to_replace.each do |line_data_and_token|
-          position = [
-            line_data_and_token[:line_number],
-            line_data_and_token[:index_on_line]
-          ]
-          if position == lex_node.position
+        nodes_of_tokens_to_replace.each do |node|
+          location = [node.token_location.start_line, node.token_location.start_column]
+          if location == lex_node.location
             match_found = true
             break
           end
         end
 
-        match_found ? new_token : lex_node.token
+        match_found ? new_token_value : lex_node.token
       end
 
       result.join

data/lib/masamune/version.rb

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

data/lib/masamune.rb

@@ -2,35 +2,22 @@
 
 require_relative "masamune/version"
 require "ripper"
+require "prism"
 require "active_support/core_ext/string/inflections"
+
+require "masamune/abstract_syntax_tree/visitors/block_parameters_visitor"
+require "masamune/abstract_syntax_tree/visitors/method_definitions_visitor"
+require "masamune/abstract_syntax_tree/visitors/method_calls_visitor"
+require "masamune/abstract_syntax_tree/visitors/parameters_visitor"
+require "masamune/abstract_syntax_tree/visitors/strings_visitor"
+require "masamune/abstract_syntax_tree/visitors/symbols_visitor"
+require "masamune/abstract_syntax_tree/visitors/variables_visitor"
+
 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"
-
-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"
 
 module Masamune
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: masamune-ast
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Gabriel Zayas
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-06-27 00:00:00.000000000 Z
+date: 2023-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.0
 description: A layer of abstraction on top of Ripper for handling Abstract Syntax
   Trees in Ruby.
 email:
@@ -40,26 +54,14 @@ files:
 - Rakefile
 - lib/masamune.rb
 - lib/masamune/abstract_syntax_tree.rb
-- lib/masamune/abstract_syntax_tree/data_node.rb
-- lib/masamune/abstract_syntax_tree/node.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/abstract_syntax_tree/prism/node_extensions.rb
+- lib/masamune/abstract_syntax_tree/visitors/block_parameters_visitor.rb
+- lib/masamune/abstract_syntax_tree/visitors/method_calls_visitor.rb
+- lib/masamune/abstract_syntax_tree/visitors/method_definitions_visitor.rb
+- lib/masamune/abstract_syntax_tree/visitors/parameters_visitor.rb
+- lib/masamune/abstract_syntax_tree/visitors/strings_visitor.rb
+- lib/masamune/abstract_syntax_tree/visitors/symbols_visitor.rb
+- lib/masamune/abstract_syntax_tree/visitors/variables_visitor.rb
 - lib/masamune/lex_node.rb
 - lib/masamune/slasher.rb
 - lib/masamune/version.rb
@@ -79,14 +81,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.0.dev
 signing_key: 
 specification_version: 4
 summary: Masamune

data/lib/masamune/abstract_syntax_tree/data_node.rb

@@ -1,65 +0,0 @@
-# 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, `line_data_and_token`,
-# which looks like this: {line_number: 4, index_on_line: 7, token: "ruby"}
-
-module Masamune
-  class AbstractSyntaxTree
-    class DataNode < Node
-      attr_reader :type, :token, :line_number, :index_on_line
-
-      def initialize(contents, ast_id, parent)
-        @type, @token, line_position = contents
-        @line_number, @index_on_line = line_position
-        @parent = parent
-        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:
-      # [
-      #   {line_number: 4, index_on_line: 7, token: "ruby"},
-      #   {line_number: 7, index_on_line: 7, token: "rails"}
-      # ]
-      # TODO: Worry about using a faster sorting algorithm later.
-      def self.order_results_by_position(results)
-        final_result = []
-
-        line_numbers = results.map {|result| result[:line_number]}.uniq.sort
-        line_numbers.each do |line_number|
-          # Group data together in an array if they're on the same line.
-          shared_line_data = results.select {|result| result[:line_number] == line_number}
-
-          # Sort the positions on each line number respectively.
-          indexes_on_line = shared_line_data.map {|data| data[:index_on_line]}.sort
-
-          # Apply to the final result.
-          indexes_on_line.each do |index_on_line|
-            shared_line_data.each do |data|
-              if data[:index_on_line] == index_on_line
-                final_result << data
-              end
-            end
-          end
-        end
-
-        final_result
-      end
-
-      def line_data_and_token
-        {
-          line_number: @line_number,
-          index_on_line: @index_on_line,
-          token: @token
-        }
-      end
-
-      def position
-        [@line_number, @index_on_line]
-      end
-    end
-  end
-end

data/lib/masamune/abstract_syntax_tree/node.rb

@@ -1,41 +0,0 @@
-# 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/nodes/assign.rb

@@ -1,11 +0,0 @@
-# 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/nodes/blocks/brace_block.rb

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

@@ -1,13 +0,0 @@
-# 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/nodes/call.rb

@@ -1,17 +0,0 @@
-# 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, self)
-        ]
-      end
-    end
-  end
-end