unparser 0.1.7 → 0.1.8

data/lib/unparser/ast/local_variable_scope.rb

@@ -0,0 +1,198 @@
+# encoding: UTF-8
+
+module Unparser
+  module AST
+    # Local variable scope enumerator
+    class LocalVariableScope
+      include Enumerable
+
+      RESET_NODES   = [:module, :class, :sclass, :def, :defs].freeze
+      INHERIT_NODES = [:block].freeze
+      CLOSE_NODES   = (RESET_NODES + INHERIT_NODES).freeze
+
+      # Nodes that assign a local variable
+      #
+      # FIXME: Kwargs are missing.
+      #
+      ASSIGN_NODES = [:lvasgn, :arg, :optarg, :restarg].freeze
+
+      # Initialize object
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize
+        @stack = [Set.new]
+      end
+
+      # Enumerate each node with its local variable scope
+      #
+      # @param [Parser::AST::Node] node
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def self.each(node, &block)
+        new.each(node, &block)
+        self
+      end
+
+      # Test for local variable inherited scope reset
+      #
+      # @param [Parser::AST::Node] node
+      #
+      # @return [true]
+      #   if local variable scope must NOT be reset
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def self.not_close_scope?(node)
+        !CLOSE_NODES.include?(node.type)
+      end
+
+      # Test for local variable scope reset
+      #
+      # @param [Parser::AST::Node] node
+      #
+      # @return [true]
+      #   if local variable scope must NOT be reset
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def self.not_reset_scope?(node)
+        !RESET_NODES.include?(node.type)
+      end
+
+      # Enumerate local variable scope scope
+      #
+      # @return [self]
+      #   if block given
+      #
+      # @return [Enumerator<Array<Symbol>>>]
+      #   otherwise
+      #
+      # @api private
+      #
+      def each(node, &block)
+        return to_enum(__method__, node) unless block_given?
+        visit(node, &block)
+      end
+
+    private
+
+      # Return current set of local variables
+      #
+      # @return [Set<Symbol>]
+      #
+      # @api private
+      #
+      def current
+        @stack.last
+      end
+
+      # Visit node and record local variable state
+      #
+      # @param [Parser::AST::Node]
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def visit(node, &block)
+        before = current.dup
+        enter(node)
+        yield node, current, before
+        node.children.each do |child|
+          if child.kind_of?(Parser::AST::Node)
+            visit(child, &block)
+          end
+        end
+        leave(node)
+      end
+
+      # Record local variable state
+      #
+      # @param [Parser::AST::Node]
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def enter(node)
+        case node.type
+        when *RESET_NODES
+          push_reset
+        when *ASSIGN_NODES
+          define(node.children.first)
+        when *INHERIT_NODES
+          push_inherit
+        end
+      end
+
+      # Pop from local variable state
+      #
+      # @param [Parser::AST::Node] node
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def leave(node)
+        if CLOSE_NODES.include?(node.type)
+          pop
+        end
+      end
+
+      # Define a local variable on current stack
+      #
+      # @param [Symbol] name
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def define(name)
+        current << name
+      end
+
+      # Push reset scope on stack
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def push_reset
+        @stack << Set.new
+      end
+
+      # Push inherited lvar scope on stack
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def push_inherit
+        @stack << current.dup
+      end
+
+      # Pop lvar scope from stack
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def pop
+        @stack.pop
+      end
+
+    end # LocalVariableScope
+  end # AST
+end # Unparser

data/lib/unparser/cli.rb

@@ -5,7 +5,6 @@ require 'optparse'
 require 'diff/lcs'
 require 'diff/lcs/hunk'
 
-require 'unparser/cli/preprocessor'
 require 'unparser/cli/source'
 require 'unparser/cli/differ'
 require 'unparser/cli/color'
@@ -39,7 +38,7 @@ module Unparser
     # @api private
     #
     def initialize(arguments)
-      @sources = []
+      @sources, @ignore = [], Set.new
 
       @success   = true
       @fail_fast = false
@@ -48,14 +47,8 @@ module Unparser
         add_options(builder)
       end
 
-      arguments = opts.parse!(arguments)
-
-      arguments.each do |name|
-        if File.directory?(name)
-          add_directory(name)
-        else
-          add_file(name)
-        end
+      opts.parse!(arguments).each do |name|
+        @sources.concat(sources(name))
       end
     end
 
@@ -73,6 +66,12 @@ module Unparser
       builder.on('-e', '--evaluate SOURCE') do |original_source|
         @sources << Source::String.new(original_source)
       end
+      builder.on('--start-with FILE') do |file|
+        @start_with = sources(file).first
+      end
+      builder.on('--ignore FILE') do |file|
+        @ignore.merge(sources(file))
+      end
       builder.on('--fail-fast') do
         @fail_fast = true
       end
@@ -85,7 +84,8 @@ module Unparser
     # @api private
     #
     def exit_status
-      @sources.each do |source|
+      effective_sources.each do |source|
+        next if @ignore.include?(source)
         process_source(source)
         if @fail_fast
           break unless @success
@@ -115,30 +115,47 @@ module Unparser
       end
     end
 
-    # Add file
+    # Return effective sources
     #
-    # @param [String] file_name
-    #
-    # @return [undefined]
+    # @return [Enumerable<CLI::Source>]
     #
     # @api private
     #
