Module: SimpleModel::Attributes::ClassMethods

Defined in:
lib/simple_model/attributes.rb

Constant Summary collapse

DEFAULT_ATTRIBUTE_SETTINGS = 
{:attributes_method => :attributes,
:allow_blank => false,
:initialize => true
}.freeze
AVAILABLE_ATTRIBUTE_METHODS = 
{
  :has_attribute => {:alias => :has_attributes, :options => {:allow_blank => true}},
  :has_boolean  => {:cast_to => :to_b, :alias => :has_booleans, :options =>  {:allow_blank => true}},
  :has_currency => {:cast_to => :to_d, :alias => :has_currencies},
  :has_date => {:cast_to => :to_date, :alias => :has_dates} ,
  :has_decimal  => {:cast_to => :to_d, :alias => :has_decimals},
  :has_float => {:cast_to => :to_f, :alias => :has_floats},
  :has_int => {:cast_to => :to_i, :alias => :has_ints},
  :has_time => {:cast_to => :to_time, :alias => :has_times}
}.freeze

Instance Method Summary collapse

Instance Method Details

#add_defined_attribute(attr, options) ⇒ Object

We want to re-run define_attribute_methods since attributes are not all defined at once, so we must set @attribute_methods_generated to nil to allow the re-run to occur ONLY IN RAILS 3.0.



228
229
230
231
232
 
# File 'lib/simple_model/attributes.rb', line 228

def add_defined_attribute(attr,options)
  defined_attributes[attr] = options
  @attribute_methods_generated = nil #if (ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR == 0)
  define_attribute_methods(defined_attributes_keys)
end

#after_initialize ⇒ Object

A hook to perform actions after all attributes have been initialized Expects an lambda that accept the object and the pending attributes hash EX: lambda {|obj| puts “initialized”}



314
315
316
 
# File 'lib/simple_model/attributes.rb', line 314

def after_initialize
  @after_initialize
end

#after_initialize=(after_initialize) ⇒ Object

Expects an lambda that accept the object and the pending attributes hash EX: lambda {|obj| puts “initialized”}



320
321
322
323
 
# File 'lib/simple_model/attributes.rb', line 320

def after_initialize=after_initialize
  raise TypeError "after_initalize must be a Proc" unless after_initialize.is_a?(Proc)
  @after_initialize = after_initialize
end

#alias_attribute(new_alias, attr) ⇒ Object

Creates alias setter and getter for the supplied attribute using the supplied alias See spec for example.

Raises:



272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
 
# File 'lib/simple_model/attributes.rb', line 272

def alias_attribute(new_alias,attr)
  
  # get to the base attribute
  while alias_attributes[attr]
    attr = alias_attributes[attr]
  end

  raise UndefinedAttribute, "#{attr} is not a defined attribute so it cannot be aliased" unless defined_attributes[attr]

  alias_attributes[new_alias] = attr

  define_method(new_alias) do
    send(attr)
  end
  define_method("#{new_alias}?") do
    send("#{attr}?")
  end
  define_method("#{new_alias}=") do |*args, &block|
    send("#{attr}=",*args, &block)
  end
end

#alias_attributes ⇒ Object 



189
190
191
 
# File 'lib/simple_model/attributes.rb', line 189

def alias_attributes
  @alias_attributes ||= HashWithIndifferentAccess.new
end

#alias_attributes=(alias_attributes) ⇒ Object 



193
194
195
 
# File 'lib/simple_model/attributes.rb', line 193

def alias_attributes=alias_attributes
  @alias_attributes = alias_attributes
end

#attribute_defined?(attr) ⇒ Boolean

Returns:

  • (Boolean) 


205
206
207
 
# File 'lib/simple_model/attributes.rb', line 205

def attribute_defined?(attr)
  defined_attributes.key?(attr)
end

#before_initialize ⇒ Object

A hook to perform actions on the pending attributes or the object before the pending attributes have been initialized. Expects an lambda that accept the object, the pending attributes hash and should return a hash to be set EX: lambda {|obj,attrs| attrs.select{|k,v| !v.blank?}}



299
300
301
 
# File 'lib/simple_model/attributes.rb', line 299

def before_initialize
  @before_initialize
end

#before_initialize=(before_initialize) ⇒ Object

Expects an lambda that accept the object, the pending attributes hash and should return a hash to be set EX: lambda {|obj,attrs| attrs.select{|k,v| !v.blank?}}



306
307
308
309
 
# File 'lib/simple_model/attributes.rb', line 306

