Module: Globalize::ActiveRecord::InstanceMethods

Defined in:
lib/globalize/active_record/instance_methods.rb

Instance Method Summary collapse

Instance Method Details

#[](attr_name) ⇒ Object 



33
34
35
36
37
38
39
 
# File 'lib/globalize/active_record/instance_methods.rb', line 33

def [](attr_name)
  if translated?(attr_name)
    read_attribute(attr_name)
  else
    read_attribute(attr_name) { |n| missing_attribute(n, caller) }
  end
end

#_assign_attributes(new_attributes) ⇒ Object 



20
21
22
23
 
# File 'lib/globalize/active_record/instance_methods.rb', line 20

def _assign_attributes(new_attributes)
  attributes = new_attributes.stringify_keys
  with_given_locale(attributes) { super(attributes.except("locale")) }
end

#_read_attribute(attr_name, options = {}, &block) ⇒ Object 



53
54
55
56
 
# File 'lib/globalize/active_record/instance_methods.rb', line 53

def _read_attribute(attr_name, options = {}, &block)
  translated_value = read_translated_attribute(attr_name, options)
  translated_value.nil? ? super(attr_name, &block) : translated_value
end

#attribute_names ⇒ Object 



58
59
60
 
# File 'lib/globalize/active_record/instance_methods.rb', line 58

def attribute_names
  translated_attribute_names.map(&:to_s) + super
end

#attributes ⇒ Object 



10
11
12
 
# File 'lib/globalize/active_record/instance_methods.rb', line 10

def attributes
  super.merge(translated_attributes)
end

#attributes=(new_attributes, *options) ⇒ Object 



14
15
16
17
18
 
# File 'lib/globalize/active_record/instance_methods.rb', line 14

def attributes=(new_attributes, *options)
  super unless new_attributes.respond_to?(:stringify_keys) && new_attributes.present?
  attributes = new_attributes.stringify_keys
  with_given_locale(attributes) { super(attributes.except("locale"), *options) }
end

#available_locales ⇒ Object

Get available locales from translations association, without a separate distinct query



138
139
140
 
# File 'lib/globalize/active_record/instance_methods.rb', line 138

def available_locales
  translations.map(&:locale).uniq
end

#cache_key ⇒ Object 



167
168
169
 
# File 'lib/globalize/active_record/instance_methods.rb', line 167

def cache_key
  [super, translation.cache_key].join("/")
end

#changed ⇒ Object 



193
194
195
 
# File 'lib/globalize/active_record/instance_methods.rb', line 193

def changed
  super.concat(globalize.changed).uniq
end

#changed? ⇒ Boolean

Returns:

  • (Boolean) 


171
172
173
 
# File 'lib/globalize/active_record/instance_methods.rb', line 171

def changed?
  changed_attributes.present? || translations.any?(&:changed?)
end

#changed_attributes ⇒ Object 



185
186
187
 
# File 'lib/globalize/active_record/instance_methods.rb', line 185

def changed_attributes
  super.merge(globalize.changed_attributes(::Globalize.locale))
end

#changes ⇒ Object 



189
190
191
 
# File 'lib/globalize/active_record/instance_methods.rb', line 189

def changes
  super.merge(globalize.changes(::Globalize.locale))
end

#column_for_attribute(name) ⇒ Object 



161
162
163
164
165
 
# File 'lib/globalize/active_record/instance_methods.rb', line 161

def column_for_attribute name
  return super if translated_attribute_names.exclude?(name)

  globalize.send(:column_for_attribute, name)
end

#globalize ⇒ Object 



6
7
8
 
# File 'lib/globalize/active_record/instance_methods.rb', line 6

def globalize
  @globalize ||= Adapter.new(self)
end

#globalize_fallbacks(locale) ⇒ Object 



142
143
144
 
# File 'lib/globalize/active_record/instance_methods.rb', line 142

def globalize_fallbacks(locale)
  Globalize.fallbacks(locale)
end

#initialize_dup(other) ⇒ Object 



99
100
101
102
103
104
105
106
 
# File 'lib/globalize/active_record/instance_methods.rb', line 99

def initialize_dup(other)
  @globalize = nil
  @translation_caches = nil
  super
  other.each_locale_and_translated_attribute do |locale, name|
    globalize.write(locale, name, other.globalize.fetch(locale, name) )
  end
end

#original_changed_attributes ⇒ Object

need to access instance variable directly since changed_attributes is frozen



