Module: ActiveEntity::AttributeMethods::ClassMethods

Defined in:
lib/active_entity/attribute_methods.rb

Instance Method Summary collapse

Instance Method Details

#_has_attribute?(attr_name) ⇒ Boolean

:nodoc:



172
173
174
 
# File 'lib/active_entity/attribute_methods.rb', line 172

def _has_attribute?(attr_name) # :nodoc:
  attribute_types.key?(attr_name)
end

#attribute_names ⇒ Object

Returns an array of column names as strings if it’s not an abstract class. Otherwise it returns an empty array.

class Person < ActiveEntity::Base
end

Person.attribute_names
# => ["id", "created_at", "updated_at", "name", "age"]



149
150
151
152
153
154
155
 
# File 'lib/active_entity/attribute_methods.rb', line 149

def attribute_names
  @attribute_names ||= if !abstract_class?
    attribute_types.keys
  else
    []
  end
end

#dangerous_attribute_method?(name) ⇒ Boolean

A method name is ‘dangerous’ if it is already (re)defined by Active Entity, but not by any ancestors. (So ‘puts’ is not dangerous but ‘save’ is.)



109
110
111
 
# File 'lib/active_entity/attribute_methods.rb', line 109

def dangerous_attribute_method?(name) # :nodoc:
  ::ActiveEntity::AttributeMethods.dangerous_attribute_methods.include?(name.to_s)
end

#dangerous_class_method?(method_name) ⇒ Boolean

A class method is ‘dangerous’ if it is already (re)defined by Active Entity, but not by any ancestors. (So ‘puts’ is not dangerous but ‘new’ is.)



127
128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/active_entity/attribute_methods.rb', line 127

def dangerous_class_method?(method_name)
  return true if RESTRICTED_CLASS_METHODS.include?(method_name.to_s)

  if Base.respond_to?(method_name, true)
    if Object.respond_to?(method_name, true)
      Base.method(method_name).owner != Object.method(method_name).owner
    else
      true
    end
  else
    false
  end
end

#define_attribute_methods ⇒ Object

Generates all the attribute related methods for columns in the database accessors, mutators and query methods.



58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/active_entity/attribute_methods.rb', line 58

def define_attribute_methods # :nodoc:
  return false if @attribute_methods_generated
  # Use a mutex; we don't want two threads simultaneously trying to define
  # attribute methods.
  generated_attribute_methods.synchronize do
    return false if @attribute_methods_generated
    superclass.define_attribute_methods unless base_class?
    super(attribute_names)
    @attribute_methods_generated = true
  end
end

#has_attribute?(attr_name) ⇒ Boolean

Returns true if the given attribute exists, otherwise false.

class Person < ActiveEntity::Base
end

Person.has_attribute?('name')     # => true
Person.has_attribute?('new_name') # => true
Person.has_attribute?(:age)       # => true
Person.has_attribute?(:nothing)   # => false



166
167
168
169
170
 
# File 'lib/active_entity/attribute_methods.rb', line 166

def has_attribute?(attr_name)
  attr_name = attr_name.to_s
  attr_name = attribute_aliases[attr_name] || attr_name
  attribute_types.key?(attr_name)
end

#inherited(child_class) ⇒ Object

:nodoc:



42
43
44
45
 
# File 'lib/active_entity/attribute_methods.rb', line 42

def inherited(child_class) #:nodoc:
  child_class.initialize_generated_modules
  super
end

#initialize_generated_modules ⇒ Object

:nodoc:



47
48
49
50
51
52
53
54
 
# File 'lib/active_entity/attribute_methods.rb', line 47

def initialize_generated_modules # :nodoc:
  @generated_attribute_methods = const_set(:GeneratedAttributeMethods, GeneratedAttributeMethods.new)
  private_constant :GeneratedAttributeMethods
  @attribute_methods_generated = false
  include @generated_attribute_methods

  super
end

#instance_method_already_implemented?(method_name) ⇒ Boolean

Raises an ActiveEntity::DangerousAttributeError exception when an Active Record method is defined in the model, otherwise false.

class Person < ActiveEntity::Base
  def save
    'already defined by Active Entity'
  end
end

Person.instance_method_already_implemented?(:save)
# => ActiveEntity::DangerousAttributeError: save is defined by Active Entity. Check to make sure that you don't have an attribute or method with the same name.

Person.instance_method_already_implemented?(:name)
# => false



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/active_entity/attribute_methods.rb', line 91

def instance_method_already_implemented?(method_name)
  if dangerous_attribute_method?(method_name)
    raise DangerousAttributeError, "#{method_name} is defined by Active Entity. Check to make sure that you don't have an attribute or method with the same name."
  end

  if superclass == Base
    super
  else
    # If ThisClass < ... < SomeSuperClass < ... < Base and SomeSuperClass
    # defines its own attribute method, then we don't want to overwrite that.
    defined = method_defined_within?(method_name, superclass, Base) &&
      ! superclass.instance_method(method_name).owner.is_a?(GeneratedAttributeMethods)
    defined || super
  end
end

#method_defined_within?(name, klass, superklass = klass.superclass) ⇒ Boolean

:nodoc:



113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/active_entity/attribute_methods.rb', line 113

def method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
  if klass.method_defined?(name) || klass.private_method_defined?(name)
    if superklass.method_defined?(name) || superklass.private_method_defined?(name)
      klass.instance_method(name).owner != superklass.instance_method(name).owner
    else
      true
    end
  else
    false
  end
end

#undefine_attribute_methods ⇒ Object

:nodoc:



70
71
72
73
74
75
 
# File 'lib/active_entity/attribute_methods.rb', line 70

def undefine_attribute_methods # :nodoc:
  generated_attribute_methods.synchronize do
    super if defined?(@attribute_methods_generated) && @attribute_methods_generated
    @attribute_methods_generated = false
  end
end