unparser 0.4.7 → 0.6.7

data/lib/unparser/comments.rb

@@ -3,8 +3,6 @@
 module Unparser
 
   # Holds the comments that remain to be emitted
-  #
-  # ignore :reek:RepeatedConditional
   class Comments
 
     # Proxy to singleton
@@ -113,39 +111,15 @@ module Unparser
 
   private
 
-    # Take comments while the provided block returns true
-    #
-    # @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)
     end
 
-    # Take comments up to the line number
-    #
-    # @param [Fixnum] line
-    #
-    # @return [Array]
-    #
-    # @api private
-    #
     def take_up_to_line(line)
       take_while { |comment| comment.location.expression.line <= line }
     end
 
-    # Unshift document comments and return the rest
-    #
-    # @param [Array] comments
-    #
-    # @return [Array]
-    #
-    # @api private
-    #
     def unshift_documents(comments)
       doc_comments, other_comments = comments.partition(&:document?)
       doc_comments.reverse_each { |comment| @comments.unshift(comment) }

data/lib/unparser/concord.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Unparser
+  # A mixin to define a composition
+  #
+  # Original code before vendoring and reduction from: https://github.com/mbj/concord.
+  class Concord < Module
+    include Adamantium, Equalizer.new(:names)
+
+    # The maximum number of objects the hosting class is composed of
+    MAX_NR_OF_OBJECTS = 3
+
+    # Return names
+    #
+    # @return [Enumerable<Symbol>]
+    #
+    # @api private
+    #
+    attr_reader :names
+
+    private
+
+    # Initialize object
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    # rubocop:disable Lint/MissingSuper
+    def initialize(*names)
+      if names.length > MAX_NR_OF_OBJECTS
+        fail "Composition of more than #{MAX_NR_OF_OBJECTS} objects is not allowed"
+      end
+
+      @names = names
+      define_initialize
+      define_readers
+      define_equalizer
+    end
+    # rubocop:enable Lint/MissingSuper
+
+    # Define equalizer
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def define_equalizer
+      include(Equalizer.new(*names))
+    end
+
+    # Define readers
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def define_readers
+      attribute_names = names
+      attr_reader(*attribute_names)
+
+      protected(*attribute_names) if attribute_names.any?
+    end
+
+    # Define initialize method
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    #
+    def define_initialize
+      ivars = instance_variable_names
+      size = names.size
+
+      define_method :initialize do |*args|
+        args_size = args.size
+        unless args_size.equal?(size)
+          fail ArgumentError, "wrong number of arguments (#{args_size} for #{size})"
+        end
+
+        ivars.zip(args) { |ivar, arg| instance_variable_set(ivar, arg) }
+      end
+    end
+
+    # Return instance variable names
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def instance_variable_names
+      names.map { |name| "@#{name}" }
+    end
+
+    # Mixin for public attribute readers
+    class Public < self
+
+      # Hook called when module is included
+      #
+      # @param [Class,Module] descendant
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def included(descendant)
+        names.each do |name|
+          descendant.__send__(:public, name)
+        end
+      end
+    end # Public
+  end # Concord
+end # Unparser

data/lib/unparser/constants.rb

@@ -2,66 +2,19 @@
 
 module Unparser
   # All unparser constants maybe included in other libraries.
-  #
-  # False positive since constants are frozen dynamically
-  # to avoid duplication of `.freeze` calls
-  #
-  # :reek:TooManyConstants
   module Constants
 
-    # Return frozen symbol set from enumerable
-    #
-    # @param [Enumerable] enumerable
-    #
-    # @return [Set<Symbol>]
-    #
-    # @api private
-    #
-    def self.symbol_set(enumerable)
-      enumerable.map(&:to_sym).freeze
-    end
-    private_class_method :symbol_set
-
-    BRACKETS_CURLY  = IceNine.deep_freeze(%w[{ }])
-    BRACKETS_ROUND  = IceNine.deep_freeze(%w[( )])
-    BRACKETS_SQUARE = IceNine.deep_freeze(%w([ ]))
-
     # All unary operators of the ruby language
