unparser 0.5.5 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 824d898a010fcf41a3a7d243d3f6c30dc551751fccc8a7d592e73fe6685dab8c
-  data.tar.gz: ef5e5fdc7df12831465d4ed15d35da615ff10eafb342d2a32495c42d88c7b415
+  metadata.gz: 2d9558d9e9cdfea4d859aaccc4c0ae5e90d28ef05c0cee26710923dd48692c5a
+  data.tar.gz: 0d8e0fe60dc8d5e443c63137e0bbe1d0117b1688eb3f8c2a7f6df273812abfe6
 SHA512:
-  metadata.gz: c902fd66c8d5195ba76c3f53d028112e41e4bff18e62d851e207949ea332d5c1e2a352a2eb478b626a6fee2c4d908303c595c94364c03539bb4aa8a72d53b64d
-  data.tar.gz: 647e6ac18916a4e2454cd1c018932da6c464598ac548d84da242d6b8d8b19c06a5ee430d9fa35338e3576bb860ac3acbde3814e6d891259db1506b9004c612cc
+  metadata.gz: e78f9eadbc554546e0a77fbf8ae198252bd30ee00d893f29c21a4e454d07be7f235eafa8c2501296fd5e3b00102d4b412cbadc6ae4d1f269cad187f8f69dbc3a
+  data.tar.gz: c22cae778457ea0377a939c9940a0aa7976631e87f53ed67e9218759102f563eae76b7102418f3f55c834c229ec4ad10b3cc532b2c3ef6383f13ebb67b01c1b1

data/README.md

