Class: ClassState

Inherits:
Object
  • Object
show all
Defined in:
lib/class_state/owner.rb,
lib/class_state/class_state.rb

Overview

monkey patch the Owner module insto the ClassState class scope

Defined Under Namespace

Modules: Owner

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(_values = {}) ⇒ ClassState 



7
8
9
10
 
# File 'lib/class_state/class_state.rb', line 7

def initialize(_values = {})
    @callback_definitions = []
    self.set(_values)
end

Instance Attribute Details

#callback_definitions ⇒ Object (readonly)

Returns the value of attribute callback_definitions.



5
6
7
 
# File 'lib/class_state/class_state.rb', line 5

def callback_definitions
  @callback_definitions
end

#values ⇒ Object (readonly)

Returns the value of attribute values.



4
5
6
 
# File 'lib/class_state/class_state.rb', line 4

def values
  @values
end

Instance Method Details

#[](attr_name) ⇒ Object 



25
26
27
 
# File 'lib/class_state/class_state.rb', line 25

def [](attr_name)
    values[attr_name]
end

#[]=(key, val) ⇒ Object

writers



35
36
37
 
# File 'lib/class_state/class_state.rb', line 35

def []=(key, val)
    return self.update(key => val)
end

#data ⇒ Object 



29
30
31
 
# File 'lib/class_state/class_state.rb', line 29

def data
    self.values
end

#get(attr_name) ⇒ Object

readers



21
22
23
 
# File 'lib/class_state/class_state.rb', line 21

def get(attr_name)
    values[attr_name]
end

#logger ⇒ Object 



12
13
14
15
16
 
# File 'lib/class_state/class_state.rb', line 12

def logger
    @_logger ||= Logger.new(STDOUT).tap do |l|
        l.level = Logger::WARNING
    end
end

#on(*args, &block) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/class_state/class_state.rb', line 80

def on(*args, &block)
    callback_definition = {:event => args.first}

    if block
        callback_definition[:block] = block
        callback_definition[:attribute] = args[1] # could be nil
    else
        if args.first == :change_attribute or args.first == :unset_attribute
            callback_definition[:attribute] = args[1]
            callback_definition[:subject] = args[2]
            callback_definition[:method] = args[3]
        else
            callback_definition[:subject] = args[1]
            callback_definition[:method] = args[2]
        end
    end

    if callback_definition[:block].nil? and callback_definition[:method].nil?
        logger.warn "ClassState.on didn't get a callback method or block"
    end
    
    if !callback_definition[:method].nil?
        callback_definition[:method] = callback_definition[:method].to_s.to_sym
    end

    # save definition
    @callback_definitions << callback_definition
end

#set(_values) ⇒ Object 



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/class_state/class_state.rb', line 44

def set(_values)
    original = self.values || {}
    @values = _values
    changes = get_changes_hash(original, _values)

    changes.keys.each do |changed_attr|
        trigger_attribute_callbacks(:change_attribute, changed_attr, self, changes)
    end

    if !changes.empty?
        trigger_callbacks(:change, self, changes)
    end
    
    return self
end

#unset(attrs) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/class_state/class_state.rb', line 60

def unset(attrs)
    unsets = {}

    [attrs].flatten.each do |attr_name|
        if self.values.keys.include?(attr_name)
            unsets.merge!(attr_name => self.values.delete(attr_name))
        end
    end
    
    unsets.keys.each do |changed_attr|
        trigger_attribute_callbacks(:unset_attribute, changed_attr, self, unsets)
    end

    if !unsets.empty?
        trigger_callbacks(:unset, self, unsets)
    end

    return unsets
end

#update(_values) ⇒ Object 



39
40
41
42
 
# File 'lib/class_state/class_state.rb', line 39

def update(_values)
    self.set(self.values.merge(_values))
    return self
end