Class: Ohm::Model

Inherits:

Object

Object
Ohm::Model

show all

Includes:

Validations

Defined in:

lib/ohm.rb

Overview

This is the class that you need to extend in order to define your own models.

Probably the most magic happening within Model is the catching of const_missing exceptions to allow the use of constants even before they are defined.

Examples:

class Post < Ohm::Model
  reference :author, User # no User definition yet!
end

class User < Ohm::Model
end

Defined Under Namespace

Modules: Validations Classes: Collection, Index, IndexNotFound, List, MissingID, Set, Wrapper

Constant Summary

@@attributes =

Hash.new { |hash, key| hash[key] = [] }

@@collections =

Hash.new { |hash, key| hash[key] = [] }

@@counters =

Hash.new { |hash, key| hash[key] = [] }

@@indices =

Hash.new { |hash, key| hash[key] = [] }

Instance Attribute Summary (collapse)

- (Object) id

Class Method Summary (collapse)

+ (Ohm::Model^?) [](id)
Allows you to find an Model instance by its id.
+ (Object) all
Returns a set containing all the members of a given class.
+ (Object) attribute(name)
Defines a string attribute for the model.
+ (Object) attributes
All the defined attributes within a class.
+ (Object) collection(name, model, reference = to_reference)
Define a collection of objects which have a reference to this model.
+ (Boolean) collection?(value) private
+ (Object) collections
All the defined collections within a class.
+ (Object) connect(*options)
Makes the model connect to a different Redis instance.
+ (Object) const_missing(name) protected
Wraps any missing constants lazily in Wrapper delaying the evaluation of constants until they are actually needed.
+ (Object) counter(name)
Defines a counter attribute for the model.
+ (Object) counters
All the defined counters within a class.
+ (Ohm::Model) create(*args)
Convenience method to create and return the newly created object.
+ (Object) db private
Provides access to the Redis database.
+ (Object) db=(connection) private
+ (String) encode(value)
Encode a value, making it safe to use as a key.
+ (Boolean) exists?(id) private
+ (Object) find(hash)
Search across multiple indices and return the intersection of the sets.
+ (Object) index(att)
Creates an index (a set) that will be used for finding instances.
+ (Ohm::Key) index_key_for(name, value) private
Get the index name for a specific index and value pair.
+ (Object) indices
All the defined indices within a class.
+ (Object) key private
Allows you to do key manipulations scoped solely to your class.
+ (Object) list(name, model)
Defines a list attribute for the model.
+ (Object) reference(name, model)
Define a reference to another object.
+ (Object) set(name, model)
Defines a set attribute for the model.
+ (Symbol) to_reference
Used by collection to infer the reference.

Instance Method Summary (collapse)

