merged

Author: catmando

docs/hyper-state/README.md

@@ -5,11 +5,7 @@
 The easiest way to understand HyperState is by example.  If you you did not see the Tic-Tac-Toe example, then **[please review it now](client-dsl/interlude-tic-tac-toe.md)**, as we are going to use this to demonstrate how to use the `Hyperstack::State::Observable` module.
 
 In our original Tic-Tac-Toe implementation the state of the game was stored in the `DisplayGame` component.  State was updated by
-<<<<<<< Updated upstream
 "bubbling up" events from lower level components up to `DisplayGame` where the event handler updated the state.
-=======
-"bubbling up" events from lower level components up to `DisplayGame` where the event hander updated the state.
->>>>>>> Stashed changes
 
 This is a nice simple approach but suffers from two issues:
 + Each level of lower level components must be responsible for bubbling up the events to the higher component.

docs/specs/spec/hyper-state/tic_tac_toe_spec.rb

@@ -71,7 +71,6 @@ def history
   end
 
   def run_the_spec(initial_history)
-    binding.pry
     expect(page).to have_content "Next player: X", wait: 0
     expect(history).to eq initial_history
     expect(squares.count).to eq 9
@@ -707,102 +706,6 @@ def draw_square(id)
       end
 
       class DisplayGame < HyperComponent
-        before_mount { Game.initialize }
-        def moves
-          return unless Game.history.length > 1
-
-          Game.history.length.times do |move|
-            LI(key: move) { move.zero? ? "Go to game start" : "Go to move ##{move}" }
-              .on(:click) { Game.jump_to!(move) }
-          end
-        end
-
-        def status
-          if (winner = Game.current_winner?)
-            "Winner: #{winner}"
-          else
-            "Next player: #{Game.player}"
-          end
-        end
-
-        render(DIV, class: :game) do
-          DIV(class: :game_board) do
-            DisplayBoard(board: Game.current)
-          end
-          DIV(class: :game_info) do
-            DIV { status }
-            OL { moves }
-          end
-        end
-      end
-    end
-    run_the_spec([])
-  end
-
-  it "using the Boot broadcast to initialize the store" do
-    insert_html "<style>\n#{CSS}</style>"
-    mount "DisplayGame" do
-      class Game
-        include Hyperstack::State::Observable
-
-        receives Hyperstack::Application::Boot do
-          @history = [[]]
-          @step = 0
-        end
-
-        class << self
-          observer :player do
-            @step.even? ? :X : :O
-          end
-
-          observer :current do
-            @history[@step]
-          end
-
-          state_reader :history
-
-          WINNING_COMBOS = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [0, 3, 6], [1, 4, 7], [2, 5, 8], [0, 4, 8], [2, 4, 6]]
-
-          def current_winner?
-            WINNING_COMBOS.each do |a, b, c|
-              return current[a] if current[a] && current[a] == current[b] && current[a] == current[c]
-            end
-            false
-          end
-
-          mutator :handle_click! do |id|
-            board = history[@step]
-            return if current_winner? || board[id]
-
-            board = board.dup
-            board[id] = player
-            @history = history[0..@step] + [board]
-            @step += 1
-          end
-
-          mutator(:jump_to!) { |step| @step = step }
-        end
-      end
-
-      class DisplayBoard < HyperComponent
-        param :board
-
-        def draw_square(id)
-          BUTTON(class: :square, id: id) { board[id] }
-          .on(:click) { Game.handle_click!(id) }
-        end
-
-        render(DIV) do
-          (0..6).step(3) do |row|
-            DIV(class: :board_row) do
-              (row..row + 2).each { |id| draw_square(id) }
-            end
-          end
-        end
-      end
-
-      class DisplayGame < HyperComponent
-        before_mount { Game.initialize }
         def moves
           return unless Game.history.length > 1
 

ruby/hyper-state/lib/ext/object_space.rb

@@ -0,0 +1,25 @@
+module ObjectSpace
+  def self.each_object(target_klass, &block)
+    klasses = [Object]
+    i = 0
+    loop do
+      klass = klasses[i]
+      yield klass
+      names = `klass.$$const` && `Object.keys(klass.$$const)`
+      names.each do |name|
+        begin
+          k = klass.const_get(name) rescue nil
+          next unless `k.$$const`
+          next unless k.respond_to?(:is_a?)
+          next if klasses.include?(k)
+
+          klasses << k if k.is_a? target_klass
+        rescue Exception => e
+          next
+        end
+      end if names
+      i += 1
+      break if i >= klasses.length
+    end
+  end
+end

ruby/hyper-state/lib/hyper-state.rb

@@ -12,7 +12,9 @@
 require 'hyperstack/state/observer'
 require 'hyperstack/state/version'
 
-if RUBY_ENGINE != 'opal'
+if RUBY_ENGINE == 'opal'
+  require 'ext/object_space'
+else
   require 'opal'
   Opal.append_path(File.expand_path('../', __FILE__).untaint)
 end

ruby/hyper-state/lib/hyperstack/state/observable.rb

@@ -107,6 +107,18 @@ def self.included(base)
         base.singleton_class.define_singleton_method(:receives) do |*args, &block|
           Internal::Receiver.mount(base, *args, &block)
         end
+
+        unless base.respond_to? :__hyperstack_state_observer_included
+          base.receives Hyperstack::Application::Boot do
+            ObjectSpace.each_object(Class) do |klass|
+              next unless klass <= base
+              next unless klass.respond_to?(:initialize)
+              next unless klass.method(:initialize).arity.zero?
+              klass.initialize
+            end
+          end
+          base.singleton_class.attr_reader :__hyperstack_state_observer_included
+        end
       end
     end
   end

ruby/hyper-state/spec/api/class_initialize_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe 'calling class initialize method', :js do
+  before(:each) do
+    isomorphic do
+      class ClassStore
+        include Hyperstack::State::Observable
+        class << self
+          attr_reader :initialized
+          def initialize
+            @initialized = !@initialized && self
+          end
+        end
+      end
+
+      class ClassSubStore < ClassStore
+        class << self
+          attr_reader :initialized
+          def initialize
+            @initialized = !@initialized && self
+          end
+        end
+      end
+
+      class ClassSubNoInit < ClassStore
+      end
+
+      class SubGumStore < ClassStore
+        include Hyperstack::State::Observable
+        class << self
+          attr_reader :initialized
+          def initialize
+            @initialized = !@initialized && self
+          end
+        end
+      end
+    end
+  end
+
+  it "the store will receive a class level initialize (client)" do
+    expect { ClassStore.initialized }.on_client_to eq(ClassStore.to_s)
+    expect { ClassSubStore.initialized }.on_client_to eq(ClassSubStore.to_s)
+    expect { SubGumStore.initialized }.on_client_to eq(SubGumStore.to_s)
+  end
+
+  it "the store will receive a class level initialize (server)" do
+    Hyperstack::Application::Boot.run
+
+    expect(ClassStore.initialized).to eq(ClassStore)
+    expect(ClassSubStore.initialized).to eq(ClassSubStore)
+    expect(SubGumStore.initialized).to eq(SubGumStore)
+  end
+end