-    UNARY_OPERATORS = symbol_set %w[
+    UNARY_OPERATORS = %i[
       ! ~ -@ +@
-    ]
+    ].to_set.freeze
 
     # All binary operators of the ruby language
-    BINARY_OPERATORS = symbol_set %w[
+    BINARY_OPERATORS = %i[
       + - * / & | && || << >> ==
       === != <= < <=> > >= =~ !~ ^
       ** %
-    ]
-
-    COMMENT = '#'
-
-    WS       = ' '
-    NL       = "\n"
-    T_DOT    = '.'
-    T_LT     = '<'
-    T_DLT    = '<<'
-    T_AMP    = '&'
-    T_ASN    = '='
-    T_SPLAT  = '*'
-    T_DSPLAT = '**'
-    T_ASR    = '=>'
-    T_PIPE   = '|'
-    T_DCL    = '::'
-    T_NEG    = '!'
-    T_OR     = '||'
-    T_AND    = '&&'
-    T_COLON  = ':'
-
-    M_PO  = '('
-    M_PC  = ')'
-
-    SNGL_QUOTE = "'"
-    DBL_QUOTE  = '"'
+    ].to_set.freeze
 
     # Keywords
     K_DO       = 'do'
@@ -107,8 +60,6 @@ module Unparser
     K_FILE     = '__FILE__'
     K_THEN     = 'then'
 
-    DEFAULT_DELIMITER = ', '.freeze
-
     KEYWORDS = constants.each_with_object([]) do |name, keywords|
       value = const_get(name).freeze
       next unless name.to_s.start_with?('K_')

data/lib/unparser/diff.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Unparser
+  # Class to create diffs from source code
+  class Diff
+    include Adamantium, 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
+
+    def diffs
+      ::Diff::LCS.diff(old, new)
+    end
+
+    def hunks
+      diffs.map do |diff|
+        ::Diff::LCS::Hunk.new(old.map(&:dup), new, diff, max_length, 0)
+      end
+    end
+
+    def minimized_hunk
+      head, *tail = hunks
+
+      tail.reduce(head) do |left, right|
+        right.merge(left)
+        right
+      end
+    end
+
+    def max_length
+      [old, new].map(&:length).max
+    end
+
+    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/dsl.rb

@@ -6,14 +6,6 @@ module Unparser
 
   private
 
-    # Define remaining children
-    #
-    # @param [Enumerable<Symbol>] names
-    #
-    # @return [undefined]
-    #
-    # @api private
-    #
     def define_remaining_children(names)
       range = names.length..-1
       define_method(:remaining_children) do
@@ -22,15 +14,6 @@ module Unparser
       private :remaining_children
     end
 
-    # Define named child
-    #
-    # @param [Symbol] name
-    # @param [Fixnum] index
-    #
-    # @return [undefined]
-    #
-    # @api private
-    #
     def define_child(name, index)
       define_method(name) do
         children.at(index)
@@ -38,15 +21,6 @@ module Unparser
       private name
     end
 
-    # Define a group of children
-    #
-    # @param [Symbol] name
-    # @param [Range] range
-    #
-    # @return [undefined]
-    #
-    # @api private
-    #
     def define_group(name, range)
       define_method(name) do
         children[range]
@@ -55,12 +29,6 @@ module Unparser
       memoize(name)
     end
 
-    # Create name helpers
-    #
-    # @return [undefined]
-    #
-    # @api private
-    #
     def children(*names)
       define_remaining_children(names)
 

