super-smart-tool 0.0.1

data/dry-types-1.9.1/lib/dry/types/constrained.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Constrained types apply rules to the input
+    #
+    # @api public
+    class Constrained
+      include Type
+      include Decorator
+      include Builder
+      include Printable
+      include ::Dry::Equalizer(:type, :rule, inspect: false, immutable: true)
+
+      # @return [Dry::Logic::Rule]
+      attr_reader :rule
+
+      # @param [Type] type
+      #
+      # @param [Hash] options
+      #
+      # @api public
+      def initialize(type, **options)
+        super
+        @rule = options.fetch(:rule)
+      end
+
+      # @return [Object]
+      #
+      # @api private
+      def call_unsafe(input)
+        result = rule.(input)
+
+        if result.success?
+          type.call_unsafe(input)
+        else
+          raise ConstraintError.new(result, input)
+        end
+      end
+
+      # @return [Object]
+      #
+      # @api private
+      def call_safe(input, &)
+        if rule[input]
+          type.call_safe(input, &)
+        else
+          yield
+        end
+      end
+
+      # Safe coercion attempt. It is similar to #call with a
+      # block given but returns a Result instance with metadata
+      # about errors (if any).
+      #
+      # @overload try(input)
+      #   @param [Object] input
+      #   @return [Logic::Result]
+      #
+      # @overload try(input)
+      #   @param [Object] input
+      #   @yieldparam [Failure] failure
+      #   @yieldreturn [Object]
+      #   @return [Object]
+      #
+      # @api public
+      def try(input, &)
+        result = rule.(input)
+
+        if result.success?
+          type.try(input, &)
+        else
+          failure = failure(input, ConstraintError.new(result, input))
+          block_given? ? yield(failure) : failure
+        end
+      end
+
+      # @param *nullary_rules [Array<Symbol>] a list of rules that do not require an additional
+      #   argument (e.g., :odd)
+      # @param **unary_rules [Hash] a list of rules that require an additional argument
+      #   (e.g., gt: 0)
+      #   The parameters are merger to create a rules hash provided to {Types.Rule} and combined
+      #   using {&} with previous {#rule}
+      #
+      # @return [Constrained]
+      #
+      # @see Dry::Logic::Operators#and
+      #
+      # @api public
+      def constrained(*nullary_rules, **unary_rules)
+        nullary_rules_hash = parse_arguments(nullary_rules)
+
+        rules = nullary_rules_hash.merge(unary_rules)
+
+        with(rule: rule & Types.Rule(rules))
+      end
+
+      # @return [true]
+      #
+      # @api public
+      def constrained? = true
+
+      # @param [Object] value
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def ===(value) = valid?(value)
+
+      # Build lax type. Constraints are not applicable to lax types hence unwrapping
+      #
+      # @return [Lax]
+      # @api public
+      def lax = type.lax
+
+      # @see Nominal#to_ast
+      # @api public
+      def to_ast(meta: true)
+        [:constrained, [type.to_ast(meta: meta), rule.to_ast]]
+      end
+
+      # @api private
+      def constructor_type = type.constructor_type
+
+      private
+
+      # @param [Object] response
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def decorate?(response) = super || response.is_a?(Constructor)
+
+      # @param [Array] positional_args
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def parse_arguments(positional_arguments)
+        return positional_arguments.first if positional_arguments.first.is_a?(::Hash)
+
+        positional_arguments.flatten.zip([]).to_h
+      end
+    end
+  end
+end

data/dry-types-1.9.1/lib/dry/types/constraints.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Dry
+  # Helper methods for constraint types
+  #
+  # @api public
+  module Types
+    # @param [Hash] options
+    #
+    # @return [Dry::Logic::Rule]
+    #
+    # @api public
+    def self.Rule(options)
+      rule_compiler.(
+        options.map { |key, val|
+          ::Dry::Logic::Rule::Predicate.build(
+            ::Dry::Logic::Predicates[:"#{key}?"]
+          ).curry(val).to_ast
+        }
+      ).reduce(:and)
+    end
+
+    # @return [Dry::Logic::RuleCompiler]
+    #
+    # @api private
+    def self.rule_compiler
+      @rule_compiler ||= ::Dry::Logic::RuleCompiler.new(::Dry::Logic::Predicates)
+    end
+  end
+end

