masamune-ast 1.1.5 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cde8e5ad304fc141ebf9a19a2b14ca11bdb5a582f37946e7190888a142cbf800
-  data.tar.gz: 79cfd7151f94c22f78efd3fcfda3be6321b68a76ea5d5175b73ecd96b2ae2331
+  metadata.gz: 3029256236d8953d9f258d370abb57d1dac4a425b9112f7f4a5a42e951634943
+  data.tar.gz: 123f4977244d1db7d1cbceebee495e6a7d8494401f1db86f4a8360de27b06f2e
 SHA512:
-  metadata.gz: 071e318a82a6c9df04ca33746f2f1e97ff2a49362e054621d7ff490bf727574bcd55648c6fcdd63ec6f49c5962eea009fbdce1acd6bc98d0f5d9bc35f3336d9e
-  data.tar.gz: 7bfd78af1aa7e621f343ef77521a2895921b449f944487518746b201ff3d925fe9e22645b17d7bd8fd83fcaf89463870f339bb2fa0a654c9bc9c9cf194bb2183
+  metadata.gz: 3282cd14e7c591bff140c5d92d782a9724be2af32e9cc2542a0aab949fd469ad4c526c2a11255be267546cb2d1634e97ea7d950c8762c21635fc4274fe5f487c
+  data.tar.gz: d652c21b25b38d460045336d9dd330afb302470358a98f43a0eacb7f79128cdc26e8efe6d233f41067f2be28af3314585ba03b0df1f83e47f8f7d8419a018d98

data/Gemfile.lock

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

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,33 +21,26 @@ 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
-
+      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 = position_and_token_ary.select do |position_and_token|
-            position_and_token[:position].first == line_number
-          end
+          shared_line_data = results.select {|result| result[:line_number] == line_number}
 
           # 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
+          indexes_on_line = shared_line_data.map {|data| data[:index_on_line]}.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
+          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
@@ -55,8 +49,16 @@ module Masamune
         final_result
       end
 
-      def position_and_token
-        {position: @line_position, token: @token}
+      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

data/lib/masamune/abstract_syntax_tree.rb

@@ -150,16 +150,17 @@ module Masamune
         # 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
+          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:)

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.0"
 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.0
 platform: ruby
 authors:
 - Gabriel Zayas
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-06-13 00:00:00.000000000 Z
+date: 2023-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport