Class: IronAdmin::Adapters::Mongoid

Inherits:
Base
  • Object
show all
Defined in:
lib/iron_admin/adapters/mongoid.rb,
lib/iron_admin/adapters/mongoid/column_descriptor.rb,
lib/iron_admin/adapters/mongoid/association_wrapper.rb

Overview

Mongoid adapter — wraps Mongoid's APIs behind the standard adapter interface.

This adapter enables IronAdmin to work with MongoDB-backed models. It implements all abstract methods from Adapters::Base using Mongoid's query interface, field introspection, and association reflection.

Examples:

Configuring a resource to use Mongoid

class ArticleResource < IronAdmin::Resource
  self.adapter_class = :mongoid
end

Defined Under Namespace

Classes: AssociationWrapper

Constant Summary collapse

MONGOID_TYPE_MAP =

Maps Mongoid field types (Ruby classes) to IronAdmin symbol types.

{
  String => :string,
  Integer => :integer,
  Float => :float,
  BigDecimal => :decimal,
  Date => :date,
  DateTime => :datetime,
  Time => :datetime,
  Hash => :json,
  Array => :text,
  Symbol => :string,
}.freeze
ColumnDescriptor =

Uses the shared ColumnDescriptor from Adapters::Base.

IronAdmin::Adapters::Base::ColumnDescriptor

Constants inherited from Base

Base::TRUTHY_VALUES

Instance Attribute Summary

Attributes inherited from Base

#model_class

Instance Method Summary collapse

Methods inherited from Base

#all, #cast_boolean, #create_record, #find_by, #find_by_keys, #human_name, #initialize, #resource_name, #update_record

Constructor Details

This class inherits a constructor from IronAdmin::Adapters::Base

Instance Method Details

#association(name) ⇒ Object 



57
58
59
60
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 57

def association(name)
  relation = model_class.relations[name.to_s]
  relation ? AssociationWrapper.new(relation) : nil
end

#associations(kind = nil) ⇒ Object 



52
53
54
55
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 52

def associations(kind = nil)
  wrappers = model_class.relations.values.map { |r| AssociationWrapper.new(r) }
  kind ? wrappers.select { |w| w.macro == kind } : wrappers
end

#attachments ⇒ Object 



62
63
64
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 62

def attachments
  {}
end

#build(attrs = {}) ⇒ Object

--- CRUD ---



159
160
161
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 159

def build(attrs = {})
  model_class.new(cast_array_attributes(attrs))
end

#column_names ⇒ Object 



38
39
40
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 38

def column_names
  model_class.fields.keys
end

#columns ⇒ Object

--- Schema Introspection ---



32
33
34
35
36
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 32

def columns
  model_class.fields.values.map do |field|
    ColumnDescriptor.new(field.name, map_field_type(field))
  end
end

#count(scope = nil) ⇒ Object 



140
141
142
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 140

def count(scope = nil)
  (scope || all).count
end

#destroy!(record) ⇒ Object 



171
172
173
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 171

def destroy!(record)
  record.destroy!
end

#distinct_values(column) ⇒ Object 



132
133
134
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 132

def distinct_values(column)
  model_class.distinct(column).compact.sort
end

#enums ⇒ Object 



46
47
48
49
50
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 46

def enums
  return model_class.defined_enums if model_class.respond_to?(:defined_enums)

  {}
end

#filter(scope, column, value) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 109

def filter(scope, column, value)
  case value
  when Array
    scope.in(column => value)
  when Range
    build_range_filter(scope, column, value)
  else
    scope.where(column => value)
  end
end

#find(id) ⇒ Object 



99
100
101
102
103
104
105
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 99

def find(id)
  model_class.find(id)
rescue StandardError => e
  raise IronAdmin::RecordNotFound, e.message if not_found_error?(e)

  raise
end

#find_each(scope) ⇒ Object

--- Batch ---



193
194
195
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 193

def find_each(scope, &)
  scope.batch_size(100).each(&)
end

#has_column?(name) ⇒ Boolean

rubocop:disable Naming/PredicatePrefix

Returns:

  • (Boolean) 


42
43
44
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 42

def has_column?(name) # rubocop:disable Naming/PredicatePrefix
  model_class.fields.key?(name.to_s)
end

#limit(scope, max) ⇒ Object 



124
125
126
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 124

def limit(scope, max)
  scope.limit(max)
end

#order_by(scope, column, direction) ⇒ Object 



120
121
122
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 120

def order_by(scope, column, direction)
  scope.order_by(column => direction)
end

#pagy_method ⇒ Object 



215
216
217
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 215

def pagy_method
  :pagy_mongoid
end

#pluck(scope, column) ⇒ Object 



136
137
138
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 136

def pluck(scope, column)
  scope.pluck(column)
end

#polymorphic_inverse_classes(polymorphic_name) ⇒ Object 



70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 70

def polymorphic_inverse_classes(polymorphic_name)
  return [] unless defined?(::Mongoid::Document)

  classes = ObjectSpace.each_object(Class).filter_map do |klass|
    next unless klass < ::Mongoid::Document
    next unless mongoid_polymorphic_inverse?(klass, polymorphic_name)

    klass
  end

  classes.sort_by { |klass| klass.name.to_s }
end

#preload(scope, association_names) ⇒ Object 



128
129
130
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 128

def preload(scope, association_names)
  scope.includes(*association_names)
end

#primary_key ⇒ Object

Mongoid documents use _id. Composite keys are not supported by Mongoid, so this always returns a String, never an Array.



91
92
93
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 91

def primary_key
  "_id"
end

#query_builder_class ⇒ Object 



211
212
213
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 211

def query_builder_class
  IronAdmin::Filters::MongoidQueryBuilder
end

#record_changes(record) ⇒ Object

--- Adapter-Agnostic Interface ---



199
200
201
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 199

def record_changes(record)
  record.previous_changes
end

#rich_text_attributes ⇒ Object 



66
67
68
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 66

def rich_text_attributes
  []
end

#save(record) ⇒ Object 



163
164
165
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 163

def save(record)
  record.save
end

#search_column(scope, column, query) ⇒ Object

--- Search ---



146
147
148
149
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 146

def search_column(scope, column, query)
  pattern = /#{Regexp.escape(query)}/i
  scope.where(column => pattern)
end

#search_columns(scope, columns, query) ⇒ Object 



151
152
153
154
155
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 151

def search_columns(scope, columns, query)
  pattern = /#{Regexp.escape(query)}/i
  conditions = columns.map { |col| { col => pattern } }
  scope.any_of(*conditions)
end

#table_name ⇒ Object

--- Naming ---



85
86
87
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 85

def table_name
  model_class.collection_name.to_s
end

#transaction ⇒ Object

--- Transactions ---



177
178
179
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 177

def transaction
  yield
end

#unscope_column(scope, column) ⇒ Object

--- Scope Manipulation ---



183
184
185
186
187
188
189
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 183

def unscope_column(scope, column)
  key = column.to_s
  new_selector = scope.selector.reject { |k, _| k == key }
  new_scope = model_class.where(new_selector)
  new_scope = new_scope.order_by(scope.options[:sort]) if scope.options[:sort]
  new_scope
end

#update(record, attrs) ⇒ Object 



167
168
169
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 167

def update(record, attrs)
  record.update(cast_array_attributes(attrs))
end

#wrap_rollback ⇒ Object 



203
204
205
206
207
208
209
 
# File 'lib/iron_admin/adapters/mongoid.rb', line 203

def wrap_rollback
  yield
rescue IronAdmin::Rollback
  # Silently absorb rollback — Mongoid transactions (if used)
  # are handled separately
  nil
end