super-smart-tool 0.0.1

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Primitives with {Kernel} coercion methods
+    KERNEL_COERCIBLE = {
+      string: String,
+      integer: Integer,
+      float: Float,
+      decimal: BigDecimal,
+      array: ::Array,
+      hash: ::Hash
+    }.freeze
+
+    # Primitives with coercions through by convention `to_*` methods
+    METHOD_COERCIBLE = {
+      symbol: Symbol
+    }.freeze
+
+    # By convention methods to coerce {METHOD_COERCIBLE} primitives
+    METHOD_COERCIBLE_METHODS = {
+      symbol: :to_sym
+    }.freeze
+
+    # Primitives that are non-coercible
+    NON_COERCIBLE = {
+      nil: NilClass,
+      class: Class,
+      true: TrueClass,
+      false: FalseClass,
+      date: Date,
+      date_time: DateTime,
+      time: Time,
+      range: Range
+    }.freeze
+
+    # All built-in primitives
+    ALL_PRIMITIVES = [
+      KERNEL_COERCIBLE, METHOD_COERCIBLE, NON_COERCIBLE
+    ].reduce(&:merge).freeze
+
+    # All coercible types
+    COERCIBLE = KERNEL_COERCIBLE.merge(METHOD_COERCIBLE).freeze
+
+    # All built-in primitives except {NilClass}
+    NON_NIL = ALL_PRIMITIVES.except(:nil).freeze
+
+    # Register generic types for {ALL_PRIMITIVES}
+    ALL_PRIMITIVES.each do |name, primitive|
+      type = Nominal[primitive].new(primitive)
+      register("nominal.#{name}", type)
+    end
+
+    # Register strict types for {ALL_PRIMITIVES}
+    ALL_PRIMITIVES.each do |name, primitive|
+      type = self["nominal.#{name}"].constrained(type: primitive)
+      register(name.to_s, type)
+      register("strict.#{name}", type)
+    end
+
+    # Register {KERNEL_COERCIBLE} types
+    KERNEL_COERCIBLE.each do |name, primitive|
+      register(
+        "coercible.#{name}",
+        self["nominal.#{name}"].constructor(::Kernel.method(primitive.name))
+      )
+    end
+
+    # Register {METHOD_COERCIBLE} types
+    METHOD_COERCIBLE.each_key do |name|
+      register(
+        "coercible.#{name}",
+        self["nominal.#{name}"].constructor(&METHOD_COERCIBLE_METHODS[name])
+      )
+    end
+
+    # Register optional strict {NON_NIL} types
+    NON_NIL.each_key do |name|
+      type = self[name.to_s].optional
+      register("optional.strict.#{name}", type)
+      register("optional.#{name}", type)
+    end
+
+    # Register optional {COERCIBLE} types
+    COERCIBLE.each_key do |name|
+      register(
+        "optional.coercible.#{name}",
+        self["coercible.#{name}"].optional
+      )
+    end
+
+    # Register `:bool` since it's common and not a built-in Ruby type :(
+    register("nominal.bool", self["nominal.true"] | self["nominal.false"])
+    bool = self["strict.true"] | self["strict.false"]
+    register("strict.bool", bool)
+    register("bool", bool)
+
+    register("any", Any)
+    register("nominal.any", Any)
+    register("strict.any", Any)
+  end
+end
+
+require "dry/types/coercions"
+require "dry/types/params"
+require "dry/types/json"

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Common API for types
+    #
+    # @api public
+    module Decorator
+      include Options
+
+      # @return [Type]
+      attr_reader :type
+
+      # @param [Type] type
+      def initialize(type, *, **)
+        super
+        @type = type
+      end
+
+      # @param [Object] input
+      # @param [#call, nil] block
+      #
+      # @return [Result,Logic::Result]
+      # @return [Object] if block given and try fails
+      #
+      # @api public
+      def try(input, &) = type.try(input, &)
+
+      # @return [Boolean]
+      #
+      # @api public
+      def default? = type.default?
+
+      # @return [Boolean]
+      #
+      # @api public
+      def constrained? = type.constrained?
+
+      # @param [Symbol] meth
+      # @param [Boolean] include_private
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def respond_to_missing?(meth, include_private = false)
+        super || type.respond_to?(meth)
+      end
+
+      # Wrap the type with a proc
+      #
+      # @return [Proc]
+      #
+      # @api public
+      def to_proc = proc { |value| self.(value) }
+
+      private
+
+      # @param [Object] response
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def decorate?(response) = response.is_a?(type.class)
+
+      # Delegates missing methods to {#type}
+      #
+      # @param [Symbol] meth
+      # @param [Array] args
+      # @param [#call, nil] block
+      #
+      # @api private
+      def method_missing(meth, ...)
+        if type.respond_to?(meth)
+          response = type.public_send(meth, ...)
+
+          if decorate?(response)
+            __new__(response)
+          else
+            response
+          end
+        else
+          super
+        end
+      end
+
+      # 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/default.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Default types are useful when a missing value should be replaced by a default one
+    #
+    # @api public
+    class Default
+      # @api private
+      class Callable < Default
+        include ::Dry::Equalizer(:type, inspect: false, immutable: true)
+
+        # Evaluates given callable
+        # @return [Object]
+        def evaluate
+          value.call(type)
+        end
+
+        # @return [true]
+        def callable?
+          true
+        end
+      end
+
+      include Type
+      include Decorator
+      include Builder
+      include Printable
+      include ::Dry::Equalizer(:type, :value, inspect: false, immutable: true)
+
+      # @return [Object]
+      attr_reader :value
+
+      alias_method :evaluate, :value
+
+      # @param [Object, #call] value
+      #
+      # @return [Class] {Default} or {Default::Callable}
+      #
+      # @api private
+      def self.[](value)
+        if value.respond_to?(:call)
+          Callable
+        else
+          self
+        end
+      end
+
+      # @param [Type] type
+      # @param [Object] value
+      #
+      # @api private
+      def initialize(type, value, **)
+        super
+        @value = value
+      end
+
+      # Build a constrained type
+      #
+      # @param [Array] args see {Dry::Types::Builder#constrained}
+      #
+      # @return [Default]
+      #
+      # @api public
+      def constrained(...) = type.constrained(...).default(value)
+
+      # @return [true]
+      #
+      # @api public
+      def default? = true
+
+      # @param [Object] input
+      #
+      # @return [Result::Success]
+      #
+      # @api public
+      def try(input = Undefined, &)
+        if input.equal?(Undefined)
+          success(evaluate)
+        else
+          type.try(input)
+        end
+      end
+
+      # @return [Boolean]
+      #
+      # @api public
+      def valid?(value = Undefined) = Undefined.equal?(value) || super
+
+      # @param [Object] input
+      #
+      # @return [Object] value passed through {#type} or {#default} value
+      #
+      # @api private
+      def call_unsafe(input = Undefined)
+        if input.equal?(Undefined)
+          evaluate
+        else
+          Undefined.default(type.call_unsafe(input)) { evaluate }
+        end
+      end
+
+      # @param [Object] input
+      #
+      # @return [Object] value passed through {#type} or {#default} value
+      #
+      # @api private
+      def call_safe(input = Undefined, &)
+        if input.equal?(Undefined)
+          evaluate
+        else
+          Undefined.default(type.call_safe(input, &)) { evaluate }
+        end
+      end
+
+      # @return [false]
+      #
+      # @api private
+      def callable? = false
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Enum types can be used to define an enum on top of an existing type
+    #
+    # @api public
+    class Enum
+      include Type
+      include ::Dry::Equalizer(:type, :mapping, inspect: false, immutable: true)
+      include Decorator
+      include Builder
+
+      # @return [Array]
+      attr_reader :values
+
+      # @return [Hash]
+      attr_reader :mapping
+
+      # @return [Hash]
+      attr_reader :inverted_mapping
+
+      # @param [Type] type
+      # @param [Hash] options
+      # @option options [Array] :values
+      #
+      # @api private
+      def initialize(type, **options)
+        super
+        @mapping = options.fetch(:mapping).freeze
+        @values = @mapping.keys.freeze
+        @inverted_mapping = @mapping.invert.freeze
+        freeze
+      end
+
+      # @return [Object]
+      #
+      # @api private
+      def call_unsafe(input) = type.call_unsafe(map_value(input))
+
+      # @return [Object]
+      #
+      # @api private
+      def call_safe(input, &) = type.call_safe(map_value(input), &)
+
+      # @see Dry::Types::Constrained#try
+      #
+      # @api public
+      def try(input, &) = super(map_value(input))
+
+      # @api private
+      def default(*)
+        raise ".enum(*values).default(value) is not supported. Call " \
+              ".default(value).enum(*values) instead"
+      end
+
+      # Check whether a value is in the enum
+      alias_method :include?, :valid?
+
+      # @see Nominal#to_ast
+      #
+      # @api public
+      def to_ast(meta: true)
+        [:enum, [type.to_ast(meta: meta), mapping]]
+      end
+
+      # @return [String]
+      #
+      # @api public
+      def to_s = PRINTER.(self)
+
+      # Iterate over each enum value
+      #
+      # @return [Array, Enumerator]
+      #
+      # @api public
+      def each_value(&)
+        values.each(&)
+      end
+
+      alias_method :inspect, :to_s
+
+      # @return [String]
+      #
+      # @api public
+      def name = "#{super}(#{joined_values})"
+
+      # @return [String]
+      #
+      # @api private
+      def joined_values
+        mapping.keys.map { |value|
+          if value.is_a?(::String)
+            value
+          else
+            value.inspect
+          end
+        }.join("|")
+      end
+
+      private
+
+      # Maps a value
+      #
+      # @param [Object] input
+      #
+      # @return [Object]
+      #
+      # @api private
+      def map_value(input)
+        if input.equal?(Undefined)
+          type.call
+        elsif mapping.key?(input)
+          input
+        else
+          inverted_mapping.fetch(input, input)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    extend ::Dry::Core::ClassAttributes
+
+    # @!attribute [r] namespace
+    #   @return [Container{String => Nominal}]
+    defines :namespace
+
+    namespace self
+
+    # Base class for coercion errors raise by dry-types
+    #
+    class CoercionError < ::StandardError
+      # @api private
+      def self.handle(exception, meta: Undefined)
+        if block_given?
+          yield
+        else
+          raise new(
+            exception.message,
+            meta: meta,
+            backtrace: exception.backtrace
+          )
+        end
+      end
+
+      # Metadata associated with the error
+      #
+      # @return [Object]
+      attr_reader :meta
+
+      # @api private
+      def initialize(message, meta: Undefined, backtrace: Undefined)
+        unless message.is_a?(::String)
+          raise ::ArgumentError, "message must be a string, #{message.class} given"
+        end
+
+        super(message)
+        @meta = Undefined.default(meta, nil)
+        set_backtrace(backtrace) unless Undefined.equal?(backtrace)
+      end
+    end
+
+    # Collection of multiple errors
+    #
+    class MultipleError < CoercionError
+      # @return [Array<CoercionError>]
+      attr_reader :errors
+
+      # @param [Array<CoercionError>] errors
+      def initialize(errors)
+        super("")
+        @errors = errors
+      end
+
+      # @return string
+      def message = errors.map(&:message).join(", ")
+
+      # @return [Array]
+      def meta = errors.map(&:meta)
+    end
+
+    class SchemaError < CoercionError
+      # @return [String, Symbol]
+      attr_reader :key
+
+      # @return [Object]
+      attr_reader :value
+
+      # @param [String,Symbol] key
+      # @param [Object] value
+      # @param [String, #to_s] result
+      def initialize(key, value, result)
+        @key = key
+        @value = value
+        super(
+          "#{value.inspect} (#{value.class}) has invalid type " \
+          "for :#{key} violates constraints (#{result} failed)"
+        )
+      end
+    end
+
+    MapError = ::Class.new(CoercionError)
+
+    SchemaKeyError = ::Class.new(CoercionError)
+    private_constant(:SchemaKeyError)
+
+    class MissingKeyError < SchemaKeyError
+      # @return [Symbol]
+      attr_reader :key
+
+      # @param [String,Symbol] key
+      def initialize(key)
+        @key = key
+        super("#{key.inspect} is missing in Hash input")
+      end
+    end
+
+    class UnknownKeysError < SchemaKeyError
+      # @return [Array<Symbol>]
+      attr_reader :keys
+
+      # @param [<String, Symbol>] keys
+      def initialize(keys)
+        @keys = keys
+        super("unexpected keys #{keys.inspect} in Hash input")
+      end
+    end
+
+    class ConstraintError < CoercionError
+      # @return [String, #to_s]
+      attr_reader :result
+      # @return [Object]
+      attr_reader :input
+
+      # @param [String, #to_s] result
+      # @param [Object] input
+      def initialize(result, input)
+        @result = result
+        @input = input
+
+        if result.is_a?(::String)
+          super(result)
+        else
+          super(to_s)
+        end
+      end
+
+      # @return [String]
+      def message
+        "#{input.inspect} violates constraints (#{result} failed)"
+      end
+      alias_method :to_s, :message
+    end
+  end
+end

