Class: DataMapper::Base

Inherits:
Object
  • Object
show all
Includes:
Associations, Extensions::ActiveRecordImpersonation, Extensions::CallbackHelpers, Extensions::ValidationHelper, UnitOfWork
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 Extensions::ValidationHelper

#errors, included, #valid?

Methods included from Extensions::CallbackHelpers

included

Methods included from Extensions::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.



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

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

.foreign_key ⇒ Object 



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

def self.foreign_key
  Inflector.underscore(self.name) + "_id"
end

.inherited(klass) ⇒ Object 



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

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 



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

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 



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

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 



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

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 



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

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

.protected_attributes ⇒ Object 



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

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

.set_table_name(value) ⇒ Object 



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

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

Instance Method Details

#attributes ⇒ Object 



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

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 



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

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 



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

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 



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

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

#lazy_load!(name) ⇒ Object 



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

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.find(self.class, :all, :select => [:id, name], :reload => true, :id => loaded_set.instances.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) 


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

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

#session ⇒ Object 



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

def session
  @session ||= database
end

#session=(value) ⇒ Object 



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

def session=(value)
  @session = value
end