Module: Coaster::SerializedProperties

Defined in:
lib/coaster/serialized_properties.rb

Defined Under Namespace

Classes: DuplicatedProperty, InvalidProperty

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.extended(base) ⇒ Object 



6
7
8
9
10
11
12
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
38
39
40
41
42
43
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
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/coaster/serialized_properties.rb', line 6

def self.extended(base)
  base.class_eval do
    def sprop_changes = self.class.serialized_property_changes(changes)
    def sprop_change(key) = sprop_changes[key.to_s]
    def sprop_changed?(key) = sprop_change(key).present?
    def sprop_was(key) = (ch = sprop_change(key)).present? ? ch[0] : nil
    
    def sprop_saved_changes = self.class.serialized_property_changes(saved_changes)
    def sprop_saved_change(key) = sprop_saved_changes[key.to_s]

    def sprop_previous_changes = self.class.serialized_property_changes(previous_changes)
    def sprop_previous_change(key) = sprop_previous_changes[key.to_s] 
    def sprop_previously_changed?(key) = sprop_previous_change(key).present?
    def sprop_previously_was(key) = (ch = sprop_previous_change(key)).present? ? ch[0] : nil

    if defined?(ActiveRecord::Base) && base < ActiveRecord::Base
      # Internal method to write serialized property value
      # @param key [String, Symbol] property key
      # @param value [Object] value to write
      # @param apply_setter [Boolean] whether to apply setter proc
      def _write_sprop_value(key, value, apply_setter: true)
        setting = self.class.serialized_property_setting(key)
        return unless setting
        col = setting[:column]
        hsh = send(col)
        if value.nil?
          hsh.delete(key.to_s)
        else
          value = setting[:setter].call(value) if apply_setter && setting[:setter]
          hsh[key.to_s] = value
        end
        value
      end

      def write_attribute(attr_name, value)
        if self.class.serialized_property_setting(attr_name)
          _write_sprop_value(attr_name, value, apply_setter: false)
        else
          super
        end
      end

      def read_attribute(attr_name)
        if (setting = self.class.serialized_property_setting(attr_name))
          col = setting[:column]
          hsh = super(col) || {}
          val = hsh[attr_name.to_s]
          val = setting[:getter].call(val) if setting[:getter]
          val
        else
          super
        end
      end

      def [](attr_name)
        if (setting = self.class.serialized_property_setting(attr_name))
          col = setting[:column]
          hsh = super(col) || {}
          val = hsh[attr_name.to_s]
          val = setting[:getter].call(val) if setting[:getter]
          val
        else
          super
        end
      end

      def []=(attr_name, value)
        if self.class.serialized_property_setting(attr_name)
          _write_sprop_value(attr_name, value, apply_setter: false)
        else
          super
        end
      end
    end
  end
end

Instance Method Details

#delete_serialized_property_setting(key) ⇒ Object 



114
115
116
117
 
# File 'lib/coaster/serialized_properties.rb', line 114

def delete_serialized_property_setting(key)
own_serialized_property_settings.delete(key.to_sym)
  serialized_property_settings.delete(key.to_sym)
end

#own_serialized_property_settings ⇒ Object 



93
94
95
 
# File 'lib/coaster/serialized_properties.rb', line 93

def own_serialized_property_settings
  @own_serialized_property_settings ||= {}
end

#rename_serialized_property_setting(from_key, to_key) ⇒ Object 



119
120
121
122
123
124
125
 
# File 'lib/coaster/serialized_properties.rb', line 119

def rename_serialized_property_setting(from_key, to_key)
  setting = own_serialized_property_settings.delete(from_key.to_sym)
  own_serialized_property_settings[to_key.to_sym] = setting
  serialized_property_settings.delete(from_key.to_sym)
  serialized_property_settings[to_key.to_sym] = setting
  setting
end

#serialized_column(serialize_column) ⇒ Object 



127
128
129
130
131
132
133
 
