isomorfeus-transport 1.0.0.zeta23 → 2.0.0.rc2

data/lib/lucid_authentication/mixin.rb

@@ -1,124 +1,122 @@
-module LucidAuthentication
-  module Mixin
-    def anonymous?
-      self.class == Anonymous
-    end
-
-    if RUBY_ENGINE == 'opal'
-      def self.included(base)
-        base.instance_exec do
-          def execute_login(&block)
-          end
-
-          def promise_login(user: nil, pass: nil, scheme: :isomorfeus, &block)
-            send("promise_authentication_with_#{scheme}", user: user, pass: pass, &block)
-          end
-
-          def promise_authentication_with_isomorfeus(user: nil, pass: nil, &block)
-            if Isomorfeus.production?
-              Isomorfeus.raise_error(message: "Connection not secure, can't login") unless Isomorfeus::Transport.socket.url.start_with?('wss:')
-            else
-              `console.warn("Connection not secure, ensure a secure connection in production, otherwise login will fail!")` unless Isomorfeus::Transport.socket.url.start_with?('wss:')
-            end
-            Isomorfeus::Transport.promise_send_path('Isomorfeus::Transport::Handler::AuthenticationHandler', 'login', self.name, user, pass).then do |agent|
-              if agent.processed
-                agent.result
-              else
-                agent.processed = true
-                if agent.response.key?(:success)
-                  Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.response[:data])
-                  class_name = agent.response[:data].keys.first
-                  key = agent.response[:data][class_name].keys.first
-                  logged_in_user = Isomorfeus.cached_data_class(class_name).new(key: key)
-                  cookie_accessor = agent.response[:session_cookie_accessor]
-                  begin
-                    target = if block_given?
-                               block.call(logged_in_user)
-                             else
-                               `window.location.pathname`
-                             end
-                    unless target.class == String && target.start_with?('/')
-                      Isomorfeus.raise_error(message: "A path must be returned as string starting with '/', returned was #{target}!")
-                    end
-                  rescue
-                    target = `window.location.pathname`
-                  end
-                  cookie_query = "#{Isomorfeus.cookie_eater_path}?#{cookie_accessor}=#{target}"
-                  `window.location = cookie_query` # doing page load and redirect
-                  nil
-                else
-                  error = agent.response[:error]
-                  `console.err(error)` if error
-                  Isomorfeus.raise_error(message: 'Login failed!') # triggers .fail
-                end
-              end
-            end
-          end
-        end
-      end
-
-      def promise_logout(scheme: :isomorfeus)
-        send("promise_deauthentication_with_#{scheme}")
-      end
-
-      def promise_deauthentication_with_isomorfeus
-        Isomorfeus::Transport.promise_send_path('Isomorfeus::Transport::Handler::AuthenticationHandler', 'logout', 'logout').then do |agent|
-          `document.cookie = "session="`
-          Isomorfeus.set_current_user(nil)
-          Isomorfeus.force_init_store!
-          agent.processed = true
-          agent.response.key?(:success) ? true : raise('Logout failed!')
-        end
-      end
-    else
-      def self.included(base)
-        Isomorfeus.add_valid_user_class(base)
-
-        base.instance_exec do
-          def execute_login(&block)
-            @execute_login_block = block
-          end
-
-          def promise_login(user: nil, pass: nil, scheme: :isomorfeus, &block)
-            send("promise_authentication_with_#{scheme}", user: user, pass: pass, &block)
-          end
-
-          def promise_authentication_with_isomorfeus(user: nil, pass: nil, &block)
-            promise_or_user = @execute_login_block.call(user: user, pass: pass)
-            if promise_or_user.class == Promise
-              if block_given?
-                promise_or_user.then do |user|
-                  block.call(user)
-                  user
-                end
-              else
-                promise_or_user
-              end
-            else
-              block.call(user) if block_given?
-              Promise.new.resolve(promise_or_user)
-            end
-          end
-        end
-      end
-
-      def encrypt_password(password, password_confirmation)
-        raise "Password and confirmation don't match!" unless password == password_confirmation
-        BCrypt::Password.create(password).to_s
-      end
-
-      def passwords_match?(encrypted_password, given_password)
-        bcrypt_pass = BCrypt::Password.new(encrypted_password)
-        bcrypt_pass == given_password
-      end
-
-      def promise_logout(scheme: :isomorfeus)
-        send("promise_deauthentication_with_#{scheme}")
-      end
-
-      def promise_deauthentication_with_isomorfeus
-        Promise.new.resolve(true)
-      end
-    end
-  end
-end
+module LucidAuthentication
+  module Mixin
+    def anonymous?
+      self.class == Anonymous
+    end
+
+    if RUBY_ENGINE == 'opal'
+      def self.included(base)
+        base.instance_exec do
+          def execute_login(&block)
+          end
+
+          def promise_login(user: nil, pass: nil, scheme: :isomorfeus, &block)
+            send("promise_authentication_with_#{scheme}", user: user, pass: pass, &block)
+          end
+
+          def promise_authentication_with_isomorfeus(user: nil, pass: nil, &block)
+            if Isomorfeus.production?
+              Isomorfeus.raise_error(message: "Connection not secure, can't login!") unless Isomorfeus::Transport.socket.url.start_with?('wss:')
+            else
+              `console.warn("Connection not secure, ensure a secure connection in production, otherwise login will fail!")` unless Isomorfeus::Transport.socket.url.start_with?('wss:')
+            end
+            Isomorfeus::Transport.promise_send_path('Isomorfeus::Transport::Handler::AuthenticationHandler', 'login', self.name, user, pass).then do |agent|
+              if agent.processed
+                agent.result
+              else
+                agent.processed = true
+                if agent.response.key?(:success)
+                  Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.response[:data])
+                  class_name = agent.response[:data].keys.first
+                  key = agent.response[:data][class_name].keys.first
+                  logged_in_user = Isomorfeus.cached_data_class(class_name).new(key: key)
+                  cookie_accessor = agent.response[:session_cookie_accessor]
+                  begin
+                    target = if block_given?
+                               block.call(logged_in_user)
+                             else
+                               `window.location.pathname`
+                             end
+                    unless target.class == String && target.start_with?('/')
+                      Isomorfeus.raise_error(message: "A path must be returned as string starting with '/', returned was #{target}!")
+                    end
+                  rescue
+                    target = `window.location.pathname`
+                  end
+                  cookie_query = "#{Isomorfeus.cookie_eater_path}?#{cookie_accessor}=#{target}"
+                  `window.location = cookie_query` # doing page load and redirect
+                  nil
+                else
+                  Isomorfeus.raise_error(message: "Login failed with '#{agent.response[:error]}'!") # triggers .fail
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def promise_logout(scheme: :isomorfeus)
+        send("promise_deauthentication_with_#{scheme}")
+      end
+
+      def promise_deauthentication_with_isomorfeus
+        Isomorfeus::Transport.promise_send_path('Isomorfeus::Transport::Handler::AuthenticationHandler', 'logout', 'logout').then do |agent|
+          `document.cookie = "session="`
+          Isomorfeus.set_current_user(nil)
+          Isomorfeus.force_init_store!
+          agent.processed = true
+          agent.response.key?(:success) ? true : raise('Logout failed!')
+        end
+      end
+    else
+      def self.included(base)
+        Isomorfeus.add_valid_user_class(base)
+
+        base.instance_exec do
+          def execute_login(&block)
+            @execute_login_block = block
+          end
+
+          def promise_login(user: nil, pass: nil, scheme: :isomorfeus, &block)
+            send("promise_authentication_with_#{scheme}", user: user, pass: pass, &block)
+          end
+
+          def promise_authentication_with_isomorfeus(user: nil, pass: nil, &block)
+            promise_or_user = @execute_login_block.call(user: user, pass: pass)
+            if promise_or_user.class == Promise
+              if block_given?
+                promise_or_user.then do |user|
+                  block.call(user)
+                  user
+                end
+              else
+                promise_or_user
+              end
+            else
+              block.call(user) if block_given?
+              Promise.new.resolve(promise_or_user)
+            end
+          end
+        end
+      end
+
+      def encrypt_password(password, password_confirmation)
+        raise "Password and confirmation don't match!" unless password == password_confirmation
+        BCrypt::Password.create(password).to_s
+      end
+
+      def passwords_match?(encrypted_password, given_password)
+        bcrypt_pass = BCrypt::Password.new(encrypted_password)
+        bcrypt_pass == given_password
+      end
+
+      def promise_logout(scheme: :isomorfeus)
+        send("promise_deauthentication_with_#{scheme}")
+      end
+
+      def promise_deauthentication_with_isomorfeus
+        Promise.new.resolve(true)
+      end
+    end
+  end
+end

