Module: Hyperstack::State::Observable

Defined in:
lib/hyperstack/state/observable.rb

Class Method Summary collapse

Class Method Details

.bulk_update(&block) ⇒ Object 



4
5
6
 
# File 'lib/hyperstack/state/observable.rb', line 4

def self.bulk_update(&block)
  Internal::State::Mapper.bulk_update(&block)
end

.included(base) ⇒ Object 



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
 
# File 'lib/hyperstack/state/observable.rb', line 8

def self.included(base)
  base.include Internal::AutoUnmount
  %i[singleton_method method].each do |kind|
    base.send(:"define_#{kind}", :receives) do |*args, &block|
      Internal::Receiver.mount(self, *args, &block)
    end
    base.send(:"define_#{kind}", :observe) do |&block|
      result = block.call if block
      Internal::State::Mapper.observed! self
      result
    end
    base.send(:"define_#{kind}", :mutate) do |*_args, &block|
      # any args will be ignored thus allowing us to say `mutate @foo = 123, @bar[:x] = 7` etc
      result = block.call if block
      Internal::State::Mapper.mutated! self
      result
    end
    if RUBY_ENGINE == 'opal'
      base.send(:"define_#{kind}", :set) do |var|
        lambda do |val|
          `self[#{var}] = #{val}`
          mutate if var =~ /^[a-z]/
        end
      end
    else
      base.send(:"define_#{kind}", :set) do |var|
        lambda do |val|
          instance_variable_set(:"@#{var}", val)
          mutate if var =~ /^[a-z]/
        end
      end
    end
    base.singleton_class.send(:"define_#{kind}", :observer) do |name, &block|
      define_method(name) do |*args|
        instance_exec(*args, &block).tap do
          Internal::State::Mapper.observed! self
        end
      end
    end
    base.singleton_class.send(:"define_#{kind}", :mutator) do |name, &block|
      define_method(name) do |*args|
        instance_exec(*args, &block).tap do
          Internal::State::Mapper.mutated! self
        end
      end
    end
    base.singleton_class.send(:"define_#{kind}", :state_reader) do |*names|
      names.each do |name|
        define_method(name) do
          instance_variable_get(:"@#{name}").tap { Internal::State::Mapper.observed!(self) }
        end
      end
    end
    base.singleton_class.send(:"define_#{kind}", :state_writer) do |*names|
      names.each do |name|
        define_method(:"#{name}=") do |x|
          instance_variable_set(:"@#{name}", x).tap { Internal::State::Mapper.mutated!(self) }
        end
      end
    end
    base.singleton_class.send(:"define_#{kind}", :state_accessor) do |*names|
      state_reader(*names)
      state_writer(*names)
    end
  end
end