hyper-operation 1.0.alpha1.8 → 1.0.0.lap28

data/lib/hyper-operation/railway/dispatcher.rb

@@ -1,6 +1,7 @@
-module Hyperstack
+module Hyperloop
   class Operation
     class Railway
+
       def receivers
         self.class.receivers
       end
@@ -8,16 +9,12 @@ module Hyperstack
       class << self
         def receivers
           # use the force: true option so that system code needing to receive
-          # boot will NOT be erased on the next Hyperstack::Context.reset!
-          Hyperstack::Context.set_var(self, :@receivers, force: true) { [] }
+          # boot will NOT be erased on the next Hyperloop::Context.reset!
+          Hyperloop::Context.set_var(self, :@receivers, force: true) { [] }
         end
 
         def add_receiver(&block)
-          cloned_block = ->(*args, &b) { block.call(*args, &b) }
-          operation = self
-          cloned_block.define_singleton_method(:unmount) { operation.receivers.delete(cloned_block) }
-          receivers << cloned_block
-          cloned_block
+          receivers << block
         end
       end
 

data/lib/hyper-operation/railway/params_wrapper.rb

@@ -1,4 +1,4 @@
-module Hyperstack
+module Hyperloop
   class Operation
     class ParamsWrapper
 
@@ -119,7 +119,7 @@ module Hyperstack
       end
 
       def self.params_wrapper
-        Hyperstack::Context.set_var(self, :@params_wrapper) do
+        Hyperloop::Context.set_var(self, :@params_wrapper) do
           if Railway == superclass
             Class.new(ParamsWrapper)
           else

data/lib/hyper-operation/railway/run.rb

@@ -1,16 +1,13 @@
-module Hyperstack
+module Hyperloop
   class Operation
 
     class Exit < StandardError
       attr_reader :state
       attr_reader :result
-      def initialize(state, result = nil)
+      def initialize(state, result)
         @state = state
         @result = result
       end
-      def to_s
-        @state
-      end
     end
 
     class Railway
@@ -24,7 +21,7 @@ module Hyperstack
           @tracks ||= []
         end
 
-        def build_tie(tie, args, block)
+        def to_opts(tie, args, block)
           if args.count.zero?
             { run: block }
           elsif args[0].is_a?(Hash)
@@ -44,7 +41,7 @@ module Hyperstack
 
         [:step, :failed, :async].each do |tie|
           define_method :"add_#{tie}" do |*args, &block|
-            tracks << build_tie(tie, args, block)
+            tracks << to_opts(tie, args, block)
           end
         end
 
@@ -58,36 +55,44 @@ module Hyperstack
       end
 
       def step(opts)
-        @promise_chain = @promise_chain
-          .then { |result| apply(result, :success, opts) }
+        if @last_result.is_a? Promise
+          @last_result = @last_result.then do |*result|
+            @last_result = result
+            apply(opts, :in_promise)
+          end
+        elsif @state == :success
+          apply(opts)
+        end
       end
 
       def failed(opts)
-        @promise_chain = @promise_chain
-          .always do |result|
-            @state = :failed if @promise_chain.rejected? && @state != :abort
-            apply(result, :failed, opts)
+        if @last_result.is_a? Promise
+          @last_result = @last_result.fail do |e|
+            @last_result = e
+            apply(opts, :in_promise)
+            raise @last_result if @last_result.is_a? Exception
+            raise e
           end
+        elsif @state == :failed
+          apply(opts)
+        end
       end
 
       def async(opts)
-        @promise_chain = @promise_chain_start = Promise.new
-        @promise_chain.resolve(@last_async_result)
-        step(opts)
+        apply(opts) if @state != :failed
       end
 
-      def apply(result, state, opts)
-        return result unless @state == state
+      def apply(opts, in_promise = nil)
         if opts[:scope] == :class
-          args = [@operation, *result]
+          args = [@operation, *@last_result]
           instance = @operation.class
         else
-          args = result
+          args = @last_result
           instance = @operation
         end
         block = opts[:run]
         block = instance.method(block) if block.is_a? Symbol
-        last_result =
+        @last_result =
           if block.arity.zero?
             instance.instance_exec(&block)
           elsif args.is_a?(Array) && block.arity == args.count
@@ -95,54 +100,40 @@ module Hyperstack
           else
             instance.instance_exec(args, &block)
           end
