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

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) # rubocop:disable Metrics/PerceivedComplexity
          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 infer_predicate has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

        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

• 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 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 resolve_missing_keys has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

      def resolve_missing_keys(hash, options) # rubocop:disable Metrics/PerceivedComplexity
        skip_missing = options.fetch(:skip_missing, false)
        resolve_defaults = options.fetch(:resolve_defaults, true)

        keys.each do |key|

• Read up
  Read up

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

Open

        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

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

Open

      def fallback(value = Undefined, shared: false, &_fallback) # rubocop:disable Metrics/PerceivedComplexity
        if Undefined.equal?(value) && !block_given?
          raise ::ArgumentError, "fallback value or a block must be given"
        end

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

Open

      def fallback(value = Undefined, shared: false, &_fallback) # rubocop:disable Metrics/PerceivedComplexity
        if Undefined.equal?(value) && !block_given?
          raise ::ArgumentError, "fallback value or a block must be given"
        end

• 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 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 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 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 to_ast has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

        def to_ast(meta: true)
          if member.respond_to?(:to_ast)
            [:array, [member.to_ast(meta: meta), meta ? self.meta : EMPTY_HASH]]
          else
            [:array, [member, meta ? self.meta : EMPTY_HASH]]

• 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

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

Open

        def self.[](fn)
          raise ::ArgumentError, "Missing constructor block" if fn.nil?

          if fn.is_a?(Function)
            fn

• Read up
  Read up

Method to_decimal has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

        def self.to_decimal(input, &_block)
          if input.is_a?(::Float)
            input.to_d
          else
            BigDecimal(input)

• Read up
  Read up

Method Constructor has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

      def Constructor(klass, cons = nil, &block) # rubocop:disable Metrics/PerceivedComplexity:
        if klass.is_a?(Type)
          if cons || block
            klass.constructor(cons || block)
          else

• Read up
  Read up