# File 'lib/coaster/serialized_properties.rb', line 127

def serialized_column(serialize_column)
  define_method serialize_column.to_sym do
    return read_attribute(serialize_column.to_sym) if read_attribute(serialize_column.to_sym)
    write_attribute(serialize_column.to_sym, {})
    read_attribute(serialize_column)
  end
end

#serialized_properties(serialize_column, *keys, type: nil, getter: nil, setter: nil, setter_callback: nil, default: nil, rescuer: nil) ⇒ Object 



147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/coaster/serialized_properties.rb', line 147

def serialized_properties(serialize_column, *keys, type: nil, getter: nil, setter: nil, setter_callback: nil, default: nil, rescuer: nil)
  keys.flatten.each do |key|
    key_name = key
    prop_hash = {type: type, getter: getter, setter: setter, setter_callback: setter_callback, default: default, rescuer: rescuer}
    if key.is_a? Hash
      key_name = key[:key]
      prop_hash = {type: type, getter: getter, setter: setter, setter_callback: setter_callback, default: default}.merge(key)
      prop_hash.delete(:key)
    end
    serialized_property(serialize_column, key_name, **prop_hash)
  end
end

#serialized_property(serialize_column, key, type: nil, comment: nil, getter: nil, setter: nil, setter_callback: nil, default: nil, rescuer: nil) ⇒ Object

Raises:



141
142
143
144
145
 
# File 'lib/coaster/serialized_properties.rb', line 141

def serialized_property(serialize_column, key, type: nil, comment: nil, getter: nil, setter: nil, setter_callback: nil, default: nil, rescuer: nil)
  raise DuplicatedProperty, "#{self.name}##{key} duplicated\n#{caller[0..5].join("\n")}" if own_serialized_property_settings[key.to_sym]
  set_serialized_property_setting(key, {column: serialize_column.to_sym, type: type, comment: comment, getter: getter, setter: setter, setter_callback: setter_callback, default: default, rescuer: rescuer})
  _typed_serialized_property(serialize_column, key, type: type, getter: getter, setter: setter, setter_callback: setter_callback, default: default, rescuer: rescuer)
end

#serialized_property_changes(changes) ⇒ Object 



83
84
85
86
87
88
89
90
91
 
# File 'lib/coaster/serialized_properties.rb', line 83

def serialized_property_changes(changes)
  serialized_property_settings.each_with_object({}) do |(key, prop), result|
    prop_ch = changes[prop[:column].to_s]
    next if prop_ch.blank?
    before = prop_ch[0] && prop_ch[0][key.to_s]
    after = prop_ch[1] && prop_ch[1][key.to_s]
    result[key.to_s] = [before, after] if before != after
  end
end

#serialized_property_comment(key) ⇒ Object 



135
136
137
138
139
 
# File 'lib/coaster/serialized_properties.rb', line 135

def serialized_property_comment(key)
  cm = serialized_property_settings[key.to_sym] &&
       serialized_property_settings[key.to_sym][:comment]
  cm || key.to_s
end

#serialized_property_setting(key) ⇒ Object 



105
106
107
 
# File 'lib/coaster/serialized_properties.rb', line 105

def serialized_property_setting(key)
  serialized_property_settings[key.to_sym]
end

#serialized_property_settings ⇒ Object 



97
98
99
100
101
102
103
 
# File 'lib/coaster/serialized_properties.rb', line 97

def serialized_property_settings
  @serialized_property_settings ||= if superclass.respond_to?(:serialized_property_settings)
    superclass.serialized_property_settings.dup
  else
    {}
  end
end

#set_serialized_property_setting(key, setting) ⇒ Object 



109
110
111
112
 
# File 'lib/coaster/serialized_properties.rb', line 109

def set_serialized_property_setting(key, setting)
  own_serialized_property_settings[key.to_sym] = setting
  serialized_property_settings[key.to_sym] = setting
end