proc_to_ast 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7b7485fc28f9e8f9106d852bd481ce684303a34b
-  data.tar.gz: 961f9b5b02d498888dcb77421498e2d1b7208d97
+  metadata.gz: af92479d75ab4508025af6183f02826935da753f
+  data.tar.gz: e7d4661d31825657ab4d3f87b5f5f773a083d89f
 SHA512:
-  metadata.gz: 40c92362331a397794ddd157fb31b914f49a9a27e796a75850eafc3be72fc89e9fe10bde4834e7ec2766b2de2567c1df30abb5f0bcdfb03543d917d1f3ab2f92
-  data.tar.gz: bf5474a65640f2e2505ae8a4407f248815c11f3951662d69725c74cd1e289204e59adfbd7e58c5865e4fda883ea786a2a1e9b5ed9d3227cd205daa6d0aa4d5f0
+  metadata.gz: bb3e438c238c4e153e9cb24adfcc11fc090a6dc713bad95dcd72748062983a62fc0eae58cc9a79721a365e4ffa7022babeb74188b3208acc010d0d13717a2048
+  data.tar.gz: ea3ca120b291b266d5bda7b2fc0541400e38d696c80ac836d36d9b48bc90f3171e976c3f2e18efbe107ee2480ae5870cca16e45330db32832c12712f34f3438c

data/lib/proc_to_ast.rb

@@ -7,74 +7,110 @@ require 'coderay'
 module ProcToAst
   class MultiMatchError < StandardError; end
 
-  class Traverser
-    def traverse_node(node)
-      if node.type != :block
-        node.children.flat_map { |child|
-          if child.is_a?(AST::Node)
-            traverse_node(child)
-          end
-        }.compact
-      else
-        [node]
-      end
+  class Parser
+    attr_reader :parser
+
+    def initialize
+      @parser = ::Parser::CurrentRuby.default_parser
+      @parser.diagnostics.consumer = ->(diagnostic) {} # suppress error message
     end
 
-    def proc_block?(node)
-      head = node.children[0]
-      return false unless head.type == :send
+    # Read file and try parsing
+    # if success parse, find proc AST
+    #
+    # @param filename [String] reading file path
+    # @param linenum [Integer] start line number
+    # @param retry_limit [Integer]
+    # @return [Parser::AST::Node] Proc AST
+    def parse(filename, linenum, retry_limit = 20)
+      @filename, @linenum = filename, linenum
+      file = File.open(filename, "rb")
 
-      receiver, symbol = head.children
+      (linenum - 1).times { file.gets }
+      buf = []
+      try_count = 0
 
-      return true if receiver.nil? && (symbol == :proc || symbol == :lambda)
+      begin
+        try_count += 1
 
-      if receiver.is_a?(AST::Node) &&
-        receiver.type == :const &&
-        receiver.children[1] == :Proc &&
-        symbol == :new
+        buf << file.gets
+        do_parse(buf)
+      rescue ::Parser::SyntaxError => e
+        node = trim_and_retry(buf)
 
-        return true
-      end
+        return node unless node.nil?
+        retry if try_count < retry_limit
 
-      false
+        raise e
+      ensure
+        file.close
+      end
     end
-  end
-end
 
-class Proc
-  def to_ast(retry_limit = 20)
-    filename, linenum = source_location
-    file = File.open(filename, "rb")
+    private
 
-    (linenum - 1).times { file.gets }
-    buf = []
-    try_count = 0
-
-    parser = Parser::CurrentRuby.default_parser
-    parser.diagnostics.consumer = ->(diagnostic) {} # suppress error message
-    begin
+    def do_parse(buf)
       parser.reset
-      try_count += 1
-
-      buf << file.gets
       source = buf.join.force_encoding(parser.default_encoding)
 
-      source_buffer = Parser::Source::Buffer.new(filename, linenum)
+      source_buffer = ::Parser::Source::Buffer.new(@filename, @linenum)
       source_buffer.source = source
       node = parser.parse(source_buffer)
