unparser 0.5.5 → 0.6.1

data/lib/unparser/buffer.rb

@@ -114,9 +114,9 @@ module Unparser
     # @api private
     #
     def capture_content
-      size_before = @content.size
+      size_before = content.size
       yield
-      @content[size_before..-1]
+      content[size_before..]
     end
 
     # Write raw fragment to buffer

data/lib/unparser/cli.rb

@@ -76,6 +76,7 @@ module Unparser
       @targets = []
 
       @fail_fast  = false
+      @start_with = nil
       @success    = true
       @validation = :validation
       @verbose    = false

data/lib/unparser/color.rb

@@ -3,7 +3,7 @@
 module Unparser
   # Class to colorize strings
   class Color
-    include Adamantium::Flat, Concord.new(:code)
+    include Adamantium, Concord.new(:code)
 
     # Format text with color
     #

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/diff.rb

@@ -3,7 +3,7 @@
 module Unparser
   # Class to create diffs from source code
   class Diff
-    include Adamantium::Flat, Concord.new(:old, :new)
+    include Adamantium, Concord.new(:old, :new)
 
     ADDITION = '+'
     DELETION = '-'

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/flow_modifier.rb

@@ -14,6 +14,12 @@ module Unparser
 
       handle(*MAP.keys)
 
+      def emit_heredoc_reminders
+        children.each do |node|
+          emitter(node).emit_heredoc_reminders
+        end
+      end
+
     private
 
       def dispatch

data/lib/unparser/emitter/hash.rb

@@ -4,10 +4,6 @@ module Unparser
   class Emitter
     # Emitter for Hash literals
     class Hash < self
-      BAREWORD = /\A[A-Za-z_][A-Za-z_0-9]*[?!]?\z/.freeze
-
-      private_constant(*constants(false))
-
       handle :hash
 
       def emit_last_argument_hash
@@ -41,34 +37,8 @@ module Unparser
       end
 
       def emit_hash_body
-        delimited(children, &method(:emit_hash_member))
-      end
-
-      def emit_hash_member(node)
-        if n_kwsplat?(node)
-          visit(node)
-        else
-          emit_pair(node)
-        end
+        delimited(children)
       end
-
-      def emit_pair(pair)
-        key, value = *pair.children
-
-        if colon?(key)
-          write(key.children.first.to_s, ': ')
-        else
-          visit(key)
-          write(' => ')
-        end
-
-        visit(value)
-      end
-
-      def colon?(key)
-        n_sym?(key) && BAREWORD.match?(key.children.first)
-      end
-
     end # Hash
   end # Emitter
 end # Unparser

data/lib/unparser/emitter/hash_pattern.rb

@@ -60,7 +60,7 @@ module Unparser
       end
 
       def write_symbol_body(symbol)
-        write(symbol.inspect[1..-1])
+        write(symbol.inspect[1..])
       end
     end # Pin
   end # Emitter

data/lib/unparser/emitter/index.rb

@@ -36,7 +36,7 @@ module Unparser
         handle :indexasgn
 
         VALUE_RANGE     = (1..-2).freeze
-        NO_VALUE_PARENT = IceNine.deep_freeze(%i[and_asgn op_asgn or_asgn].to_set)
+        NO_VALUE_PARENT = %i[and_asgn op_asgn or_asgn].to_set.freeze
 
         private_constant(*constants(false))
 

data/lib/unparser/emitter/kwargs.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    class Kwargs < self
+      handle :kwargs
+
+      def dispatch
+        delimited(children)
+      end
+    end # Kwargs
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/match_pattern.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for in pattern nodes
+    class MatchPattern < self
+
+      handle :match_pattern
+      handle :match_pattern_p
+
+      children :target, :pattern
+
+    private
+
+      def dispatch
+        visit(target)
+        write(' in ')
+        visit(pattern)
+      end
+    end # InPattern
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/op_assign.rb

@@ -7,10 +7,10 @@ module Unparser
     class BinaryAssign < self
       children :target, :expression
 
-      MAP = IceNine.deep_freeze(
+      MAP = {
         and_asgn: '&&=',
         or_asgn:  '||='
-      )
+      }.freeze
 
       handle(*MAP.keys)
 

data/lib/unparser/emitter/pair.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for key value pairs in hash literals or kwargs
+    class Pair < self
+      BAREWORD = /\A[A-Za-z_][A-Za-z_0-9]*[?!]?\z/.freeze
+
+      private_constant(*constants(false))
+
+      handle :pair
+
+      children :key, :value
+
+    private
+
+      def dispatch
+        if colon?(key)
+          write(key.children.first.to_s, ': ')
+        else
+          visit(key)
+          write(' => ')
+        end
+
+        visit(value)
+      end
+
+      def colon?(key)
+        n_sym?(key) && BAREWORD.match?(key.children.first)
+      end
+    end
+  end
+end

data/lib/unparser/emitter/primitive.rb

@@ -28,11 +28,11 @@ module Unparser
         RATIONAL_FORMAT = 'i'.freeze
 
         MAP =
-          IceNine.deep_freeze(
+          {
             ::Float    => :float,
             ::Rational => :rational,
             ::Integer  => :int
-          )
+          }.freeze
 
       private
 

data/lib/unparser/emitter/simple.rb

