Class: React::State

Inherits:
Object show all
Defined in:
lib/react/state.rb

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.current_observer ⇒ Object (readonly)

Returns the value of attribute current_observer.



40
41
42
 
# File 'lib/react/state.rb', line 40

def current_observer
  @current_observer
end

Class Method Details

.get_state(object, name, current_observer = @current_observer) ⇒ Object 



46
47
48
49
50
51
 
# File 'lib/react/state.rb', line 46

def get_state(object, name, current_observer = @current_observer)
  # get current value of name for object, remember that the current object depends on this state,
  # current observer can be overriden with last param
  new_observers[current_observer][object] << name if current_observer && !new_observers[current_observer][object].include?(name)
  states[object][name]
end

.initialize_states(object, initial_values) ⇒ Object

initialize objects’ name/value pairs



42
43
44
 
# File 'lib/react/state.rb', line 42

def initialize_states(object, initial_values) # initialize objects' name/value pairs
  states[object].merge!(initial_values || {})
end

.is_observing?(object, name, current_observer) ⇒ Boolean

Returns:

  • (Boolean) 


86
87
88
 
# File 'lib/react/state.rb', line 86

def is_observing?(object, name, current_observer)
  current_observer && observers_by_name[object][name].include?(current_observer)
end

.notify_observers(object, name, value) ⇒ Object 



63
64
65
66
67
68
69
70
 
# File 'lib/react/state.rb', line 63

def notify_observers(object, name, value)
  object_needs_notification = object.respond_to? :update_react_js_state
  observers_by_name[object][name].dup.each do |observer|
    observer.update_react_js_state(object, name, value)
    object_needs_notification = false if object == observer
  end
  object.update_react_js_state(nil, name, value) if object_needs_notification
end

.notify_observers_after_thread_completes(object, name, value) ⇒ Object 



72
73
74
75
76
77
78
79
80
 
# File 'lib/react/state.rb', line 72

def notify_observers_after_thread_completes(object, name, value)
  (@delayed_updates ||= []) << [object, name, value]
  @delayed_updater ||= after(0) do
    delayed_updates = @delayed_updates
    @delayed_updates = []
    @delayed_updater = nil
    delayed_updates.each { |args| notify_observers(*args) }
  end
end

.remove ⇒ Object

call after component is unmounted



106
107
108
109
110
111
112
113
114
 
# File 'lib/react/state.rb', line 106

def remove # call after component is unmounted
  raise "remove called outside of watch block" unless @current_observer
  current_observers[@current_observer].each do |object, names|
    names.each do |name|
      observers_by_name[object][name].delete(@current_observer)
    end
  end
  current_observers.delete(@current_observer)
end

.set_state(object, name, value, wait_till_thread_completes = nil) ⇒ Object 



53
54
55
56
57
58
59
60
61
 
# File 'lib/react/state.rb', line 53

def set_state(object, name, value, wait_till_thread_completes = nil)
  states[object][name] = value
  if wait_till_thread_completes
    notify_observers_after_thread_completes(object, name, value)
  elsif @rendering_level == 0
    notify_observers(object, name, value)
  end
  value
end

.set_state_context_to(observer, rendering = nil) ⇒ Object

wrap all execution that may set or get states in a block so we know which observer is executing



116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/react/state.rb', line 116

def set_state_context_to(observer, rendering = nil) # wrap all execution that may set or get states in a block so we know which observer is executing
  if `typeof window.reactive_ruby_timing !== 'undefined'`
    @nesting_level = (@nesting_level || 0) + 1
    start_time = Time.now.to_f
    observer_name = (observer.class.respond_to?(:name) ? observer.class.name : observer.to_s) rescue "object:#{observer.object_id}"
  end
  saved_current_observer = @current_observer
  @current_observer = observer
  @rendering_level += 1 if rendering
  return_value = yield
  return_value
ensure
  @current_observer = saved_current_observer
  @rendering_level -= 1 if rendering
  @nesting_level = [0, @nesting_level - 1].max if `typeof window.reactive_ruby_timing !== 'undefined'`
  return_value
end

.states ⇒ Object 



134
135
136
 
# File 'lib/react/state.rb', line 134

def states
  @states ||= Hash.new { |h, k| h[k] = {} }
end

.update_states_to_observe(current_observer = @current_observer) ⇒ Object

should be called after the last after_render callback, currently called after components render method



90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/react/state.rb', line 90

def update_states_to_observe(current_observer = @current_observer)  # should be called after the last after_render callback, currently called after components render method
  raise "update_states_to_observer called outside of watch block" unless current_observer
  current_observers[current_observer].each do |object, names|
    names.each do |name|
      observers_by_name[object][name].delete(current_observer)
    end
  end
  observers = current_observers[current_observer] = new_observers[current_observer]
  new_observers.delete(current_observer)
  observers.each do |object, names|
    names.each do |name|
      observers_by_name[object][name] << current_observer
    end
  end
end

.will_be_observing?(object, name, current_observer) ⇒ Boolean

Returns:

  • (Boolean) 


82
83
84
 
# File 'lib/react/state.rb', line 82

def will_be_observing?(object, name, current_observer)
  current_observer && new_observers[current_observer][object].include?(name)
end