Class: ActiveRepository::Base

Inherits:
ActiveHash::Base show all
Extended by:
ActiveModel::Callbacks, Finders, Writers
Includes:
ActiveModel::Validations, ActiveModel::Validations::Callbacks, Associations, Writers::InstanceMethods
Defined in:
lib/active_repository/base.rb

Overview

Base class for ActiveRepository gem. Extends it in order to use it.

Options

There are 2 class attributes to help configure your ActiveRepository class:

* +class_model+: Use it to specify the class that is responsible for the
  persistence of the objects. Default is self, so it is always saving in
  memory by default.

* +save_in_memory+: Used to ignore the class_model attribute, you can use
  it in your test suite, this way all your tests will be saved in memory.
  Default is set to true so it saves in memory by default.

Examples

Using ActiveHash to persist objects in memory:

class SaveInMemoryTest < ActiveRepository::Base
end

Using ActiveRecord/Mongoid to persist objects:

class SaveInORMOrODMTest < ActiveRepository::Base
  SaveInORMOrODMTest.set_model_class(ORMOrODMModelClass)
  SaveInORMOrODMTest.set_save_in_memory(false)
end
Author

Caio Torres ([email protected])

License

GPL

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Finders

define_custom_find_all_by_field, define_custom_find_by_field, find, find_all_by_field, find_by_id, first, last

Methods included from Writers

create, find_or_create, find_or_initialize

Methods included from Writers::InstanceMethods

#attributes=, #delete, #update_attribute, #update_attributes

Methods included from Associations

included

Methods inherited from ActiveHash::Base

#delete, #eql?, insert, #persisted?, #readonly?, remove, #to_param, #update_attribute, validate_unique_id

Class Method Details

.all ⇒ Object

Returns all persisted objects



71
72
73
 
# File 'lib/active_repository/base.rb', line 71

def self.all
  (repository? ? super : PersistenceAdapter.all(self).map { |object| serialize!(object.attributes) })
end

.constantize ⇒ Object

Constantize class name



76
77
78
 
# File 'lib/active_repository/base.rb', line 76

def self.constantize
  self.to_s.constantize
end

.delete_all ⇒ Object

Deletes all persisted objects



81
82
83
 
# File 'lib/active_repository/base.rb', line 81

def self.delete_all
  repository? ? super : PersistenceAdapter.delete_all(self)
end

.exists?(id) ⇒ Boolean

Checks the existence of a persisted object with the specified id

Returns:

  • (Boolean) 


86
87
88
 
# File 'lib/active_repository/base.rb', line 86

def self.exists?(id)
  repository? ? find_by_id(id).present? : PersistenceAdapter.exists?(self, id)
end

.get_model_class ⇒ Object

Returns the Class responsible for persisting the objects



91
92
93
94
 
# File 'lib/active_repository/base.rb', line 91

def self.get_model_class
  return self if self.model_class.nil? || self.save_in_memory?
  save_in_memory? ? self : self.model_class
end

.serialize!(other) ⇒ Object

Converts Persisted object(s) to it’s ActiveRepository counterpart



97
98
99
100
101
102
103
104
 
# File 'lib/active_repository/base.rb', line 97

def self.serialize!(other)
  case other.class.to_s
  when "Hash", "ActiveSupport::HashWithIndifferentAccess" then self.new.serialize!(other)
  when "Array"                                            then other.map { |o| serialize!(o.attributes) }
  when "Moped::BSON::Document"                            then self.new.serialize!(other)
  else self.new.serialize!(other.attributes)
  end
end

.serialized_attributes ⇒ Object

Returns a array with the field names of the Class



107
108
109
 
# File 'lib/active_repository/base.rb', line 107

def self.serialized_attributes
  field_names.map &:to_s
end

.set_model_class(value) ⇒ Object

Sets the class attribute model_class, responsible to persist the ActiveRepository objects



112
113
114
115
116
117
118
119
120
121
 
# File 'lib/active_repository/base.rb', line 112

def self.set_model_class(value)
  self.model_class = value if model_class.nil?

  self.set_save_in_memory(repository?)

  field_names.each do |field_name|
    define_custom_find_by_field(field_name)
    define_custom_find_all_by_field(field_name)
  end
end

.set_save_in_memory(value) ⇒ Object

Sets the class attribute save_in_memory, set it to true to ignore model_class attribute and persist objects in memory



125
126
127
 
# File 'lib/active_repository/base.rb', line 125

def self.set_save_in_memory(value)
  self.save_in_memory = value
end

.where(*args) ⇒ Object

Searches persisted objects that matches the criterias in the parameters. Can be used in ActiveRecord/Mongoid way or in SQL like way.

Example:

* RelatedClass.where(:name => "Peter")
* RelatedClass.where("name = 'Peter'")

Raises:

  • (ArgumentError) 


136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/active_repository/base.rb', line 136

def self.where(*args)
  raise ArgumentError.new("wrong number of arguments (0 for 1)") if args.empty?

  if repository?
    args = args.first if args.try(:first).is_a?(Array)
    super(ActiveHash::SQLQueryExecutor.args_to_query(args))
  else
    objects = PersistenceAdapter.where(self, sanitize_args(args)).map do |object|
      self.serialize!(object.attributes)
    end

    objects
  end
end

Instance Method Details

#get_model_class ⇒ Object 



151
152
153
 
# File 'lib/active_repository/base.rb', line 151

def get_model_class
  self.class.get_model_class
end

#persist ⇒ Object

Persists the object using the class defined on the model_class attribute, if none defined it is saved in memory.



157
158
159
160
161
 
# File 'lib/active_repository/base.rb', line 157

def persist
  if self.valid?
    save_in_memory? ? save : self.convert.present?
  end
end

#reload ⇒ Object

Gathers the persisted object from database and updates self with it’s attributes.



164
165
166
167
168
 
# File 'lib/active_repository/base.rb', line 164

def reload
  object = self.id.present? ? get_model_class.find(self.id) : self

  serialize! object.attributes
end

#save(force = false) ⇒ Object 



170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/active_repository/base.rb', line 170

def save(force=false)
  if self.class == get_model_class
    object = get_model_class.find(self.id)

    if force || self.id.nil?
      self.id = nil if self.id.nil?
      super
    elsif self.valid?
      object.attributes = self.attributes
      object.save(true)
    end

    self.valid?
  else
    self.persist
  end
end

#serialize!(attributes) ⇒ Object

Updates attributes from self with the attributes from the parameters



189
190
191
192
193
194
195
 
# File 'lib/active_repository/base.rb', line 189

def serialize!(attributes)
  unless attributes.nil?
    self.attributes = attributes
  end

  self.dup
end