Method Type has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring.

Open

      def self.Type type, **params
        case Snake(type)
        when 'string'
          if Falsey?(params[:strip])
            :str?

• Read up
  Read up

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

Open

      def self.SnakeSafe(whatever, existing = [], update_existing: true, short: false, symbolize: false)
        result = Snake(whatever, short: short)
        str = loop do
          break result unless existing.include? result
          suffix = result[/(?<=_)\d+(?=\z)/]

• Read up
  Read up

Method patch_message_set has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

        def self.patch_message_set(set)
          return nil if set.empty?

          fail TypeError, "Expected: ::Dry::Validation::MessageSet; got: #{set.class}" unless set.is_a?(::Dry::Validation::MessageSet)

• Read up
  Read up

Method prepended has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def self.prepended base
          fail ArgumentError, "Can not prepend #{self.class} to #{base.class}: base class must be a ::Mutations::Command descendant." unless base < ::Mutations::Command
          base.extend(DSL::Module) unless base.ancestors.include?(DSL::Module)
          base.extend(Module.new do
            def exceptions_as_errors(value)

Method Type has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def self.Type type, **params
        case Snake(type)
        when 'string'
          if Falsey?(params[:strip])
            :str?

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

Open

      def self.Either input
        case input
        when Class then input.prepend Either unless input.ancestors.include?(Either)
        when Module then input.include Either unless input.ancestors.include?(Either)
        else input.singleton_class.prepend Either unless input.singleton_class.ancestors.include?(Either)

• Read up
  Read up

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

Open

        def fix_accessors!
          schema.rules.keys.each do |method|
            next if respond_to?(name = method)

            singleton_class.tap do |c|

• Read up
  Read up

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

Open

        def derived_schema input_processor:, type:, **options, &block
          this = is_a?(Class) ? self : self.class

          parent_with_schema = this.ancestors.drop(1).detect do |klazz|
            next if [this, ::Mutations::Command, ::Dry::Mutations::Extensions::Command].include?(klazz)

• Read up
  Read up

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

Open

        def array name, **params, &cb
          current = @current # closure scope

          nested =  begin
                      Nested.!(current, &cb)

• Read up
  Read up

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

Open

    def self.Schema(input_processor: nil, type: :schema, **options, &block)
      type = :schema unless type && ::Dry::Mutations.const_defined?(type.to_s.capitalize)
      parent = ::Dry::Mutations.const_get(type.to_s.capitalize)
      ::Dry::Validation.Schema(parent, **options) do
        configure { config.input_processor = input_processor } if input_processor

• Read up
  Read up

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

Open

        def self.prepended base
          fail ArgumentError, "Can not prepend #{self.class} to #{base.class}: base class must be a ::Mutations::Command descendant." unless base < ::Mutations::Command
          base.extend(DSL::Module) unless base.ancestors.include?(DSL::Module)
          base.extend(Module.new do
            def exceptions_as_errors(value)

• Read up
  Read up

Method schema has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

        def schema *args, input_processor: nil, type: :form, **options, &block
          case args.count
          when 0, 1
            schema, = args
            @schema ||= patched_schema(schema) \

• Read up
  Read up

Method RawInputs has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

      def self.RawInputs *args
        args.inject(Utils.Hash({})) do |h, arg|
          h.merge! case arg
                   when Hash then arg
                   when ::Dry::Monads::Either::Right then arg.value

• Read up
  Read up

Method finalizer has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

        def finalizer(type, outcome)
          fin = self.class.instance_variable_get :@finalizers
          # rubocop:disable Lint/AssignmentInCondition
          return nil unless fin.is_a?(Hash) && finalizer = fin[type]
          # rubocop:enable Lint/AssignmentInCondition

• Read up
  Read up

Method Outcome has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

      def self.Outcome input
        case input
        when ::Mutations::Outcome then input
        when ::Dry::Monads::Either::Left
          ::Mutations::Outcome.new(false, nil, input.value, nil).tap do |outcome|

• Read up
  Read up

Method dig has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

        def dig(predicate, input = schema)
          case input.rules
          when Hash # the whole schema
            input.rules.map do |k, v|
              pred = predicates(v).detect do |p|

• Read up
  Read up

Method extended has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

        def self.extended base
          fail Errors::TypeError.new("Extended class [#{base}] should not respond to :call, it is defined by this extension.") if base.respond_to?(:call)
          base.send :define_method, :initialize do |*input|
            @input = Utils.RawInputs(*input)
          end unless base.instance_methods(false).include?(:initialize)

• Read up
  Read up