closes #98

Author: catmando

ruby/hyper-operation/lib/hyper-operation/transport/policy.rb

@@ -21,7 +21,7 @@ def initialize(regulated_klass)
     EXPOSED_METHODS = [
       :regulate_class_connection, :always_allow_connection, :regulate_instance_connections,
       :regulate_all_broadcasts, :regulate_broadcast,
-      :dispatch_to, :regulate_dispatches_from, :always_dispatch_from,
+      :regulate_dispatches_from, :always_dispatch_from,
       :allow_change, :allow_create, :allow_read, :allow_update, :allow_destroy
     ]
 
@@ -58,21 +58,6 @@ def always_dispatch_from(*args, &regulation)
       regulate_dispatches_from(*args) { true }
     end
 
-    def dispatch_to(*args, &regulation)
-      actual_klass = if regulated_klass.is_a?(Class)
-                       regulated_klass
-                     else
-                       begin
-                         regulated_klass.constantize
-                       rescue NameError
-                         nil
-                       end
-                     end
-      raise 'you can only dispatch_to Operation classes' unless actual_klass.respond_to? :dispatch_to
-      actual_klass.dispatch_to(actual_klass)
-      actual_klass.dispatch_to(*args, &regulation)
-    end
-
     CHANGE_POLICIES = [:create, :update, :destroy]
 
     def self.allow_policy(policy, method)

ruby/hyper-operation/spec/aaa_run_first/transports_spec.rb

@@ -99,22 +99,22 @@ def connect(*args)
       mount "TestComponent"
       evaluate_ruby "Hyperstack.go_ahead_and_connect"
       Timecop.travel(Time.now+Hyperstack::Connection.transport.expire_new_connection_in)
-      wait_for { Hyperstack::Connection.active }.to eq(['ScopeIt::TestApplication'])
+      wait_for { sleep 0.25; Hyperstack::Connection.active }.to eq(['ScopeIt::TestApplication'])
     end
 
     it "will not keep the temporary polled connection open" do
       mount "TestComponent"
       Hyperstack::Connection.active.should =~ ['ScopeIt::TestApplication']
       Timecop.travel(Time.now+Hyperstack::Connection.transport.expire_new_connection_in)
-      wait_for { Hyperstack::Connection.active }.to eq([])
+      wait_for { sleep 0.25; Hyperstack::Connection.active }.to eq([])
       sleep 1
     end
 
     it "sees the connection going offline" do
       mount "TestComponent"
       evaluate_ruby "Hyperstack.go_ahead_and_connect"
       Timecop.travel(Time.now+Hyperstack::Connection.transport.expire_new_connection_in)
-      wait_for { sleep 1; Hyperstack::Connection.active }.to eq(['ScopeIt::TestApplication'])
+      wait_for { sleep 0.25; Hyperstack::Connection.active }.to eq(['ScopeIt::TestApplication'])
       ApplicationController.acting_user = true
       mount "TestComponent"
       evaluate_ruby "Hyperstack.go_ahead_and_connect"
@@ -169,21 +169,21 @@ def connect(*args)
       mount "TestComponent"
       evaluate_ruby "Hyperstack.go_ahead_and_connect"
       Timecop.travel(Time.now+Hyperstack::Connection.transport.expire_new_connection_in)
-      wait_for { Hyperstack::Connection.active }.to eq(['ScopeIt::TestApplication'])
+      wait_for { sleep 0.25; Hyperstack::Connection.active }.to eq(['ScopeIt::TestApplication'])
     end
 
     it "will not keep the temporary polled connection open" do
       mount "TestComponent"
       Hyperstack::Connection.active.should =~ ['ScopeIt::TestApplication']
       Timecop.travel(Time.now+Hyperstack::Connection.transport.expire_new_connection_in)
-      wait_for { Hyperstack::Connection.active }.to eq([])
+      wait_for { sleep 0.25; Hyperstack::Connection.active }.to eq([])
     end
 
     it "sees the connection going offline" do
       mount "TestComponent"
       evaluate_ruby "Hyperstack.go_ahead_and_connect"
       Timecop.travel(Time.now+Hyperstack::Connection.transport.expire_new_connection_in)
-      wait_for { Hyperstack::Connection.active }.to eq(['ScopeIt::TestApplication'])
+      wait_for { sleep 0.25; Hyperstack::Connection.active }.to eq(['ScopeIt::TestApplication'])
       ApplicationController.acting_user = true
       mount "TestComponent"
       evaluate_ruby "Hyperstack.go_ahead_and_connect"
@@ -240,27 +240,27 @@ def connect(*args)
       mount "TestComponent"
       evaluate_ruby "Hyperstack.go_ahead_and_connect"
       Timecop.travel(Time.now+Hyperstack::Connection.transport.expire_new_connection_in)
-      wait_for { Hyperstack::Connection.active }.to eq(['ScopeIt::TestApplication'])
+      wait_for { sleep 0.25; Hyperstack::Connection.active }.to eq(['ScopeIt::TestApplication'])
     end
 
     it "will not keep the temporary polled connection open" do
       mount "TestComponent"
       Hyperstack::Connection.active.should =~ ['ScopeIt::TestApplication']
       Timecop.travel(Time.now+Hyperstack::Connection.transport.expire_new_connection_in)
-      wait_for { Hyperstack::Connection.active }.to eq([])
+      wait_for { sleep 0.25; Hyperstack::Connection.active }.to eq([])
     end
 
     it "sees the connection going offline", skip: 'this keeps failing intermittently, but not due to functional issues' do
       mount "TestComponent"
       evaluate_ruby "Hyperstack.go_ahead_and_connect"
       Timecop.travel(Time.now+Hyperstack::Connection.transport.expire_new_connection_in)
-      wait_for { Hyperstack::Connection.active }.to eq(['ScopeIt::TestApplication'])
+      wait_for { sleep 0.25; Hyperstack::Connection.active }.to eq(['ScopeIt::TestApplication'])
       ApplicationController.acting_user = true
       sleep 1 # needed so Pusher can catch up since its not controlled by timecop
       mount "TestComponent"
       evaluate_ruby "Hyperstack.go_ahead_and_connect"
       Timecop.travel(Time.now+Hyperstack::Connection.transport.refresh_channels_every)
-      wait_for { Hyperstack::Connection.active }.to eq([])
+      wait_for { sleep 0.25; Hyperstack::Connection.active }.to eq([])
     end
 
     it "receives change notifications" do

ruby/hyper-operation/spec/hyper-operation/server_op_spec.rb

@@ -249,26 +249,6 @@ class Operation < Hyperstack::ServerOp
       expect(page).to have_content("The server says 'goodby'!")
     end
 
-    it 'can regulate dispatches with the regulate_dispatch applied to a policy' do
-      isomorphic do
-        class Operation < Hyperstack::ServerOp
-          param :message
-          param :broadcast, default: false
-        end
-      end
-      stub_const "ApplicationPolicy", Class.new
-      stub_const "OperationPolicy", Class.new
-      ApplicationPolicy.always_allow_connection
-      OperationPolicy.dispatch_to { ['Application'] if params.broadcast }
-      mount 'Test'
-      expect(page).to have_content('No messages yet')
-      Operation.run(message: 'hello')
-      wait_for_ajax
-      expect(page).not_to have_content("The server says 'hello'!", wait: 0)
-      Operation.run(message: 'goodby', broadcast: true)
-      expect(page).to have_content("The server says 'goodby'!")
-    end
-
     it 'will regulate with the always_dispatch_from regulation' do
       isomorphic do
         class Operation < Hyperstack::ServerOp