Class: DataMapper::Base

Inherits:
Object show all
Includes:
Associations, Support::ActiveRecordImpersonation, UnitOfWork, Validations::ValidationHelper
Defined in:
lib/data_mapper/base.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Associations

included

Methods included from Validations::ValidationHelper

#errors, included, #valid?

Methods included from Support::ActiveRecordImpersonation

#destroy!, included, #reload, #reload!, #save

Methods included from UnitOfWork

#dirty?, #dirty_attributes, #new_record?, #original_hashes

Constructor Details

#initialize(details = nil) ⇒ Base

Returns a new instance of Base.



41
42
43
44
45
46
47
48
49
50
 
# File 'lib/data_mapper/base.rb', line 41

def initialize(details = nil)
  
  unless details.nil?
    details.reject do |key, value|
      protected_attribute? key
    end.each_pair do |key, value|
      instance_variable_set("@#{key}", value)
    end
  end
end

Instance Attribute Details

#loaded_set ⇒ Object

This probably needs to be protected



12
13
14
 
# File 'lib/data_mapper/base.rb', line 12

def loaded_set
  @loaded_set
end

Class Method Details

.callbacks ⇒ Object

Callbacks associated with this class.



160
161
162
 
# File 'lib/data_mapper/base.rb', line 160

def self.callbacks
  @callbacks || ( @callbacks = Callbacks.new )
end

.foreign_key ⇒ Object 



128
129
130
 
# File 'lib/data_mapper/base.rb', line 128

def self.foreign_key
  String::memoized_underscore(self.name) + "_id"
end

.inherited(klass) ⇒ Object 



19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/data_mapper/base.rb', line 19

def self.inherited(klass)
  klass.send(:undef_method, :id)
  
  # When this class is sub-classed, copy the declared columns.
  klass.class_eval do
    def self.inherited(subclass)
      
      database.schema[subclass.superclass].columns.each do |c|
        subclass.property(c.name, c.type, c.options)
        subclass.before_create do
          @type = self.class
        end if c.name == :type
      end
      
    end
  end
end

.property(name, type, options = {}) ⇒ Object 



52
53
54
55
56
57
 
# File 'lib/data_mapper/base.rb', line 52

def self.property(name, type, options = {})
  mapping = database.schema[self].add_column(name, type, options)
  property_getter(name, mapping)
  property_setter(name, mapping)
  return name
end

.property_getter(name, mapping) ⇒ Object 



59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/data_mapper/base.rb', line 59

def self.property_getter(name, mapping)
  if mapping.lazy?
    class_eval <<-EOS
      def #{name}
        lazy_load!("#{name}")
      end
    EOS
  else
    class_eval("def #{name}; #{mapping.instance_variable_name} end")
  end
end

.property_setter(name, mapping) ⇒ Object 



71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/data_mapper/base.rb', line 71

def self.property_setter(name, mapping)
  if mapping.lazy?
    class_eval <<-EOS
      def #{name.to_s.sub(/\?$/, '')}=(value)
        class << self;
          attr_accessor #{name.inspect}
        end
        @#{name} = value
      end
    EOS
  else
    class_eval("def #{name.to_s.sub(/\?$/, '')}=(value); #{mapping.instance_variable_name} = value end")
  end
end

.protect(*keys) ⇒ Object 



124
125
126
 
# File 'lib/data_mapper/base.rb', line 124

def self.protect(*keys)
  keys.each { |key| protected_attributes << key.to_sym }
end

.protected_attributes ⇒ Object 



120
121
122
 
# File 'lib/data_mapper/base.rb', line 120

def self.protected_attributes
  @protected_attributes ||= []
end

.set_table_name(value) ⇒ Object 



37
38
39
 
# File 'lib/data_mapper/base.rb', line 37

def self.set_table_name(value)
  database.schema[self].name = value
end

Instance Method Details

#attributes ⇒ Object 



102
103
104
105
106
 
# File 'lib/data_mapper/base.rb', line 102

def attributes
  session.schema[self.class].columns.inject({}) do |values, column|
    values[column.name] = instance_variable_get(column.instance_variable_name); values
  end
end

#attributes=(values_hash) ⇒ Object 



108
109
110
111
112
113
114
 
# File 'lib/data_mapper/base.rb', line 108

def attributes=(values_hash)
  values_hash.reject do |key, value|
    protected_attribute? key
  end.each_pair do |key, value|
    symbolic_instance_variable_set(key, value)
  end
end

#inspect ⇒ Object 



132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/data_mapper/base.rb', line 132

def inspect
  inspected_attributes = attributes.map { |k,v| "@#{k}=#{v.inspect}" }
  
  instance_variables.each do |name|
    if instance_variable_get(name).kind_of?(Associations::HasManyAssociation)
      inspected_attributes << "#{name}=#{instance_variable_get(name).inspect}"
    end
  end
  
  "#<%s:0x%x @new_record=%s, %s>" % [self.class.name, (object_id * 2), new_record?, inspected_attributes.join(', ')]
end

#key ⇒ Object 



152
153
154
155
156
157
 
# File 'lib/data_mapper/base.rb', line 152

def key
  @__key || @__key = begin
    key_column = session.schema[self.class].key
    key_column.type_cast_value(instance_variable_get(key_column.instance_variable_name))
  end
end

#lazy_load!(name) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/data_mapper/base.rb', line 86

def lazy_load!(name)
  (class << self; self end).send(:attr_accessor, name)
  
  column = session.schema[self.class][name.to_sym]
  
  # If the value is already loaded, then we don't need to do it again.
  value = instance_variable_get(column.instance_variable_name)
  return value unless value.nil?
  
  session.all(self.class, :select => [:id, name], :reload => true, :id => loaded_set.map(&:id)).each do |instance|
    (class << self; self end).send(:attr_accessor, name)
  end
  
  instance_variable_get(column.instance_variable_name)
end

#protected_attribute?(key) ⇒ Boolean

Returns:

  • (Boolean) 


116
117
118
 
# File 'lib/data_mapper/base.rb', line 116

def protected_attribute?(key)
  self.class.protected_attributes.include?(key.kind_of?(Symbol) ? key : key.to_sym)
end

#session ⇒ Object 



148
149
150
 
# File 'lib/data_mapper/base.rb', line 148

def session
  @session || ( @session = database )
end

#session=(value) ⇒ Object 



144
145
146
 
# File 'lib/data_mapper/base.rb', line 144

def session=(value)
  @session = value
end