data/dry-types-1.9.1/lib/dry/types/extensions/maybe.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+require "dry/monads/version"
+
+if Gem::Version.new(Dry::Monads::VERSION) < Gem::Version.new("1.5.0")
+  raise "dry-types requires dry-monads >= 1.5.0"
+end
+
+module Dry
+  module Types
+    # Maybe extension provides Maybe types where values are wrapped using `Either` monad
+    #
+    # @api public
+    class Maybe
+      include Type
+      include ::Dry::Equalizer(:type, :options, inspect: false, immutable: true)
+      include Decorator
+      include Builder
+      include Printable
+      include ::Dry::Monads[:maybe]
+
+      # @param [Dry::Monads::Maybe, Object] input
+      #
+      # @return [Dry::Monads::Maybe]
+      #
+      # @api private
+      def call_unsafe(input = Undefined)
+        case input
+        when ::Dry::Monads::Maybe
+          input
+        when Undefined
+          None()
+        else
+          Maybe(type.call_unsafe(input))
+        end
+      end
+
+      # @param [Dry::Monads::Maybe, Object] input
+      #
+      # @return [Dry::Monads::Maybe]
+      #
+      # @api private
+      def call_safe(input = Undefined)
+        case input
+        when ::Dry::Monads::Maybe
+          input
+        when Undefined
+          None()
+        else
+          Maybe(type.call_safe(input) { |output = input| return yield(output) })
+        end
+      end
+
+      # @param [Object] input
+      #
+      # @return [Result::Success]
+      #
+      # @api public
+      def try(input = Undefined, &)
+        result = type.try(input)
+
+        if result.success?
+          Result::Success.new(Maybe(result.input))
+        else
+          result
+        end
+      end
+
+      # @return [true]
+      #
+      # @api public
+      def default? = true
+
+      # @param [Object] value
+      #
+      # @see Dry::Types::Builder#default
+      #
+      # @raise [ArgumentError] if nil provided as default value
+      #
+      # @api public
+      def default(value)
+        if value.nil?
+          raise ::ArgumentError, "nil cannot be used as a default of a maybe type"
+        else
+          super
+        end
+      end
+    end
+
+    module Builder
+      # Turn a type into a maybe type
+      #
+      # @return [Maybe]
+      #
+      # @api public
+      def maybe = Maybe.new(Types["nil"] | self)
+    end
+
+    # @api private
+    class Schema::Key # rubocop:disable Style/ClassAndModuleChildren
+      # @api private
+      def maybe = __new__(type.maybe)
+    end
+
+    # @api private
+    class Printer
+      MAPPING[Maybe] = :visit_maybe
+
+      # @api private
+      def visit_maybe(maybe)
+        visit(maybe.type) do |type|
+          yield "Maybe<#{type}>"
+        end
+      end
+    end
+
+    # Register non-coercible maybe types
+    NON_NIL.each_key do |name|
+      register("maybe.strict.#{name}", self[name.to_s].maybe)
+    end
+
+    # Register coercible maybe types
+    COERCIBLE.each_key do |name|
+      register("maybe.coercible.#{name}", self["coercible.#{name}"].maybe)
+    end
+  end
+end