Class Schema has 24 methods (exceeds 20 allowed). Consider refactoring.

Open

    class Schema < Hash
      NO_TRANSFORM = Dry::Types::FnContainer.register { |x| x }
      SYMBOLIZE_KEY = Dry::Types::FnContainer.register(:to_sym.to_proc)

      include ::Enumerable

File printer.rb has 273 lines of code (exceeds 250 allowed). Consider refactoring.

Open

module Dry
  module Types
    # @api private
    class Printer
      MAPPING = {

Class Compiler has 21 methods (exceeds 20 allowed). Consider refactoring.

Open

    class Compiler
      extend ::Dry::Core::Deprecations[:'dry-types']

      attr_reader :registry

Method try has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

        def try(input, &block)
          if primitive?(input)
            output = []

            result = input.map { |el| member.try(el) }

• Read up
  Read up

Method try has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

      def try(input)
        if primitive?(input)
          success = true
          output = {}
          result = {}

• Read up
  Read up

Method visit_callable has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

      def visit_callable(callable)
        fn = callable.is_a?(String) ? FnContainer[callable] : callable

        case fn
        when Method

• Read up
  Read up

Method visit_options has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

      def visit_options(options, meta = EMPTY_HASH)
        if options.empty? && meta.empty?
          yield ''
        else
          opts = options.empty? ? '' : " options=#{options.inspect}"

• Read up
  Read up

Method try has 38 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def try(input)
        if primitive?(input)
          success = true
          output = {}
          result = {}

Method resolve_missing_keys has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

      def resolve_missing_keys(hash, options)
        skip_missing = options.fetch(:skip_missing, false)
        resolve_defaults = options.fetch(:resolve_defaults, true)

        keys.each do |key|

• Read up
  Read up

Method type_constants has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

      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

• Read up
  Read up

Method visit_schema has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def visit_schema(schema)
        options = schema.options.dup
        size = schema.count
        key_fn_str = ''
        type_fn_str = ''

Method visit_sum_constructors has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def visit_sum_constructors(sum)
        case sum.left
        when Sum
          visit_sum_constructors(sum.left) do |left|
            case sum.right

Method visit_callable has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def visit_callable(callable)
        fn = callable.is_a?(String) ? FnContainer[callable] : callable

        case fn
        when Method

Method try has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

        def try(input, &block)
          result = type.try(input)

          if result.success?
            validation = rule.(result.input)

• Read up
  Read up

Method visit_sum_constructors has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

      def visit_sum_constructors(sum)
        case sum.left
        when Sum
          visit_sum_constructors(sum.left) do |left|
            case sum.right

• Read up
  Read up

Method [] has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def self.[](name)
      type_map.fetch_or_store(name) do
        case name
        when ::String
          result = name.match(TYPE_SPEC_REGEX)

• Read up
  Read up

Method coerce has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

      def coerce(input)
        unless primitive?(input)
          return failure(
            input, CoercionError.new("#{input.inspect} must be an instance of #{primitive}")
          )

• Read up
  Read up

Method call_safe has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

        def call_safe(input)
          if primitive?(input)
            failed = false

            result = input.each_with_object([]) do |el, output|

• Read up
  Read up

Method visit_schema has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

      def visit_schema(schema)
        options = schema.options.dup
        size = schema.count
        key_fn_str = ''
        type_fn_str = ''

• Read up
  Read up

Method define_constants has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def define_constants(constants, mod = self)
        constants.each do |name, value|
          case value
          when ::Hash
            if mod.const_defined?(name, false)

• Read up
  Read up