data/dry-types-1.9.1/lib/dry/types/constructor/function.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
+module Dry
+  module Types
+    class Constructor < Nominal
+      # Function is used internally by Constructor types
+      #
+      # @api private
+      class Function
+        # Wrapper for unsafe coercion functions
+        #
+        # @api private
+        class Safe < Function
+          def call(input, &)
+            @fn.(input)
+          rescue ::NoMethodError, ::TypeError, ::ArgumentError => exception
+            CoercionError.handle(exception, &)
+          end
+        end
+
+        # Coercion via a method call on a known object
+        #
+        # @api private
+        class MethodCall < Function
+          @cache = ::Concurrent::Map.new
+
+          # Choose or build the base class
+          #
+          # @return [Function]
+          def self.call_class(method, public, safe)
+            @cache.fetch_or_store([method, public, safe]) do
+              if public
+                ::Class.new(PublicCall) do
+                  include PublicCall.call_interface(method, safe)
+
+                  define_method(:__to_s__) do
+                    "#<PublicCall for :#{method}>"
+                  end
+                end
+              elsif safe
+                PrivateCall
+              else
+                PrivateSafeCall
+              end
+            end
+          end
+
+          # Coercion with a publicly accessible method call
+          #
+          # @api private
+          class PublicCall < MethodCall
+            @interfaces = ::Concurrent::Map.new
+
+            # Choose or build the interface
+            #
+            # @return [::Module]
+            def self.call_interface(method, safe)
+              @interfaces.fetch_or_store([method, safe]) do
+                ::Module.new do
+                  if safe
+                    module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+                      def call(input, &)             # def call(input, &)
+                        @target.#{method}(input, &)  #   @target.coerce(input, &)
+                      end                            # end
+                    RUBY
+                  else
+                    module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+                      def call(input, &)                                             # def call(input, &)
+                        @target.#{method}(input)                                     #   @target.coerce(input)
+                      rescue ::NoMethodError, ::TypeError, ::ArgumentError => error  # rescue ::NoMethodError, ::TypeError, ::ArgumentError => error
+                        CoercionError.handle(error, &)                               #   CoercionError.handle(error, &)
+                      end                                                            # end
+                    RUBY
+                  end
+                end
+              end
+            end
+          end
+
+          # Coercion via a private method call
+          #
+          # @api private
+          class PrivateCall < MethodCall
+            def call(input, &) = @target.send(@name, input, &)
+          end
+
+          # Coercion via an unsafe private method call
+          #
+          # @api private
+          class PrivateSafeCall < PrivateCall
+            def call(input, &)
+              @target.send(@name, input)
+            rescue ::NoMethodError, ::TypeError, ::ArgumentError => exception
+              CoercionError.handle(exception, &)
+            end
+          end
+
+          # @api private
+          #
+          # @return [MethodCall]
+          def self.[](fn, safe)
+            public = fn.receiver.respond_to?(fn.name)
+            MethodCall.call_class(fn.name, public, safe).new(fn)
+          end
+
+          attr_reader :target, :name
+
+          def initialize(fn)
+            super
+            @target = fn.receiver
+            @name = fn.name
+          end
+
+          def to_ast = [:method, target, name]
+        end
+
+        class Wrapper < Function
+          # @return [Object]
+          def call(input, type, &)
+            @fn.(input, type, &)
+          rescue ::NoMethodError, ::TypeError, ::ArgumentError => exception
+            CoercionError.handle(exception, &)
+          end
+          alias_method :[], :call
+
+          def arity = 2
+        end
+
+        # Choose or build specialized invokation code for a callable
+        #
+        # @param [#call] fn
+        # @return [Function]
+        def self.[](fn)
+          raise ::ArgumentError, "Missing constructor block" if fn.nil?
+
+          if fn.is_a?(Function)
+            fn
+          elsif fn.respond_to?(:arity) && fn.arity.equal?(2)
+            Wrapper.new(fn)
+          elsif fn.is_a?(::Method)
+            MethodCall[fn, yields_block?(fn)]
+          elsif yields_block?(fn)
+            new(fn)
+          else
+            Safe.new(fn)
+          end
+        end
+
+        # @return [Boolean]
+        def self.yields_block?(fn)
+          *, (last_arg,) =
+            if fn.respond_to?(:parameters)
+              fn.parameters
+            else
+              fn.method(:call).parameters
+            end
+
+          last_arg.equal?(:block)
+        end
+
+        include ::Dry::Equalizer(:fn, immutable: true)
+
+        attr_reader :fn
+
+        def initialize(fn)
+          @fn = fn
+        end
+
+        # @return [Object]
+        def call(input, &) = @fn.(input, &)
+        alias_method :[], :call
+
+        # @return [Integer]
+        def arity = 1
+
+        def wrapper? = arity.equal?(2)
+
+        # @return [Array]
+        def to_ast
+          if fn.is_a?(::Proc)
+            [:id, FnContainer.register(fn)]
+          else
+            [:callable, fn]
+          end
+        end
+
+        # @return [Function]
+        def >>(other)
+          f = Function[other]
+          Function[-> x, &b { f.(self.(x, &b), &b) }]
+        end
+
+        # @return [Function]
+        def <<(other)
+          f = Function[other]
+          Function[-> x, &b { self.(f.(x, &b), &b) }]
+        end
+      end
+    end
+  end
+end

data/dry-types-1.9.1/lib/dry/types/constructor/wrapper.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # @api public
+    class Constructor < Nominal
+      module Wrapper
+        # @return [Object]
+        #
+        # @api private
+        def call_safe(input, &) = fn.(input, type, &)
+
+        # @return [Object]
+        #
+        # @api private
+        def call_unsafe(input) = fn.(input, type)
+
+        # @param [Object] input
+        # @param [#call,nil] block
+        #
+        # @return [Logic::Result, Types::Result]
+        # @return [Object] if block given and try fails
+        #
+        # @api public
+        def try(input, &)
+          value = fn.(input, type)
+        rescue CoercionError => exception
+          failure = failure(input, exception)
+          block_given? ? yield(failure) : failure
+        else
+          type.try(value, &)
+        end
+
+        # Define a constructor for the type
+        #
+        # @param [#call,nil] constructor
+        # @param [Hash] options
+        # @param [#call,nil] block
+        #
+        # @return [Constructor]
+        #
+        # @api public
+        define_method(:constructor, Builder.instance_method(:constructor))
+        alias_method :append, :constructor
+        alias_method :>>, :constructor
+
+        # Build a new constructor by prepending a block to the coercion function
+        #
+        # @param [#call, nil] new_fn
+        # @param [Hash] options
+        # @param [#call, nil] block
+        #
+        # @return [Constructor]
+        #
+        # @api public
+        def prepend(new_fn = nil, **options, &block)
+          prep_fn = Function[new_fn || block]
+
+          decorated =
+            if prep_fn.wrapper?
+              type.constructor(prep_fn, **options)
+            else
+              type.prepend(prep_fn, **options)
+            end
+
+          __new__(decorated)
+        end
+        alias_method :<<, :prepend
+
+        # @return [Constructor]
+        #
+        # @api public
+        def lax
+          # return self back because wrapping function
+          # can handle failed type check
+          self
+        end
+
+        private
+
+        # Replace underlying type
+        #
+        # @api private
+        def __new__(type) = self.class.new(type, *@__args__.drop(1), **@options)
+      end
+    end
+  end
+end