@@ -4,7 +4,7 @@ module Unparser
   class Emitter
     # Emitter for simple nodes that generate a single token
     class Simple < self
-      MAP = IceNine.deep_freeze(
+      MAP = {
         __ENCODING__:      '__ENCODING__',
         __FILE__:          '__FILE__',
         __LINE__:          '__LINE__',
@@ -19,7 +19,7 @@ module Unparser
         self:              'self',
         true:              'true',
         zsuper:            'super'
-      )
+      }.freeze
 
       handle(*MAP.keys)
 

data/lib/unparser/emitter.rb

@@ -5,7 +5,7 @@ module Unparser
 
   # Emitter base class
   class Emitter
-    include Adamantium::Flat, AbstractType, Constants, Generation, NodeHelpers
+    include Adamantium, AbstractType, Constants, Generation, NodeHelpers
     include Anima.new(:buffer, :comments, :node, :local_variable_scope)
 
     public :node

data/lib/unparser/equalizer.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Unparser
+  # Define equality, equivalence and inspection methods
+  #
+  # Original code before vendoring and reduction from: https://github.com/dkubb/equalizer.
+  class Equalizer < Module
+    # Initialize an Equalizer with the given keys
+    #
+    # Will use the keys with which it is initialized to define #cmp?,
+    # #hash, and #inspect
+    #
+    # @param [Array<Symbol>] keys
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    # rubocop:disable Lint/MissingSuper
+    def initialize(*keys)
+      @keys = keys
+      define_methods
+      freeze
+    end
+    # rubocop:enable Lint/MissingSuper
+
+    private
+
+    def included(descendant)
+      descendant.include(Methods)
+    end
+
+    def define_methods
+      define_cmp_method
+      define_hash_method
+      define_inspect_method
+    end
+
+    def define_cmp_method
+      keys = @keys
+      define_method(:cmp?) do |comparator, other|
+        keys.all? do |key|
+          __send__(key).public_send(comparator, other.__send__(key))
+        end
+      end
+      private :cmp?
+    end
+
+    def define_hash_method
+      keys = @keys
+      define_method(:hash) do
+        keys.map(&public_method(:__send__)).push(self.class).hash
+      end
+    end
+
+    def define_inspect_method
+      keys = @keys
+      define_method(:inspect) do
+        klass = self.class
+        name  = klass.name || klass.inspect
+        "#<#{name}#{keys.map { |key| " #{key}=#{__send__(key).inspect}" }.join}>"
+      end
+    end
+
+    # The comparison methods
+    module Methods
+      # Compare the object with other object for equality
+      #
+      # @example
+      #   object.eql?(other)  # => true or false
+      #
+      # @param [Object] other
+      #   the other object to compare with
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def eql?(other)
+        instance_of?(other.class) && cmp?(__method__, other)
+      end
+
+      # Compare the object with other object for equivalency
+      #
+      # @example
+      #   object == other  # => true or false
+      #
+      # @param [Object] other
+      #   the other object to compare with
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def ==(other)
+        instance_of?(other.class) && cmp?(__method__, other)
+      end
+    end # module Methods
+  end # class Equalizer
+end # Unparser

data/lib/unparser/node_details/send.rb

@@ -19,7 +19,10 @@ module Unparser
       end
 
       def binary_syntax_allowed?
-        selector_binary_operator? && arguments.one? && !n_splat?(arguments.first)
+        selector_binary_operator?        \
+          && arguments.one?              \
+          && !n_splat?(arguments.first)  \
+          && !n_kwargs?(arguments.first)
       end
 
       def selector_unary_operator?
@@ -48,7 +51,7 @@ module Unparser
       memoize :assignment?
 
       def arguments
-        children[2..-1]
+        children[2..]
       end
       memoize :arguments
 

data/lib/unparser/node_details.rb

@@ -6,7 +6,7 @@ module Unparser
 
     def self.included(descendant)
       descendant.class_eval do
-        include Adamantium::Flat, Concord.new(:node)
+        include Adamantium, Concord.new(:node)
 
         extend DSL
       end

data/lib/unparser/node_helpers.rb

@@ -36,18 +36,20 @@ module Unparser
       args
       array
       array_pattern
-      empty_else
       begin
       block
       cbase
       const
       dstr
+      empty_else
       ensure
       hash
       hash_pattern
       if
       in_pattern
       int
+      kwarg
+      kwargs
       kwsplat
       lambda
       match_rest

data/lib/unparser/validation.rb

@@ -3,7 +3,7 @@
 module Unparser
   # Validation of unparser results
   class Validation
-    include Adamantium::Flat, Anima.new(
+    include Adamantium, Anima.new(
       :generated_node,
       :generated_source,
       :identification,
@@ -64,7 +64,7 @@ module Unparser
 
       new(
         identification:   '(string)',
-        original_source:  MPrelude::Either::Right.new(original_source),
+        original_source:  Either::Right.new(original_source),
         original_node:    original_node,
         generated_source: generated_source,
         generated_node:   generated_node
@@ -86,7 +86,7 @@ module Unparser
       new(
         identification:   '(string)',
         original_source:  generated_source,
-        original_node:    MPrelude::Either::Right.new(original_node),
+        original_node:    Either::Right.new(original_node),
         generated_source: generated_source,
         generated_node:   generated_node
       )