super-smart-tool 0.0.1

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

@@ -0,0 +1,34 @@
+# 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
+    # Monad extension for Result
+    #
+    # @api public
+    class Result
+      include ::Dry::Monads[:result]
+
+      # Turn result into a monad
+      #
+      # This makes result objects work with dry-monads (or anything with a compatible interface)
+      #
+      # @return [Dry::Monads::Success,Dry::Monads::Failure]
+      #
+      # @api public
+      def to_monad
+        if success?
+          Success(input)
+        else
+          Failure([error, input])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+Dry::Types.register_extension(:maybe) do
+  require "dry/types/extensions/maybe"
+end
+
+Dry::Types.register_extension(:monads) do
+  require "dry/types/extensions/monads"
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Internal container for constructor functions used by the built-in types
+    #
+    # @api private
+    class FnContainer
+      # @api private
+      def self.container
+        @container ||= Container.new
+      end
+
+      # @api private
+      def self.register(function = ::Dry::Core::Constants::Undefined, &block)
+        fn = ::Dry::Core::Constants::Undefined.default(function, block)
+        fn_name = register_name(fn)
+        container.register(fn_name, fn) unless container.key?(fn_name)
+        fn_name
+      end
+
+      # @api private
+      def self.[](fn_name)
+        if container.key?(fn_name)
+          container[fn_name]
+        else
+          fn_name
+        end
+      end
+
+      # @api private
+      def self.register_name(function)
+        "fn_#{function.__id__}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Hash type exposes additional APIs for working with schema hashes
+    #
+    # @api public
+    class Hash < Nominal
+      class Constructor < ::Dry::Types::Constructor
+        # @api private
+        def constructor_type = ::Dry::Types::Hash::Constructor
+
+        # @return [Lax]
+        #
+        # @api public
+        def lax = Lax.new(type.lax.constructor(fn, meta: meta))
+
+        # @see Dry::Types::Array#of
+        #
+        # @api public
+        def schema(...) = type.schema(...).constructor(fn, meta: meta)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Hash types can be used to define maps and schemas
+    #
+    # @api public
+    class Hash < Nominal
+      NOT_REQUIRED = {required: false}.freeze
+
+      # @overload schema(type_map, meta = EMPTY_HASH)
+      #   @param [{Symbol => Dry::Types::Nominal}] type_map
+      #   @param [Hash] meta
+      #   @return [Dry::Types::Schema]
+      #
+      # @overload schema(keys)
+      #   @param [Array<Dry::Types::Schema::Key>] key List of schema keys
+      #   @param [Hash] meta
+      #   @return [Dry::Types::Schema]
+      #
+      # @api public
+      def schema(keys_or_map, meta = EMPTY_HASH)
+        if keys_or_map.is_a?(::Array)
+          keys = keys_or_map
+        else
+          keys = build_keys(keys_or_map)
+        end
+
+        Schema.new(primitive, keys: keys, **options, meta: self.meta.merge(meta))
+      end
+
+      # Build a map type
+      #
+      # @param [Type] key_type
+      # @param [Type] value_type
+      #
+      # @return [Map]
+      #
+      # @api public
+      def map(key_type, value_type)
+        Map.new(
+          primitive,
+          key_type: resolve_type(key_type),
+          value_type: resolve_type(value_type),
+          meta: meta
+        )
+      end
+
+      # @api private
+      def weak(*)
+        raise "Support for old hash schemas was removed, please refer to the CHANGELOG " \
+              "on how to proceed with the new API https://github.com/dry-rb/dry-types/blob/main/CHANGELOG.md"
+      end
+      alias_method :permissive, :weak
+      alias_method :strict, :weak
+      alias_method :strict_with_defaults, :weak
+      alias_method :symbolized, :weak
+
+      # Injects a type transformation function for building schemas
+      #
+      # @param [#call,nil] proc
+      # @param [#call,nil] block
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def with_type_transform(proc = nil, &block)
+        fn = proc || block
+
+        raise ::ArgumentError, "a block or callable argument is required" if fn.nil?
+
+        handle = ::Dry::Types::FnContainer.register(fn)
+        with(type_transform_fn: handle)
+      end
+
+      # @api private
+      def constructor_type
+        ::Dry::Types::Hash::Constructor
+      end
+
+      # Whether the type transforms types of schemas created by {Dry::Types::Hash#schema}
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def transform_types?
+        !options[:type_transform_fn].nil?
+      end
+
+      # @param meta [Boolean] Whether to dump the meta to the AST
+      #
+      # @return [Array] An AST representation
+      #
+      # @api public
+      def to_ast(meta: true)
+        [:hash,
+         [options.slice(:type_transform_fn, :namespace),
+          meta_ast(meta)]]
+      end
+
+      private
+
+      # @api private
+      def build_keys(type_map)
+        type_fn = options.fetch(:type_transform_fn, Schema::NO_TRANSFORM)
+        type_transform = ::Dry::Types::FnContainer[type_fn]
+
+        type_map.map do |map_key, type|
+          name, options = key_name(map_key)
+          key = Schema::Key.new(resolve_type(type), name, **options)
+          type_transform.(key)
+        end
+      end
+
+      # @api private
+      def resolve_type(type)
+        case type
+        when Type then type
+        when ::Class, ::String then Types[type]
+        else type
+        end
+      end
+
+      # @api private
+      def key_name(key)
+        if key.to_s.end_with?("?")
+          [key.to_s.chop.to_sym, NOT_REQUIRED]
+        else
+          [key, EMPTY_HASH]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Implication type
+    #
+    # @api public
+    class Implication
+      include Composition
+
+      def self.operator = :>
+
+      # @param [Object] input
+      #
+      # @return [Object]
+      #
+      # @api private
+      def call_unsafe(input)
+        if left.try(input).success?
+          right.call_unsafe(input)
+        else
+          input
+        end
+      end
+
+      # @param [Object] input
+      #
+      # @return [Object]
+      #
+      # @api private
+      def call_safe(input, &)
+        if left.try(input).success?
+          right.call_safe(input, &)
+        else
+          input
+        end
+      end
+
+      # @param [Object] input
+      #
+      # @api public
+      def try(input, &)
+        if left.try(input).success?
+          right.try(input, &)
+        else
+          Result::Success.new(input)
+        end
+      end
+
+      # @param [Object] value
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def primitive?(value)
+        if left.primitive?(value)
+          right.primitive?(value)
+        else
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+
+module Dry
+  module Types
+    Inflector = ::Dry::Inflector.new
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "dry/types/options"
+require "dry/types/meta"
+
+module Dry
+  module Types
+    # Intersection type
+    #
+    # @api public
+    class Intersection
+      include Composition
+
+      def self.operator = :&
+
+      # @param [Object] input
+      #
+      # @return [Object]
+      #
+      # @api private
+      def call_unsafe(input)
+        merge_results(left.call_unsafe(input), right.call_unsafe(input))
+      end
+
+      # @param [Object] input
+      #
+      # @return [Object]
+      #
+      # @api private
+      def call_safe(input, &) = try_sides(input, &).input
+
+      # @param [Object] input
+      #
+      # @api public
+      def try(input)
+        try_sides(input) do |failure|
+          if block_given?
+            yield(failure)
+          else
+            failure
+          end
+        end
+      end
+
+      # @param [Object] value
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def primitive?(value)
+        left.primitive?(value) && right.primitive?(value)
+      end
+
+      private
+
+      # @api private
+      def try_sides(input, &block)
+        results = []
+
+        [left, right].each do |side|
+          result = try_side(side, input, &block)
+          return result if result.failure?
+
+          results << result
+        end
+
+        Result::Success.new(merge_results(*results.map(&:input)))
+      end
+
+      # @api private
+      def try_side(side, input)
+        failure = nil
+
+        result = side.try(input) do |f|
+          failure = f
+          yield(f)
+        end
+
+        if result.is_a?(Result)
+          result
+        elsif failure
+          Result::Failure.new(result, failure)
+        else
+          Result::Success.new(result)
+        end
+      end
+
+      # @api private
+      def merge_results(left_result, right_result)
+        case left_result
+        when ::Array
+          left_result.zip(right_result).map { merge_results(_1, _2) }
+        when ::Hash
+          left_result.merge(right_result)
+        else
+          left_result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "dry/types/coercions/json"
+
+module Dry
+  module Types
+    register("json.nil") do
+      self["nominal.nil"].constructor(Coercions::JSON.method(:to_nil))
+    end
+
+    register("json.date") do
+      self["nominal.date"].constructor(Coercions::JSON.method(:to_date))
+    end
+
+    register("json.date_time") do
+      self["nominal.date_time"].constructor(Coercions::JSON.method(:to_date_time))
+    end
+
+    register("json.time") do
+      self["nominal.time"].constructor(Coercions::JSON.method(:to_time))
+    end
+
+    register("json.decimal") do
+      self["nominal.decimal"].constructor(Coercions::JSON.method(:to_decimal))
+    end
+
+    register("json.symbol") do
+      self["nominal.symbol"].constructor(Coercions::JSON.method(:to_symbol))
+    end
+
+    register("json.array") { self["array"] }
+
+    register("json.hash") { self["hash"] }
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Lax types rescue from type-related errors when constructors fail
+    #
+    # @api public
+    class Lax
+      include Type
+      include Decorator
+      include Builder
+      include Printable
+      include ::Dry::Equalizer(:type, inspect: false, immutable: true)
+
+      undef :options, :constructor, :<<, :>>, :prepend, :append
+
+      # @param [Object] input
+      #
+      # @return [Object]
+      #
+      # @api public
+      def call(input, &)
+        type.call_safe(input) { |output = input| output }
+      end
+      alias_method :[], :call
+      alias_method :call_safe, :call
+      alias_method :call_unsafe, :call
+
+      # @param [Object] input
+      # @param [#call,nil] block
+      #
+      # @yieldparam [Failure] failure
+      # @yieldreturn [Result]
+      #
+      # @return [Result,Logic::Result]
+      #
+      # @api public
+      def try(input, &) = type.try(input, &)
+
+      # @see Nominal#to_ast
+      #
+      # @api public
+      def to_ast(meta: true) = [:lax, type.to_ast(meta: meta)]
+
+      # @return [Lax]
+      #
+      # @api public
+      def lax = self
+
+      private
+
+      # @param [Object, Dry::Types::Constructor] response
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def decorate?(response)
+        super || response.is_a?(type.constructor_type)
+      end
+    end
+
+    extend ::Dry::Core::Deprecations[:"dry-types"]
+    Safe = Lax
+    deprecate_constant(:Safe)
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Homogeneous mapping. It describes a hash with unknown keys that match a certain type.
+    #
+    # @example
+    #   type = Dry::Types['hash'].map(
+    #     Dry::Types['integer'].constrained(gteq: 1, lteq: 10),
+    #     Dry::Types['string']
+    #   )
+    #
+    #   type.(1 => 'right')
+    #   # => {1 => 'right'}
+    #
+    #   type.('1' => 'wrong')
+    #   # Dry::Types::MapError: "1" violates constraints (type?(Integer, "1")
+    #   #                                                 AND gteq?(1, "1")
+    #   #                                                 AND lteq?(10, "1") failed)
+    #
+    #   type.(11 => 'wrong')
+    #   # Dry::Types::MapError: 11 violates constraints (lteq?(10, 11) failed)
+    #
+    # @api public
+    class Map < Nominal
+      def initialize(primitive, key_type: Types["any"], value_type: Types["any"], meta: EMPTY_HASH)
+        super
+      end
+
+      # @return [Type]
+      #
+      # @api public
+      def key_type = options[:key_type]
+
+      # @return [Type]
+      #
+      # @api public
+      def value_type = options[:value_type]
+
+      # @return [String]
+      #
+      # @api public
+      def name = "Map"
+
+      # @param [Hash] hash
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def call_unsafe(hash)
+        try(hash) { |failure|
+          raise MapError, failure.error.message
+        }.input
+      end
+
+      # @param [Hash] hash
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def call_safe(hash) = try(hash) { return yield }.input
+
+      # @param [Hash] hash
+      #
+      # @return [Result]
+      #
+      # @api public
+      def try(hash)
+        result = coerce(hash)
+        return result if result.success? || !block_given?
+
+        yield(result)
+      end
+
+      # @param meta [Boolean] Whether to dump the meta to the AST
+      #
+      # @return [Array] An AST representation
+      #
+      # @api public
+      def to_ast(meta: true)
+        [:map,
+         [key_type.to_ast(meta: true),
+          value_type.to_ast(meta: true),
+          meta_ast(meta)]]
+      end
+
+      # @return [Boolean]
+      #
+      # @api public
+      def constrained? = value_type.constrained?
+
+      private
+
+      # @api private
+      # rubocop:disable Metrics/AbcSize
+      def coerce(input)
+        assert_primitive(input) do
+          output = {}
+          failures = []
+
+          input.each do |k, v|
+            res_k = key_type.try(k)
+            res_v = value_type.try(v)
+
+            if res_k.failure?
+              failures << res_k.error
+            elsif output.key?(res_k.input)
+              failures << CoercionError.new("duplicate coerced hash key #{res_k.input.inspect}")
+            elsif res_v.failure?
+              failures << res_v.error
+            else
+              output[res_k.input] = res_v.input
+            end
+          end
+
+          if failures.empty?
+            success(output)
+          else
+            failure(input, MultipleError.new(failures))
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def assert_primitive(input)
+        if primitive?(input)
+          yield
+        else
+          failure(input, CoercionError.new("#{input.inspect} must be an instance of #{primitive}"))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Storage for meta-data
+    #
+    # @api public
+    module Meta
+      def initialize(*args, meta: EMPTY_HASH, **options)
+        super(*args, **options)
+        @meta = meta.freeze
+      end
+
+      # @param options [Hash] new_options
+      #
+      # @return [Type]
+      #
+      # @api public
+      def with(**options)
+        if options.empty?
+          self
+        else
+          super(meta: @meta, **options)
+        end
+      end
+
+      # @overload meta
+      #   @return [Hash] metadata associated with type
+      #
+      # @overload meta(data)
+      #   @param [Hash] new metadata to merge into existing metadata
+      #   @return [Type] new type with added metadata
+      #
+      # @api public
+      def meta(data = Undefined)
+        if Undefined.equal?(data)
+          @meta
+        elsif data.empty?
+          self
+        else
+          with(meta: @meta.merge(data))
+        end
+      end
+
+      # Resets meta
+      #
+      # @return [Dry::Types::Type]
+      #
+      # @api public
+      def pristine = with(meta: EMPTY_HASH)
+    end
+  end
+end