-        @last_async_result = last_result unless last_result.is_a? Promise
-        last_result
+        return @last_result unless @last_result.is_a? Promise
+        raise @last_result.error if @last_result.rejected?
+        @last_result = @last_result.value if @last_result.resolved?
+        @last_result
       rescue Exit => e
-        # the promise chain ends with an always block which will process
-        # any immediate exits by checking the value of @state.   All other
-        # step/failed/async blocks will be skipped because state will not equal
-        # :succeed or :failed
-        if e.state == :failed
-          @state = :abort
-          # exit via the final always block with the exception
-          raise e.result.is_a?(Exception) ? e.result : e
-        else
-          @state = :succeed
-          # exit via the final then block with the success value
-          e.result
-        end
+        @state = e.state
+        @last_result = (e.state != :failed || e.result.is_a?(Exception)) ? e.result : e
+        raise e
       rescue Exception => e
         @state = :failed
-        raise e
+        @last_result = e
+        raise e if in_promise
       end
 
       def run
-        # if @operation.has_errors? || @state
-        #   @last_result ||= ValidationException.new(@operation.instance_variable_get('@errors'))
-        #   # following handles abort out of validation.  if state is already set then we are aborting
-        #   # otherwise if state is not set but we have errors then we are failed
-        #   @state ||= :failed
-        # else
-        #   @state = :success
-        # end
-        @state ||= :success
-        @promise_chain_start = @promise_chain = Promise.new
-        @promise_chain_start.resolve(@last_result)
-        tracks.each { |opts| opts[:tie].bind(self).call(opts) } unless @state == :abort
+        if @operation.has_errors? || @state
+          @last_result ||= ValidationException.new(@operation.instance_variable_get('@errors'))
+          return if @state  # handles abort out of validation
+          @state = :failed
+        else
+          @state = :success
+        end
+        tracks.each { |opts| opts[:tie].bind(self).call(opts) }
+      rescue Exit
       end
 
       def result
-        @result ||= @promise_chain.always do |e|
-          if %i[abort failed].include? @state
-            if e.is_a? Exception
-              raise e
-            else
-              raise Promise::Fail.new(e)
-            end
+        return @last_result if @last_result.is_a? Promise
+        @last_result =
+          if @state == :success
+            Promise.new.resolve(@last_result)
           else
-            e
+            Promise.new.reject(@last_result)
           end
-        end
       end
     end
   end

data/lib/hyper-operation/railway/validations.rb

@@ -1,4 +1,4 @@
-module Hyperstack
+module Hyperloop
   class Operation
     class Railway
 
@@ -28,8 +28,6 @@ module Hyperstack
             rescue Exit => e
               raise e unless e.state == :failed
               add_error(param, symbol, message)
-              # use a bogus exit state which will skip adding
-              # a validation error (see catch block in process_validations method)
               raise Exit.new(:abort_from_add_error, e.result)
             end
           end
@@ -49,22 +47,17 @@ module Hyperstack
             when :failed
               add_validation_error(i, "param validation #{i+1} aborted")
             end
-            @state = :abort
+            @state = :failed
             return # break does not work in Opal
           rescue AccessViolation => e
             add_validation_error(i, e)
-            @state = :abort
+            @state = :failed
             @last_result = e
             return # break does not work in Opal
           rescue Exception => e
             add_validation_error(i, e)
           end
         end
-      ensure
-        if @operation.has_errors?
-          @last_result ||= ValidationException.new(@operation.instance_variable_get('@errors'))
-          @state ||= :failed
-        end
       end
     end
   end

data/lib/hyper-operation/server_op.rb

@@ -1,30 +1,26 @@
 require 'net/http' unless RUBY_ENGINE == 'opal'
 
-module Hyperstack
+module Hyperloop
   class ServerOp < Operation
 
     class << self
-      include Hyperstack::Component::IsomorphicHelpers
+      include React::IsomorphicHelpers
 
       if RUBY_ENGINE == 'opal'
         if on_opal_client?
           def run(*args)
             hash = _Railway.params_wrapper.combine_arg_array(args)
             hash = serialize_params(hash)