-    def add_file(file_name)
-      @sources << Source::File.new(file_name)
+    def effective_sources
+      if @start_with
+        reject = true
+        @sources.reject do |source|
+          if reject && source == @start_with
+            reject = false
+          end
+
+          reject
+        end
+      else
+        @sources
+      end
     end
 
-    # Add directory
+    # Return sources for file name
     #
-    # @param [String] directory_name
+    # @param [String] file_name
     #
-    # @return [undefined]
+    # @return [Enumerable<CLI::Source>]
     #
     # @api private
     #
-    def add_directory(directory_name)
-      Dir.glob(File.join(directory_name, '**/*.rb')).each do |file_name|
-        add_file(file_name)
-      end
+    def sources(file_name)
+      files =
+        case
+        when File.directory?(file_name)
+          Dir.glob(File.join(file_name, '**/*.rb')).sort
+        when File.file?(file_name)
+          [file_name]
+        else
+          Dir.glob(file_name).sort
+        end
+
+      files.map(&Source::File.method(:new))
     end
 
   end # CLI

data/lib/unparser/cli/differ.rb

@@ -6,6 +6,41 @@ module Unparser
     class Differ
       include Adamantium::Flat, Concord.new(:old, :new), Procto.call(:colorized_diff)
 
+      CONTEXT_LINES = 5
+
+      # Return hunks
+      #
+      # @return [Array<Diff::LCS::Hunk>]
+      #
+      # @api private
+      #
+      def hunks
+        file_length_difference = new.length - old.length
+        diffs.map do |piece|
+          hunk = Diff::LCS::Hunk.new(old, new, piece, CONTEXT_LINES, file_length_difference)
+          file_length_difference = hunk.file_length_difference
+          hunk
+        end
+      end
+
+      # Return collapsed hunks
+      #
+      # @return [Enumerable<Diff::LCS::Hunk>]
+      #
+      # @api private
+      #
+      def collapsed_hunks
+        hunks.each_with_object([]) do |hunk, output|
+          last = output.last
+
+          if last && hunk.merge(last)
+            output.pop
+          end
+
+          output << hunk
+        end
+      end
+
       # Return source diff
       #
       # @return [String]
@@ -17,24 +52,11 @@ module Unparser
       # @api private
       #
       def diff
-        output = ""
-        lines = 5
-        hunk = oldhunk = nil
-        file_length_difference = new.length - old.length
-        diffs.each do |piece|
-          begin
-            hunk = Diff::LCS::Hunk.new(old, new, piece, lines, file_length_difference)
-            file_length_difference = hunk.file_length_difference
+        output = ''
 
-            next unless oldhunk
-            next if (lines > 0) && hunk.merge(oldhunk)
-
-            output << oldhunk.diff(:unified) << "\n"
-          ensure
-            oldhunk = hunk
-          end
+        collapsed_hunks.each do |hunk|
+          output << hunk.diff(:unified) << "\n"
         end
-        output << oldhunk.diff(:unified) << "\n"
 
         output
       end

data/lib/unparser/cli/source.rb

@@ -26,15 +26,17 @@ module Unparser
       # @api private
       #
       def error_report
-        if original_ast && generated_ast
+        case
+        when original_ast && generated_ast
           error_report_with_ast_diff
-        else
-          error_report_with_parser_error
+        when !original_ast
+          error_report_original
+        when !generated_ast
+          error_report_generated
         end
       end
       memoize :error_report
 
-
     private
 
       # Return generated source
@@ -48,21 +50,33 @@ module Unparser
       end
       memoize :generated_source
 
-      # Return error report with parser error
+      # Return error report for parsing original
       #
       # @return [String]
       #
       # @api private
       #
-      def error_report_with_parser_error
-        unless original_ast
-          return "Parsing of original source failed:\n#{original_source}"
-        end
-
-        unless generated_ast
-          return "Parsing of generated source failed:\nOriginal-AST:#{original_ast.inspect}\nSource:\n#{generated_source}"
-        end
+      def error_report_original
+        strip(<<-MESSAGE)
+          Parsing of original source failed:
+          #{original_source}
+        MESSAGE
+      end
 
+      # Return error report for parsing generated
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def error_report_generated
+        strip(<<-MESSAGE)
+          Parsing of generated source failed:
+          Original-AST:
+          #{original_ast.inspect}
+          Source:
+          #{generated_source}
+        MESSAGE
       end
 
       # Return error report with AST difference
@@ -72,11 +86,26 @@ module Unparser
       # @api private
       #
       def error_report_with_ast_diff
-        diff = Differ.call(
+        strip(<<-MESSAGE)
+          #{diff}
+          Original-Source:\n#{original_source}
+          Original-AST:\n#{original_ast.inspect}
+          Generated-Source:\n#{generated_source}
+          Generated-AST:\n#{generated_ast.inspect}
+        MESSAGE
+      end
+
+      # Return ast diff
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def ast_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
 
       # Return generated AST
@@ -90,7 +119,7 @@ module Unparser
       # @api private
       #
       def generated_ast
-        Preprocessor.run(parse(generated_source)) || s(:empty)
+        Preprocessor.run(parse(generated_source))
       rescue Parser::SyntaxError
         nil
       end
@@ -103,7 +132,7 @@ module Unparser
       # @api private
       #
       def original_ast
-        Preprocessor.run(parse(original_source)) || s(:empty)
+        Preprocessor.run(parse(original_source))
       rescue Parser::SyntaxError
         nil
       end