198
199
200
 
# File 'lib/globalize/active_record/instance_methods.rb', line 198

def original_changed_attributes
  @changed_attributes
end

#read_attribute(attr_name, options = {}, &block) ⇒ Object 



41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/globalize/active_record/instance_methods.rb', line 41

def read_attribute(attr_name, options = {}, &block)
  name = if self.class.attribute_alias?(attr_name)
           self.class.attribute_alias(attr_name).to_s
         else
           attr_name.to_s
         end

  name = self.class.primary_key if name == "id".freeze && self.class.primary_key

  _read_attribute(name, options, &block)
end

#reload(options = nil) ⇒ Object 



92
93
94
95
96
97
 
# File 'lib/globalize/active_record/instance_methods.rb', line 92

def reload(options = nil)
  translation_caches.clear
  translated_attribute_names.each { |name| @attributes.reset(name.to_s) }
  globalize.reset
  super(options)
end

#saved_changes ⇒ Object 



175
176
177
178
179
180
181
182
183
 
# File 'lib/globalize/active_record/instance_methods.rb', line 175

def saved_changes
  super.tap do |changes|
    translation = translation_for(::Globalize.locale, false)
    if translation
      translation_changes = translation.saved_changes.select { |name| translated?(name) }
      changes.merge!(translation_changes) if translation_changes.any?
    end
  end
end

#set_translations(options) ⇒ Object 



78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/globalize/active_record/instance_methods.rb', line 78

def set_translations(options)
  options.keys.each do |locale|
    translation = translation_for(locale) ||
                  translations.build(:locale => locale.to_s)

    options[locale].each do |key, value|
      translation.send :"#{key}=", value
      translation.globalized_model.send :"#{key}=", value
    end
    translation.save if persisted?
  end
  globalize.reset
end

#translated_attribute_by_locale(name) ⇒ Object 



133
134
135
 
# File 'lib/globalize/active_record/instance_methods.rb', line 133

def translated_attribute_by_locale(name)
  translations_by_locale(&:"#{name}")
end

#translated_attributes ⇒ Object 



64
65
66
67
68
 
# File 'lib/globalize/active_record/instance_methods.rb', line 64

def translated_attributes
  translated_attribute_names.inject({}) do |attributes, name|
    attributes.merge(name.to_s => send(name))
  end
end

#translation ⇒ Object 



108
109
110
 
# File 'lib/globalize/active_record/instance_methods.rb', line 108

def translation
  translation_for(::Globalize.locale)
end

#translation_caches ⇒ Object 



123
124
125
 
# File 'lib/globalize/active_record/instance_methods.rb', line 123

def translation_caches
  @translation_caches ||= {}
end

#translation_for(locale, build_if_missing = true) ⇒ Object 



112
113
114
115
116
117
118
119
120
121
 
# File 'lib/globalize/active_record/instance_methods.rb', line 112

def translation_for(locale, build_if_missing = true)
  unless translation_caches[locale]
    # Fetch translations from database as those in the translation collection may be incomplete
    _translation = translations.detect{|t| t.locale.to_s == locale.to_s}
    _translation ||= translations.with_locale(locale).first unless translations.loaded?
    _translation ||= translations.build(:locale => locale) if build_if_missing
    translation_caches[locale] = _translation if _translation
  end
  translation_caches[locale]
end

#translations_by_locale ⇒ Object 



127
128
129
130
131
 
# File 'lib/globalize/active_record/instance_methods.rb', line 127

def translations_by_locale
  translations.each_with_object(HashWithIndifferentAccess.new) do |t, hash|
    hash[t.locale] = block_given? ? yield(t) : t
  end
end

#untranslated_attributes ⇒ Object

This method is basically the method built into Rails but we have to pass => false



72
73
74
75
76
 
# File 'lib/globalize/active_record/instance_methods.rb', line 72

def untranslated_attributes
  attribute_names.inject({}) do |attrs, name|
    attrs[name] = read_attribute(name, {:translated => false}); attrs
  end
end

#write_attribute(name, value, *args, &block) ⇒ Object 



25
26
27
28
29
30
31
 
# File 'lib/globalize/active_record/instance_methods.rb', line 25

def write_attribute(name, value, *args, &block)
  return super(name, value, *args, &block) unless translated?(name)

  options = {:locale => Globalize.locale}.merge(args.first || {})

  globalize.write(options[:locale], name, value)
end