unparser 0.1.5 → 0.1.6

data/lib/unparser/cli/differ.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Unparser
+  class CLI
+    # Unparser CLI specific differ
+    class Differ < Mutant::Differ
+      include Procto.call(:colorized_diff)
+
+      # Return source diff
+      #
+      # FIXME: Multiple diffs get screwed up!
+      #
+      # @return [String]
+      #   if there is a diff
+      #
+      # @return [nil]
+      #   otherwise
+      #
+      # @api private
+      #
+      def diff
+        diffs.map do |piece|
+          Diff::LCS::Hunk.new(old, new, piece, max_length, old.length - new.length).diff(:unified) << "\n"
+        end.join
+      end
+      memoize :diff
+
+    end # Differ
+  end # CLI
+end # Unparser

data/lib/unparser/cli/preprocessor.rb

@@ -0,0 +1,196 @@
+# encoding: utf-8
+
+module Unparser
+  class CLI
+
+    # CLI Specific preprocessor used for equivalency testing
+    class Preprocessor
+      include Adamantium::Flat, NodeHelpers, AbstractType, Concord.new(:node), Procto.call(:result)
+
+      # Return preprocessor result
+      #
+      # @return [Parser::AST::Node]
+      #
+      # @api private
+      #
+      abstract_method :result
+
+      # Run preprocessor for node
+      #
+      # @param [Parser::AST::Node, nil] node
+      #
+      # @return [Parser::AST::Node, nil]
+      #
+      # @api private
+      #
+      def self.run(node)
+        return if node.nil?
+        REGISTRY.fetch(node.type, Noop).new(node).result
+      end
+
+      REGISTRY = {}
+
+      # Register preprocessor
+      #
+      # @param [Symbol] type
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def self.register(type)
+        REGISTRY[type] = self
+      end
+      private_class_method :register
+
+    private
+
+      # Visit node
+      #
+      # @param [Parser::AST::Node]
+      #
+      # @api private
+      #
+      def visit(node)
+        self.class.run(node)
+      end
+
+      # Return children
+      #
+      # @return [Array<Parser::AST::Node>]
+      #
+      # @api private
+      #
+      def children
+        node.children
+      end
+
+      # Return mapped children
+      #
+      # @return [Array<Parser::Ast::Node>]
+      #
+      # @api private
+      #
+      def mapped_children
+        children.map do |node|
+          if node.kind_of?(Parser::AST::Node)
+            visit(node)
+          else
+            node
+          end
+        end
+      end
+
+      # Noop preprocessor that just passes through noode.
+      class Noop < self
+
+        # Return preprocessor result
+        #
+        # @return [Parser::AST::Node]
+        #
+        # @api private
+        #
+        def result
+          s(node.type, *mapped_children)
+        end
+      end # Noop
+
+      # Preprocessor for dynamic string nodes. Collapses adjacent string segments into one.
+      class Dstr < self
+
+        register :dstr
+
+        # Return preprocessor result
+        #
+        # @return [Parser::AST::Node]
+        #
+        # @api private
+        #
+        def result
+          if collapsed_children.all? { |node| node.type == :str }
+            s(:str, collapsed_children.map { |node| node.children.first }.join)
+          else
+            node.updated(nil, collapsed_children)
+          end
+        end
+
+      private
+
+        # Return collapsed children
+        #
+        # @return [Array<Parser::AST::Node>]
+        #
+        # @api private
+        #
+        def collapsed_children
+          chunked_children.each_with_object([]) do |(type, nodes), aggregate|
+            if type == :str
+              aggregate << s(:str, nodes.map { |node| node.children.first }.join)
+            else
+              aggregate.concat(nodes)
+            end
+          end
+        end
+        memoize :collapsed_children
+
+        # Return chunked children
+        #
+        # @return [Array<Parser::AST::Node>]
+        #
+        # @api private
+        #
+        def chunked_children
+          mapped_children.chunk do |item|
+            item.type
+          end
+        end
+
+      end # Begin
+
+      # Preprocessor for regexp nodes. Normalizes quoting.
+      class Regexp < self
+
+        register :regexp
+
+        # Return preprocesso result
+        #
+        # @return [Parser::AST::Node]
+        #
+        # @api private
+        #
+        def result
+          location = node.location
+          if location && location.begin.source.start_with?('%r')
+            Parser::CurrentRuby.parse(Unparser.unparse(node))
+          else
+            node
+          end
+        end
+      end
+
+      # Preprocessor for begin nodes. Removes begin nodes with one child.
+      #
+      # These superflownosely currently get generated by unparser.
+      #
+      class Begin < self
+
+        register :begin
+
+        # Return preprocessor result
+        #
+        # @return [Parser::AST::Node]
+        #
+        # @api private
+        #
+        def result
+          if children.one?
+            visit(children.first)
+          else
+            Noop.call(node)
+          end
+        end
+
+      end # Begin
+    end # Preprocessor
+  end # CLI
+end # Unparser

