Class Mash has 43 methods (exceeds 20 allowed). Consider refactoring.

Open

  class Mash < Hash
    include Hashie::Extensions::RubyVersionCheck
    extend Hashie::Extensions::KeyConflictWarning

    ALLOWED_SUFFIXES = %w[? ! = _].freeze

Method all has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.

Open

    def all(query)
      return to_enum(:all, query) unless block_given?

      if @hash.include? query
        yield @hash[query]

• Read up
  Read up

Class Dash has 23 methods (exceeds 20 allowed). Consider refactoring.

Open

  class Dash < Hash
    include Hashie::Extensions::PrettyInspect

    alias to_s inspect

File mash.rb has 261 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require 'hashie/hash'
require 'hashie/array'
require 'hashie/utils'
require 'hashie/logger'
require 'hashie/extensions/key_conflict_warning'

Method build_coercion has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

        def build_coercion(type)
          if type.is_a? Enumerable
            if type.class == ::Hash
              type, key_type, value_type = type.class, *type.first
              build_hash_coercion(type, key_type, value_type)

• Read up
  Read up

Method <=> has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

      def <=>(other)
        lhsegments = segments
        rhsegments = other.segments

        lhsize = lhsegments.size

• Read up
  Read up

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

Open

    def update_attributes!(attributes)
      update_attributes(attributes)

      self.class.defaults.each_pair do |prop, value|
        next unless fetch(prop, nil).nil?

• Read up
  Read up

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

Open

    def all(query)
      return to_enum(:all, query) unless block_given?

      if @hash.include? query
        yield @hash[query]

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

Open

      def _recursive_merge(hash, other_hash, &block)
        other_hash.each do |k, v|
          hash[k] =
            if hash.key?(k) && hash[k].is_a?(::Hash) && v.is_a?(::Hash)
              _recursive_merge(hash[k], v, &block)

• Read up
  Read up

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

Open

    def to_hash(options = {})
      out = {}
      each_key do |k|
        assignment_key =
          if options[:stringify_keys]

• Read up
  Read up

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

Open

      def deep_fetch(*args, &block)
        args.reduce(self) do |obj, arg|
          begin
            arg = Integer(arg) if obj.is_a? Array
            obj.fetch(arg)

• Read up
  Read up

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

Open

      def method_missing(name, *args)
        return super unless args.empty?

        if query_method?(name)
          key = key_from_query_method(name)

• Read up
  Read up

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

Open

      def self._deep_locate(comparator, object, result = [])
        if object.is_a?(::Enumerable)
          if object.any? { |value| _match_comparator?(value, comparator, object) }
            result.push object
          end

• Read up
  Read up

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

Open

      def self.included(base)
        Hashie::Extensions::Dash::IndifferentAccess.maybe_extend(base)

        base.class_eval do
          alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)

• Read up
  Read up

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

Open

        def coerce_value(from, into, options = {})
          options = { strict: true }.merge(options)

          if ABSTRACT_CORE_TYPES.key? from
            ABSTRACT_CORE_TYPES[from].each do |type|

• Read up
  Read up

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

Open

      def method_missing(name, *args)
        if key?(name)
          self[name]
        else
          sname = name.to_s

• Read up
  Read up

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

Open

    def log_collision?(method_key)
      return unless method_key.is_a?(String) || method_key.is_a?(Symbol)
      return unless respond_to?(method_key)

      _, suffix = method_name_and_suffix(method_key)

• Read up
  Read up

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

Open

    def _deep_update(other_hash, &blk)
      other_hash.each_pair do |k, v|
        key = convert_key(k)
        if v.is_a?(::Hash) && key?(key) && regular_reader(key).is_a?(Mash)
          custom_reader(key).deep_update(v, &blk)

• Read up
  Read up

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

Open

    def convert_value(val, duping = false) #:nodoc:
      case val
      when self.class
        val.dup
      when Hash

• Read up
  Read up

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

Open

          def []=(property, value)
            if self.class.translation_exists? property
              send("#{property}=", value)

              if self.class.transformation_exists? property

• Read up
  Read up