-      block_nodes = ProcToAst::Traverser.new.traverse_node(node)
+      block_nodes = traverse_node(node)
+
       if block_nodes.length == 1
         block_nodes.first
       else
         raise ProcToAst::MultiMatchError
       end
-    rescue Parser::SyntaxError
-      retry if try_count < retry_limit
     end
+
+    # Remove tail comma or Hash syntax, and retry parsing
+    def trim_and_retry(buf)
+      *lines, last = buf
+
+      # For inner Array or Hash or Arguments list.
+      lines << last.gsub(/,\s*/, "")
+
+      lines[0] = lines[0]
+        .gsub(/[0-9a-zA-Z_]+:\s*/, "")
+        .gsub(/[^\s]+\s*=>\s*/, "")
+
+      begin
+        do_parse(lines)
+      rescue ::Parser::SyntaxError
+        nil
+      end
+    end
+
+    def traverse_node(node)
+      if node.type != :block
+        node.children.flat_map { |child|
+          if child.is_a?(AST::Node)
+            traverse_node(child)
+          end
+        }.compact
+      else
+        [node]
+      end
+    end
+  end
+end
+
+class Proc
+  # @param retry_limit [Integer]
+  # @return [Parser::AST::Node] Proc AST
+  def to_ast(retry_limit = 20)
+    filename, linenum = source_location
+    parser = ProcToAst::Parser.new
+    parser.parse(filename, linenum, retry_limit)
   end
 
-  def to_source(highlight: false)
-    source = Unparser.unparse(to_ast)
+  # @param highlight [Boolean] enable output highlight
+  # @param retry_limit [Integer]
+  # @return [String] proc source code
+  def to_source(highlight: false, retry_limit: 20)
+    source = Unparser.unparse(to_ast(retry_limit))
     if highlight
       CodeRay.scan(source, :ruby).terminal
     else

data/lib/proc_to_ast/version.rb

@@ -1,3 +1,3 @@
 module ProcToAst
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/proc_to_ast_spec.rb

@@ -48,6 +48,50 @@ describe Proc do
 
         expect{ fuga.to_ast }.to raise_error(ProcToAst::MultiMatchError)
       end
+
+      it "inner array" do
+        array = [
+          1,
+          -> { 2 },
+          [
+            -> {
+              3
+            },
+          ],
+          proc do |a|
+            [
+              a,
+            ]
+          end
+        ]
+        expect(array[1].to_ast).to be_a(AST::Node)
+        expect(array[1].to_source).to eq("lambda do\n  2\nend")
+        expect(array[2][0].to_source).to eq("lambda do\n  3\nend")
+        expect(array[3].to_source).to eq("proc do |a|\n  [a]\nend")
+      end
+
+      it "inner hash" do
+        hash_oneline = {a: -> { 1 }}
+        expect(hash_oneline[:a].to_ast).to be_a(AST::Node)
+        expect(hash_oneline[:a].to_source).to eq("lambda do\n  1\nend")
+
+        hash = {
+          a: -> { 1 },
+          :b => -> { 2 },
+          c: -> {
+            3
+          },
+          d: -> { 4 }
+        }
+        expect(hash[:a].to_ast).to be_a(AST::Node)
+        expect(hash[:a].to_source).to eq("lambda do\n  1\nend")
+        expect(hash[:b].to_ast).to be_a(AST::Node)
+        expect(hash[:b].to_source).to eq("lambda do\n  2\nend")
+        expect(hash[:c].to_ast).to be_a(AST::Node)
+        expect(hash[:c].to_source).to eq("lambda do\n  3\nend")
+        expect(hash[:d].to_ast).to be_a(AST::Node)
+        expect(hash[:d].to_source).to eq("lambda do\n  4\nend")
+      end
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: proc_to_ast
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - joker1007