unparser 0.4.7 → 0.4.8

data/README.md

@@ -1,8 +1,7 @@
 unparser
 ========
 
-[![Build Status](https://secure.travis-ci.org/mbj/unparser.svg?branch=master)](http://travis-ci.org/mbj/unparser)
-[![Code Climate](https://codeclimate.com/github/mbj/unparser.svg)](https://codeclimate.com/github/mbj/unparser)
+[![CI](https://github.com/mbj/unparser/workflows/CI/badge.svg)
 [![Gem Version](https://img.shields.io/gem/v/unparser.svg)](https://rubygems.org/gems/unparser)
 
 Generate equivalent source for ASTs from whitequarks [parser](https://github.com/whitequark/parser).

data/lib/unparser.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
-require 'set'
 require 'abstract_type'
-require 'procto'
+require 'anima'
 require 'concord'
+require 'diff/lcs'
+require 'diff/lcs/hunk'
+require 'mprelude'
 require 'parser/current'
+require 'procto'
+require 'set'
 
 # Library namespace
 module Unparser
@@ -40,11 +44,22 @@ module Unparser
   #
   # @param [String] source
   #
-  # @return [Parser::AST::Node]
+  # @return [Parser::AST::Node, nil]
   def self.parse(source)
     parser.parse(buffer(source))
   end
 
+  # Parse string into either syntax error or AST
+  #
+  # @param [String] source
+  #
+  # @return [MPrelude::Either<Parser::SyntaxError, (Parser::ASTNode, nil)>]
+  def self.parse_either(source)
+    MPrelude::Either.wrap_error(Parser::SyntaxError) do
+      parser.parse(buffer(source))
+    end
+  end
+
   # Parse string into AST, with comments
   #
   # @param [String] source
@@ -100,6 +115,8 @@ require 'unparser/constants'
 require 'unparser/dsl'
 require 'unparser/ast'
 require 'unparser/ast/local_variable_scope'
+require 'unparser/diff'
+require 'unparser/color'
 require 'unparser/emitter'
 require 'unparser/emitter/literal'
 require 'unparser/emitter/literal/primitive'
@@ -152,5 +169,6 @@ require 'unparser/emitter/resbody'
 require 'unparser/emitter/ensure'
 require 'unparser/emitter/index'
 require 'unparser/emitter/lambda'
+require 'unparser/validation'
 # make it easy for zombie
 require 'unparser/finalize'

data/lib/unparser/cli.rb

@@ -2,12 +2,6 @@
 
 require 'unparser'
 require 'optparse'
-require 'diff/lcs'
-require 'diff/lcs/hunk'
-
-require 'unparser/cli/source'
-require 'unparser/cli/differ'
-require 'unparser/cli/color'
 
 module Unparser
   # Unparser CLI implementation
@@ -19,6 +13,36 @@ module Unparser
     EXIT_SUCCESS = 0
     EXIT_FAILURE = 1
 
+    class Target
+      include AbstractType
+
+      # Path target
+      class Path < self
+        include Concord.new(:path)
+
+        # Validation for this target
+        #
+        # @return [Validation]
+        def validation
+          Validation.from_path(path)
+        end
+      end
+
+      # String target
+      class String
+        include Concord.new(:string)
+
+        # Validation for this target
+        #
+        # @return [Validation]
+        def validation
+          Validation.from_string(string)
+        end
+      end # String
+    end # Target
+
+    private_constant(*constants(false))
+
     # Run CLI
     #
     # @param [Array<String>] arguments
@@ -42,8 +66,8 @@ module Unparser
     #
     # ignore :reek:TooManyStatements
     def initialize(arguments)
-      @sources = []
-      @ignore = Set.new
+      @ignore  = Set.new
+      @targets = []
 
       @success   = true
       @fail_fast = false
@@ -54,7 +78,7 @@ module Unparser
       end
 
       opts.parse!(arguments).each do |name|
-        @sources.concat(sources(name))
+        @targets.concat(targets(name))
       end
     end
 
@@ -71,16 +95,16 @@ module Unparser
       builder.banner = 'usage: unparse [options] FILE [FILE]'
       builder.separator('')
       builder.on('-e', '--evaluate SOURCE') do |source|
-        @sources << Source::String.new(source)
+        @targets << Target::String.new(source)
       end
-      builder.on('--start-with FILE') do |file|
-        @start_with = sources(file).first
+      builder.on('--start-with FILE') do |path|
+        @start_with = targets(path).first
       end
       builder.on('-v', '--verbose') do
         @verbose = true
       end
       builder.on('--ignore FILE') do |file|
-        @ignore.merge(sources(file))
+        @ignore.merge(targets(file))
       end
       builder.on('--fail-fast') do
         @fail_fast = true
@@ -94,10 +118,8 @@ module Unparser
     # @api private
     #
     def exit_status
-      effective_sources.each do |source|
-        next if @ignore.include?(source)
-
-        process_source(source)
+      effective_targets.each do |target|
+        process_target(target)
         break if @fail_fast && !@success
       end
 
@@ -106,66 +128,64 @@ module Unparser
 
   private
 
-    # Process source
+    # Process target
     #
-    # @param [CLI::Source] source
+    # @param [Target] target
     #
     # @return [undefined]
     #
     # @api private
     #
-    def process_source(source)
-      if source.success?
-        puts source.report if @verbose
-        puts "Success: #{source.identification}"
+    def process_target(target)
+      validation = target.validation
+      if validation.success?
+        puts validation.report if @verbose
+        puts "Success: #{validation.identification}"
       else
-        puts source.report
-        puts "Error: #{source.identification}"
+        puts validation.report
+        puts "Error: #{validation.identification}"
         @success = false
       end
     end
 
-    # Return effective sources
+    # Return effective targets
     #
-    # @return [Enumerable<CLI::Source>]
+    # @return [Enumerable<Target>]
     #
     # @api private
     #
-    def effective_sources
+    def effective_targets
       if @start_with
         reject = true
-        @sources.reject do |source|
-          if reject && source.eql?(@start_with)
+        @targets.reject do |targets|
+          if reject && targets.eql?(@start_with)
             reject = false
           end
 
           reject
         end
       else
-        @sources
-      end
+        @targets
+      end.reject(&@ignore.method(:include?))
     end
 
-    # Return sources for file name
+    # Return targets for file name
     #
     # @param [String] file_name
     #
-    # @return [Enumerable<CLI::Source>]
+    # @return [Enumerable<Target>]
     #
     # @api private
     #
     # ignore :reek:UtilityFunction
-    def sources(file_name)
-      files =
-        if File.directory?(file_name)
-          Dir.glob(File.join(file_name, '**/*.rb')).sort
-        elsif File.file?(file_name)
-          [file_name]
-        else
-          Dir.glob(file_name).sort
-        end
-
-      files.map(&Source::File.method(:new))
+    def targets(file_name)
+      if File.directory?(file_name)
+        Dir.glob(File.join(file_name, '**/*.rb')).sort
+      elsif File.file?(file_name)
+        [file_name]
+      else
+        Dir.glob(file_name).sort
+      end.map { |file| Target::Path.new(Pathname.new(file)) }
     end
 
   end # CLI

data/lib/unparser/{cli/color.rb → color.rb}

@@ -10,9 +10,6 @@ module Unparser
     # @param [String] text
     #
     # @return [String]
-    #
-    # @api private
-    #
     def format(text)
       "\e[#{code}m#{text}\e[0m"
     end
@@ -25,9 +22,6 @@ module Unparser
       #
       # @return [String]
       #   the argument string
-      #
-      # @api private
-      #
       def format(text)
         text
       end
@@ -37,16 +31,12 @@ module Unparser
       # Initialize null color
       #
       # @return [undefined]
-      #
-      # @api private
-      #
       def initialize; end
 
     end.new
 
     RED   = Color.new(31)
     GREEN = Color.new(32)
-    BLUE  = Color.new(34)
 
   end # Color
 end # Unparser

data/lib/unparser/diff.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Unparser
+  # Class to create diffs from source code
+  class Diff
+    include Adamantium::Flat, Concord.new(:old, :new)
+
+    ADDITION = '+'
+    DELETION = '-'
+    NEWLINE  = "\n"
+
+    # Unified source diff between old and new
+    #
+    # @return [String]
+    #   if there is exactly one diff
+    #
+    # @return [nil]
+    #   otherwise
+    def diff
+      return if diffs.empty?
+
+      minimized_hunk.diff(:unified) + NEWLINE
+    end
+    memoize :diff
+
+    # Colorized unified source diff between old and new
+    #
+    # @return [String]
+    #   if there is a diff
+    #
+    # @return [nil]
+    #   otherwise
+    def colorized_diff
+      return unless diff
+
+      diff.lines.map(&self.class.method(:colorize_line)).join
+    end
+    memoize :colorized_diff
+
+    # Build new object from source strings
+    #
+    # @param [String] old
+    # @param [String] new
+    #
+    # @return [Diff]
+    def self.build(old, new)
+      new(lines(old), lines(new))
+    end
+
+    # Break up source into lines
+    #
+    # @param [String] source
+    #
+    # @return [Array<String>]
+    def self.lines(source)
+      source.lines.map(&:chomp)
+    end
+    private_class_method :lines
+
+  private
+
+    # Diffs between old and new
+    #
+    # @return [Array<Array>]
+    def diffs
+      ::Diff::LCS.diff(old, new)
+    end
+
+    # Raw diff-lcs hunks
+    #
+    # @return [Array<Diff::LCS::Hunk>]
+    def hunks
+      diffs.map do |diff|
+        ::Diff::LCS::Hunk.new(old.map(&:dup), new, diff, max_length, 0)
+      end
+    end
+
+    # Minimized hunk
+    #
+    # @return Diff::LCS::Hunk
+    def minimized_hunk
+      head, *tail = hunks
+
+      tail.reduce(head) do |left, right|
+        right.merge(left)
+        right
+      end
+    end
+
+    # Max length of source line in new and old
+    #
+    # @return [Integer]
+    def max_length
+      [old, new].map(&:length).max
+    end
+
+    # Colorized a unified diff line
+    #
+    # @param [String] line
+    #
+    # @return [String]
+    def self.colorize_line(line)
+      case line[0]
+      when ADDITION
+        Color::GREEN
+      when DELETION
+        Color::RED
+      else
+        Color::NONE
+      end.format(line)
+    end
+    private_class_method :colorize_line
+
+  end # Diff
+end # Unparser

data/lib/unparser/emitter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Unparser
+  UnknownNodeError = Class.new(ArgumentError)
 
   # Emitter base class
   #
@@ -116,7 +117,7 @@ module Unparser
     def self.emitter(node, parent)
       type = node.type
       klass = REGISTRY.fetch(type) do
-        raise ArgumentError, "No emitter for node: #{type.inspect}"
+        raise UnknownNodeError, "Unknown node type: #{type.inspect}"
       end
       klass.new(node, parent)
     end

data/lib/unparser/validation.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Unparser
+  # Validation of unparser results
+  #
+  # ignore :reek:TooManyMethods
+  class Validation
+    include Adamantium::Flat, Anima.new(
+      :generated_node,
+      :generated_source,
+      :identification,
+      :original_node,
+      :original_source
+    )
+
+    # Test if source could be unparsed successfully
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    #
+    def success?
+      [
+        original_source,
+        original_node,
+        generated_source,
+        generated_node
+      ].all?(&:right?) && generated_node.from_right.eql?(original_node.from_right)
+    end
+
+    # Return error report
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def report
+      message = [identification]
+
+      message.concat(make_report('Original-Source',  :original_source))
+      message.concat(make_report('Generated-Source', :generated_source))
+      message.concat(make_report('Original-Node',    :original_node))
+      message.concat(make_report('Generated-Node',   :generated_node))
+      message.concat(node_diff_report)
+
+      message.join("\n")
+    end
+    memoize :report
+
+    # Create validator from string
+    #
+    # @param [String] original_source
+    #
+    # @return [Validator]
+    def self.from_string(original_source)
+      original_node = Unparser
+        .parse_either(original_source)
+        .fmap(&Preprocessor.method(:run))
+
+      generated_source = original_node
+        .lmap(&method(:const_unit))
+        .bind(&method(:unparse_either))
+
+      generated_node = generated_source
+        .lmap(&method(:const_unit))
+        .bind(&Unparser.method(:parse_either))
+        .fmap(&Preprocessor.method(:run))
+
+      new(
+        identification:   '(string)',
+        original_source:  MPrelude::Either::Right.new(original_source),
+        original_node:    original_node,
+        generated_source: generated_source,
+        generated_node:   generated_node
+      )
+    end
+
+    # Create validator from file
+    #
+    # @param [Pathname] path
+    #
+    # @return [Validator]
+    def self.from_path(path)
+      from_string(path.read).with(identification: path.to_s)
+    end
+
+  private
+
+    # Create a labeled report from
+    #
+    # @param [String] label
+    # @param [Symbol] attribute_name
+    #
+    # @return [Array<String>]
+    def make_report(label, attribute_name)
+      ["#{label}:"].concat(public_send(attribute_name).either(method(:report_exception), ->(value) { [value] }))
+    end
+
+    # Report optional exception
+    #
+    # @param [Exception, nil] exception
+    #
+    # @return [Array<String>]
+    def report_exception(exception)
+      if exception
+        [exception.inspect].concat(exception.backtrace.take(20))
+      else
+        ['undefined']
+      end
+    end
+
+    # Report the node diff
+    #
+    # @return [Array<String>]
+    def node_diff_report
+      diff = nil
+
+      original_node.fmap do |original|
+        generated_node.fmap do |generated|
+          diff = Diff.new(
+            original.to_s.lines.map(&:chomp),
+            generated.to_s.lines.map(&:chomp)
+          ).colorized_diff
+        end
+      end
+
+      diff ? ['Node-Diff:', diff] : []
+    end
+
+    # Create unit represented as nil
+    #
+    # @param [Object] _value
+    #
+    # @return [nil]
+    def self.const_unit(_value); end
+    private_class_method :const_unit
+
+    # Unparse capturing errors
+    #
+    # @param [Parser::AST::Node] node
+    #
+    # @return [Either<RuntimeError, String>]
+    def self.unparse_either(node)
+      MPrelude::Either
+        .wrap_error(RuntimeError) { Unparser.unparse(node) }
+    end
+    private_class_method :unparse_either
+  end # Validation
+end # Unparser