masamune-ast 1.1.5 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cde8e5ad304fc141ebf9a19a2b14ca11bdb5a582f37946e7190888a142cbf800
-  data.tar.gz: 79cfd7151f94c22f78efd3fcfda3be6321b68a76ea5d5175b73ecd96b2ae2331
+  metadata.gz: f599b770d8e12444bbb2c2bb6aad28d8d0b9673e99708d9d713af4186f96fb4f
+  data.tar.gz: 723f6ab17c2152f9ab92e6da6f0130bc1ab1aa1fd0174ee00a1d9bb7206df182
 SHA512:
-  metadata.gz: 071e318a82a6c9df04ca33746f2f1e97ff2a49362e054621d7ff490bf727574bcd55648c6fcdd63ec6f49c5962eea009fbdce1acd6bc98d0f5d9bc35f3336d9e
-  data.tar.gz: 7bfd78af1aa7e621f343ef77521a2895921b449f944487518746b201ff3d925fe9e22645b17d7bd8fd83fcaf89463870f339bb2fa0a654c9bc9c9cf194bb2183
+  metadata.gz: 622cfe88710212e12d4045fe39837dd9767b56b64abb62872f544b37d6ac286f85dfb9324ef709bb32ab4219e280eff7f4fc6a966ddb379b79b5a5b3b9c06dc3
+  data.tar.gz: 7db8c29128764c9c36f79a98156c68d4bc008a183ceeed351405a6377606721e33523b267362b0cf1f3a19119db3e1606d494869ec28f340680a8812a4e3868b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    masamune-ast (1.1.5)
+    masamune-ast (1.2.1)
       activesupport
 
 GEM
@@ -26,6 +26,7 @@ GEM
       concurrent-ruby (~> 1.0)
 
 PLATFORMS
+  x86_64-darwin-21
   x86_64-linux
 
 DEPENDENCIES

data/README.md

@@ -57,21 +57,21 @@ CODE
 msmn = Masamune::AbstractSyntaxTree.new(code)
 
 msmn.variables
-#=> [{: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"}]
+#=> [{:line_number=>1, :index_on_line=>0, :token=>"java"},
+#=> {:line_number=>2, :index_on_line=>0, :token=>"javascript"},
+#=> {:line_number=>2, :index_on_line=>13, :token=>"java"},
+#=> {:line_number=>3, :index_on_line=>5, :token=>"java"},
+#=> {:line_number=>3, :index_on_line=>25, :token=>"javascript"}]
 
 msmn.strings
-#=> [{:position=>[1, 8], :token=>"java"},
-#=> {:position=>[2, 21], :token=>"script"},
-#=> {:position=>[3, 13], :token=>" is not "}]
+#=> [{:line_number=>1, :index_on_line=>8, :token=>"java"},
+#=> {:line_number=>2, :index_on_line=>21, :token=>"script"},
+#=> {:line_number=>3, :index_on_line=>13, :token=>" is not "}]
 
 msmn.variables(name: "java")
-#=> [{position: [1, 0], token: "java"},
-#=> {position: [2, 13], token: "java"},
-#=> {position: [3, 5], token: "java"}]
+#=> [{:line_number=>1, :index_on_line=>0, :token=>"java"},
+#=> {:line_number=>2, :index_on_line=>13, :token=>"java"},
+#=> {:line_number=>3, :index_on_line=>5, :token=>"java"}]
 
 code = <<CODE
 ary = [1, 2, 3]
@@ -88,22 +88,22 @@ CODE
 msmn = Masamune::AbstractSyntaxTree.new(code)
 
 msmn.all_methods
-#=> [{: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"}]
+#=> [{:line_number=>2, :index_on_line=>4, :token=>"sum"},
+#=> {:line_number=>2, :index_on_line=>8, :token=>"times"},
+#=> {:line_number=>3, :index_on_line=>2, :token=>"puts"},
+#=> {:line_number=>6, :index_on_line=>4, :token=>"foo"},
+#=> {:line_number=>8, :index_on_line=>0, :token=>"foo"},
+#=> {:line_number=>9, :index_on_line=>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"}]
+#=> [{:line_number=>2, :index_on_line=>4, :token=>"sum"},
+#=> {:line_number=>2, :index_on_line=>8, :token=>"times"},
+#=> {:line_number=>3, :index_on_line=>2, :token=>"puts"},
+#=> {:line_number=>8, :index_on_line=>0, :token=>"foo"},
+#=> {:line_number=>9, :index_on_line=>0, :token=>"foo"}]
 
 msmn.method_definitions