data/lib/lucid_channel/base.rb

@@ -1,11 +1,8 @@
-module LucidChannel
-  class Base
-    if RUBY_ENGINE != 'opal'
-      def self.inherited(base)
-        Isomorfeus.add_valid_channel_class(base)
-      end
-    end
-
-    include LucidChannel::Mixin
-  end
-end
+module LucidChannel
+  class Base
+    def self.inherited(base)
+      base.include LucidChannel::Mixin
+      Isomorfeus.add_valid_channel_class(base)
+    end
+  end
+end

data/lib/lucid_channel/mixin.rb

@@ -1,50 +1,105 @@
-module LucidChannel
-  module Mixin
-    def self.included(base)
-
-      if RUBY_ENGINE != 'opal'
-        Isomorfeus.add_valid_channel_class(base) unless base == LucidChannel::Base
-      end
-
-      base.instance_exec do
-        def process_message(channel, message = nil)
-          if @message_processor
-            if channel == self.name
-              @message_processor.call(message)
-            else
-              @message_processor.call(channel, message)
-            end
-          else
-            puts "#{self} received: #{channel} #{message}, but no 'on_message' block defined!"
-          end
-        end
-
-        def on_message(&block)
-          @message_processor = block
-        end
-
-        def send_message(channel, message = nil)
-          unless message
-            message = channel
-            channel = self.name
-          end
-          Isomorfeus::Transport.send_notification(self, channel, message)
-        end
-
-        def subscribe(channel = nil)
-          channel = channel ? channel : self.name
-          Isomorfeus::Transport.subscribe(self, channel)
-        end
-
-        def unsubscribe(channel = nil)
-          channel = channel ? channel : self.name
-          Isomorfeus::Transport.unsubscribe(self, channel)
-        end
-
-        def current_user
-          Isomorfeus.current_user
-        end
-      end
-    end
-  end
-end
+module LucidChannel
+  module Mixin
+    def self.included(base)
+      Isomorfeus.add_valid_channel_class(base) unless base == LucidChannel::Base
+
+      base.instance_exec do
+        def subscription_channels
+          @subscription_channels ||= {}
+        end
+
+        def channel(name, options = {})
+          subscription_channels[name.to_s] = options
+        end
+
+        def valid_channel?(name)
+          name = name.to_s
+          subscription_channels.key?(name) || name == self.name
+        end
+
+        def process_message(message, error, channel = nil)
+          channel = self.name unless channel
+          channel = channel.to_s
+          unless valid_channel?(channel)
+            Isomorfeus.raise_error(message: "No such channel '#{channel}' declared for #{self.name}! Cannot process message")
+          end
+          block = subscription_channels[channel][:block]
+          Isomorfeus.raise_error(message: "#{self} received: #{channel} #{message}, but no 'on_message' block defined!") unless block
+          block.call(message, error)
+          nil
+        end
+
+        def on_message(channel = nil, &block)
+          channel = self.name unless channel
+          channel = channel.to_s
+          unless valid_channel?(channel)
+            Isomorfeus.raise_error(message: "No such channel #{channel} declared, please declare it first!")
+          end
+          subscription_channels[channel] = {} unless subscription_channels.key?(channel)
+          subscription_channels[channel][:block] = block
+        end
+
+        def send_message(message, channel = nil)
+          channel = self.name unless channel
+          unless valid_channel?(channel)
+            Isomorfeus.raise_error(message: "No such channel '#{channel}' declared for #{self.name}! Cannot send message")
+          end
+          Isomorfeus::Transport.send_message(self, channel, message)
+        end
+
+        def subscribe(channel = nil)
+          promise_subscribe(channel)
+          nil
+        end
+
+        def promise_subscribe(channel = nil)
+          channel = channel ? channel : self.name
+          Isomorfeus::Transport.promise_subscribe(self.name, channel)
+        end
+
+        def unsubscribe(channel = nil)
+          promise_unsubscribe(channel)
+          nil
+        end
+
+        def promise_unsubscribe(channel = nil)
+          channel = channel ? channel : self.name
+          Isomorfeus::Transport.promise_unsubscribe(self.name, channel)
+        end
+
+        if RUBY_ENGINE == 'opal'
+          def server_subscription_channels; end
+          def server_process_message(message, channel = nil); end
+          def server_on_message(channel = nil, &block); end
+        else
+          def server_is_processing_messages?(channel)
+            return false if server_subscription_channels.empty?
+            return true if server_subscription_channels.key?(channel) && server_subscription_channels[channel].key?(:block)
+            false
+          end
+
+          def server_subscription_channels
+            @server_subscription_channels ||= {}
+          end
+
+          def server_process_message(message, channel = nil)
+            channel = self.name unless channel
+            channel = channel.to_s
+            block = server_subscription_channels[channel][:block]
+            block.call(message)
+          end
+
+          def server_on_message(channel = nil, &block)
+            channel = self.name unless channel
+            channel = channel.to_s
+            unless valid_channel?(channel)
+              Isomorfeus.raise_error(message: "No such channel #{channel} declared, please declare it first!")
+            end
+            server_subscription_channels[channel] = {} unless server_subscription_channels.key?(channel)
+            server_subscription_channels[channel][:block] = block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lucid_handler/base.rb