data/lib/unparser/cli/source.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+
+module Unparser
+  class CLI
+    # Source representation for CLI sources
+    class Source
+      include AbstractType, Adamantium::Flat
+
+      # Test if source could be unparsed successfully
+      #
+      # @return [true]
+      #   if source could be unparsed successfully
+      #
+      # @return [false]
+      #
+      # @api private
+      #
+      def success?
+        original_ast == generated_ast
+      end
+
+      # Return error report
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def error_report
+        diff = Differ.call(
+          original_ast.inspect.lines.map(&:chomp),
+          generated_ast.inspect.lines.map(&:chomp)
+        )
+        "#{diff}\nOriginal:\n#{original_source}\nGenerated:\n#{generated_source}"
+      end
+      memoize :error_report
+
+    private
+
+      # Return generated source
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def generated_source
+        Unparser.unparse(original_ast)
+      end
+      memoize :generated_source
+
+      # Return generated AST
+      #
+      # @return [Parser::AST::Node]
+      #
+      # @api private
+      #
+      def generated_ast
+        Preprocessor.run(Parser::CurrentRuby.parse(generated_source))
+      end
+      memoize :generated_ast
+
+      # Return original AST
+      #
+      # @return [Parser::AST::Node]
+      #
+      # @api private
+      #
+      def original_ast
+        Preprocessor.run(Parser::CurrentRuby.parse(original_source))
+      end
+      memoize :original_ast
+
+      # CLI source from string
+      class String < self
+        include Concord.new(:original_source)
+
+        # Return identification
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def identification
+          '(string)'
+        end
+
+      end # String
+
+      # CLI source from file
+      class File < self
+        include Concord.new(:file_name)
+
+        # Return identification
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def identification
+          "(#{file_name})"
+        end
+
+      private
+
+        # Return original source
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def original_source
+          ::File.read(file_name)
+        end
+        memoize :original_source
+
+      end # File
+    end # Source
+  end # CLI
+end # Unparser

data/lib/unparser/comments.rb

@@ -1,17 +1,35 @@
+# encoding: utf-8
+
 module Unparser
 
   # Holds the comments that remain to be emitted
   class Comments
 
+    # Proxy to singleton
+    #
+    # NOTICE:
+    #   Delegating to stateless helpers is a pattern I saw many times in our code.
+    #   Maybe we should make another helper module? include SingletonDelegator.new(:source_range) ?
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def source_range(*arguments)
+      self.class.source_range(*arguments)
+    end
+
     # Initialize object
     #
     # @param [Array] comments
     #
     # @return [undefined]
     #
+    # @api private
+    #
     def initialize(comments)
       @comments = comments.dup
-      @last_range_consumed = @eol_text_to_skip = nil
+      @last_range_consumed = nil
     end
 
     # Consume part or all of the node
@@ -21,39 +39,33 @@ module Unparser
     #
     # @return [undefined]
     #
-    def consume(node, source_part = :expression)
-      location = node.location
-      return unless location
-      @last_range_consumed = location.public_send(source_part)
-    end
-
-    # Skip any EOL comment with the specified text next time they're taken
-    #
-    # @param [String] comment_text
+    # @api private
     #
-    # @return [undefined]
-    #
-    def skip_eol_comment(comment_text)
-      @eol_text_to_skip = comment_text
+    def consume(node, source_part = :expression)
+      range = source_range(node, source_part)
+      if range
+        @last_range_consumed = range
+      end
     end
 
     # Take end-of-line comments
     #
     # @return [Array]
     #
+    # @api private
+    #
     def take_eol_comments
-      text_to_skip = @eol_text_to_skip
-      @eol_text_to_skip = nil
-      return [] unless @last_range_consumed
+      return EMPTY_ARRAY unless @last_range_consumed
       comments = take_up_to_line(@last_range_consumed.end.line)
-      eol_comments = unshift_documents(comments)
-      eol_comments.reject { |comment| comment.text == text_to_skip }
+      unshift_documents(comments)
     end
 
     # Take all remaining comments
     #
     # @return [Array]
     #
+    # @api private
+    #
     def take_all
       take_while { true }
     end
@@ -65,24 +77,49 @@ module Unparser
     #
     # @return [Array]
     #
+    # @api private
+    #
     def take_before(node, source_part)
-      location = node.location
-      if location.respond_to?(source_part)
-        range = location.public_send(source_part)
+      range = source_range(node, source_part)
+      if range
         take_while { |comment| comment.location.expression.end_pos <= range.begin_pos }
       else
         EMPTY_ARRAY
       end
     end
 
+    # Return source location part
+    #
+    # FIXME: This method should not be needed. It does to much inline signalling.
+    #
+    # @param [Parser::AST::Node] node
+    # @param [Symbol] part
+    #
+    # @return [Parser::Source::Range]
+    #   if present
+    #
+    # @return [nil]
+    #   otherwise
+    #
+    # @api private
+    #
+    def self.source_range(node, part)
+      location = node.location
+      if location && location.respond_to?(part)
+        location.public_send(part)
+      end
+    end
+
   private
 
     # Take comments while the provided block returns true
     #
-    # @yield [comment]
+    # @yield [Parser::Source::Comment]
     #
     # @return [Array]
     #
+    # @api private
+    #
     def take_while
       number_to_take = @comments.index { |comment| !yield(comment) } || @comments.size
       @comments.shift(number_to_take)
@@ -94,6 +131,8 @@ module Unparser
     #
     # @return [Array]
     #
+    # @api private
+    #
     def take_up_to_line(line)
       take_while { |comment| comment.location.expression.line <= line }
     end
@@ -104,6 +143,8 @@ module Unparser
     #
     # @return [Array]
     #
+    # @api private
+    #
     def unshift_documents(comments)
       doc_comments, other_comments = comments.partition(&:document?)
       doc_comments.reverse_each { |comment| @comments.unshift(comment) }