unparser 0.4.7 → 0.6.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc149df7cd940bb78d005b8f3d30635a877c270d37f40cfe8e7d9ba8b305ab8a
-  data.tar.gz: c8a1d3dd4aba58f7fd6a6188341916566857057663d660bd24a2d40f6247158a
+  metadata.gz: 43c55e0072230fba02c24266555e1599559396739677e4371b6c9bca4b2a29b1
+  data.tar.gz: 4743b675c63ed3cf84ee3c784b70fd5078f8ed4e022e02bde27473a7bf44dbbe
 SHA512:
-  metadata.gz: 1cba4e5c9f029441dbca0eb39304478562e76c13023ec22b83dc5eeb58d7640d5c0d83878dad104e45ae6369662f3be0e7141398fb7cf37f6e4932075e305b0b
-  data.tar.gz: 2c61445c8d43bf01f24bb2f79dd2c49ba96fceef9479c6f1b94a77d7b5eba43fb79f0bbbf7d3995e143b81d208da6ad04852ec761daaf210741f46a049da0893
+  metadata.gz: 94bc33d333f3652cbdfa12169432d7a139b568cb72d4ae08994921760d2f7c8348a8d35f717053c059866ce7e640d08c9af6495a5e37132b2b667d1895b889da
+  data.tar.gz: ee2ee8e37250de111c419566c74d7b5954b02137f9e6fcb88cf9ff26820583698faf2533e6d01ae5738481bab91797060e2773781e9c93cb8da26efce602c1b0

data/README.md

@@ -1,20 +1,24 @@
 unparser
 ========
 
-[![Build Status](https://secure.travis-ci.org/mbj/unparser.svg?branch=master)](http://travis-ci.org/mbj/unparser)
-[![Code Climate](https://codeclimate.com/github/mbj/unparser.svg)](https://codeclimate.com/github/mbj/unparser)
+![CI](https://github.com/mbj/unparser/workflows/CI/badge.svg)
 [![Gem Version](https://img.shields.io/gem/v/unparser.svg)](https://rubygems.org/gems/unparser)
 
-Generate equivalent source for ASTs from whitequarks [parser](https://github.com/whitequark/parser).
+Generate equivalent source for ASTs from [parser](https://github.com/whitequark/parser).
 
 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.7
 
-It serves well for [mutant](https://github.com/mbj/mutant) mutators and the in-memory vendoring for self hosting,
-and other tooling.
+Notable Users:
+
+* [mutant](https://github.com/mbj/mutant) - Code review engine via mutation testing.
+* [ruby-next](https://github.com/ruby-next/ruby-next) - Ruby Syntax Backports.
+* May other [reverse-dependencies](https://rubygems.org/gems/unparser/reverse_dependencies).
+
+(if you want your tool to be mentioned here please PR the addition with a TLDR of your use case).
 
 Public API:
 -----------
@@ -87,16 +91,26 @@ RUBY
 
 generated = Unparser.unparse(node) # ["foo", "bar"], NOT %w[foo bar] !
 
-code == generated                            # false, not identical code
+code == generated                 # false, not identical code
 Unparser.parse(generated) == node # true, but identical AST
 ```
 
 Summary: unparser does not reproduce your source! It produces equivalent source.
 
+Ruby Versions:
+--------------
+
+Unparsers primay reason for existance is mutant and its
+supported [Ruby-Versions](https://github.com/mbj/mutant#ruby-versions).
+
+Basically: All non EOL MRI releases.
+
+If you need to generate Ruby Syntax outside of this band feel free to contact me (email in gemspec).
+
 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.
 
@@ -154,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
 -------------
 
@@ -161,10 +187,15 @@ Contributing
 * Make your feature addition or bug fix.
 * Add tests for it. This is important so I don't break it in a
   future version unintentionally.
-* Commit, do not mess with Rakefile or version
+* Commit, do not mess with version
   (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
 * Send me a pull request. Bonus points for topic branches.
 
+Known Users
+-------------
+
+* [RailsRocket](https://www.railsrocket.app) - A no-code app builder that creates Rails apps
+
 License
 -------
 

data/bin/unparser

@@ -2,9 +2,9 @@
 # frozen_string_literal: true
 
 trap('INT') do |status|
-  exit! 128 + status
+  exit! status + 128
 end
 
-require 'unparser/cli'
+require 'unparser'
 
 exit Unparser::CLI.run(ARGV)

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