data/lib/unparser/either.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Unparser
+  module RequireBlock
+
+  private
+
+    # Raise error unless block is provided
+    #
+    # @raise [MissingBlockError]
+    #   if no block is given
+    #
+    # @return [self]
+    def require_block
+      fail LocalJumpError unless block_given?
+
+      self
+    end
+  end # RequireBLock
+
+  class Either
+    include(
+      Adamantium,
+      Concord.new(:value),
+      RequireBlock
+    )
+
+    # Execute block and wrap error in left
+    #
+    # @param [Class<Exception>] exception
+    #
+    # @return [Either<Exception, Object>]
+    def self.wrap_error(*exceptions)
+      Right.new(yield)
+    rescue *exceptions => error
+      Left.new(error)
+    end
+
+    # Test for left constructor
+    #
+    # @return [Boolean]
+    def left?
+      instance_of?(Left)
+    end
+
+    # Test for right constructor
+    #
+    # @return [Boolean]
+    def right?
+      instance_of?(Right)
+    end
+
+    class Left < self
+      # Evaluate functor block
+      #
+      # @return [Either::Left<Object>]
+      def fmap(&block)
+        require_block(&block)
+      end
+
+      # Evaluate applicative block
+      #
+      # @return [Either::Left<Object>]
+      def bind(&block)
+        require_block(&block)
+      end
+
+      # Unwrap value from left
+      #
+      # @return [Object]
+      def from_left
+        value
+      end
+
+      # Unwrap value from right
+      #
+      # @return [Object]
+      #
+      def from_right
+        if block_given?
+          yield(value)
+        else
+          fail "Expected right value, got #{inspect}"
+        end
+      end
+
+      # Map over left value
+      #
+      # @return [Either::Right<Object>]
+      def lmap
+        Left.new(yield(value))
+      end
+
+      # Evaluate left side of branch
+      #
+      # @param [#call] left
+      # @param [#call] _right
+      def either(left, _right)
+        left.call(value)
+      end
+    end # Left
+
+    class Right < self
+      # Evaluate functor block
+      #
+      # @return [Either::Right<Object>]
+      def fmap
+        Right.new(yield(value))
+      end
+
+      # Evaluate applicative block
+      #
+      # @return [Either<Object>]
+      def bind
+        yield(value)
+      end
+
+      # Unwrap value from left
+      #
+      # @return [Object]
+      #
+      def from_left
+        if block_given?
+          yield(value)
+        else
+          fail "Expected left value, got #{inspect}"
+        end
+      end
+
+      # Unwrap value from right
+      #
+      # @return [Object]
+      def from_right
+        value
+      end
+
+      # Map over left value
+      #
+      # @return [Either::Right<Object>]
+      def lmap(&block)
+        require_block(&block)
+      end
+
+      # Evaluate right side of branch
+      #
+      # @param [#call] _left
+      # @param [#call] right
+      def either(_left, right)
+        right.call(value)
+      end
+    end # Right
+  end # Either
+end # Unparser

data/lib/unparser/emitter/alias.rb

@@ -11,16 +11,10 @@ module Unparser
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        write(K_ALIAS, WS)
+        write('alias ')
         visit(target)
-        write(WS)
+        ws
         visit(source)
       end
 

data/lib/unparser/emitter/args.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Arguments emitter
+    class Args < self
+      def emit_block_arguments
+        delimited(normal_arguments)
+
+        write(',') if normal_arguments.one? && n_arg?(normal_arguments.first)
+
+        emit_shadowargs
+      end
+
+      def emit_def_arguments
+        delimited(normal_arguments)
+      end
+
+      def emit_lambda_arguments
+        delimited(normal_arguments)
+        emit_shadowargs
+      end
+
+    private
+
+      def emit_shadowargs
+        return if shadowargs.empty?
+
+        write('; ')
+        delimited(shadowargs)
+      end
+
+      def normal_arguments
+        children.reject(&method(:n_shadowarg?))
+      end
+      memoize :normal_arguments
+
+      def shadowargs
+        children.select(&method(:n_shadowarg?))
+      end
+      memoize :shadowargs
+
+    end # Arguments
+  end # Emitter
+end # Unparser