Class: Mongoid::Indexable::Specification

Relationships & Source Files
Inherits:	Object
Defined in:	lib/mongoid/indexable/specification.rb

Overview

Encapsulates behavior around an index specification.

Constant Summary

MAPPINGS =

The mappings of nice Ruby-style names to the corresponding driver option name.

# File 'lib/mongoid/indexable/specification.rb', line 12
```
{
  expire_after_seconds: :expire_after
}
```

Class Method Summary

.new(klass, key, opts = nil) ⇒ Specification constructor

Instantiate a new index specification.

Instance Method Summary

#==(other) ⇒ true | false

Is this index specification equal to another?
#name ⇒ String

Get the index name, generated using the index key.
#superficial_match?(key: {}, name: nil) ⇒ true | false

Performs a superficial comparison with the given criteria, checking only the key and (optionally) the name.
#normalize_aliases!(spec) ⇒ Hash private Internal use only Internal use only

Normalize the spec in-place, in case aliased fields are provided.
#normalize_options!(options) ⇒ Hash private Internal use only Internal use only

Normalize the index options in-place.
#recursive_normalize_conditionals!(options) ⇒ Hash | Array | Object private Internal use only Internal use only

Recursively normalizes the nested elements of an options hash in-place, to account for $and operator (and other potential $-prefixed operators which may be supported by MongoDB in the future.).

Constructor Details

.new(klass, key, opts = nil) ⇒ `Specification`

Instantiate a new index specification.

Examples:

Create the new specification.

Specification.new(Band, { name: 1 }, background: true)

Parameters:

klass (Class) —

The class the index is defined on.
key (Hash) —

The hash of name/direction pairs.
opts (Hash) (defaults to: nil) —

the index options.

[ GitHub ]

# File 'lib/mongoid/indexable/specification.rb', line 62

def initialize(klass, key, opts = nil)
  options = opts || {}
  Validators::Options.validate(klass, key, options)
  @klass = klass
  @key = normalize_aliases!(key.dup)
  @fields = @key.keys
  @options = normalize_options!(options.deep_dup)
end

Instance Attribute Details

#fields (readonly)

[ GitHub ]

# File 'lib/mongoid/indexable/specification.rb', line 22

attr_reader :klass, :key, :fields, :options

#key ⇒ Hash (rw)

Returns:

(Hash) —

The index key.

[ GitHub ]

# File 'lib/mongoid/indexable/specification.rb', line 22

attr_reader :klass, :key, :fields, :options

#klass ⇒ `Class` (rw)

Returns:

(Class) —

The class the index is defined on.

[ GitHub ]

# File 'lib/mongoid/indexable/specification.rb', line 22

attr_reader :klass, :key, :fields, :options

#options (rw)

[ GitHub ]

# File 'lib/mongoid/indexable/specification.rb', line 22

attr_reader :klass, :key, :fields, :options

Instance Method Details

#==(other) ⇒ `true` | `false`

Is this index specification equal to another?

Examples:

Check equality of the specifications.

specification == other

Parameters:

other (Specification) —

The spec to compare against.

Returns:

(true | false) —

If the specs are equal.

[ GitHub ]

# File 'lib/mongoid/indexable/specification.rb', line 32

def ==(other)
  superficial_match?(key: other.key)
end

#name ⇒ String

Get the index name, generated using the index key.

Examples:

Get the index name.

specification.name

Returns:

(String) —

name The index name.

[ GitHub ]

# File 'lib/mongoid/indexable/specification.rb', line 77

def name
  @name ||= key.reduce([]) do |n, (k,v)|
    n << "#{k}_#{v}"
  end.join('_')
end

#normalize_aliases!(spec) ⇒ Hash (private)

This method is for internal use only.

Normalize the spec in-place, in case aliased fields are provided.

Examples:

Normalize the spec in-place.

specification.normalize_aliases!(name: 1)

Parameters:

spec (Hash) —

The index specification.

Returns:

(Hash) —

The normalized specification.

[ GitHub ]

# File 'lib/mongoid/indexable/specification.rb', line 95

def normalize_aliases!(spec)
  return unless spec.is_a?(Hash)

  spec.transform_keys! do |name|
    klass.database_field_name(name).to_sym
  end
end

#normalize_options!(options) ⇒ Hash (private)

This method is for internal use only.

Normalize the index options in-place. Performs deep normalization on options which have a fields hash value.

Examples:

Normalize the index options in-place.

specification.normalize_options!(unique: true)

Parameters:

options (Hash) —

The index options.

Returns:

(Hash) —

The normalized options.

[ GitHub ]

# File 'lib/mongoid/indexable/specification.rb', line 114

def normalize_options!(options)

  options.transform_keys! do |option|
    option = option.to_sym
    MAPPINGS[option] || option
  end

  %i[partial_filter_expression weights wildcard_projection].each do |key|
    recursive_normalize_conditionals!(options[key])
  end

  options
end

#recursive_normalize_conditionals!(options) ⇒ Hash | Array | `Object` (private)

This method is for internal use only.

Recursively normalizes the nested elements of an options hash in-place, to account for $and operator (and other potential $-prefixed operators which may be supported by MongoDB in the future.)

Examples:

Recursively normalize the index options in-place.

opts = { '$and' => [{ name: { '$eq' => 'Bob' } },
                    { age: { '$gte' => 20 } }] }
specification.recursive_normalize_conditionals!(opts)

Parameters:

options (Hash | Array | Object) —

The index options.

Returns:

(Hash | Array | Object) —

The normalized options.

[ GitHub ]

# File 'lib/mongoid/indexable/specification.rb', line 142

def recursive_normalize_conditionals!(options)
  case options
  when Hash
    normalize_aliases!(options)
    options.keys.select { |key| key.to_s.start_with?('$') }.each do |key|
      recursive_normalize_conditionals!(options[key])
    end
  when Array
    options.each { |opt| recursive_normalize_conditionals!(opt) }
  end

  options
end

#superficial_match?(key: {}, name: nil) ⇒ `true` | `false`

Performs a superficial comparison with the given criteria, checking only the key and (optionally) the name. Options are not compared.

Note that the ordering of the fields in the key is significant. Two keys with different orderings will not match, here.

Parameters:

key (Hash) —

the key that defines the index.
name (String | nil) —

the name given to the index, or nil to ignore the name.

Returns:

(true | false) —

the result of the comparison, true if this specification matches the criteria, and false otherwise.

[ GitHub ]

# File 'lib/mongoid/indexable/specification.rb', line 48

def superficial_match?(key: {}, name: nil)
  (name && name == self.name) ||
    self.fields == key.keys &&
    self.key == key
end

Class: Mongoid::Indexable::Specification

Overview

Constant Summary

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new(klass, key, opts = nil) ⇒ Specification

Instance Attribute Details

#fields (readonly)

#key ⇒ Hash (rw)

#klass ⇒ Class (rw)

#options (rw)

Instance Method Details

#==(other) ⇒ true | false

#name ⇒ String

#normalize_aliases!(spec) ⇒ Hash (private)

#normalize_options!(options) ⇒ Hash (private)

#recursive_normalize_conditionals!(options) ⇒ Hash | Array | Object (private)

#superficial_match?(key: {}, name: nil) ⇒ true | false

.new(klass, key, opts = nil) ⇒ `Specification`

#klass ⇒ `Class` (rw)

#==(other) ⇒ `true` | `false`

#recursive_normalize_conditionals!(options) ⇒ Hash | Array | `Object` (private)

#superficial_match?(key: {}, name: nil) ⇒ `true` | `false`