@@ -10,7 +10,7 @@ The following constraints apply:
 
 * No support for macruby extensions
 * Only support for the [modern AST](https://github.com/whitequark/parser/#usage) format
-* Only support for Ruby >= 2.5
+* Only support for Ruby >= 2.6
 
 Notable Users:
 
@@ -110,7 +110,7 @@ If you need to generate Ruby Syntax outside of this band feel free to contact me
 Testing:
 --------
 
-Unparser currently successfully round trips almost all ruby code around. Using MRI-2.5.x.
+Unparser currently successfully round trips almost all ruby code around. Using Ruby >= 2.6.
 If there is a non round trippable example that is NOT subjected to known [Limitations](#limitations).
 please report a bug.
 
@@ -168,6 +168,18 @@ People
 
 Various people contributed to this repository. See [Contributors](https://github.com/mbj/unparser/graphs/contributors).
 
+Included Libraries
+------------------
+
+For dependency reduction reasons unparser ships vendored (and reduced) versions of:
+
+* [abstract_type](https://github.com/mbj/concord) -> Unparser::AbstractType
+* [adamantium](https://github.com/dkubb/adamantium) -> Unparser::Adamantium
+* [anima](https://github.com/mbj/concord) -> Unparser::Anima
+* [concord](https://github.com/mbj/concord) -> Unparser::Concord
+* [memoizable](https://github.com/dkubb/memoizable) -> Unparser::Adamantium
+* [mprelude](https://github.com/dkubb/memoizable) -> Unparser::Either
+
 Contributing
 -------------
 

data/lib/unparser/abstract_type.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Unparser
+  # Module to allow class and methods to be abstract
+  #
+  # Original code before vendoring and reduction from: https://github.com/dkubb/abstract_type.
+  module AbstractType
+
+    # Hook called when module is included
+    #
+    # @param [Module] descendant
+    #   the module or class including AbstractType
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def self.included(descendant)
+      super
+      create_new_method(descendant)
+      descendant.extend(AbstractMethodDeclarations)
+    end
+
+    private_class_method :included
+
+    # Define the new method on the abstract type
+    #
+    # Ensures that the instance cannot be of the abstract type
+    # and must be a descendant.
+    #
+    # @param [Class] abstract_class
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def self.create_new_method(abstract_class)
+      abstract_class.define_singleton_method(:new) do |*args, &block|
+        if equal?(abstract_class)
+          fail NotImplementedError, "#{self} is an abstract type"
+        else
+          super(*args, &block)
+        end
+      end
+    end
+
+    private_class_method :create_new_method
+
+    module AbstractMethodDeclarations
+
+      # Create abstract instance methods
+      #
+      # @example
+      #   class Foo
+      #     include AbstractType
+      #
+      #     # Create an abstract instance method
+      #     abstract_method :some_method
+      #   end
+      #
+      # @param [Array<#to_s>] names
+      #
+      # @return [self]
+      #
+      # @api public
+      def abstract_method(*names)
+        names.each(&method(:create_abstract_instance_method))
+        self
+      end
+
+      # Create abstract singleton methods
+      #
+      # @example
+      #   class Foo
+      #     include AbstractType
+      #
+      #     # Create an abstract instance method
+      #     abstract_singleton_method :some_method
+      #   end
+      #
+      # @param [Array<#to_s>] names
+      #
+      # @return [self]
+      #
+      # @api private
+      def abstract_singleton_method(*names)
+        names.each(&method(:create_abstract_singleton_method))
+        self
+      end
+
+    private
+
+      # Create abstract singleton method
+      #
+      # @param [#to_s] name
+      #   the name of the method to create
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def create_abstract_singleton_method(name)
+        define_singleton_method(name) do |*|
+          fail NotImplementedError, "#{self}.#{name} is not implemented"
+        end
+      end
+
+      # Create abstract instance method
+      #
+      # @param [#to_s] name
+      #   the name of the method to create
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def create_abstract_instance_method(name)
+        define_method(name) do |*|
+          fail NotImplementedError, "#{self.class}##{name} is not implemented"
+        end
+      end
+
+    end # AbstractMethodDeclarations
+  end # AbstractType
+end # Unparser

data/lib/unparser/adamantium/method_builder.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Adamantium
+    # Build the memoized method
+    class MethodBuilder
+
+      # Raised when the method arity is invalid
+      class InvalidArityError < ArgumentError
+
+        # Initialize an invalid arity exception
+        #
+        # @param [Module] descendant
+        # @param [Symbol] method
+        # @param [Integer] arity
+        #
+        # @api private
+        def initialize(descendant, method, arity)
+          super("Cannot memoize #{descendant}##{method}, its arity is #{arity}")
+        end
+
+      end # InvalidArityError
+
+      # Raised when a block is passed to a memoized method
+      class BlockNotAllowedError < ArgumentError
+
+        # Initialize a block not allowed exception
+        #
+        # @param [Module] descendant
+        # @param [Symbol] method
+        #
+        # @api private
+        def initialize(descendant, method)
+          super("Cannot pass a block to #{descendant}##{method}, it is memoized")
+        end
+
+      end # BlockNotAllowedError
+
+      # Initialize an object to build a memoized method
+      #
+      # @param [Module] descendant
+      # @param [Symbol] method_name
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(descendant, method_name)
+        @descendant          = descendant
+        @method_name         = method_name
+        @original_visibility = visibility
+        @original_method     = @descendant.instance_method(@method_name)
+        assert_arity(@original_method.arity)
+      end
+
+      # Build a new memoized method
+      #
+      # @example
+      #   method_builder.call  # => creates new method
+      #
+      # @return [UnboundMethod]
+      #
+      # @api public
+      def call
+        remove_original_method
+        create_memoized_method
+        set_method_visibility
+        @original_method
+      end
+
+    private
+
+      def assert_arity(arity)
+        if arity.nonzero?
+          fail InvalidArityError.new(@descendant, @method_name, arity)
+        end
+      end
+
+      def remove_original_method
+        name = @method_name
+        @descendant.module_eval { undef_method(name) }
+      end
+
+      def create_memoized_method
+        name =   @method_name
+        method = @original_method
+        @descendant.module_eval do
+          define_method(name) do |&block|
+            fail BlockNotAllowedError.new(self.class, name) if block
+
+            memoized_method_cache.fetch(name) do
+              method.bind(self).call.freeze
+            end
+          end
+        end
+      end
+
+      def set_method_visibility
+        @descendant.__send__(@original_visibility, @method_name)
+      end
+
+      def visibility
+        if    @descendant.private_method_defined?(@method_name)   then :private
+        elsif @descendant.protected_method_defined?(@method_name) then :protected
+        else
+          :public
+        end
+      end
+
+    end # MethodBuilder
+  end # Adamantium
+end # Unparser

data/lib/unparser/adamantium.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Unparser
+  # Allows objects to be made immutable
+  #
+  # Original code before vendoring and reduction from: https://github.com/dkubb/adamantium.
+  module Adamantium
+    module InstanceMethods
+      # A noop #dup for immutable objects
+      #
+      # @return [self]
+      #
+      # @api public
+      def dup
+        self
+      end
+
+      # Freeze the object
+      #
+      # @return [Object]
+      #
+      # @api public
+      def freeze
+        memoized_method_cache
+        super()
+      end
+
+    private
+
+      def memoized_method_cache
+        @memoized_method_cache ||= Memory.new({})
+      end
+
+    end # InstanceMethods
+
+    # Storage for memoized methods
+    class Memory
+
+      # Initialize the memory storage for memoized methods
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(values)
+        @values  = values
+        @monitor = Monitor.new
+        freeze
+      end
+
+      # Fetch the value from memory, or evaluate if it does not exist
+      #
+      # @param [Symbol] name
+      #
+      # @yieldreturn [Object]
+      #   the value to memoize
+      #
+      # @api public
+      def fetch(name)
+        @values.fetch(name) do      # check for the key
+          @monitor.synchronize do   # acquire a lock if the key is not found
+            @values.fetch(name) do  # recheck under lock
+              @values[name] = yield # set the value
+            end
+          end
+        end
+      end
+    end # Memory
+
+    # Methods mixed in to adamantium classes
+    module ClassMethods
+
+      # Instantiate a new frozen object
+      #
+      # @return [Object]
+      #
+      # @api public
+      def new(*)
+        super.freeze
+      end
+
+    end # ClassMethods
+
+    # Methods mixed in to adamantium modules
+    module ModuleMethods
+
+      # Memoize a list of methods
+      #
+      # @param [Array<#to_s>] methods
+      #   a list of methods to memoize
+      #
+      # @return [self]
+      #
+      # @api public
+      def memoize(*methods)
+        methods.each(&method(:memoize_method))
+        self
+      end
+
+      # Test if method is memoized
+      #
+      # @param [Symbol] name
+      #
+      # @return [Bool]
+      def memoized?(method_name)
+        memoized_methods.key?(method_name)
+      end
+
+      # Return unmemoized instance method
+      #
+      # @param [Symbol] name
+      #
+      # @return [UnboundMethod]
+      #   the memoized method
+      #
+      # @raise [NameError]
+      #   raised if the method is unknown
+      #
+      # @api public
+      def unmemoized_instance_method(method_name)
+        memoized_methods.fetch(method_name) do
+          fail ArgumentError, "##{method_name} is not memoized"
+        end
+      end
+
+    private
+
+      def memoize_method(method_name)
+        if memoized_methods.key?(method_name)
+          fail ArgumentError, "##{method_name} is already memoized"
+        end
+
+        memoized_methods[method_name] = MethodBuilder.new(self, method_name).call
+      end
+
+      def memoized_methods
+        @memoized_methods ||= {}
+      end
+
+    end # ModuleMethods
+
+    def self.included(descendant)
+      descendant.class_eval do
+        include InstanceMethods
+        extend ModuleMethods
+        extend ClassMethods if instance_of?(Class)
+      end
+    end
+    private_class_method :included
+  end # Adamantium
+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/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/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
       #