super-smart-tool 0.0.1

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "date"
+require "bigdecimal"
+require "bigdecimal/util"
+require "time"
+
+module Dry
+  module Types
+    module Coercions
+      # JSON-specific coercions
+      #
+      # @api public
+      module JSON
+        extend Coercions
+
+        # @param [Object] input
+        #
+        # @return [nil] if the input is nil
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_nil(input, &)
+          if input.nil?
+            nil
+          elsif block_given?
+            yield
+          else
+            raise CoercionError, "#{input.inspect} is not nil"
+          end
+        end
+
+        # @param [#to_d, Object] input
+        #
+        # @return [BigDecimal,nil]
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_decimal(input, &)
+          if input.is_a?(::Float)
+            input.to_d
+          else
+            BigDecimal(input)
+          end
+        rescue ::ArgumentError, ::TypeError
+          if block_given?
+            yield
+          else
+            raise CoercionError, "#{input} cannot be coerced to decimal"
+          end
+        end
+      end
+    end
+  end
+end

data/dry-types-1.9.1/lib/dry/types/coercions/params.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "bigdecimal/util"
+
+module Dry
+  module Types
+    module Coercions
+      # Params-specific coercions
+      #
+      # @api public
+      module Params
+        TRUE_VALUES = %w[1 on On ON t true True TRUE T y yes Yes YES Y].freeze
+        FALSE_VALUES = %w[0 off Off OFF f false False FALSE F n no No NO N].freeze
+        BOOLEAN_MAP = EMPTY_HASH.merge(
+          [true, *TRUE_VALUES].to_h { |v| [v, true] },
+          [false, *FALSE_VALUES].to_h { |v| [v, false] }
+        ).freeze
+
+        extend Coercions
+
+        # @param [Object] input
+        #
+        # @return [nil] if the input is an empty string or nil
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_nil(input, &)
+          if input.nil? || empty_str?(input)
+            nil
+          elsif block_given?
+            yield
+          else
+            raise CoercionError, "#{input.inspect} is not nil"
+          end
+        end
+
+        # @param [String, Object] input
+        #
+        # @return [Boolean,Object]
+        #
+        # @see TRUE_VALUES
+        # @see FALSE_VALUES
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_true(input, &)
+          BOOLEAN_MAP.fetch(input.to_s) do
+            if block_given?
+              yield
+            else
+              raise CoercionError, "#{input} cannot be coerced to true"
+            end
+          end
+        end
+
+        # @param [String, Object] input
+        #
+        # @return [Boolean,Object]
+        #
+        # @see TRUE_VALUES
+        # @see FALSE_VALUES
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_false(input, &)
+          BOOLEAN_MAP.fetch(input.to_s) do
+            if block_given?
+              yield
+            else
+              raise CoercionError, "#{input} cannot be coerced to false"
+            end
+          end
+        end
+
+        # @param [#to_int, #to_i, Object] input
+        #
+        # @return [Integer, nil, Object]
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_int(input, &)
+          if input.is_a?(::String)
+            Integer(input, 10)
+          else
+            Integer(input)
+          end
+        rescue ::ArgumentError, ::TypeError => exception
+          CoercionError.handle(exception, &)
+        end
+
+        # @param [#to_f, Object] input
+        #
+        # @return [Float, nil, Object]
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_float(input, &)
+          Float(input)
+        rescue ::ArgumentError, ::TypeError => exception
+          CoercionError.handle(exception, &)
+        end
+
+        # @param [#to_d, Object] input
+        #
+        # @return [BigDecimal, nil, Object]
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_decimal(input, &)
+          to_float(input) do
+            if block_given?
+              return yield
+            else
+              raise CoercionError, "#{input.inspect} cannot be coerced to decimal"
+            end
+          end
+
+          input.to_d
+        end
+
+        # @param [Array, String, Object] input
+        #
+        # @return [Array, Object]
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_ary(input, &)
+          if empty_str?(input)
+            []
+          elsif input.is_a?(::Array)
+            input
+          elsif block_given?
+            yield
+          else
+            raise CoercionError, "#{input.inspect} cannot be coerced to array"
+          end
+        end
+
+        # @param [Hash, String, Object] input
+        #
+        # @return [Hash, Object]
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_hash(input, &)
+          if empty_str?(input)
+            {}
+          elsif input.is_a?(::Hash)
+            input
+          elsif block_given?
+            yield
+          else
+            raise CoercionError, "#{input.inspect} cannot be coerced to hash"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Common coercion functions used by the built-in `Params` and `JSON` types
+    #
+    # @api public
+    module Coercions
+      include Dry::Core::Constants
+
+      # @param [#to_str, Object] input
+      #
+      # @return [Date, Object]
+      #
+      # @see Date.parse
+      #
+      # @api public
+      def to_date(input, &)
+        if input.respond_to?(:to_str)
+          begin
+            ::Date.parse(input)
+          rescue ::ArgumentError, ::RangeError => exception
+            CoercionError.handle(exception, &)
+          end
+        elsif input.is_a?(::Date)
+          input
+        elsif block_given?
+          yield
+        else
+          raise CoercionError, "#{input.inspect} is not a string"
+        end
+      end
+
+      # @param [#to_str, Object] input
+      #
+      # @return [DateTime, Object]
+      #
+      # @see DateTime.parse
+      #
+      # @api public
+      def to_date_time(input, &)
+        if input.respond_to?(:to_str)
+          begin
+            ::DateTime.parse(input)
+          rescue ::ArgumentError => exception
+            CoercionError.handle(exception, &)
+          end
+        elsif input.is_a?(::DateTime)
+          input
+        elsif block_given?
+          yield
+        else
+          raise CoercionError, "#{input.inspect} is not a string"
+        end
+      end
+
+      # @param [#to_str, Object] input
+      #
+      # @return [Time, Object]
+      #
+      # @see Time.parse
+      #
+      # @api public
+      def to_time(input, &)
+        if input.respond_to?(:to_str)
+          begin
+            ::Time.parse(input)
+          rescue ::ArgumentError => exception
+            CoercionError.handle(exception, &)
+          end
+        elsif input.is_a?(::Time)
+          input
+        elsif block_given?
+          yield
+        else
+          raise CoercionError, "#{input.inspect} is not a string"
+        end
+      end
+
+      # @param [#to_sym, Object] input
+      #
+      # @return [Symbol, Object]
+      #
+      # @raise CoercionError
+      #
+      # @api public
+      def to_symbol(input, &)
+        input.to_sym
+      rescue ::NoMethodError => exception
+        CoercionError.handle(exception, &)
+      end
+
+      private
+
+      # Checks whether String is empty
+      #
+      # @param [String, Object] value
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def empty_str?(value) = EMPTY_STRING.eql?(value)
+    end
+  end
+end

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

