Class: Localized::Model

Inherits:
Object
  • Object
show all
Defined in:
lib/localized/model.rb

Defined Under Namespace

Classes: ConfigurationError

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(active_record) ⇒ Model

Returns a new instance of Model.



42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/localized/model.rb', line 42

def initialize(active_record)
  @active_record   = active_record
  @table_name      = @active_record.table_name
  @view_properties = {}
  @yaml = YAML::load_file(absolute_yaml_path)
  logger.debug("Loaded localized setting from '#{absolute_yaml_path}'")
rescue Errno::ENOENT
  raise ConfigurationError, "Cannot read YAML data from #{absolute_yaml_path}.\nRun 'rake arv:create:view %s'" % @active_record
rescue ArgumentError => err
  logger.debug("Localize Error: YAML #{err} in #{yaml_path}")
  @load_error = true
end

Instance Attribute Details

#active_record ⇒ Object (readonly)

Returns the value of attribute active_record.



2
3
4
 
# File 'lib/localized/model.rb', line 2

def active_record
  @active_record
end

Class Method Details

.[](model_name) ⇒ Object 



11
12
13
14
15
 
# File 'lib/localized/model.rb', line 11

def [](model_name)
  klass = active_record_class_for(model_name)
  @localized_models ||= {}
  @localized_models[klass.table_name] ||= new(klass)
end

.active_record_class_for(klass) ⇒ Object 



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
# File 'lib/localized/model.rb', line 17

def active_record_class_for(klass)
  case klass
  when Class
    # nop
  when ActiveRecord::Base
    klass = klass.class
  else
    klass = klass.to_s.classify.constantize
  end

  klass.ancestors.include?(ActiveRecord::Base) or
    raise ConfigurationError, "#{name}[] expects ActiveRecord class, but got #{klass.name}"

  return klass
end

.human_value(record, column_name) ⇒ Object 



33
34
35
 
# File 'lib/localized/model.rb', line 33

def human_value(record, column_name)
  self[record.class].view_property(column_name).human_value(record[column_name])
end

.masters(model_name, column_name) ⇒ Object 



37
38
39
 
# File 'lib/localized/model.rb', line 37

def masters(model_name, column_name)
  self[model_name].view_property(column_name).masters
end

Instance Method Details

#[](group_name, attr_name = nil) ⇒ Object 



55
56
57
58
59
60
61
62
63
 
# File 'lib/localized/model.rb', line 55

def [] (group_name, attr_name = nil)
  return nil if load_error?
  localized_name = @yaml[group_name.to_s]
  localized_name = localized_name[attr_name] if attr_name
  return localized_name
rescue => err
  logger.debug("Localize Error: for (%s,%s). %s" % [group_name, attr_name, err])
  return nil
end

#instance_name ⇒ Object 



65
66
67
 
# File 'lib/localized/model.rb', line 65

def instance_name
  self[:names][:instance]
end

#load_error? ⇒ Boolean

Returns:

  • (Boolean) 


86
87
88
 
# File 'lib/localized/model.rb', line 86

def load_error?
  @load_error
end

#localize_instance(record) ⇒ Object 



75
76
77
78
79
80
81
82
83
84
 
# File 'lib/localized/model.rb', line 75

def localize_instance (record)
  name = instance_name
  case name
  when NilClass ; return nil
  when Symbol ; return record.send(name)
  when String ; return name.gsub('%d', record.id.to_s)
  else
    raise TypeError, "got %s, expected Symbol or String. Check '%s'" % [name.class, yaml_path]
  end
end

#masters ⇒ Object 



69
70
71
72
73
 
# File 'lib/localized/model.rb', line 69

def masters
  pkey    = active_record.primary_key
  options = active_record.columns_hash[instance_name.to_s] && {:select=>"#{pkey},#{instance_name}"} || {}
  active_record.find(:all, options.merge(:order=>pkey)).collect{|r| [r[pkey], localize_instance(r)]}
end

#view_property(column_name) ⇒ Object 



90
91
92
 
# File 'lib/localized/model.rb', line 90

def view_property(column_name)
  @view_properties[column_name] ||= Localized::ViewProperty.new(self, column_name, self["property_#{column_name}"])
end