super-smart-tool 0.0.1

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "dry/types/builder_methods"
+
+module Dry
+  module Types
+    # Export types registered in a container as module constants.
+    # @example
+    #   module Types
+    #     include Dry.Types(:strict, :coercible, :nominal, default: :strict)
+    #   end
+    #
+    #   Types.constants
+    #   # => [:Class, :Strict, :Symbol, :Integer, :Float, :String, :Array, :Hash,
+    #   #     :Decimal, :Nil, :True, :False, :Bool, :Date, :Nominal, :DateTime, :Range,
+    #   #     :Coercible, :Time]
+    #
+    # @api public
+    class Module < ::Module
+      def initialize(registry, *args, **kwargs)
+        @registry = registry
+        check_parameters(*args, **kwargs)
+        constants = type_constants(*args, **kwargs)
+        define_constants(constants)
+        extend(BuilderMethods)
+
+        if constants.key?(:Nominal)
+          singleton_class.define_method(:included) do |base|
+            super(base)
+            base.instance_exec(const_get(:Nominal, false)) do |nominal|
+              extend Dry::Core::Deprecations[:"dry-types"]
+              const_set(:Definition, nominal)
+              deprecate_constant(:Definition, message: "Nominal")
+            end
+          end
+        end
+      end
+
+      # @api private
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/PerceivedComplexity
+      def type_constants(*namespaces, default: Undefined, **aliases)
+        if namespaces.empty? && aliases.empty? && Undefined.equal?(default)
+          default_ns = :Strict
+        elsif Undefined.equal?(default)
+          default_ns = Undefined
+        else
+          default_ns = Types::Inflector.camelize(default).to_sym
+        end
+
+        tree = registry_tree
+
+        if namespaces.empty? && aliases.empty?
+          modules = tree.select { _2.is_a?(::Hash) }.map(&:first)
+        else
+          modules = (namespaces + aliases.keys).map { |n|
+            Types::Inflector.camelize(n).to_sym
+          }
+        end
+
+        tree.each_with_object({}) do |(key, value), constants|
+          if modules.include?(key)
+            name = aliases.fetch(Inflector.underscore(key).to_sym, key)
+            constants[name] = value
+          end
+
+          constants.update(value) if key == default_ns
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      # @api private
+      def registry_tree
+        @registry_tree ||= @registry.keys.each_with_object({}) { |key, tree|
+          type = @registry[key]
+          *modules, const_name = key.split(".").map { |part|
+            Types::Inflector.camelize(part).to_sym
+          }
+          next if modules.empty?
+
+          modules.reduce(tree) { |br, name| br[name] ||= {} }[const_name] = type
+        }.freeze
+      end
+
+      private
+
+      # @api private
+      def check_parameters(*namespaces, default: Undefined, **aliases)
+        referenced = namespaces.dup
+        referenced << default unless false.equal?(default) || Undefined.equal?(default)
+        referenced.concat(aliases.keys)
+
+        known = @registry.keys.map { |k|
+          ns, *path = k.split(".")
+          ns.to_sym unless path.empty?
+        }.compact.uniq
+
+        unknown = (referenced.uniq - known).first
+
+        if unknown
+          raise ::ArgumentError,
+                "#{unknown.inspect} is not a known type namespace. " \
+                "Supported options are #{known.map(&:inspect).join(", ")}"
+        end
+      end
+
+      # @api private
+      def define_constants(constants, mod = self)
+        constants.each do |name, value|
+          case value
+          when ::Hash
+            if mod.const_defined?(name, false)
+              define_constants(value, mod.const_get(name, false))
+            else
+              m = ::Module.new
+              mod.const_set(name, m)
+              define_constants(value, m)
+            end
+          else
+            mod.const_set(name, value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Nominal types define a primitive class and do not apply any constructors or constraints
+    #
+    # Use these types for annotations and the base for building more complex types on top of them.
+    #
+    # @api public
+    class Nominal
+      include Type
+      include Options
+      include Meta
+      include Builder
+      include Printable
+      include ::Dry::Equalizer(:primitive, :options, :meta, inspect: false, immutable: true)
+
+      # @return [Class]
+      attr_reader :primitive
+
+      # @return [String, nil]
+      attr_reader :namespace
+
+      # @param [Class] primitive
+      #
+      # @return [Type]
+      #
+      # @api private
+      def self.[](primitive)
+        if primitive == ::Array
+          Types::Array
+        elsif primitive == ::Hash
+          Types::Hash
+        else
+          self
+        end
+      end
+
+      ALWAYS = proc { true }
+
+      # @param [Type,Class] primitive
+      # @param [Hash] options
+      #
+      # @api private
+      def initialize(primitive, **options)
+        super
+        @primitive = primitive
+        @namespace = options[:namespace]
+        freeze
+      end
+
+      # @return [String]
+      #
+      # @api public
+      def name = primitive.name
+
+      # @return [false]
+      #
+      # @api public
+      def default? = false
+
+      # @return [false]
+      #
+      # @api public
+      def constrained? = false
+
+      # @return [false]
+      #
+      # @api public
+      def optional? = false
+
+      # @param [BasicObject] input
+      #
+      # @return [BasicObject]
+      #
+      # @api private
+      def call_unsafe(input) = input
+
+      # @param [BasicObject] input
+      #
+      # @return [BasicObject]
+      #
+      # @api private
+      def call_safe(input, &) = input
+
+      # @param [Object] input
+      #
+      # @yieldparam [Failure] failure
+      # @yieldreturn [Result]
+      #
+      # @return [Result,Logic::Result] when a block is not provided
+      # @return [nil] otherwise
+      #
+      # @api public
+      def try(input, &) = success(input)
+
+      # @param (see Dry::Types::Success#initialize)
+      #
+      # @return [Result::Success]
+      #
+      # @api public
+      def success(input) = Result::Success.new(input)
+
+      # @param (see Failure#initialize)
+      #
+      # @return [Result::Failure]
+      #
+      # @api public
+      def failure(input, error)
+        raise ::ArgumentError, "error must be a CoercionError" unless error.is_a?(CoercionError)
+
+        Result::Failure.new(input, error)
+      end
+
+      # Checks whether value is of a #primitive class
+      #
+      # @param [Object] value
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def primitive?(value) = value.is_a?(primitive)
+
+      # @api private
+      def coerce(input, &)
+        if primitive?(input)
+          input
+        elsif block_given?
+          yield
+        else
+          raise CoercionError, "#{input.inspect} must be an instance of #{primitive}"
+        end
+      end
+
+      # @api private
+      def try_coerce(input)
+        result = success(input)
+
+        coerce(input) do
+          result = failure(
+            input,
+            CoercionError.new("#{input.inspect} must be an instance of #{primitive}")
+          )
+        end
+
+        if block_given?
+          yield(result)
+        else
+          result
+        end
+      end
+
+      # Return AST representation of a type nominal
+      #
+      # @return [Array]
+      #
+      # @api public
+      def to_ast(meta: true)
+        [:nominal, [primitive, namespace_ast, meta_ast(meta)]]
+      end
+
+      # Return self. Nominal types are lax by definition
+      #
+      # @return [Nominal]
+      #
+      # @api public
+      def lax = self
+
+      # Wrap the type with a proc
+      #
+      # @return [Proc]
+      #
+      # @api public
+      def to_proc = ALWAYS
+
+      private
+
+      # @api private
+      def namespace_ast
+        if @namespace
+          {namespace: @namespace}
+        else
+          EMPTY_HASH
+        end
+      end
+
+      # @api private
+      def meta_ast(meta)
+        if meta
+          self.meta
+        else
+          EMPTY_HASH
+        end
+      end
+    end
+
+    extend ::Dry::Core::Deprecations[:"dry-types"]
+    Definition = Nominal
+    deprecate_constant(:Definition, message: "Nominal")
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Common API for types with options
+    #
+    # @api private
+    module Options
+      # @return [Hash]
+      attr_reader :options
+
+      # @see Nominal#initialize
+      #
+      # @api private
+      def initialize(*args, **options)
+        @__args__ = args.freeze
+        @options = options.freeze
+      end
+
+      # @param [Hash] new_options
+      #
+      # @return [Type]
+      #
+      # @api private
+      def with(**new_options)
+        if new_options.empty?
+          self
+        else
+          self.class.new(*@__args__, **options, **new_options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "dry/types/coercions/params"
+
+module Dry
+  module Types
+    options = {namespace: "params"}
+
+    {
+      "nil" => :to_nil,
+      "date" => :to_date,
+      "date_time" => :to_date_time,
+      "time" => :to_time,
+      "true" => :to_true,
+      "false" => :to_false,
+      "integer" => :to_int,
+      "float" => :to_float,
+      "decimal" => :to_decimal,
+      "array" => :to_ary,
+      "hash" => :to_hash,
+      "symbol" => :to_symbol
+    }.each do |name, method|
+      register("params.#{name}") do
+        self["nominal.#{name}"].with(**options).constructor(Coercions::Params.method(method))
+      end
+    end
+
+    register("params.bool") do
+      self["params.true"] | self["params.false"]
+    end
+
+    register("params.string", self["string"].with(**options))
+
+    COERCIBLE.each_key do |name|
+      register("optional.params.#{name}", self["params.nil"] | self["params.#{name}"])
+    end
+  end
+end

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

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # PredicateInferrer returns the list of predicates used by a type.
+    #
+    # @api public
+    class PredicateInferrer
+      extend Core::Cache
+
+      TYPE_TO_PREDICATE = {
+        ::DateTime => :date_time?,
+        ::Date => :date?,
+        ::Time => :time?,
+        ::FalseClass => :false?,
+        ::Integer => :int?,
+        ::Float => :float?,
+        ::NilClass => :nil?,
+        ::String => :str?,
+        ::TrueClass => :true?,
+        ::BigDecimal => :decimal?,
+        ::Array => :array?
+      }.freeze
+
+      REDUCED_TYPES = {
+        [[[:true?], [:false?]]] => %i[bool?]
+      }.freeze
+
+      HASH = %i[hash?].freeze
+
+      ARRAY = %i[array?].freeze
+
+      NIL = %i[nil?].freeze
+
+      # Compiler reduces type AST into a list of predicates
+      #
+      # @api private
+      class Compiler
+        extend Core::ClassAttributes
+
+        defines :infer_predicate_by_class_name
+        infer_predicate_by_class_name nil
+
+        # @return [PredicateRegistry]
+        # @api private
+        attr_reader :registry
+
+        # @api private
+        def initialize(registry)
+          @registry = registry
+        end
+
+        # @api private
+        def infer_predicate(type) # rubocop:disable Metrics/PerceivedComplexity
+          pred = TYPE_TO_PREDICATE.fetch(type) do
+            if type.name.nil? || self.class.infer_predicate_by_class_name.equal?(false)
+              nil
+            else
+              candidate = :"#{type.name.split("::").last.downcase}?"
+
+              if registry.key?(candidate)
+                if self.class.infer_predicate_by_class_name
+                  candidate
+                else
+                  raise ::KeyError, <<~MESSAGE
+                    Automatic predicate inferring from class names is deprecated
+                    and will be removed in dry-types 2.0.
+                    Use `Dry::Types::PredicateInferrer::Compiler.infer_predicate_by_class_name true`
+                    to restore the previous behavior
+                    or `Dry::Types::PredicateInferrer::Compiler.infer_predicate_by_class_name false`
+                    to explicitly opt-out (i.e. no exception + no inferring).
+                    Note: for dry-schema and dry-validation use Dry::Schema::PredicateInferrer::Compiler.
+                  MESSAGE
+                end
+              else
+                nil
+              end
+            end
+          end
+
+          if pred.nil?
+            EMPTY_ARRAY
+          else
+            [pred]
+          end
+        end
+
+        # @api private
+        def visit(node)
+          meth, rest = node
+          public_send(:"visit_#{meth}", rest)
+        end
+
+        # @api private
+        def visit_nominal(node)
+          type = node[0]
+          predicate = infer_predicate(type)
+
+          if !predicate.empty? && registry.key?(predicate[0])
+            predicate
+          else
+            [type?: type]
+          end
+        end
+
+        # @api private
+        def visit_hash(_)
+          HASH
+        end
+        alias_method :visit_schema, :visit_hash
+
+        # @api private
+        def visit_array(_)
+          ARRAY
+        end
+
+        # @api private
+        def visit_lax(node)
+          visit(node)
+        end
+
+        # @api private
+        def visit_constructor(node)
+          other, * = node
+          visit(other)
+        end
+
+        # @api private
+        def visit_enum(node)
+          other, * = node
+          visit(other)
+        end
+
+        # @api private
+        def visit_sum(node)
+          left_node, right_node, = node
+          left = visit(left_node)
+          right = visit(right_node)
+
+          if left.eql?(NIL)
+            right
+          else
+            [[left, right]]
+          end
+        end
+
+        # @api private
+        def visit_constrained(node)
+          other, rules = node
+          predicates = visit(rules)
+
+          if predicates.empty?
+            visit(other)
+          else
+            [*visit(other), *merge_predicates(predicates)]
+          end
+        end
+
+        # @api private
+        def visit_any(_) = EMPTY_ARRAY
+
+        # @api private
+        def visit_and(node)
+          left, right = node
+          visit(left) + visit(right)
+        end
+
+        # @api private
+        def visit_predicate(node)
+          pred, args = node
+
+          if pred.equal?(:type?) || !registry.key?(pred)
+            EMPTY_ARRAY
+          else
+            *curried, _ = args
+            values = curried.map { |_, v| v }
+
+            if values.empty?
+              [pred]
+            else
+              [pred => values[0]]
+            end
+          end
+        end
+
+        # @api private
+        def visit_map(_node)
+          raise ::NotImplementedError, "map types are not supported yet"
+        end
+
+        private
+
+        # @api private
+        def merge_predicates(nodes)
+          preds, merged = nodes.each_with_object([[], {}]) do |predicate, (ps, h)|
+            if predicate.is_a?(::Hash)
+              h.update(predicate)
+            else
+              ps << predicate
+            end
+          end
+
+          merged.empty? ? preds : [*preds, merged]
+        end
+      end
+
+      # @return [Compiler]
+      # @api private
+      attr_reader :compiler
+
+      # @api private
+      def initialize(registry = PredicateRegistry.new)
+        @compiler = Compiler.new(registry)
+      end
+
+      # Infer predicate identifier from the provided type
+      #
+      # @param [Type] type
+      # @return [Symbol]
+      #
+      # @api private
+      def [](type)
+        self.class.fetch_or_store(type) do
+          predicates = compiler.visit(type.to_ast)
+
+          if predicates.is_a?(::Hash)
+            predicates
+          else
+            REDUCED_TYPES[predicates] || predicates
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # A registry with predicate objects from `Dry::Logic::Predicates`
+    #
+    # @api private
+    class PredicateRegistry
+      # @api private
+      attr_reader :predicates
+
+      # @api private
+      attr_reader :has_predicate
+
+      KERNEL_RESPOND_TO = ::Kernel.instance_method(:respond_to?)
+      private_constant(:KERNEL_RESPOND_TO)
+
+      # @api private
+      def initialize(predicates = Logic::Predicates)
+        @predicates = predicates
+      end
+
+      # @api private
+      def key?(name)
+        KERNEL_RESPOND_TO.bind_call(@predicates, name)
+      end
+
+      # @api private
+      def [](name) = predicates[name]
+    end
+  end
+end