unparser 0.5.7 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32c3cddc21f0047b0a97da52b3e897bc58a07128322cf3ebf9191e37a775a694
-  data.tar.gz: 40c3e5f35f04aa0f53450aa3753d056d41fd0057c3deafbe21b6d2a822347e2f
+  metadata.gz: 0a585e06cf743ca1901a601efa2fb7f178528307f89a6bea190df19014e3abf3
+  data.tar.gz: dc1980af7f00fa4b54da6fc91cc740857588bf5d1bf30f6c362be995a86a2d83
 SHA512:
-  metadata.gz: 05dec75daa6a074277a407862b37f1e1ded8989e8e1978b468363f4e413015f158311620dbfb8547ed1b179ad6a81a161620509ec0e1e26772115c0f07e3921d
-  data.tar.gz: 6794a56773e8ee22f2868d23ca48969d73c75e0c877ddeb001511261e919ddcb1e3026de91b816703209445d359fb41e95e338625fe1a8f3362dd06e772ec1bb
+  metadata.gz: da5524a1621bd1202f943c201b79b425ae4c203a9642a633b2a8a66fc85a0b8d3a250464c18432b791ce7e656c5b1a3940bc93d004f0bc18aa5413f931fc74bf
+  data.tar.gz: ab9cd266e002fcf85a12e1051a6b6a9fb9f47479ac2d7d883abcb99306d09ea6a196cb5d7de98a8c4f8a6635a78284e14e689cc2786f0a994eb504db0a0545ee

data/README.md

@@ -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.rb

@@ -1,16 +1,22 @@
 # frozen_string_literal: true
 
-require 'abstract_type'
-require 'anima'
-require 'concord'
 require 'diff/lcs'
 require 'diff/lcs/hunk'
-require 'mprelude'
 require 'optparse'
 require 'parser/current'
-require 'procto'
 require 'set'
 
+require 'unparser/equalizer'
+require 'unparser/adamantium'
+require 'unparser/adamantium/method_builder'
+require 'unparser/abstract_type'
+
+require 'unparser/concord'
+require 'unparser/either'
+require 'unparser/anima'
+require 'unparser/anima/attribute'
+require 'unparser/anima/error'
+
 # Library namespace
 module Unparser
   # Unparser specific AST builder defaulting to modern AST format
@@ -27,7 +33,18 @@ module Unparser
   EMPTY_STRING = ''.freeze
   EMPTY_ARRAY  = [].freeze
 
-  private_constant(*constants(false))
+  private_constant(*constants(false) - %i[Adamantium AbstractType Anima Concord Either Equalizer Memoizable])
+
+  # Error raised when unparser encounters an invalid AST
+  class InvalidNodeError < RuntimeError
+    attr_reader :node
+
+    def initialize(message, node)
+      super(message)
+      @node = node
+      freeze
+    end
+  end
 
   # Unparse an AST (and, optionally, comments) into a string
   #
@@ -36,8 +53,10 @@ module Unparser
   #
   # @return [String]
   #
-  # @api private
+  # @raise InvalidNodeError
+  #   if the node passed is invalid
   #
+  # @api public
   def self.unparse(node, comment_array = [])
     return '' if node.nil?
 
@@ -61,9 +80,9 @@ module Unparser
     validation = Validation.from_string(generated)
 
     if validation.success?
-      MPrelude::Either::Right.new(generated)
+      Either::Right.new(generated)
     else
-      MPrelude::Either::Left.new(validation)
+      Either::Left.new(validation)
     end
   end
 
@@ -75,8 +94,7 @@ module Unparser
   #
   # @return [Either<Exception, String>]
   def self.unparse_either(node)
-    MPrelude::Either
-      .wrap_error(Exception) { unparse(node) }
+    Either.wrap_error(Exception) { unparse(node) }
   end
 
   # Parse string into AST
@@ -92,9 +110,9 @@ module Unparser
   #
   # @param [String] source
   #
-  # @return [MPrelude::Either<Parser::SyntaxError, (Parser::ASTNode, nil)>]
+  # @return [Either<Parser::SyntaxError, (Parser::ASTNode, nil)>]
   def self.parse_either(source)
-    MPrelude::Either.wrap_error(Parser::SyntaxError) do
+    Either.wrap_error(Parser::SyntaxError) do
       parser.parse(buffer(source))
     end
   end

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.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/adamantium/method_builder.rb

@@ -0,0 +1,110 @@
+# 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