def before_initialize=before_initialize
  raise TypeError "before_initialize must be a lambda that accepts the attributes to be initialize" unless before_initialize.is_a?(Proc)
  @before_initialize = before_initialize
end

#create_attribute_methods(attributes, options) ⇒ Object

builds the setter and getter methods



242
243
244
245
246
247
248
249
250
 
# File 'lib/simple_model/attributes.rb', line 242

def create_attribute_methods(attributes,options)
  unless attributes.blank?
    attributes.each do |attr|
      define_setter_with_options(attr,options)
      define_reader_with_options(attr,options)
      add_defined_attribute(attr,options)
    end
  end
end

#default_attribute_settings ⇒ Object

The default settings for a SimpeModel class Options:

  • :on_set - accepts a lambda that is run when an attribute is set

  • :on_get - accepts a lambda that is run when you get/read an attribute

  • :default - the default value for the attribute, can be a symbol that is sent for a method

  • :initialize - informations the object whether or not it should initialize the attribute with :default value, defaults to true

** If :initialize is set to false you must set :allow_blank to false or it will never set the default value

  • :allow_blank - when set to false, if an attributes value is blank attempts to set the default value, defaults to true



217
218
219
 
# File 'lib/simple_model/attributes.rb', line 217

def default_attribute_settings
  @default_attribute_settings ||= DEFAULT_ATTRIBUTE_SETTINGS
end

#default_attribute_settings=(default_attribute_settings) ⇒ Object 



221
222
223
 
# File 'lib/simple_model/attributes.rb', line 221

def default_attribute_settings=default_attribute_settings
  @default_attribute_settings = default_attribute_settings
end

#define_reader_with_options(attr, options) ⇒ Object 



252
253
254
255
256
257
258
259
 
# File 'lib/simple_model/attributes.rb', line 252

def define_reader_with_options(attr,options)
  define_method(attr) do
    get_attribute(attr)
  end
  define_method("#{attr}?") do
    get_attribute?(attr)
  end
end

#define_setter_with_options(attr, options) ⇒ Object

Creates setter methods for the provided attributes On set, it will mark the attribute as changed if the attributes has been initialized.



264
265
266
267
268
 
# File 'lib/simple_model/attributes.rb', line 264

def define_setter_with_options(attr,options)
  define_method("#{attr}=") do |val|
    set_attribute(attr,val)
  end
end

#defined_attributes ⇒ Object 



197
198
199
 
# File 'lib/simple_model/attributes.rb', line 197

def defined_attributes
  @defined_attributes ||= HashWithIndifferentAccess.new
end

#defined_attributes=(defined_attributes) ⇒ Object 



201
202
203
 
# File 'lib/simple_model/attributes.rb', line 201

def defined_attributes=defined_attributes
  @defined_attributes = defined_attributes
end

#defined_attributes_keys ⇒ Object

We don’t want to call define_attribute_methods on methods defined in the parent class



235
236
237
238
239
 
# File 'lib/simple_model/attributes.rb', line 235

def defined_attributes_keys
  dak = defined_attributes.keys
  dak = dak - superclass.defined_attributes.keys if superclass.respond_to?(:defined_attributes)
  dak
end

#inherited(base) ⇒ Object

Must inherit super’s defined_attributes and alias_attributes Rails 3.0 does some weird stuff with ActiveModel::Dirty so we need a hack to keep things working when a class inherits from a super that has ActiveModel::Dirty included



329
330
331
332
333
334
335
336
337
338
 
# File 'lib/simple_model/attributes.rb', line 329

def inherited(base)
  base.defined_attributes = defined_attributes.merge(base.defined_attributes)
  base.alias_attributes = alias_attributes.merge(base.alias_attributes)
  super
  # Rails 3.0 Hack
  if (ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR == 0)
    base.attribute_method_suffix '_changed?', '_change', '_will_change!', '_was'
    base.attribute_method_affix :prefix => 'reset_', :suffix => '!'
  end
end

#new_with_store(session_hash) ⇒ Object

Creates a new instance where the attributes store is set to object provided, which allows one to pass a session store hash or any other hash-like object to be used for persistence. Typically used for modeling session stores for authorization or shopping carts EX:

class ApplicationController < ActionController::Base
  def session_user
    session[:user] ||= {}
    @session_user ||= SessionUser.new_with_store(session[:user])
  end
  helper_method :session_user
end



182
183
184
185
186
187
 
# File 'lib/simple_model/attributes.rb', line 182

def new_with_store(session_hash)
  nw = self.new()
  nw.attributes = session_hash
  nw.set(nw.send(:attributes_for_init,session_hash))
  nw
end