- (true, false) ==(other) (also: #eql?)
Implementation of equality checking.
- (Object) add_to_index(att, value = send(att)) private
- (Object) add_to_indices private
- (Object) attributes
Convenience wrapper for attributes.
- (Boolean) collection?(value) private
- (Object) collections
Convenience wrapper for collections.
- (Object) counters
Convenience wrapper for counters.
- (Ohm::Model^?) create
Create this model if it passes all validations.
- (Object) create_model_membership private
- (Object) db private
- (Object) decr(att, count = 1)
Decrement the counter denoted by :att.
- (Ohm::Model) delete
Delete this object from the Redis datastore, ensuring that all indices, attributes, collections, etc are also deleted with it.
- (Object) delete_attributes(atts) private
- (Object) delete_from_indices private
- (Object) delete_model_membership private
- (Fixnum) hash
Allows you to safely use an instance of Model as a key in a Ruby hash without running into weird scenarios.
- (Object) incr(att, count = 1)
Increment the counter denoted by :att.
- (Object) index_key_for(att, value) private
Thin wrapper around index_key_for.
- (Object) indices
Convenience wrapper for indices.
- (Model) initialize(attrs = {}) constructor
Constructor for all subclasses of Model, which optionally takes a Hash of attribute value pairs.
- (Object) initialize_id private
The meat of the ID generation code for Ohm.
- (Object) inspect
Returns everything, including attributes, collections, counters, and the id of this object.
- (Ohm::Key) key
A key scoped to the model which uses this object’s id.
- (Object) lock! private
Lock the object so no other instances can modify it.
- (Boolean) lock_expired?(timestamp) private
- (Object) mutex
Lock the object before executing the block, and release it once the block is done.
- (true, false) new?
Whether or not this object has an id.
- (String) read_local(att) private
Get the value of a specific attribute.
- (Object) read_locals(attrs) private
Read attributes en masse locally.
- (String) read_remote(att) private
Used internally be the @_attributes hash to lazily load attributes when you need them.
- (Object) read_remotes(attrs) private
Read attributes en masse remotely.
- (Ohm::Model^?) save
Create or update this object based on the state of #new?.
- (Object) to_hash
Export the id and errors of the object.
- (String) to_json(*args)
Returns the JSON representation of the #to_hash for this object.
- (Object) unlock! private
Release the lock.
- (Ohm::Model^?) update(attrs)
Update this object, optionally accepting new attributes.
- (Object) update_attributes(attrs)
Locally update all attributes without persisting the changes.
- (Object) update_indices private
- (Object) write protected
Write all the attributes and counters of this object.
- (Object) write_local(att, value) private
Write the value of an attribute locally, without persisting it.
- (Object) write_remote(att, value) protected
Write a single attribute both locally and remotely.

Methods included from Validations

#assert_unique

Methods included from Validations

#assert, #assert_format, #assert_numeric, #assert_present, #errors, #valid?, #validate

Constructor Details

- (Model) initialize(attrs = {})

Constructor for all subclasses of Ohm::Model, which optionally takes a Hash of attribute value pairs.

Starting with Ohm 0.1.0, you can use custom ids instead of being forced to use auto incrementing numeric ids, but keep in mind that you have to pass in the preferred id during object initialization.

Examples:

class User < Ohm::Model
end

class Post < Ohm::Model
  attribute :title
  reference :user, User
end

user = User.create
p1 = Post.new(:title => "Redis", :user_id => user.id)
p1.save

p1.user_id == user.id
# => true

p1.user == user
# => true

# You can also just pass the actual User object, which is the better
# way to do it:
Post.new(:title => "Different way", :user => user).user == user
# => true

# Let's try and generate custom ids
p2 = Post.new(:id => "ohm-redis-library", :title => "Lib")
p2 == Post["ohm-redis-library"]
# => true

Parameters:

attrs (Hash) (defaults to: {}) —
Attribute value pairs.

# File 'lib/ohm.rb', line 1436

def initialize(attrs = {})
  @id = nil
  @_memo = {}
  @_attributes = Hash.new { |hash, key| hash[key] = read_remote(key) }
  update_attributes(attrs)
end

Instance Attribute Details

- (Object) id



1048
1049
1050

# File 'lib/ohm.rb', line 1048

def id
  @id or raise MissingID
end

Class Method Details

+ (Ohm::Model^?) [](id)

Allows you to find an Ohm::Model instance by its id.

Parameters:

id (#to_s) —
The id of the model you want to find.

Returns:

(Ohm::Model, nil) —
The instance of Ohm::Model or nil of it does not exist.



1284
1285
1286

# File 'lib/ohm.rb', line 1284

def self.[](id)
  new(:id => id) if id && exists?(id)
end

+ (Object) all

Returns a set containing all the members of a given class.

Examples:

class Post < Ohm::Model
end

post = Post.create

Post.all.include?(post)
# => true

post.delete

Post.all.include?(post)
# => false



1310
1311
1312

# File 'lib/ohm.rb', line 1310

def self.all
  Ohm::Model::Index.new(key[:all], Wrapper.wrap(self))
end

+ (Object) attribute(name)

Defines a string attribute for the model. This attribute will be persisted by Redis as a string. Any value stored here will be retrieved in its string representation.

If you’re looking to have typecasting built in, you may want to look at Ohm::Typecast in Ohm::Contrib.

Parameters:

name (Symbol) —
Name of the attribute.

Parameters:

name (Symbol) —
Name of the collection.
model (Constant) —
Model where the reference is defined.
reference (Symbol) (defaults to: to_reference) —
Reference as defined in the associated model.

Returns:

(Boolean)

# File 'lib/ohm.rb', line 1879

def self.collection?(value)
  value.kind_of?(Enumerable) &&
  value.kind_of?(String) == false
end

+ (Object) collections

All the defined collections within a class. This will be comprised of all sets and lists defined within your class.

Examples:

class Post < Ohm::Model
  set  :authors, Author
  list :comments, Comment
end

Post.collections == [:authors, :comments]
# => true

Examples:

class Post < Ohm::Model
  connect :port => 6380, :db => 2

  attribute :body
end

# Since these settings are usually environment-specific,
# you may want to call this method from outside of the class
# definition:
Post.connect(:port => 6380, :db => 2)

Parameters:

name (Symbol) —
Name of the counter.

# File 'lib/ohm.rb', line 1077

def self.counter(name)
  define_method(name) do
    read_local(name).to_i
  end

  counters << name unless counters.include?(name)
end

+ (Object) counters

All the defined counters within a class.

Examples:

class Post < Ohm::Model
  attribute :title
end

post = Post.create(:title => "A new post")

Parameters:

args (Hash) —
attribute-value pairs for the object.

Returns:

(Ohm::Model) —
an instance of the class you’re trying to create.

# File 'lib/ohm.rb', line 1363

def self.create(*args)
  model = new(*args)
  model.create
  model
end

+ (Object) db (private)

Provides access to the Redis database. This is shared accross all models and instances.



1805
1806
1807

# File 'lib/ohm.rb', line 1805

def self.db
  Ohm.threaded[self] || Ohm.redis
end

+ (Object) db=(connection) (private)



1809
1810
1811

# File 'lib/ohm.rb', line 1809

def self.db=(connection)
  Ohm.threaded[self] = connection
end

+ (String) encode(value)

Encode a value, making it safe to use as a key. Internally used by index_key_for to canonicalize the indexed values.

Parameters:

value (#to_s) —
Any object you want to be able to use as a key.

Returns:

(String) —
A string which is safe to use as a key.

Returns:

(Boolean)



1818
1819
1820

# File 'lib/ohm.rb', line 1818

def self.exists?(id)
  key[:all].sismember(id)
end

+ (Object) find(hash)

Search across multiple indices and return the intersection of the sets.

Examples:

Finds all the user events for the supplied days

event1 = Event.create day: "2009-09-09", author: "Albert"
event2 = Event.create day: "2009-09-09", author: "Benoit"
event3 = Event.create day: "2009-09-10", author: "Albert"

[event1] == Event.find(author: "Albert", day: "2009-09-09").to_a
# => true

# File 'lib/ohm.rb', line 1378

def self.find(hash)
  unless hash.kind_of?(Hash)
    raise ArgumentError,
      "You need to supply a hash with filters. " +
      "If you want to find by ID, use #{self}[id] instead."
  end

  all.find(hash)
end

+ (Object) index(att)

Creates an index (a set) that will be used for finding instances.

If you want to find a model instance by some attribute value, then an index for that attribute must exist.

Examples:

class User < Ohm::Model
  attribute :email
  index :email
end

# Now this is possible:
User.find :email => "ohm@example.com"

Parameters:

name (Symbol) —
Name of the attribute to be indexed.



1144
1145
1146

# File 'lib/ohm.rb', line 1144

def self.index(att)
  indices << att unless indices.include?(att)
end

+ (Ohm::Key) index_key_for(name, value) (private)

Get the index name for a specific index and value pair. The return value is an instance of Key, which you can readily do Redis operations on.

Examples:

class Post < Ohm::Model
  attribute :title
  index :title
end

post = Post.create(:title => "Foo")
key = Post.index_key_for(:title, "Foo")
key == "Post:title:Rm9v"
key.scard == 1
key.smembers == [post.id]
# => true

Parameters:

name (Symbol) —
The name of the index.
value (#to_s) —
The value for the index.

Returns:

(Ohm::Key) —
A key which you can treat as a string, but also do Redis operations on.

Raises:

(IndexNotFound)

# File 'lib/ohm.rb', line 1966

def self.index_key_for(name, value)
  raise IndexNotFound, name unless indices.include?(name)
  key[name][encode(value)]
end

+ (Object) indices

All the defined indices within a class.

Examples:

class Post < Ohm::Model
  list :comments, Comment
end

class Comment < Ohm::Model
end

# WRONG!!!
post = Post.new
post.comments << Comment.create

# Right :-)
post = Post.create
post.comments << Comment.create

# Alternative way if you want to have custom ids.
post = Post.new(:id => "my-id")
post.comments << Comment.create
post.create

Parameters:

name (Symbol) —
Name of the list.

# File 'lib/ohm.rb', line 1112

def self.list(name, model)
  define_memoized_method(name) { List.new(key[name], Wrapper.wrap(model)) }
  collections << name unless collections.include?(name)
end

+ (Object) reference(name, model)

Define a reference to another object.

Examples:

class Comment < Ohm::Model
  attribute :content
  reference :post, Post
end

@post = Post.create :content => "Interesting stuff"

@comment = Comment.create(:content => "Indeed!", :post => @post)

@comment.post.content
# => "Interesting stuff"

@comment.post = Post.create(:content => "Wonderful stuff")

@comment.post.content
# => "Wonderful stuff"

@comment.post.update(:content => "Magnific stuff")

@comment.post.content
# => "Magnific stuff"

@comment.post = nil

@comment.post
# => nil

Parameters:

name (Symbol) —
Name of the set.

# File 'lib/ohm.rb', line 1123

def self.set(name, model)
  define_memoized_method(name) { Set.new(key[name], Wrapper.wrap(model)) }
  collections << name unless collections.include?(name)
end

+ (Symbol) to_reference

Used by collection to infer the reference.

Returns:

(Symbol) —
Representation of this class in an all-lowercase format, separated by underscores and demodulized.

# File 'lib/ohm.rb', line 1265

def self.to_reference
  name.to_s.
    match(/^(?:.*::)*(.*)$/)[1].
    gsub(/([a-z\d])([A-Z])/, '\1_\2').
    downcase.to_sym
end

Instance Method Details

- (true, false) ==(other) Also known as: eql?

Implementation of equality checking. Equality is defined by two simple rules:

They have the same class.
They have the same key (Redis key e.g. Post:1 == Post:1).

Returns:

(true, false) —
Whether or not the passed object is equal.

# File 'lib/ohm.rb', line 1624

def ==(other)
  other.kind_of?(self.class) && other.key == key
rescue MissingID
  false
end

- (Object) add_to_index(att, value = send(att)) (private)

# File 'lib/ohm.rb', line 1884

def add_to_index(att, value = send(att))
  index = index_key_for(att, value)
  index.sadd(id)
  key[:_indices].sadd(index)
end

- (Object) add_to_indices (private)

# File 'lib/ohm.rb', line 1868

def add_to_indices
  indices.each do |att|
    next add_to_index(att) unless collection?(send(att))
    send(att).each { |value| add_to_index(att, value) }
  end
end

- (Object) attributes

Convenience wrapper for attributes.



1598
1599
1600

# File 'lib/ohm.rb', line 1598

def attributes
  self.class.attributes
end

- (Boolean) collection?(value) (private)

Returns:

(Boolean)



1875
1876
1877

# File 'lib/ohm.rb', line 1875

def collection?(value)
  self.class.collection?(value)
end

- (Object) collections

Convenience wrapper for collections.



1608
1609
1610

# File 'lib/ohm.rb', line 1608

def collections
  self.class.collections
end

- (Object) counters

Convenience wrapper for counters.



1603
1604
1605

# File 'lib/ohm.rb', line 1603

def counters
  self.class.counters
end

- (Ohm::Model^?) create

Create this model if it passes all validations.

Returns:

(Ohm::Model, nil) —
The newly created object or nil if it fails validation.

# File 'lib/ohm.rb', line 1452

def create
  return unless valid?
  initialize_id

  mutex do
    create_model_membership
    write
    add_to_indices
  end
end

- (Object) create_model_membership (private)



1854
1855
1856

# File 'lib/ohm.rb', line 1854

def create_model_membership
  self.class.all << self
end

- (Object) db (private)



1846
1847
1848

# File 'lib/ohm.rb', line 1846

def db
  self.class.db
end

- (Object) decr(att, count = 1)

Decrement the counter denoted by :att.

Parameters:

att (Symbol) —
Attribute to decrement.
count (Fixnum) (defaults to: 1) —
An optional decrement step to use.



1526
1527
1528

# File 'lib/ohm.rb', line 1526

def decr(att, count = 1)
  incr(att, -count)
end

- (Ohm::Model) delete

Delete this object from the Redis datastore, ensuring that all indices, attributes, collections, etc are also deleted with it.

Returns:

(Ohm::Model) —
Returns a reference of itself.

# File 'lib/ohm.rb', line 1503

def delete
  delete_from_indices
  delete_attributes(collections) unless collections.empty?
  delete_model_membership
  self
end

- (Object) delete_attributes(atts) (private)



1850
1851
1852

# File 'lib/ohm.rb', line 1850

def delete_attributes(atts)
  db.del(*atts.map { |att| key[att] })
end

- (Object) delete_from_indices (private)

# File 'lib/ohm.rb', line 1890

def delete_from_indices
  key[:_indices].smembers.each do |index|
    db.srem(index, id)
  end

  key[:_indices].del
end

- (Object) delete_model_membership (private)

# File 'lib/ohm.rb', line 1858

def delete_model_membership
  key.del
  self.class.all.delete(self)
end

- (Fixnum) hash

Allows you to safely use an instance of Ohm::Model as a key in a Ruby hash without running into weird scenarios.

Examples:

class Post < Ohm::Model
end

h = {}
p1 = Post.new
h[p1] = "Ruby"
h[p1] == "Ruby"
# => true

p1.save
h[p1] == "Ruby"
# => false

Returns:

(Fixnum) —
An integer representing this object to be used as the index for hashes in Ruby.



1651
1652
1653

# File 'lib/ohm.rb', line 1651

def hash
  new? ? super : key.hash
end

- (Object) incr(att, count = 1)

Increment the counter denoted by :att.

Parameters:

att (Symbol) —
Attribute to increment.
count (Fixnum) (defaults to: 1) —
An optional increment step to use.

# File 'lib/ohm.rb', line 1514

def incr(att, count = 1)
  unless counters.include?(att)
    raise ArgumentError, "#{att.inspect} is not a counter."
  end

  write_local(att, key.hincrby(att, count))
end

- (Object) index_key_for(att, value) (private)

Thin wrapper around index_key_for.



1972
1973
1974

# File 'lib/ohm.rb', line 1972

def index_key_for(att, value)
  self.class.index_key_for(att, value)
end

- (Object) indices

Convenience wrapper for indices.



1613
1614
1615

# File 'lib/ohm.rb', line 1613

def indices
  self.class.indices
end

- (Object) initialize_id (private)

The meat of the ID generation code for Ohm. For cases where you want to customize ID generation (i.e. use GUIDs or Base62 ids) then you simply override this method in your model.

Examples:

module UUID
  def self.new
    `uuidgen`.strip
  end
end

class Post < Ohm::Model

private
  def initialize_id
    @id ||= UUID.new
  end
end



1842
1843
1844

# File 'lib/ohm.rb', line 1842

def initialize_id
  @id ||= self.class.key[:id].incr.to_s
end

- (Object) inspect

Returns everything, including attributes, collections, counters, and the id of this object.

Useful for debugging and for doing irb work.

# File 'lib/ohm.rb', line 1676

def inspect
  everything = (attributes + collections + counters).map do |att|
    value = begin
              send(att)
            rescue MissingID
              nil
            end

    [att, value.inspect]
  end

  sprintf("#<%s:%s %s>",
          self.class,
          new? ? "?" : id,
          everything.map {|e| e.join("=") }.join(" ")
  )
end

- (Ohm::Key) key

A key scoped to the model which uses this object’s id.

Returns:

(Ohm::Key) —
A key scoped to the model which uses this object’s id.

Returns:

(Boolean)



1997
1998
1999

# File 'lib/ohm.rb', line 1997

def lock_expired?(timestamp)
  timestamp.to_f < Time.now.to_f
end

- (Object) mutex

Lock the object before executing the block, and release it once the block is done.

This is used during #create and #save to ensure that no race conditions occur.

Returns:

(true, false) —
Whether or not this object has an id.



1444
1445
1446

# File 'lib/ohm.rb', line 1444

def new?
  !@id
end

- (String) read_local(att) (private)

Get the value of a specific attribute. An important fact about attributes in Ohm is that they are all loaded lazily.

Parameters:

att (Symbol) —
The attribute you you want to get.

Returns:

(String) —
The value of att.



1903
1904
1905

# File 'lib/ohm.rb', line 1903

def read_local(att)
  @_attributes[att]
end

- (Object) read_locals(attrs) (private)

Read attributes en masse locally.

# File 'lib/ohm.rb', line 1931

def read_locals(attrs)
  attrs.map do |att|
    send(att)
  end
end

- (String) read_remote(att) (private)

Used internally be the @_attributes hash to lazily load attributes when you need them. You may also use this in your code if you know what you are doing.

Parameters:

att (Symbol) —
The attribute you you want to get.

Returns:

(String) —
The value of att.

# File 'lib/ohm.rb', line 1921

def read_remote(att)
  unless new?
    value = key.hget(att)
    value.respond_to?(:force_encoding) ?
      value.force_encoding("UTF-8") :
      value
  end
end

- (Object) read_remotes(attrs) (private)

Read attributes en masse remotely.

# File 'lib/ohm.rb', line 1938

def read_remotes(attrs)
  attrs.map do |att|
    read_remote(att)
  end
end

- (Ohm::Model^?) save

Create or update this object based on the state of #new?.

Returns:

(Ohm::Model, nil) —
The saved object or nil if it fails validation.

# File 'lib/ohm.rb', line 1467

def save
  return create if new?
  return unless valid?

  mutex do
    write
    update_indices
  end
end

- (Object) to_hash

Export the id and errors of the object. The `to_hash` takes the opposite approach of providing all the attributes and instead favors a white listed approach.

Examples:

person = Person.create(:name => "John Doe")
person.to_hash == { :id => '1' }
# => true

# if the person asserts presence of name, the errors will be included
person = Person.create(:name => "John Doe")
person.name = nil
person.valid?
# => false

person.to_hash == { :id => '1', :errors => [[:name, :not_present]] }
# => true

# for cases where you want to provide white listed attributes just do:

class Person < Ohm::Model
  def to_hash
    super.merge(:name => name)
  end
end

# now we have the name when doing a to_hash
person = Person.create(:name => "John Doe")
person.to_hash == { :id => '1', :name => "John Doe" }
# => true

# File 'lib/ohm.rb', line 1561

def to_hash
  attrs = {}
  attrs[:id] = id unless new?
  attrs[:errors] = errors unless errors.empty?
  attrs
end

- (String) to_json(*args)

Returns the JSON representation of the #to_hash for this object. Defining a custom #to_hash method will also affect this and return a corresponding JSON representation of whatever you have in your #to_hash.

Examples:

require "json"

class Post < Ohm::Model
  attribute :title

  def to_hash
    super.merge(:title => title)
  end
end

p1 = Post.create(:title => "Delta Force")
p1.to_hash == { :id => "1", :title => "Delta Force" }
# => true

p1.to_json == "{\"id\":\"1\",\"title\":\"Delta Force\"}"
# => true

Returns:

(String) —
The JSON representation of this object defined in terms of #to_hash.



1593
1594
1595

# File 'lib/ohm.rb', line 1593

def to_json(*args)
  to_hash.to_json(*args)
end

- (Object) unlock! (private)

Release the lock.

Parameters:

attrs (Hash) —
Attribute value pairs to use for the updated version

Returns:

(Ohm::Model, nil) —
The updated object or nil if it fails validation.

# File 'lib/ohm.rb', line 1483

def update(attrs)
  update_attributes(attrs)
  save
end

- (Object) update_attributes(attrs)

Locally update all attributes without persisting the changes. Internally used by #initialize and #update to set attribute value pairs.

Parameters:

attrs (Hash) —
Attribute value pairs.

# File 'lib/ohm.rb', line 1493

def update_attributes(attrs)
  attrs.each do |key, value|
    send(:#{key}=", value)
  end
end

- (Object) update_indices (private)

# File 'lib/ohm.rb', line 1863

def update_indices
  delete_from_indices
  add_to_indices
end

- (Object) write (protected)

Write all the attributes and counters of this object. The operation is actually a 2-step process:

Delete the current key, e.g. Post:2.
Set all of the new attributes (using HMSET).

The DEL and HMSET operations are wrapped in a MULTI EXEC block to ensure the atomicity of the write operation.

Parameters:

att (Symbol) —
The attribute you want to set.
value (#to_s) —
The value of the attribute you want to set.



1911
1912
1913

# File 'lib/ohm.rb', line 1911

def write_local(att, value)
  @_attributes[att] = value
end

- (Object) write_remote(att, value) (protected)

Write a single attribute both locally and remotely. It’s very important to know that this method skips validation checks, therefore you must ensure data integrity and validity in your application code.

Parameters:

att (Symbol, String) —
The name of the attribute to write.
value (#to_s) —
The value of the attribute to write.

Class: Ohm::Model

Overview

Examples:

See Also:

Defined Under Namespace

Constant Summary

Instance Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Methods included from Validations

Methods included from Validations

Constructor Details

Examples:

Parameters:

Instance Attribute Details

Class Method Details

Parameters:

Returns:

Examples:

Parameters:

See Also:

See Also:

Parameters:

See Also:

Returns:

Examples:

See Also:

Examples:

See Also:

See Also:

Parameters:

See Also:

Examples:

Parameters:

Returns:

Parameters:

Returns:

See Also:

Returns:

Examples:

Finds all the user events for the supplied days

Examples:

Parameters:

Examples:

Parameters:

Returns:

Raises:

See Also:

Examples:

Parameters:

Examples:

See Also:

Parameters:

Returns:

Instance Method Details

Returns:

Returns:

Returns:

Parameters:

Returns:

Examples:

Returns:

Parameters:

Examples:

Returns:

See Also:

See Also:

Returns:

See Also:

Returns:

Parameters:

Returns:

Parameters:

Returns:

Returns:

Examples:

Examples:

Returns:

See Also:

Parameters: