litecable 0.4.0

data/examples/sinatra/views/room.slim

@@ -0,0 +1,68 @@
+h2 ="Room: #{@room_id}"
+
+.messages#message_list
+
+.message-form
+  form#message_form
+    .row
+      input#message_txt type="text" required="required"
+    .row
+      button.btn type="submit"
+        span Send!
+
+javascript:
+  var roomId = #{{ @room_id }};
+  var user = "#{{ @user }}";
+  var socketId = Date.now();
+
+  var messageList = document.getElementById("message_list");
+  var messageForm = document.getElementById("message_form");
+  var textInput = document.getElementById("message_txt");
+
+  messageForm.onsubmit = function(e){
+    e.preventDefault();
+    var msg = textInput.value;
+    console.log("Send message", msg);
+    textInput.value = null;
+    chatChannel.perform('speak', { message: msg });
+  };
+
+  var escape = function(str) {
+    return ('' + str).replace(/&/g, '&')
+                     .replace(/</g, '&lt;')
+                     .replace(/>/g, '&gt;')
+                     .replace(/"/g, '&quot;');
+  }
+
+  var addMessage = function(data){
+    var node = document.createElement('div');
+    var me = data['user'] == user && data['sid'] == socketId
+    node.className = "message" + (me ? ' me' : '') + (data['system'] ? ' system' : '');
+    node.innerHTML =
+      '<div class="author">' + escape(data['user']) + '</div>' +
+      '<div class="txt">' + escape(data['message']) + '</div>';
+    messageList.appendChild(node);
+  };
+
+  ActionCable.startDebugging();
+  var cable = ActionCable.createConsumer('#{{ CABLE_URL }}?sid=' + socketId);
+
+  var chatChannel = cable.subscriptions.create(
+    { channel: 'chat', id: roomId },
+    {
+      connected: function(){
+        console.log("Connected");
+        addMessage({ user: 'BOT', message: "I'm connected", system: true });
+      },
+
+      disconnected: function(){
+        console.log("Connected");
+        addMessage({ user: 'BOT', message: "Sorry, but you've been disconnected(", system: true });
+      },
+
+      received: function(data){
+        console.log("Received", data);
+        addMessage(data);
+      }
+    }
+  )

data/lib/lite_cable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require "lite_cable/version"
+require "lite_cable/internal"
+require "lite_cable/logging"
+
+# Lightwieght ActionCable implementation.
+#
+# Contains application logic (channels, streams, broadcasting) and
+# also (optional) Rack hijack based server (suitable only for development and test).
+#
+# Compatible with AnyCable (for production usage).
+module LiteCable
+  require "lite_cable/connection"
+  require "lite_cable/channel"
+  require "lite_cable/coders"
+  require "lite_cable/config"
+  require "lite_cable/anycable"
+
+  class << self
+    def config
+      @config ||= Config.new
+    end
+
+    # Broadcast encoded message to the stream
+    def broadcast(*args)
+      LiteCable::Server.broadcast(*args)
+    end
+  end
+end

data/lib/lite_cable/anycable.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+module LiteCable
+  # AnyCable extensions
+  module AnyCable
+    module Broadcasting # :nodoc:
+      def broadcast(stream, message, coder: nil)
+        coder ||= LiteCable.config.coder
+        Anycable.broadcast stream, coder.encode(message)
+      end
+    end
+
+    module Connection # :nodoc:
+      def self.extended(base)
+        base.prepend InstanceMethods
+      end
+
+      def create(socket, **options)
+        new(socket, **options)
+      end
+
+      module InstanceMethods # :nodoc:
+        def initialize(socket, subscriptions: nil, **hargs)
+          super(socket, **hargs)
+          # Initialize channels if any
+          subscriptions&.each { |id| @subscriptions.add(id, false) }
+        end
+
+        def request
+          @request ||= Rack::Request.new(socket.env)
+        end
+
+        def handle_channel_command(identifier, command, data)
+          channel = subscriptions.add(identifier, false)
+          case command
+          when "subscribe"
+            !subscriptions.send(:subscribe_channel, channel).nil?
+          when "unsubscribe"
+            subscriptions.remove(identifier)
+            true
+          when "message"
+            subscriptions.perform_action identifier, data
+            true
+          else
+            false
+          end
+        rescue LiteCable::Connection::Subscriptions::Error,
+               LiteCable::Channel::Error,
+               LiteCable::Channel::Registry::Error => e
+          log(:error, log_fmt("Connection command failed: #{e}"))
+          close
+          false
+        end
+      end
+    end
+  end
+
+  # Patch Lite Cable  with AnyCable functionality
+  def self.anycable!
+    LiteCable::Connection::Base.extend LiteCable::AnyCable::Connection
+    LiteCable.singleton_class.prepend LiteCable::AnyCable::Broadcasting
+  end
+end

data/lib/lite_cable/channel.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module LiteCable
+  module Channel # :nodoc:
+    require "lite_cable/channel/registry"
+    require "lite_cable/channel/streams"
+    require "lite_cable/channel/base"
+  end
+end

data/lib/lite_cable/channel/base.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+module LiteCable
+  # rubocop:disable Metrics/LineLength
+  module Channel
+    class Error < StandardError; end
+    class RejectedError < Error; end
+    class UnproccessableActionError < Error; end
+
+    # The channel provides the basic structure of grouping behavior into logical units when communicating over the connection.
+    # You can think of a channel like a form of controller, but one that's capable of pushing content to the subscriber in addition to simply
+    # responding to the subscriber's direct requests.
+    #
+    # == Identification
+    #
+    # Each channel must have a unique identifier, which is used by the connection to resolve the channel's class.
+    #
+    # Example:
+    #
+    #  class SecretChannel < LiteCable::Channel::Base
+    #    identifier 'my_super_secret_channel'
+    #  end
+    #
+    #  # client-side
+    #  App.cable.subscriptions.create('my_super_secret_channel')
+    #
+    # == Action processing
+    #
+    # You can declare any public method on the channel (optionally taking a `data` argument),
+    # and this method is automatically exposed as callable to the client.
+    #
+    # Example:
+    #
+    #   class AppearanceChannel < LiteCable::Channel::Base
+    #     def unsubscribed
+    #       # here `current_user` is a connection identifier
+    #       current_user.disappear
+    #     end
+    #
+    #     def appear(data)
+    #       current_user.appear on: data['appearing_on']
+    #     end
+    #
+    #     def away
+    #       current_user.away
+    #     end
+    #   end
+    #
+    # == Rejecting subscription requests
+    #
+    # A channel can reject a subscription request in the #subscribed callback by
+    # invoking the #reject method:
+    #
+    #   class ChatChannel < ApplicationCable::Channel
+    #     def subscribed
+    #       room = Chat::Room[params['room_number']]
+    #       reject unless current_user.can_access?(room)
+    #     end
+    #   end
+    #
+    # In this example, the subscription will be rejected if the
+    # <tt>current_user</tt> does not have access to the chat room. On the
+    # client-side, the <tt>Channel#rejected</tt> callback will get invoked when
+    # the server rejects the subscription request.
+    class Base
+      # rubocop:enable Metrics/LineLength
+      class << self
+        # A set of method names that should be considered actions.
+        # This includes all public instance methods on a channel except from Channel::Base methods.
+        def action_methods
+          @action_methods ||= begin
+            # All public instance methods of this class, including ancestors
+            methods = (public_instance_methods(true) -
+              # Except for public instance methods of Base and its ancestors
+              LiteCable::Channel::Base.public_instance_methods(true) +
+              # Be sure to include shadowed public instance methods of this class
+              public_instance_methods(false)).uniq.map(&:to_s)
+            methods.to_set
+          end
+        end
+
+        attr_reader :id
+
+        # Register the channel by its unique identifier
+        # (in order to resolve the channel's class for connections)
+        def identifier(id)
+          Registry.add(id.to_s, self)
+          @id = id
+        end
+      end
+
+      include Logging
+      prepend Streams
+
+      attr_reader :connection, :identifier, :params
+
+      def initialize(connection, identifier, params)
+        @connection = connection
+        @identifier = identifier
+        @params = params.freeze
+
+        delegate_connection_identifiers
+      end
+
+      def handle_subscribe
+        subscribed if respond_to?(:subscribed)
+      end
+
+      def handle_unsubscribe
+        unsubscribed if respond_to?(:unsubscribed)
+      end
+
+      def handle_action(encoded_message)
+        perform_action connection.coder.decode(encoded_message)
+      end
+
+      protected
+
+      def reject
+        raise RejectedError
+      end
+
+      def transmit(data)
+        connection.transmit identifier: identifier, message: data
+      end
+
+      # Extract the action name from the passed data and process it via the channel.
+      def perform_action(data)
+        action = extract_action(data)
+
+        raise UnproccessableActionError unless processable_action?(action)
+        log(:debug) { log_fmt("Perform action #{action}(#{data})") }
+        dispatch_action(action, data)
+      end
+
+      def dispatch_action(action, data)
+        if method(action).arity == 1
+          public_send action, data
+        else
+          public_send action
+        end
+      end
+
+      def extract_action(data)
+        data.delete("action") || "receive"
+      end
+
+      def processable_action?(action)
+        self.class.action_methods.include?(action)
+      end
+
+      def delegate_connection_identifiers
+        connection.identifiers.each do |identifier|
+          define_singleton_method(identifier) do
+            connection.send(identifier)
+          end
+        end
+      end
+
+      # Add prefix to channel log messages
+      def log_fmt(msg)
+        "[connection:#{connection.identifier}] [channel:#{self.class.id}] #{msg}"
+      end
+    end
+  end
+end

data/lib/lite_cable/channel/registry.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module LiteCable
+  module Channel
+    # Stores channels identifiers and corresponding classes.
+    module Registry
+      class Error < StandardError; end
+      class AlreadyRegisteredError < Error; end
+      class UnknownChannelError < Error; end
+
+      class << self
+        def add(id, channel_class)
+          raise AlreadyRegisteredError if find(id)
+          channels[id] = channel_class
+        end
+
+        def find(id)
+          channels[id]
+        end
+
+        def find!(id)
+          channel_class = find(id)
+          raise UnknownChannelError unless channel_class
+          channel_class
+        end
+
+        private
+
+        def channels
+          @channels ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/lite_cable/channel/streams.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module LiteCable
+  # rubocop:disable Metrics/LineLength
+  module Channel
+    # Streams allow channels to route broadcastings to the subscriber. A broadcasting is a pubsub queue where any data
+    # placed into it is automatically sent to the clients that are connected at that time.
+
+    # Most commonly, the streamed broadcast is sent straight to the subscriber on the client-side. The channel just acts as a connector between
+    # the two parties (the broadcaster and the channel subscriber). Here's an example of a channel that allows subscribers to get all new
+    # comments on a given page:
+    #
+    #   class CommentsChannel < ApplicationCable::Channel
+    #     def follow(data)
+    #       stream_from "comments_for_#{data['recording_id']}"
+    #     end
+    #
+    #     def unfollow
+    #       stop_all_streams
+    #     end
+    #   end
+    #
+    # Based on the above example, the subscribers of this channel will get whatever data is put into the,
+    # let's say, `comments_for_45` broadcasting as soon as it's put there.
+    #
+    # An example broadcasting for this channel looks like so:
+    #
+    #   LiteCable.server.broadcast "comments_for_45", author: 'Donald Duck', content: 'Quack-quack-quack'
+    #
+    # You can stop streaming from all broadcasts by calling #stop_all_streams or use #stop_from to stop streaming broadcasts from the specified stream.
+    module Streams
+      # rubocop:enable Metrics/LineLength
+      def handle_unsubscribe
+        stop_all_streams
+        super
+      end
+
+      # Start streaming from the named broadcasting pubsub queue.
+      def stream_from(broadcasting)
+        log(:debug) { log_fmt("Stream from #{broadcasting}") }
+        connection.streams.add(identifier, broadcasting)
+      end
+
+      # Stop streaming from the named broadcasting pubsub queue.
+      def stop_stream(broadcasting)
+        log(:debug) { log_fmt("Stop stream from #{broadcasting}") }
+        connection.streams.remove(identifier, broadcasting)
+      end
+
+      # Unsubscribes all streams associated with this channel from the pubsub queue.
+      def stop_all_streams
+        log(:debug) { log_fmt("Stop all streams") }
+        connection.streams.remove_all(identifier)
+      end
+    end
+  end
+end

data/lib/lite_cable/coders.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module LiteCable
+  module Coders # :nodoc:
+    require "lite_cable/coders/raw"
+    require "lite_cable/coders/json"
+  end
+end

data/lib/lite_cable/coders/json.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+require "json"
+
+module LiteCable
+  module Coders
+    # Wrapper over JSON
+    module JSON
+      class << self
+        def decode(json_str)
+          ::JSON.parse(json_str)
+        end
+
+        def encode(ruby_obj)
+          ruby_obj.to_json
+        end
+      end
+    end
+  end
+end