data/dry-types-1.9.1/lib/dry/types/constructor.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Constructor types apply a function to the input that is supposed to return
+    # a new value. Coercion is a common use case for constructor types.
+    #
+    # @api public
+    class Constructor < Nominal
+      include ::Dry::Equalizer(:type, :options, inspect: false, immutable: true)
+
+      # @return [#call]
+      attr_reader :fn
+
+      # @return [Type]
+      attr_reader :type
+
+      undef :constrained?, :meta, :optional?, :primitive, :primitive?, :default?, :name, :namespace
+
+      # @param [Builder, Object] input
+      # @param [Hash] options
+      # @param [#call, nil] block
+      #
+      # @api public
+      def self.new(input, fn: Undefined, **options, &block)
+        type = input.is_a?(Builder) ? input : Nominal.new(input)
+        super(type, **options, fn: Function[Undefined.default(fn, block)])
+      end
+
+      # @param [Builder, Object] input
+      # @param [Hash] options
+      # @param [#call, nil] block
+      #
+      # @api public
+      def self.[](type, fn:, **options)
+        function = Function[fn]
+
+        if function.wrapper?
+          wrapper_type.new(type, fn: function, **options)
+        else
+          new(type, fn: function, **options)
+        end
+      end
+
+      # @api private
+      def self.wrapper_type
+        @wrapper_type ||=
+          if self < Wrapper
+            self
+          else
+            const_set(:Wrapping, ::Class.new(self).include(Wrapper))
+          end
+      end
+
+      # Instantiate a new constructor type instance
+      #
+      # @param [Type] type
+      # @option [Function] fn
+      # @param [Hash] options
+      #
+      # @api private
+      def initialize(type, fn: nil, **options)
+        @type = type
+        @fn = fn
+
+        super(type, **options, fn: fn)
+      end
+
+      # @return [Object]
+      #
+      # @api private
+      def call_safe(input, &block)
+        # block.call is slower in JRuby than yield, but in JRuby 10.0.2.0 there is a bug
+        # with default block arguments, so block.call is chosen for correctness.
+        # This was introduced in PR https://github.com/dry-rb/dry-types/pull/493, might be reverted
+        # in the bug is fixed in JRuby.
+        coerced = fn.(input) { |output = input| return block.call(output) }
+        type.call_safe(coerced) { |output = coerced| block.call(output) }
+      end
+
+      # @return [Object]
+      #
+      # @api private
+      def call_unsafe(input) = type.call_unsafe(fn.(input))
+
+      # @param [Object] input
+      # @param [#call,nil] block
+      #
+      # @return [Logic::Result, Types::Result]
+      # @return [Object] if block given and try fails
+      #
+      # @api public
+      def try(input, &)
+        value = fn.(input)
+      rescue CoercionError => exception
+        failure = failure(input, exception)
+        block_given? ? yield(failure) : failure
+      else
+        type.try(value, &)
+      end
+
+      # Build a new constructor by appending a block to the coercion function
+      #
+      # @param [#call, nil] new_fn
+      # @param [Hash] options
+      # @param [#call, nil] block
+      #
+      # @return [Constructor]
+      #
+      # @api public
+      def constructor(new_fn = nil, **options, &block)
+        next_fn = Function[new_fn || block]
+
+        if next_fn.wrapper?
+          self.class.wrapper_type.new(with(**options), fn: next_fn)
+        else
+          with(**options, fn: fn >> next_fn)
+        end
+      end
+      alias_method :append, :constructor
+      alias_method :>>, :constructor
+
+      # @return [Class]
+      #
+      # @api private
+      def constrained_type = Constrained::Coercible
+
+      # @see Nominal#to_ast
+      #
+      # @api public
+      def to_ast(meta: true)
+        [:constructor, [type.to_ast(meta: meta), fn.to_ast]]
+      end
+
+      # Build a new constructor by prepending a block to the coercion function
+      #
+      # @param [#call, nil] new_fn
+      # @param [Hash] options
+      # @param [#call, nil] block
+      #
+      # @return [Constructor]
+      #
+      # @api public
+      def prepend(new_fn = nil, **options, &block)
+        with(**options, fn: fn << (new_fn || block))
+      end
+      alias_method :<<, :prepend
+
+      # Build a lax type
+      #
+      # @return [Lax]
+      # @api public
+      def lax = Lax.new(constructor_type[type.lax, **options])
+
+      # Wrap the type with a proc
+      #
+      # @return [Proc]
+      #
+      # @api public
+      def to_proc = proc { self.(_1) }
+
+      private
+
+      # @param [Symbol] meth
+      # @param [Boolean] include_private
+      # @return [Boolean]
+      #
+      # @api private
+      def respond_to_missing?(meth, include_private = false)
+        super || type.respond_to?(meth)
+      end
+
+      # Delegates missing methods to {#type}
+      #
+      # @param [Symbol] method
+      # @param [Array] args
+      # @param [#call, nil] block
+      #
+      # @api private
+      def method_missing(method, ...)
+        if type.respond_to?(method)
+          response = type.public_send(method, ...)
+
+          if response.is_a?(Type) && response.instance_of?(type.class)
+            response.constructor_type[response, **options]
+          else
+            response
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/dry-types-1.9.1/lib/dry/types/container.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Internal container for the built-in types
+    #
+    # @api private
+    class Container
+      include Core::Container::Mixin
+    end
+  end
+end