Module: Aduki
- Defined in:
- lib/aduki.rb,
lib/aduki/version.rb
Defined Under Namespace
Modules: ClassMethods, Initializer Classes: AttrFinder, Initializable, RecursiveHash
Constant Summary collapse
- VERSION =
"0.2.6"
Class Method Summary collapse
- .apply_array_attribute(klass, object, getter, value) ⇒ Object
- .apply_attribute(klass, object, setter, value) ⇒ Object
- .apply_attributes(object, attrs) ⇒ Object
- .apply_new_single_attribute(klass, object, setter, value) ⇒ Object
- .apply_single_attribute(klass, object, setter, value) ⇒ Object
- .install_monkey_patches ⇒ Object
- .maybe_parse_date(str) ⇒ Object
- .split_attributes(attrs) ⇒ Object
- .to_aduki(obj, collector = { }, key = "", join = "") ⇒ Object
- .to_typed_hash(klass, value) ⇒ Object
- .to_value(klass, setter, value) ⇒ Object
Class Method Details
.apply_array_attribute(klass, object, getter, value) ⇒ Object
96 97 98 99 100 101 102 |
# File 'lib/aduki.rb', line 96 def self.apply_array_attribute klass, object, getter, value setter_method = "#{getter}=".to_sym return unless object.respond_to? setter_method array = object.send(getter) || [] array << to_value(klass, getter, value) object.send(setter_method, array) end |
.apply_attribute(klass, object, setter, value) ⇒ Object
126 127 128 129 130 131 132 133 |
# File 'lib/aduki.rb', line 126 def self.apply_attribute klass, object, setter, value if setter.match(/\[\d+\]/) getter = setter.gsub(/\[\d+\]/, '').to_sym apply_array_attribute klass, object, getter, value else apply_single_attribute klass, object, setter, value end end |
.apply_attributes(object, attrs) ⇒ Object
135 136 137 138 139 140 141 142 |
# File 'lib/aduki.rb', line 135 def self.apply_attributes object, attrs setters = split_attributes(attrs || { }) klass = object.class setters.sort.each do |setter, value| apply_attribute klass, object, setter, value end end |
.apply_new_single_attribute(klass, object, setter, value) ⇒ Object
104 105 106 107 108 109 |
# File 'lib/aduki.rb', line 104 def self.apply_new_single_attribute klass, object, setter, value setter_method = "#{setter}=".to_sym return unless object.respond_to? setter_method object.send setter_method, to_value(klass, setter, value) end |
.apply_single_attribute(klass, object, setter, value) ⇒ Object
111 112 113 114 115 116 117 118 119 120 121 122 123 124 |
# File 'lib/aduki.rb', line 111 def self.apply_single_attribute klass, object, setter, value if value.is_a?(Hash) existing_value = object.send setter if object.respond_to?(setter) if existing_value if existing_value.is_a? Hash value.each { |k, v| existing_value[k] = v } else Aduki.apply_attributes existing_value, value end return end end apply_new_single_attribute klass, object, setter, value end |
.install_monkey_patches ⇒ Object
8 9 10 11 |
# File 'lib/aduki.rb', line 8 def self.install_monkey_patches require 'core_ext/array' require 'core_ext/hash' end |
.maybe_parse_date(str) ⇒ Object
39 40 41 42 |
# File 'lib/aduki.rb', line 39 def self.maybe_parse_date str return nil if (str == nil) || (str == '') Date.parse(str) end |
.split_attributes(attrs) ⇒ Object
82 83 84 85 86 87 88 89 90 91 92 93 94 |
# File 'lib/aduki.rb', line 82 def self.split_attributes attrs setters = { } attrs.each do |setter, value| if setter.match(/\./) first, rest = setter.split(/\./, 2) setters[first] ||= { } setters[first][rest] = value else setters[setter.to_s] = value end end setters end |
.to_aduki(obj, collector = { }, key = "", join = "") ⇒ Object
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
# File 'lib/aduki.rb', line 13 def self.to_aduki obj, collector={ }, key="", join="" case obj when Hash obj.keys.inject(collector) { |result, k| v = obj[k] to_aduki v, collector, "#{key}#{join}#{k}", "." result } when Array obj.each_with_index do |av, ix| to_aduki av, collector, "#{key}[#{ix}]", "." end when String, Numeric, Symbol collector[key] = obj else vv = obj.instance_variables vv.each do |v| accessor = v.to_s.gsub(/^@/, "").to_sym if obj.respond_to?(accessor) && obj.respond_to?("#{accessor}=".to_sym) to_aduki obj.send(accessor), collector, "#{key}#{join}#{accessor}", "." end end end collector end |
.to_typed_hash(klass, value) ⇒ Object
73 74 75 76 77 78 79 80 |
# File 'lib/aduki.rb', line 73 def self.to_typed_hash klass, value setters = split_attributes value hsh = { } setters.each { |k, v| hsh[k] = klass.new(v) } hsh end |
.to_value(klass, setter, value) ⇒ Object
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 |
# File 'lib/aduki.rb', line 44 def self.to_value klass, setter, value return value.map { |v| to_value klass, setter, v} if value.is_a? Array type = klass.aduki_type_for_attribute_name setter if type && type.is_a?(Class) && (value.class <= type) value elsif type.is_a? Hash to_typed_hash type.values.first, value elsif type == Date case value when Date; value when String; maybe_parse_date(value) end elsif type == Time case value when Time; value when String; Time.parse(value) end elsif type && (type <= Integer) value.to_i elsif type && (type <= Float) value.to_f elsif type.respond_to? :aduki_find type.aduki_find value else type ? type.new(value) : value end end |