-#=> [{:position=>[6, 4], :token=>"foo"}]
+#=> [{:line_number=>6, :index_on_line=>4, :token=>"foo"}]
 ```
 
 You can also return the node classes themselves and get the data from there:
@@ -115,28 +115,32 @@ 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>]>]
+#=> [#<Masamune::AbstractSyntaxTree::StringContent:0x00007ff2d987c020
+#=>   @ast_id=406820,
+#=>   @contents=[:string_content, [:@tstring_content, "ruby", [1, 1]]],
+#=>   @data_nodes=
+#=>    [#<Masamune::AbstractSyntaxTree::DataNode:0x00007ff2d9883fc8
+#=>      @ast_id=406820,
+#=>      @contents=[:@tstring_content, "ruby", [1, 1]],
+#=>      @data_nodes=nil,
+#=>      @index_on_line=1,
+#=>      @line_number=1,
+#=>      @parent=#<Masamune::AbstractSyntaxTree::StringContent:0x00007ff2d987c020 ...>,
+#=>      @token="ruby",
+#=>      @type=:@tstring_content>]>,
+#=>  #<Masamune::AbstractSyntaxTree::StringContent:0x00007ff2d9883190
+#=>   @ast_id=406820,
+#=>   @contents=[:string_content, [:@tstring_content, "rails", [2, 1]]],
+#=>   @data_nodes=
+#=>    [#<Masamune::AbstractSyntaxTree::DataNode:0x00007ff2d9883168
+#=>      @ast_id=406820,
+#=>      @contents=[:@tstring_content, "rails", [2, 1]],
+#=>      @data_nodes=nil,
+#=>      @index_on_line=1,
+#=>      @line_number=2,
+#=>      @parent=#<Masamune::AbstractSyntaxTree::StringContent:0x00007ff2d9883190 ...>,
+#=>      @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:

data/lib/masamune/abstract_syntax_tree/data_node.rb

@@ -3,16 +3,17 @@
 # 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"}
+# 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_position
+      attr_reader :type, :token, :line_number, :index_on_line
 
       def initialize(contents, ast_id, parent)
-        @type, @token, @line_position = contents
+        @type, @token, line_position = contents
+        @line_number, @index_on_line = line_position
         @parent = parent
         super(contents, ast_id)
       end
@@ -20,43 +21,28 @@ module Masamune
       # 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"}
+      #   {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(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|
-          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
+      def self.order_results_by_position(results)
+        results.sort do |a, b|
+          by_line = a[:line_number] <=> b[:line_number]
+          # If we're on the same line, refer to the inner index for order.
+          by_line.zero? ? a[:index_on_line] <=> b[:index_on_line] : by_line
         end
+      end
 
-        final_result
+      def line_data_and_token
+        {
+          line_number: @line_number,
+          index_on_line: @index_on_line,
+          token: @token
+        }
       end
 
-      def position_and_token
-        {position: @line_position, token: @token}
+      def position
+        [@line_number, @index_on_line]
       end
     end
   end

data/lib/masamune/abstract_syntax_tree.rb

@@ -52,32 +52,22 @@ module Masamune
 
     # 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)
+      results = find_nodes([VarField, VarRef, Params], token: name, result_type: result_type)
       order_results(results)
     end
 
     def strings(content: nil, result_type: Hash)
-      results = find_nodes(get_node_class(:string_content), token: content, result_type: result_type)
+      results = find_nodes(StringContent, token: content, result_type: result_type)
       order_results(results)
     end
 
     def method_definitions(name: nil, result_type: Hash)
-      results = find_nodes(get_node_class(:def), token: name, result_type: result_type)
+      results = find_nodes(Def, token: name, result_type: result_type)
       order_results(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)
+      results = find_nodes([Vcall, Call, Command], token: name, result_type: result_type)
       order_results(results)
     end
 
@@ -95,17 +85,17 @@ module Masamune
     end
 
     def symbol_literals(content: nil, result_type: Hash)
-      results = find_nodes(get_node_class(:symbol_literal), token: content, result_type: result_type)
+      results = find_nodes(SymbolLiteral, 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)
+      results = find_nodes(DynaSymbol, token: content, result_type: result_type)
       order_results(results)
     end
 
     def comments(content: nil, result_type: Hash)
-      results = find_nodes(get_node_class(:comment), token: content, result_type: result_type)
+      results = find_nodes(Comment, token: content, result_type: result_type)
       order_results(results)
     end
 
@@ -116,17 +106,16 @@ module Masamune
 
     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)
+      results = find_nodes(Params, token: content, result_type: result_type)
       order_results(results)
     end
 
     def find_nodes(token_classes, token: nil, result_type: Hash)
-      # Ensure the classes are in an array
-      token_classes = [token_classes].flatten
+      token_classes = Array(token_classes)
 
       nodes = []
       token_classes.each do |klass|
-        if klass == Masamune::AbstractSyntaxTree::Comment
+        if klass == Comment
           nodes = @comment_list.dup
         else
           nodes << @node_list.select {|node| node.class == klass}
@@ -149,17 +138,18 @@ module Masamune
       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.position_and_token
+        if node.class == SymbolLiteral || node.class == DynaSymbol
+          final_result << node.get_symbol_data.line_data_and_token
         else
-          node.data_nodes.each {|dn| final_result << dn.position_and_token} if node.data_nodes
+          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
+      # nodes.first.class.is_a?(Hash) ? DataNode.order_results_by_position(final_result) : final_result
+      final_result
     end
 
     def replace(type:, old_token:, new_token:)
@@ -175,13 +165,7 @@ 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
+      "#{self.class}::#{type.to_s.camelize}".safe_constantize || Node # Return base Node class for any not-yet-covered nodes.
     end
 
     # We only order results when they are a Hash.

data/lib/masamune/slasher.rb

@@ -3,22 +3,26 @@ 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)
+      line_data_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
 
-      tokens_to_replace = position_and_token_ary.select do |pos_and_tok|
-        pos_and_tok[:token] == old_token
+      tokens_to_replace = line_data_and_token_ary.select do |line_data_and_token|
+        line_data_and_token[: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
+        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
             match_found = true
             break
           end

data/lib/masamune/version.rb

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

data/lib/masamune.rb

@@ -30,7 +30,6 @@ 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.1.5
+  version: 1.2.1
 platform: ruby
 authors:
 - Gabriel Zayas
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-13 00:00:00.000000000 Z
+date: 2023-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -71,7 +71,7 @@ metadata:
   homepage_uri: https://www.github.com/gazayas/masamune-ast
   source_code_uri: https://www.github.com/gazayas/masamune-ast
   changelog_uri: https://www.github.com/gazayas/masamune-ast
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -86,8 +86,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key: 
+rubygems_version: 3.4.1
+signing_key:
 specification_version: 4
 summary: Masamune
 test_files: []