@@ -1,9 +1,8 @@
-module LucidHandler
-  class Base
-    def self.inherited(base)
-      Isomorfeus.add_valid_handler_class(base)
-    end
-
-    include LucidHandler::Mixin
-  end
-end
+module LucidHandler
+  class Base
+    def self.inherited(base)
+      base.include LucidHandler::Mixin
+      Isomorfeus.add_valid_handler_class(base)
+    end
+  end
+end

data/lib/lucid_handler/mixin.rb

@@ -1,27 +1,27 @@
-module LucidHandler
-  module Mixin
-    def self.included(base)
-      Isomorfeus.add_valid_handler_class(base) unless base == LucidHandler::Base
-
-      base.instance_exec do
-        def on_request(&block)
-          define_method :process_request do |*args|
-            instance_exec(*args, &block)
-          end
-        end
-      end
-    end
-
-    def resolving?
-      false
-    end
-
-    def current_user
-      Isomorfeus.current_user
-    end
-
-    def pub_sub_client
-      Isomorfeus.pub_sub_client
-    end
-  end
-end
+module LucidHandler
+  module Mixin
+    def self.included(base)
+      Isomorfeus.add_valid_handler_class(base) unless base == LucidHandler::Base
+
+      base.instance_exec do
+        def on_request(&block)
+          define_method :process_request do |*args|
+            instance_exec(*args, &block)
+          end
+        end
+      end
+    end
+
+    def resolving?
+      false
+    end
+
+    def current_user
+      Isomorfeus.current_user
+    end
+
+    def pub_sub_client
+      Isomorfeus.pub_sub_client
+    end
+  end
+end

data/node_modules/.package-lock.json

@@ -0,0 +1,27 @@
+{
+  "name": "isomorfeus-transport",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "node_modules/ws": {
+      "version": "8.2.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.2.1.tgz",
+      "integrity": "sha512-XkgWpJU3sHU7gX8f13NqTn6KQ85bd1WU7noBHTT8fSohx7OS1TPY8k+cyRPCzFkia7C4mM229yeHr1qK9sM4JQ==",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": "^5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

data/node_modules/ws/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.