super-smart-tool 0.0.1

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # PrimitiveInferrer returns the list of classes matching a type.
+    #
+    # @api public
+    class PrimitiveInferrer
+      extend Core::Cache
+
+      # Compiler reduces type AST into a list of primitives
+      #
+      # @api private
+      class Compiler
+        # @api private
+        def visit(node)
+          meth, rest = node
+          public_send(:"visit_#{meth}", rest)
+        end
+
+        # @api private
+        def visit_nominal(node) = node[0]
+
+        # @api private
+        def visit_hash(_) = ::Hash
+        alias_method :visit_schema, :visit_hash
+
+        # @api private
+        def visit_array(_) = ::Array
+
+        # @api private
+        def visit_lax(node) = visit(node)
+
+        # @api private
+        def visit_constructor(node) = visit(node[0])
+
+        # @api private
+        def visit_enum(node) = visit(node[0])
+
+        # @api private
+        def visit_sum(node)
+          left, right = node
+
+          [visit(left), visit(right)].flatten(1)
+        end
+
+        # @api private
+        def visit_constrained(node) = visit(node[0])
+
+        # @api private
+        def visit_any(_) = ::Object
+      end
+
+      # @return [Compiler]
+      # @api private
+      attr_reader :compiler
+
+      # @api private
+      def initialize
+        @compiler = Compiler.new
+      end
+
+      # Infer primitives from the provided type
+      #
+      # @return [Array[Class]]
+      #
+      # @api private
+      def [](type)
+        self.class.fetch_or_store(type) do
+          Array(compiler.visit(type.to_ast)).freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # @api private
+    module Printable
+      # @return [String]
+      #
+      # @api private
+      def to_s = PRINTER.(self)
+      alias_method :inspect, :to_s
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # @api private
+    class Printer
+      # @api private
+      class Composition
+        def initialize(printer, composition_class)
+          @printer = printer
+          @composition_class = composition_class
+          freeze
+        end
+
+        def visit(composition)
+          visit_constructors(composition) do |constructors|
+            @printer.visit_options(composition.options, composition.meta) do |opts|
+              yield "#{@composition_class.composition_name}<#{constructors}#{opts}>"
+            end
+          end
+        end
+
+        private
+
+        def visit_constructors(composition)
+          visit_constructor(composition.left) do |left|
+            visit_constructor(composition.right) do |right|
+              yield "#{left} #{@composition_class.operator} #{right}"
+            end
+          end
+        end
+
+        def visit_constructor(type, &)
+          case type
+          when @composition_class
+            visit_constructors(type, &)
+          else
+            @printer.visit(type, &)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+require "dry/types/printer/composition"
+
+module Dry
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/PerceivedComplexity
+  module Types
+    # @api private
+    class Printer
+      MAPPING = {
+        Nominal => :visit_nominal,
+        Constructor => :visit_constructor,
+        [
+          Constrained,
+          Constrained::Coercible
+        ] => :visit_constrained,
+        Types::Hash => :visit_hash,
+        Schema => :visit_schema,
+        Schema::Key => :visit_key,
+        Map => :visit_map,
+        Array => :visit_array,
+        Array::Member => :visit_array_member,
+        Lax => :visit_lax,
+        Enum => :visit_enum,
+        [Default, Default::Callable] => :visit_default,
+        [
+          Sum,
+          Sum::Constrained,
+          Intersection,
+          Intersection::Constrained,
+          Implication,
+          Implication::Constrained
+        ] => :visit_composition,
+        Any.class => :visit_any
+      }.flat_map { |k, v| Array(k).map { |kk| [kk, v] } }.to_h
+
+      def initialize
+        @composition_printers = {}
+        freeze
+      end
+
+      def call(type)
+        output = "".dup
+        visit(type) { |str| output << str }
+        "#<Dry::Types[#{output}]>"
+      end
+
+      def visit(type, &)
+        print_with = MAPPING.fetch(type.class) do
+          if type.class < Constructor
+            :visit_constructor
+          elsif type.is_a?(Type)
+            return yield type.inspect
+          else
+            raise ArgumentError, "Do not know how to print #{type.class}"
+          end
+        end
+        send(print_with, type, &)
+      end
+
+      def visit_any(_) = yield "Any"
+
+      def visit_array(type)
+        visit_options(EMPTY_HASH, type.meta) do |opts|
+          yield "Array#{opts}"
+        end
+      end
+
+      def visit_array_member(array)
+        visit(array.member) do |type|
+          visit_options(EMPTY_HASH, array.meta) do |opts|
+            yield "Array<#{type}#{opts}>"
+          end
+        end
+      end
+
+      def visit_constructor(constructor)
+        visit(constructor.type) do |type|
+          visit_callable(constructor.fn.fn) do |fn|
+            options = constructor.options.dup
+            options.delete(:fn)
+
+            visit_options(options) do |opts|
+              yield "Constructor<#{type} fn=#{fn}#{opts}>"
+            end
+          end
+        end
+      end
+
+      def visit_constrained(constrained)
+        visit(constrained.type) do |type|
+          options = constrained.options.dup
+          rule = options.delete(:rule)
+
+          visit_options(options) do |_opts|
+            yield "Constrained<#{type} rule=[#{rule}]>"
+          end
+        end
+      end
+
+      def visit_composition(composition, &)
+        klass = composition.class
+        @composition_printers[klass] = Composition.new(self, klass)
+        @composition_printers[klass].visit(composition, &)
+      end
+
+      def visit_sum_constructors(sum)
+        visit_sum_constructor(sum.left) do |left|
+          visit_sum_constructor(sum.right) do |right|
+            yield "#{left} #{sum.class.operator} #{right}"
+          end
+        end
+      end
+
+      def visit_sum_constructor(type, &)
+        if type.is_a?(Dry::Types::Sum)
+          visit_sum_constructors(type, &)
+        else
+          visit(type, &)
+        end
+      end
+
+      def visit_enum(enum)
+        visit(enum.type) do |type|
+          options = enum.options.dup
+          mapping = options.delete(:mapping)
+
+          visit_options(options) do |opts|
+            if mapping == enum.inverted_mapping
+              yield "Enum(#{enum.joined_values})<#{type}#{opts}>"
+            else
+              mapping_str = mapping.map { |key, value|
+                "#{key.inspect}=>#{value.inspect}"
+              }.join(", ")
+              yield "Enum<#{type} mapping={#{mapping_str}}#{opts}>"
+            end
+          end
+        end
+      end
+
+      def visit_default(default)
+        visit(default.type) do |type|
+          visit_options(default.options) do |opts|
+            if default.is_a?(Default::Callable)
+              visit_callable(default.value) do |fn|
+                yield "Default<#{type} value_fn=#{fn}#{opts}>"
+              end
+            else
+              yield "Default<#{type} value=#{default.value.inspect}#{opts}>"
+            end
+          end
+        end
+      end
+
+      def visit_nominal(type)
+        visit_options(type.options, type.meta) do |opts|
+          yield "Nominal<#{type.primitive}#{opts}>"
+        end
+      end
+
+      def visit_lax(lax)
+        visit(lax.type) do |type|
+          yield "Lax<#{type}>"
+        end
+      end
+
+      def visit_callable(callable)
+        fn = callable.is_a?(String) ? FnContainer[callable] : callable
+
+        case fn
+        when ::Method
+          yield "#{fn.receiver}.#{fn.name}"
+        when ::Proc
+          path, line = fn.source_location
+
+          if line&.zero?
+            yield ".#{path}"
+          elsif path
+            yield "#{path.sub("#{Dir.pwd}/", EMPTY_STRING)}:#{line}"
+          else
+            match = fn.to_s.match(/\A#<Proc:0x\h+\(&:(?<name>\w+)\)(:? \(lambda\))?>\z/)
+
+            if match
+              yield ".#{match[:name]}"
+            elsif fn.lambda?
+              yield "(lambda)"
+            else
+              yield "(proc)"
+            end
+          end
+        else
+          call = fn.method(:call)
+
+          if call.owner == fn.class
+            yield "#{fn.class}#call"
+          else
+            yield "#{fn}.call"
+          end
+        end
+      end
+
+      def visit_schema(schema)
+        options = schema.options.dup
+        size = schema.count
+        key_fn_str = ""
+        type_fn_str = ""
+        strict_str = ""
+
+        strict_str = "strict " if options.delete(:strict)
+
+        if (key_fn = options.delete(:key_transform_fn))
+          visit_callable(key_fn) do |fn|
+            key_fn_str = "key_fn=#{fn} "
+          end
+        end
+
+        if (type_fn = options.delete(:type_transform_fn))
+          visit_callable(type_fn) do |fn|
+            type_fn_str = "type_fn=#{fn} "
+          end
+        end
+
+        keys = options.delete(:keys)
+
+        visit_options(options, schema.meta) do |opts|
+          opts = "#{opts[1..]} " unless opts.empty?
+          schema_parameters = "#{key_fn_str}#{type_fn_str}#{strict_str}#{opts}"
+
+          header = "Schema<#{schema_parameters}keys={"
+
+          if size.zero?
+            yield "#{header}}>"
+          else
+            yield header.dup << keys.map { |key|
+              visit(key) { |type| type }
+            }.join(" ") << "}>"
+          end
+        end
+      end
+
+      def visit_map(map)
+        visit(map.key_type) do |key|
+          visit(map.value_type) do |value|
+            options = map.options.dup
+            options.delete(:key_type)
+            options.delete(:value_type)
+
+            visit_options(options) do |_opts|
+              yield "Map<#{key} => #{value}>"
+            end
+          end
+        end
+      end
+
+      def visit_key(key)
+        visit(key.type) do |type|
+          if key.required?
+            yield "#{key.name}: #{type}"
+          else
+            yield "#{key.name}?: #{type}"
+          end
+        end
+      end
+
+      def visit_hash(hash)
+        options = hash.options.dup
+        type_fn_str = ""
+
+        if (type_fn = options.delete(:type_transform_fn))
+          visit_callable(type_fn) do |fn|
+            type_fn_str = "type_fn=#{fn}"
+          end
+        end
+
+        visit_options(options, hash.meta) do |opts|
+          if opts.empty? && type_fn_str.empty?
+            yield "Hash"
+          else
+            yield "Hash<#{type_fn_str}#{opts}>"
+          end
+        end
+      end
+
+      def visit_options(options, meta = EMPTY_HASH) # rubocop:disable Metrics/PerceivedComplexity
+        if options.empty? && meta.empty?
+          yield ""
+        else
+          opts = options.empty? ? "" : " options=#{options.inspect}"
+
+          if meta.empty?
+            yield opts
+          else
+            values = meta.map do |key, value|
+              case key
+              when Symbol
+                "#{key}: #{value.inspect}"
+              else
+                "#{key.inspect}=>#{value.inspect}"
+              end
+            end
+
+            yield "#{opts} meta={#{values.join(", ")}}"
+          end
+        end
+      end
+    end
+
+    PRINTER = Printer.new
+  end
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/PerceivedComplexity
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Result class used by {Type#try}
+    #
+    # @api public
+    class Result
+      include ::Dry::Equalizer(:input, immutable: true)
+
+      # @return [Object]
+      attr_reader :input
+
+      # @param [Object] input
+      #
+      # @api private
+      def initialize(input)
+        @input = input
+      end
+
+      # Success result
+      #
+      # @api public
+      class Success < Result
+        # @return [true]
+        #
+        # @api public
+        def success? = true
+
+        # @return [false]
+        #
+        # @api public
+        def failure? = false
+      end
+
+      # Failure result
+      #
+      # @api public
+      class Failure < Result
+        include ::Dry::Equalizer(:input, :error, immutable: true)
+
+        # @return [#to_s]
+        attr_reader :error
+
+        # @param [Object] input
+        #
+        # @param [#to_s] error
+        #
+        # @api private
+        def initialize(input, error)
+          super(input)
+          @error = error
+        end
+
+        # @return [String]
+        #
+        # @api private
+        def to_s = error.to_s
+
+        # @return [false]
+        #
+        # @api public
+        def success? = false
+
+        # @return [true]
+        #
+        # @api public
+        def failure? = true
+      end
+    end
+  end
+end

data/dry-types-1.9.1/lib/dry/types/schema/key.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Schema is a hash with explicit member types defined
+    #
+    # @api public
+    class Schema < Hash
+      # Proxy type for schema keys. Contains only key name and
+      # whether it's required or not. All other calls deletaged
+      # to the wrapped type.
+      #
+      # @see Dry::Types::Schema
+      class Key
+        extend ::Dry::Core::Deprecations[:"dry-types"]
+        include Type
+        include Dry::Equalizer(:name, :type, :options, inspect: false, immutable: true)
+        include Decorator
+        include Builder
+        include Printable
+
+        # @return [Symbol]
+        attr_reader :name
+
+        # @api private
+        def initialize(type, name, required: Undefined, **options)
+          required = Undefined.default(required) do
+            type.meta.fetch(:required) { !type.meta.fetch(:omittable, false) }
+          end
+
+          unless name.is_a?(::Symbol)
+            raise ::ArgumentError,
+                  "Schemas can only contain symbol keys, #{name.inspect} given"
+          end
+
+          super
+          @name = name
+        end
+
+        # @api private
+        def call_safe(input, &) = type.call_safe(input, &)
+
+        # @api private
+        def call_unsafe(input) = type.call_unsafe(input)
+
+        # @see Dry::Types::Nominal#try
+        #
+        # @api public
+        def try(input, &) = type.try(input, &)
+
+        # Whether the key is required in schema input
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def required? = options.fetch(:required)
+
+        # Control whether the key is required
+        #
+        # @overload required
+        #   @return [Boolean]
+        #
+        # @overload required(required)
+        #   Change key's "requireness"
+        #
+        #   @param [Boolean] required New value
+        #   @return [Dry::Types::Schema::Key]
+        #
+        # @api public
+        def required(required = Undefined)
+          if Undefined.equal?(required)
+            options.fetch(:required)
+          else
+            with(required: required)
+          end
+        end
+
+        # Make key not required
+        #
+        # @return [Dry::Types::Schema::Key]
+        #
+        # @api public
+        def omittable = required(false)
+
+        # Turn key into a lax type. Lax types are not strict hence such keys are not required
+        #
+        # @return [Lax]
+        #
+        # @api public
+        def lax = __new__(type.lax).required(false)
+
+        # Make wrapped type optional
+        #
+        # @return [Key]
+        #
+        # @api public
+        def optional = __new__(type.optional)
+
+        # Dump to internal AST representation
+        #
+        # @return [Array]
+        #
+        # @api public
+        def to_ast(meta: true)
+          [
+            :key,
+            [
+              name,
+              required,
+              type.to_ast(meta: meta)
+            ]
+          ]
+        end
+
+        # @see Dry::Types::Meta#meta
+        #
+        # @api public
+        def meta(data = Undefined)
+          if Undefined.equal?(data) || !data.key?(:omittable)
+            super
+          else
+            self.class.warn(
+              "Using meta for making schema keys is deprecated, " \
+              "please use .omittable or .required(false) instead" \
+              "\n" + Core::Deprecations::STACK.()
+            )
+            super.required(!data[:omittable])
+          end
+        end
+
+        private
+
+        # @api private
+        def decorate?(response) = response.is_a?(Type)
+      end
+    end
+  end
+end