unparser 0.5.3 → 0.6.0

data/lib/unparser/anima.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Unparser
+  # Original code before vendoring and reduction from: https://github.com/mbj/anima.
+  class Anima < Module
+    include Adamantium, Equalizer.new(:attributes)
+
+    # Return names
+    #
+    # @return [AttributeSet]
+    attr_reader :attributes
+
+    # Initialize object
+    #
+    # @return [undefined]
+    #
+    # rubocop:disable Lint/MissingSuper
+    def initialize(*names)
+      @attributes = names.uniq.map(&Attribute.public_method(:new)).freeze
+    end
+    # rubocop:enable Lint/MissingSuper
+
+    # Return new anima with attributes added
+    #
+    # @return [Anima]
+    #
+    # @example
+    #   anima = Anima.new(:foo)
+    #   anima.add(:bar) # equals Anima.new(:foo, :bar)
+    #
+    def add(*names)
+      new(attribute_names + names)
+    end
+
+    # Return new anima with attributes removed
+    #
+    # @return [Anima]
+    #
+    # @example
+    #   anima = Anima.new(:foo, :bar)
+    #   anima.remove(:bar) # equals Anima.new(:foo)
+    #
+    def remove(*names)
+      new(attribute_names - names)
+    end
+
+    # Return attributes hash for instance
+    #
+    # @param [Object] object
+    #
+    # @return [Hash]
+    def attributes_hash(object)
+      attributes.each_with_object({}) do |attribute, attributes_hash|
+        attributes_hash[attribute.name] = attribute.get(object)
+      end
+    end
+
+    # Return attribute names
+    #
+    # @return [Enumerable<Symbol>]
+    def attribute_names
+      attributes.map(&:name)
+    end
+    memoize :attribute_names
+
+    # Initialize instance
+    #
+    # @param [Object] object
+    #
+    # @param [Hash] attribute_hash
+    #
+    # @return [self]
+    def initialize_instance(object, attribute_hash)
+      assert_known_attributes(object.class, attribute_hash)
+      attributes.each do |attribute|
+        attribute.load(object, attribute_hash)
+      end
+      self
+    end
+
+    # Static instance methods for anima infected classes
+    module InstanceMethods
+      # Initialize an anima infected object
+      #
+      # @param [#to_h] attributes
+      #   a hash that matches anima defined attributes
+      #
+      # @return [undefined]
+      #
+      # rubocop:disable Lint/MissingSuper
+      def initialize(attributes)
+        self.class.anima.initialize_instance(self, attributes)
+      end
+      # rubocop:enable Lint/MissingSuper
+
+      # Return a hash representation of an anima infected object
+      #
+      # @example
+      #   anima.to_h # => { :foo => : bar }
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def to_h
+        self.class.anima.attributes_hash(self)
+      end
+
+      # Return updated instance
+      #
+      # @example
+      #   klass = Class.new do
+      #     include Anima.new(:foo, :bar)
+      #   end
+      #
+      #   foo = klass.new(:foo => 1, :bar => 2)
+      #   updated = foo.with(:foo => 3)
+      #   updated.foo # => 3
+      #   updated.bar # => 2
+      #
+      # @param [Hash] attributes
+      #
+      # @return [Anima]
+      #
+      # @api public
+      def with(attributes)
+        self.class.new(to_h.update(attributes))
+      end
+    end # InstanceMethods
+
+    private
+
+    # Infect the instance with anima
+    #
+    # @param [Class, Module] scope
+    #
+    # @return [undefined]
+    def included(descendant)
+      descendant.instance_exec(self, attribute_names) do |anima, names|
+        # Define anima method
+        define_singleton_method(:anima) { anima }
+
+        # Define instance methods
+        include InstanceMethods
+
+        # Define attribute readers
+        attr_reader(*names)
+
+        # Define equalizer
+        include Equalizer.new(*names)
+      end
+    end
+
+    # Fail unless keys in +attribute_hash+ matches #attribute_names
+    #
+    # @param [Class] klass
+    #   the class being initialized
+    #
+    # @param [Hash] attribute_hash
+    #   the attributes to initialize +object+ with
+    #
+    # @return [undefined]
+    #
+    # @raise [Error]
+    def assert_known_attributes(klass, attribute_hash)
+      keys = attribute_hash.keys
+
+      unknown = keys - attribute_names
+      missing = attribute_names - keys
+
+      unless unknown.empty? && missing.empty?
+        fail Error.new(klass, missing, unknown)
+      end
+    end
+
+    # Return new instance
+    #
+    # @param [Enumerable<Symbol>] attributes
+    #
+    # @return [Anima]
+    def new(attributes)
+      self.class.new(*attributes)
+    end
+  end # Anima
+end # Unparser

data/lib/unparser/anima/attribute.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Anima
+    # An attribute
+    class Attribute
+      include Adamantium, Equalizer.new(:name)
+
+      # Initialize attribute
+      #
+      # @param [Symbol] name
+      def initialize(name)
+        @name = name
+        @instance_variable_name = :"@#{name}"
+      end
+
+      # Return attribute name
+      #
+      # @return [Symbol]
+      attr_reader :name
+
+      # Return instance variable name
+      #
+      # @return [Symbol]
+      attr_reader :instance_variable_name
+
+      # Load attribute
+      #
+      # @param [Object] object
+      # @param [Hash] attributes
+      #
+      # @return [self]
+      def load(object, attributes)
+        set(object, attributes.fetch(name))
+      end
+
+      # Get attribute value from object
+      #
+      # @param [Object] object
+      #
+      # @return [Object]
+      def get(object)
+        object.public_send(name)
+      end
+
+      # Set attribute value in object
+      #
+      # @param [Object] object
+      # @param [Object] value
+      #
+      # @return [self]
+      def set(object, value)
+        object.instance_variable_set(instance_variable_name, value)
+
+        self
+      end
+    end # Attribute
+  end # Anima
+end # Unparser

data/lib/unparser/anima/error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Anima
+    # Abstract base class for anima errors
+    class Error < RuntimeError
+      FORMAT = '%s attributes missing: %s, unknown: %s'.freeze
+      private_constant(*constants(false))
+
+      # Initialize object
+      #
+      # @param [Class] klass
+      #   the class being initialized
+      # @param [Enumerable<Symbol>] missing
+      # @param [Enumerable<Symbol>] unknown
+      #
+      # @return [undefined]
+      def initialize(klass, missing, unknown)
+        super(format(FORMAT, klass, missing, unknown))
+      end
+    end # Error
+  end # Anima
+end # Unparser

data/lib/unparser/ast.rb

@@ -3,7 +3,6 @@
 module Unparser
   # Namespace for AST processing tools
   module AST
-
     FIRST_CHILD = ->(node) { node.children.first }.freeze
     TAUTOLOGY   = ->(_node) { true }.freeze
 
@@ -79,7 +78,7 @@ module Unparser
 
     # AST enumerator
     class Enumerator
-      include Adamantium::Flat, Concord.new(:node, :controller), Enumerable
+      include Adamantium, Concord.new(:node, :controller), Enumerable
 
       # Return new instance
       #

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