@@ -0,0 +1 @@
+# frozen_string_literal: true

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # @api private
+    class Compiler
+      extend ::Dry::Core::Deprecations[:"dry-types"]
+
+      attr_reader :registry
+
+      def initialize(registry)
+        @registry = registry
+      end
+
+      def call(ast) = visit(ast)
+
+      def visit(node)
+        type, body = node
+        send(:"visit_#{type}", body)
+      end
+
+      def visit_constrained(node)
+        nominal, rule = node
+        type = visit(nominal)
+        type.constrained_type.new(type, rule: visit_rule(rule))
+      end
+
+      def visit_constructor(node)
+        nominal, fn = node
+        primitive = visit(nominal)
+        primitive.constructor(compile_fn(fn))
+      end
+
+      def visit_lax(node)
+        Types::Lax.new(visit(node))
+      end
+      deprecate(:visit_safe, :visit_lax)
+
+      def visit_nominal(node)
+        type, options, meta =
+          case node
+          in [type, options, meta]
+            node
+          in [type, meta]
+            [type, EMPTY_HASH, meta]
+          end
+
+        nominal_name = "nominal.#{Types.identifier(type)}"
+
+        if registry.registered?(nominal_name)
+          registry[nominal_name].with(**options).meta(meta)
+        else
+          Nominal.new(type, meta: meta, **options)
+        end
+      end
+
+      def visit_rule(node)
+        ::Dry::Types.rule_compiler.([node])[0]
+      end
+
+      def visit_sum(node)
+        *types, meta = node
+        types.map { |type| visit(type) }.reduce(:|).meta(meta)
+      end
+
+      def visit_array(node)
+        member, meta = node
+        member = visit(member) unless member.is_a?(::Class)
+        registry["nominal.array"].of(member).meta(meta)
+      end
+
+      def visit_hash(node)
+        opts, meta = node
+        registry["nominal.hash"].with(**opts, meta: meta)
+      end
+
+      def visit_schema(node)
+        keys, options, meta = node
+        registry["nominal.hash"].schema(keys.map { |key| visit(key) }).with(**options, meta: meta)
+      end
+
+      def visit_json_hash(node)
+        keys, meta = node
+        registry["json.hash"].schema(keys.map { |key| visit(key) }, meta)
+      end
+
+      def visit_json_array(node)
+        member, meta = node
+        registry["json.array"].of(visit(member)).meta(meta)
+      end
+
+      def visit_params_hash(node)
+        keys, meta = node
+        registry["params.hash"].schema(keys.map { |key| visit(key) }, meta)
+      end
+
+      def visit_params_array(node)
+        member, meta = node
+        registry["params.array"].of(visit(member)).meta(meta)
+      end
+
+      def visit_key(node)
+        name, required, type = node
+        Schema::Key.new(visit(type), name, required: required)
+      end
+
+      def visit_enum(node)
+        type, mapping = node
+        Enum.new(visit(type), mapping: mapping)
+      end
+
+      def visit_map(node)
+        key_type, value_type, meta = node
+        registry["nominal.hash"].map(visit(key_type), visit(value_type)).meta(meta)
+      end
+
+      def visit_any(meta)
+        registry["any"].meta(meta)
+      end
+
+      def compile_fn(fn)
+        type, *node = fn
+
+        case type
+        when :id
+          ::Dry::Types::FnContainer[node.fetch(0)]
+        when :callable
+          node.fetch(0)
+        when :method
+          target, method = node
+          target.method(method)
+        else
+          raise ::ArgumentError, "Cannot build callable from #{fn.inspect}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "dry/types/options"
+require "dry/types/meta"
+
+module Dry
+  module Types
+    module Composition
+      include Type
+      include Builder
+      include Options
+      include Meta
+      include Printable
+      include ::Dry::Equalizer(
+        :left, :right, :options, :meta,
+        inspect: false,
+        immutable: true
+      )
+
+      # @return [Type]
+      attr_reader :left
+
+      # @return [Type]
+      attr_reader :right
+
+      module Constrained
+        def rule
+          left.rule.public_send(self.class.operator, right.rule)
+        end
+
+        def constrained?
+          true
+        end
+      end
+
+      def self.included(base)
+        composition_name = Inflector.demodulize(base)
+        ast_type = Inflector.underscore(composition_name).to_sym
+        base.define_singleton_method(:ast_type) { ast_type }
+        base.define_singleton_method(:composition_name) { composition_name }
+        base.const_set("Constrained", ::Class.new(base) { include Constrained })
+      end
+
+      # @param [Type] left
+      # @param [Type] right
+      # @param [Hash] options
+      #
+      # @api private
+      def initialize(left, right, **options)
+        super
+        @left, @right = left, right
+        freeze
+      end
+
+      # @return [String]
+      #
+      # @api public
+      def name = "#{left.name} #{self.class.operator} #{right.name}"
+
+      # @return [false]
+      #
+      # @api public
+      def default? = false
+
+      # @return [false]
+      #
+      # @api public
+      def constrained? = false
+
+      # @return [Boolean]
+      #
+      # @api public
+      def optional? = false
+
+      # @param [Object] input
+      #
+      # @return [Object]
+      #
+      # @api private
+      def call_unsafe(input) = raise ::NotImplementedError
+
+      # @param [Object] input
+      #
+      # @return [Object]
+      #
+      # @api private
+      def call_safe(input, &) = raise ::NotImplementedError
+
+      # @param [Object] input
+      #
+      # @api public
+      def try(input, &) = raise ::NotImplementedError
+
+      # @api private
+      def success(input)
+        result = try(input)
+        if result.success?
+          result
+        else
+          raise ::ArgumentError, "Invalid success value '#{input}' for #{inspect}"
+        end
+      end
+
+      # @api private
+      def failure(input, _error = nil)
+        result = try(input)
+        if result.failure?
+          result
+        else
+          raise ::ArgumentError, "Invalid failure value '#{input}' for #{inspect}"
+        end
+      end
+
+      # @param [Object] value
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def primitive?(value) = raise ::NotImplementedError
+
+      # @see Nominal#to_ast
+      #
+      # @api public
+      def to_ast(meta: true)
+        [self.class.ast_type,
+         [left.to_ast(meta: meta), right.to_ast(meta: meta), meta ? self.meta : EMPTY_HASH]]
+      end
+
+      # Wrap the type with a proc
+      #
+      # @return [Proc]
+      #
+      # @api public
+      def to_proc = proc { |value| self.(value) }
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    class Constrained
+      # Common coercion-related API for constrained types
+      #
+      # @api public
+      class Coercible < Constrained
+        # @return [Object]
+        #
+        # @api private
+        def call_unsafe(input)
+          coerced = type.call_unsafe(input)
+          result = rule.(coerced)
+
+          if result.success?
+            coerced
+          else
+            raise ConstraintError.new(result, input)
+          end
+        end
+
+        # @return [Object]
+        #
+        # @api private
+        def call_safe(input)
+          coerced = type.call_safe(input) { return yield }
+
+          if rule[coerced]
+            coerced
+          else
+            yield(coerced)
+          end
+        end
+
+        # @see Dry::Types::Constrained#try
+        #
+        # @api public
+        def try(input, &)
+          result = type.try(input)
+
+          if result.success?
+            validation = rule.(result.input)
+
+            if validation.success?
+              result
+            else
+              failure = failure(result.input, ConstraintError.new(validation, input))
+              block_given? ? yield(failure) : failure
+            end
+          else
+            block_given? ? yield(result) : result
+          end
+        end
+      end
+    end
+  end
+end