-            Hyperstack::HTTP.post(
-              "#{`window.HyperstackEnginePath`}/execute_remote",
-              payload: {hyperstack_secured_json: {operation: name, params: hash}.to_json},
-              headers: headers.merge('X-CSRF-Token' => Hyperstack::ClientDrivers.opts[:form_authenticity_token])
+            Hyperloop::HTTP.post(
+              "#{`window.HyperloopEnginePath`}/execute_remote",
+              payload: {json: {operation: name, params: hash}.to_json},
+              headers: {'X-CSRF-Token' => Hyperloop::ClientDrivers.opts[:form_authenticity_token] }
               )
             .then do |response|
               deserialize_response response.json[:response]
             end
             .fail do |response|
-              begin
-                const_get(response.json[:error_class]).new(response.json[:error])
-              rescue
-                Exception.new response.json[:error]
-              end
+              Exception.new response.json[:error]
             end
           end
         elsif on_opal_server?
@@ -44,21 +40,19 @@ module Hyperstack
       isomorphic_method(:internal_iso_run) do |f, klass_name, op_params|
         f.send_to_server(klass_name, op_params)
         f.when_on_server {
-          Hyperstack::ServerOp.run_from_client(:acting_user, controller, klass_name, *op_params)
+          Hyperloop::ServerOp.run_from_client(:acting_user, controller, klass_name, *op_params)
         }
       end
 
       def descendants_map_cache
         # calling descendants alone may take 10ms in a complex app, so better cache it
-        @cached_descendants ||= Hyperstack::ServerOp.descendants.map(&:to_s)
+        @cached_descendants ||= Hyperloop::ServerOp.descendants.map(&:to_s)
       end
 
       def run_from_client(security_param, controller, operation, params)
         if Rails.env.production?
           # in production everything is eager loaded so ServerOp.descendants is filled and can be used to guard the .constantize
-          unless Hyperstack::ServerOp.descendants_map_cache.include?(operation)
-            Hyperstack::InternalPolicy.raise_operation_access_violation(:illegal_remote_op_call, "Operation: #{operation} (in production)")
-          end
+          Hyperloop::InternalPolicy.raise_operation_access_violation unless Hyperloop::ServerOp.descendants_map_cache.include?(operation)
           # however ...
         else
           # ... in development things are autoloaded on demand, thus ServerOp.descendants can be empty or partially filled and above guard
@@ -68,17 +62,15 @@ module Hyperstack
           begin
             const = Object.const_get(operation)
           rescue NameError
-            Hyperstack::InternalPolicy.raise_operation_access_violation(:illegal_remote_op_call, "Operation: #{operation} (const not found)")
-          end
-          unless const < Hyperstack::ServerOp
-            Hyperstack::InternalPolicy.raise_operation_access_violation(:illegal_remote_op_call, "Operation: #{operation} (not a ServerOp subclass)")
+            Hyperloop::InternalPolicy.raise_operation_access_violation
           end
+          Hyperloop::InternalPolicy.raise_operation_access_violation unless const < Hyperloop::ServerOp
         end
         operation.constantize.class_eval do
           if _Railway.params_wrapper.method_defined?(:controller)
             params[:controller] = controller
           elsif !_Railway.params_wrapper.method_defined?(security_param)
-            raise AccessViolation.new(:remote_access_not_allowed)
+            raise AccessViolation
           end
           run(deserialize_params(params))
           .then { |r| return { json: { response: serialize_response(r) } } }
@@ -88,27 +80,13 @@ module Hyperstack
         handle_exception(e, operation, params)
       end
 
-      def status(e)
-        if e.is_a? AccessViolation
-          403
-        elsif e.is_a? Operation::ValidationException
-          400
-        else
-          500
-        end
-      end
-
       def handle_exception(e, operation, params)
-        if e.respond_to? :__hyperstack_on_error
-          params = params.to_h
-          message = []
-          message << Pastel.new.red("HYPERSTACK ERROR during #{operation} #{e.inspect}")
-          params.each { |param, value| message << "  #{param} => #{value.inspect.truncate(120, separator: '...')}" }
-          message << "\n#{e.details}" if e.respond_to? :details
-          e.__hyperstack_on_error(operation, params, message.join("\n"))
+        if defined? ::Rails
+          params.delete(:controller)
+          ::Rails.logger.debug "\033[0;31;1mERROR: Hyperloop::ServerOp exception caught when running "\
+                               "#{operation} with params \"#{params}\": #{e}\033[0;30;21m"
         end
-
-        { json: { error_class: e.class.to_s, error: e}, status: status(e) }
+        { json: { error: e }, status: 500 }
       end
 
 
@@ -122,17 +100,13 @@ module Hyperstack
         end
         request.body = {
           operation: name,
-          params: Hyperstack::Operation::ParamsWrapper.combine_arg_array(args)
+          params: Hyperloop::Operation::ParamsWrapper.combine_arg_array(args)
         }.to_json
         promise.resolve http.request(request)
       rescue Exception => e
         promise.reject e
       end
 
-      def headers
-        {}
-      end
-
       def serialize_params(hash)
         hash
       end
@@ -174,7 +148,7 @@ module Hyperstack
           [operation.instance_exec(*context, &regulation)].flatten.compact.uniq.each do |channel|
             unless operation.instance_variable_get(:@_dispatched_channels).include?(channel)
               operation.instance_variable_set(:@_dispatched_channels, operation.instance_variable_get(:@_dispatched_channels) << channel)
-              Hyperstack.dispatch(channel: Hyperstack::InternalPolicy.channel_to_string(channel), operation: operation.class.name, params: serialized_params)
+              Hyperloop.dispatch(channel: Hyperloop::InternalPolicy.channel_to_string(channel), operation: operation.class.name, params: serialized_params)
             end
           end
         end

data/lib/hyper-operation/transport/action_cable.rb

@@ -3,7 +3,7 @@ module ApplicationCable
   class Connection < ActionCable::Connection::Base; end
 end
 
-module Hyperstack
+module Hyperloop
   class ActionCableChannel < ApplicationCable::Channel
     class << self
       def subscriptions
@@ -12,28 +12,28 @@ module Hyperstack
     end
 
     def inc_subscription
-      self.class.subscriptions[params[:hyperstack_channel]] =
-        self.class.subscriptions[params[:hyperstack_channel]] + 1
+      self.class.subscriptions[params[:hyperloop_channel]] =
+        self.class.subscriptions[params[:hyperloop_channel]] + 1
     end
 
     def dec_subscription
-      self.class.subscriptions[params[:hyperstack_channel]] =
-        self.class.subscriptions[params[:hyperstack_channel]] - 1
+      self.class.subscriptions[params[:hyperloop_channel]] =
+        self.class.subscriptions[params[:hyperloop_channel]] - 1
     end
 
     def subscribed
       session_id = params["client_id"]
-      authorization = Hyperstack.authorization(params["salt"], params["hyperstack_channel"], session_id)
+      authorization = Hyperloop.authorization(params["salt"], params["hyperloop_channel"], session_id)
       if params["authorization"] == authorization
         inc_subscription
-        stream_from "hyperstack-#{params[:hyperstack_channel]}"
+        stream_from "hyperloop-#{params[:hyperloop_channel]}"
       else
         reject
       end
     end
 
     def unsubscribed
-      Hyperstack::Connection.disconnect(params[:hyperstack_channel]) if dec_subscription == 0
+      Hyperloop::Connection.disconnect(params[:hyperloop_channel]) if dec_subscription == 0
     end
   end
 end

data/lib/hyper-operation/transport/client_drivers.rb

@@ -1,18 +1,14 @@
 #### this is going to need some refactoring so that HyperMesh can add its methods in here...
 
-module Hyperstack
+module Hyperloop
   # Client side handling of synchronization messages
   # When a synchronization message comes in, the client will sync_dispatch
   # We use ERB to determine the configuration and implement the appropriate
   # client interface to sync_change or sync_destroy
 
-  def self.anti_csrf_token
-    ClientDrivers.opts[:form_authenticity_token]
-  end
-
   class Application
-    extend Component::IsomorphicHelpers::ClassMethods
-
+    extend React::IsomorphicHelpers::ClassMethods
+    
     if on_opal_client?
       def self.acting_user_id
         ClientDrivers.opts[:acting_user_id]
@@ -35,41 +31,22 @@ module Hyperstack
 
 
   if RUBY_ENGINE == 'opal'
-    # Patch in a dummy copy of Model.load in case we are not using models
-    # this will be defined properly by hyper-model
-    module Model
-      def self.load
-        Promise.new.tap { |promise| promise.resolve(yield) }
-      end unless respond_to?(:load)
-    end
-
     def self.connect(*channels)
       channels.each do |channel|
         if channel.is_a? Class
           IncomingBroadcast.connect_to(channel.name)
         elsif channel.is_a?(String) || channel.is_a?(Array)
           IncomingBroadcast.connect_to(*channel)
-        elsif channel.respond_to?(:id)
-          Hyperstack::Model.load do
-            channel.id
-          end.then do |id|
-            raise "Hyperstack.connect cannot connect to #{channel.inspect}.  "\
-                  "The id is nil. This can be caused by connecting to a model "\
-                  "that is not saved, or that does not exist." unless id
-            IncomingBroadcast.connect_to(channel.class.name, id)
-          end
+        elsif channel.id
+          IncomingBroadcast.connect_to(channel.class.name, channel.id)
         else
-          raise "Hyperstack.connect cannot connect to #{channel.inspect}.\n"\
-                "Channels must be either a class, or a class name,\n"\
-                "a string in the form 'ClassName-id',\n"\
-                "an array in the form [class, id] or [class-name, id],\n"\
-                "or an object that responds to the id method with a non-nil value"
+          raise "cannot connect to model before it has been saved"
         end
       end
     end
 
     def self.connect_session
-      connect(['Hyperstack::Session', ClientDrivers.opts[:id].split('-').last])
+      connect(['Hyperloop::Session', ClientDrivers.opts[:id].split('-').last])
     end
 
     def self.action_cable_consumer
@@ -84,39 +61,36 @@ module Hyperstack
 
       def self.add_connection(channel_name, id = nil)
         channel_string = "#{channel_name}#{'-'+id.to_s if id}"
-        return if open_channels.include? channel_string
         open_channels << channel_string
         channel_string
       end
 
       def self.connect_to(channel_name, id = nil)
         channel_string = add_connection(channel_name, id)
-        return unless channel_string # already connected!
         if ClientDrivers.opts[:transport] == :pusher
           channel = "#{ClientDrivers.opts[:channel]}-#{channel_string}"
           %x{
             var channel = #{ClientDrivers.opts[:pusher_api]}.subscribe(#{channel.gsub('::', '==')});
             channel.bind('dispatch', #{ClientDrivers.opts[:dispatch]})
-            channel.bind('pusher:subscription_succeeded', #{->(*) { ClientDrivers.get_queued_data("connect-to-transport", channel_string)}})
+            channel.bind('pusher:subscription_succeeded', #{lambda {ClientDrivers.get_queued_data("connect-to-transport", channel_string)}})
           }
-          @pusher_dispatcher_registered = true
         elsif ClientDrivers.opts[:transport] == :action_cable
           channel = "#{ClientDrivers.opts[:channel]}-#{channel_string}"
-          Hyperstack::HTTP.post(ClientDrivers.polling_path('action-cable-auth', channel), headers: { 'X-CSRF-Token' => ClientDrivers.opts[:form_authenticity_token] }).then do |response|
+          Hyperloop::HTTP.post(ClientDrivers.polling_path('action-cable-auth', channel), headers: { 'X-CSRF-Token' => ClientDrivers.opts[:form_authenticity_token] }).then do |response|
             %x{
               var fix_opal_0110 = 'return';
-              #{Hyperstack.action_cable_consumer}.subscriptions.create(
+              #{Hyperloop.action_cable_consumer}.subscriptions.create(
                 {
-                  channel: "Hyperstack::ActionCableChannel",
+                  channel: "Hyperloop::ActionCableChannel",
                   client_id: #{ClientDrivers.opts[:id]},
-                  hyperstack_channel: #{channel_string},
+                  hyperloop_channel: #{channel_string},
                   authorization: #{response.json[:authorization]},
                   salt: #{response.json[:salt]}
                 },
                 {
                   connected: function() {
                     if (#{ClientDrivers.env == 'development'}) { console.log("ActionCable connected to: ", channel_string); }
-                    #{ClientDrivers.complete_connection(channel_string)}
+                    #{ClientDrivers.get_queued_data("connect-to-transport", channel_string)}
                   },
                   received: function(data) {
                     if (#{ClientDrivers.env == 'development'}) { console.log("ActionCable received: ", data); }
@@ -127,14 +101,14 @@ module Hyperstack
             }
           end
         else
-          Hyperstack::HTTP.get(ClientDrivers.polling_path(:subscribe, channel_string))
+          Hyperloop::HTTP.get(ClientDrivers.polling_path(:subscribe, channel_string))
         end
       end
     end
   end
 
   class ClientDrivers
-    include Hyperstack::Component::IsomorphicHelpers
+    include React::IsomorphicHelpers
 
     def self.sync_dispatch(data)
       # TODO old synchromesh double checked at this point to make sure that this client
@@ -142,7 +116,7 @@ module Hyperstack
       data[:operation].constantize.dispatch_from_server(data[:params])
     end
 
-    # save the configuration info needed in window.HyperstackOpts
+    # save the configuration info needed in window.HyperloopOpts
 
     # we keep a list of all channels by session with connections in progress
     # for each broadcast we check the list, and add the message to a queue for that
@@ -151,51 +125,45 @@ module Hyperstack
     # will remove the session from the list.
 
     prerender_footer do |controller|
-      unless Hyperstack.transport == :none
-        if defined?(PusherFake)
-          path = ::Rails.application.routes.routes.detect do |route|
-            route.app == Hyperstack::Engine ||
-              (route.app.respond_to?(:app) && route.app.app == Hyperstack::Engine)
-          end.path.spec
-          pusher_fake_js = PusherFake.javascript(
-            auth: { headers: { 'X-CSRF-Token' => controller.send(:form_authenticity_token) } },
-            authEndpoint: "#{path}/hyperstack-pusher-auth"
-          )
-        end
-        controller.session.delete 'hyperstack-dummy-init' unless controller.session.id
-        id = "#{SecureRandom.uuid}-#{controller.session.id}"
-        auto_connections = Hyperstack::AutoConnect.channels(id, controller.acting_user) rescue []
+      next if Hyperloop.transport == :none
+      if defined?(PusherFake)
+        path = ::Rails.application.routes.routes.detect do |route|
+          route.app == Hyperloop::Engine ||
+            (route.app.respond_to?(:app) && route.app.app == Hyperloop::Engine)
+        end.path.spec
+        pusher_fake_js = PusherFake.javascript(
+          auth: { headers: { 'X-CSRF-Token' => controller.send(:form_authenticity_token) } },
+          authEndpoint: "#{path}/hyperloop-pusher-auth"
+        )
       end
+      controller.session.delete 'hyperloop-dummy-init' unless controller.session.id
+      id = "#{SecureRandom.uuid}-#{controller.session.id}"
+      auto_connections = Hyperloop::AutoConnect.channels(id, controller.acting_user)
       config_hash = {
-        transport: Hyperstack.transport,
+        transport: Hyperloop.transport,
         id: id,
-        acting_user_id: (controller.acting_user.respond_to?(:id) && controller.acting_user.id),
+        acting_user_id: (controller.acting_user && controller.acting_user.id),
         env: ::Rails.env,
-        client_logging: Hyperstack.client_logging,
+        client_logging: Hyperloop.client_logging,
         pusher_fake_js: pusher_fake_js,
-        key: Hyperstack.key,
-        cluster: Hyperstack.cluster,
-        encrypted: Hyperstack.encrypted,
-        channel: Hyperstack.channel,
+        key: Hyperloop.key,
+        cluster: Hyperloop.cluster,
+        encrypted: Hyperloop.encrypted,
+        channel: Hyperloop.channel,
         form_authenticity_token: controller.send(:form_authenticity_token),
-        seconds_between_poll: Hyperstack.seconds_between_poll,
+        seconds_between_poll: Hyperloop.seconds_between_poll,
         auto_connect:  auto_connections
       }
       path = ::Rails.application.routes.routes.detect do |route|
         # not sure why the second check is needed.  It happens in the test app
-        route.app == Hyperstack::Engine or (route.app.respond_to?(:app) and route.app.app == Hyperstack::Engine)
-      end
-      if path
-        path = path.path.spec
-        "<script type='text/javascript'>\n"\
-          "window.HyperstackEnginePath = '#{path}';\n"\
-          "window.HyperstackOpts = #{config_hash.to_json}\n"\
-        "</script>\n"
-      else
-        "<script type='text/javascript'>\n"\
-          "window.HyperstackOpts = #{config_hash.to_json}\n"\
-        "</script>\n"
+        route.app == Hyperloop::Engine or (route.app.respond_to?(:app) and route.app.app == Hyperloop::Engine)
       end
+      raise 'Hyperloop::Engine mount point not found.  Check your config/routes.rb file' unless path
+      path = path.path.spec
+      "<script type='text/javascript'>\n"\
+        "window.HyperloopEnginePath = '#{path}';\n"\
+        "window.HyperloopOpts = #{config_hash.to_json}\n"\
+      "</script>\n"
     end if RUBY_ENGINE != 'opal'
 
     class << self
@@ -213,14 +181,8 @@ module Hyperstack
       f.when_on_server { ::Rails.env }
     end
 
-    def self.complete_connection(channel, retries = 10)
-      get_queued_data('connect-to-transport', channel).fail do
-        after(0.25) { complete_connection(channel, retries - 1) } unless retries.zero?
-      end
-    end
-
     def self.get_queued_data(operation, channel = nil, opts = {})
-      Hyperstack::HTTP.get(polling_path(operation, channel), opts).then do |response|
+      Hyperloop::HTTP.get(polling_path(operation, channel), opts).then do |response|
         response.json.each do |data|
           `console.log("simple_poller received: ", data)` if ClientDrivers.env == 'development'
           sync_dispatch(data[1])
@@ -232,11 +194,11 @@ module Hyperstack
 
       if @initialized
         # 1) skip initialization if already initialized
-        if on_opal_client? && Hyperstack.action_cable_consumer
+        if on_opal_client? && Hyperloop.action_cable_consumer
           # 2) if running action_cable make sure connection is up after pinging the server_up
           #    action cable closes the connection if files change on the server
-          Hyperstack::HTTP.get("#{`window.HyperstackEnginePath`}/server_up") do
-            `#{Hyperstack.action_cable_consumer}.connection.open()` if `#{Hyperstack.action_cable_consumer}.connection.disconnected`
+          Hyperloop::HTTP.get("#{`window.HyperloopEnginePath`}/server_up") do
+            `#{Hyperloop.action_cable_consumer}.connection.open()` if `#{Hyperloop.action_cable_consumer}.connection.disconnected`
           end
         end
         return
@@ -246,12 +208,9 @@ module Hyperstack
       @opts = {}
 
       if on_opal_client?
-
-        @opts = Hash.new(`window.HyperstackOpts`)
-
-        if opts[:transport] != :none && `typeof(window.HyperstackEnginePath) == 'undefined'`
-          raise "No hyperstack mount point found!\nCheck your Rails routes.rb file";
-        end
+        
+        @opts = Hash.new(`window.HyperloopOpts`)
+        
 
         if opts[:transport] == :pusher
 
@@ -271,18 +230,18 @@ module Hyperstack
               h = {
                 encrypted: #{opts[:encrypted]},
                 cluster: #{opts[:cluster]},
-                authEndpoint: window.HyperstackEnginePath+'/hyperstack-pusher-auth',
+                authEndpoint: window.HyperloopEnginePath+'/hyperloop-pusher-auth',
                 auth: {headers: {'X-CSRF-Token': #{opts[:form_authenticity_token]}}}
               };
               pusher_api = new Pusher(#{opts[:key]}, h)
             }
             opts[:pusher_api] = pusher_api
           end
-          Hyperstack.connect(*opts[:auto_connect])
+          Hyperloop.connect(*opts[:auto_connect])
         elsif opts[:transport] == :action_cable
           opts[:action_cable_consumer] =
             `ActionCable.createConsumer.apply(ActionCable, #{[*opts[:action_cable_consumer_url]]})`
-          Hyperstack.connect(*opts[:auto_connect])
+          Hyperloop.connect(*opts[:auto_connect])
         elsif opts[:transport] == :simple_poller
           opts[:auto_connect].each { |channel| IncomingBroadcast.add_connection(*channel) }
           every(opts[:seconds_between_poll]) do
@@ -293,7 +252,7 @@ module Hyperstack
     end
 
     def self.polling_path(to, id = nil)
-      s = "#{`window.HyperstackEnginePath`}/hyperstack-#{to}/#{opts[:id]}"
+      s = "#{`window.HyperloopEnginePath`}/hyperloop-#{to}/#{opts[:id]}"
       s = "#{s}/#{id}" if id
       s
     end