litecable 0.4.2 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: bb4185917544c4f463632a1b1013df954e4e33cd
-  data.tar.gz: 03a56b7e69b7e9b5b4bd6034106790f161ef1ab8
+SHA256:
+  metadata.gz: 0f2e128a054097e5ccd19b490792950d8f8cb53f36d3c6d5c56113271e6f9bb9
+  data.tar.gz: bb9439ac1dad7d8be53173b942362eba9a3869674cd598a37a3bda9071efdeff
 SHA512:
-  metadata.gz: cedbf509d8ed3b1498ce07de93604498f8f86cba3a1655624c65aa4d0b156e2f386a58e41bbfbc0346512ee58e27b78accf78163ef56d97a9f5f6fcdef1c99e6
-  data.tar.gz: bb8b8afb66153923fbfe1a1109d6dbc63d6100dd99743e321066f1ee34a8b3809868d31a3a302bb9dd7afba775e4da03aba329dc6bdbdb1dab4ca459d3dd2a45
+  metadata.gz: 430ea53e7ebbc00b1f2df127b642235200fb55e9710813d88c4182d337d38d8202b2fac0aadae6d6119e35a612a25c77e10146c1039bba130595e5e28e4579cb
+  data.tar.gz: c31bc0b7b6fa0f33754915966bb8e16199dac3ceab604270e9df24c52b2b1b91267e5c32a1cbd5e91dfbb7b5a3f2f074649a8ec7f0d4ac13db68da5ebbe24410

data/CHANGELOG.md

@@ -1,8 +1,45 @@
 # Change log
 
+## master (unreleased)
+
+## 0.7.2 (2021-07-06)
+
+- Fixed Ruby 3.0.1 compatibility.
+
+## 0.7.1 (2021-01-06)
+
+- Fix handling client disconnection during socket write. ([@palkan][])
+
+## 0.7.0 (2020-01-07)
+
+- Refactor AnyCable integration ([@palkan][])
+
+Now you only need to set AnyCable broadcast adapter:
+
+```ruby
+LiteCable.broadcast_adapter = :any_cable
+```
+
+```sh
+# or via env/config
+LITECABLE_BROADCAST_ADAPTER=any_cable ruby my_app.rb
+```
+
+- Adapterize broadcast adapters ([@palkan][])
+
+- Drop Ruby 2.4 support ([palkan][])
+
+## 0.6.0 (2019-04-12) 🚀
+
+- Drop Ruby 2.3 support ([@palkan][])
+
+## 0.5.0 (2017-12-20)
+
+- Upgrade for AnyCable 0.5.0 ([@palkan][])
+
 ## 0.4.1 (2017-02-04)
 
-- Use `websocket-ruby` with subprotocols support ([@palkan][])
+- Use `websocket-ruby` with sub-protocols support ([@palkan][])
 
 ## 0.4.0 (2017-01-29)
 

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2017 palkan
+Copyright (c) 2017-2020 palkan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,5 +1,5 @@
-[![Gem Version](https://badge.fury.io/rb/litecable.svg)](https://rubygems.org/gems/litecable) [![Build Status](https://travis-ci.org/palkan/litecable.svg?branch=master)](https://travis-ci.org/palkan/litecable) [![Circle CI](https://circleci.com/gh/palkan/litecable/tree/master.svg?style=svg)](https://circleci.com/gh/palkan/litecable/tree/master)
-[![Dependency Status](https://dependencyci.com/github/palkan/litecable/badge)](https://dependencyci.com/github/palkan/litecable)
+[![Gem Version](https://badge.fury.io/rb/litecable.svg)](https://rubygems.org/gems/litecable)
+[![Build](https://github.com/palkan/litecable/workflows/Build/badge.svg)](https://github.com/palkan/litecable/actions)
 
 # Lite Cable
 
@@ -23,20 +23,14 @@ Compatible with [AnyCable](http://anycable.io) (for production usage).
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'litecable'
+gem "litecable"
 ```
 
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install litecable
+And run `bundle install`.
 
 ## Usage
 
-Please, checkout [Action Cable guides](http://guides.rubyonrails.org/action_cable_overview.html) for general information. Lite Cable aims to be compatible with Action Cable as much as possible without the loss of simplicity and _ligthness_.
+Please, checkout [Action Cable guides](http://guides.rubyonrails.org/action_cable_overview.html) for general information. Lite Cable aims to be compatible with Action Cable as much as possible without the loss of simplicity and _lightness_.
 
 You can use Action Cable javascript client without any change (precompiled version can be found [here](https://github.com/palkan/litecable/tree/master/examples/sinatra/assets/cable.js)).
 
@@ -74,36 +68,42 @@ To use Lite Cable server:
 
 ```ruby
 Rack::Builder.new do
-  map '/cable' do
+  map "/cable" do
     # You have to specify your app's connection class
     use LiteCable::Server::Middleware, connection_class: App::Connection
-    run proc { |_| [200, { 'Content-Type' => 'text/plain' }, ['OK']] }
+    run proc { |_| [200, {"Content-Type" => "text/plain"}, ["OK"]] }
   end
 end
 ```
 
 ### Using with AnyCable
 
-Lite Cable is AnyCable-compatible out-of-the-box. You should write a simple server script:
+Lite Cable is AnyCable-compatible out-of-the-box:
+
+- Set broadcast adapter to AnyCable:
 
 ```ruby
-#!/usr/bin/env ruby
+LiteCable.broadcast_adapter = :any_cable
+```
 
-require "my_app"
-require "rack"
-require "anycable"
+You can also do this via configuration, e.g., env var (`LITECABLE_BROADCAST_ADAPTER=any_cable`) or `broadcast_adapter: any_cable` in a YAML config.
 
-# Turn AnyCable compatibility mode
-LiteCable.anycable!
+- Configure connection factory:
 
-Anycable.configure do |config|
-  config.connection_factory = MyApp::Connection
-end
+```ruby
+AnyCable.connection_factory = MyApp::Connection
+```
+
+Then run AnyCable along with the app:
 
-Anycable::Server.start
+```sh
+bundle exec anycable
+
+# add -r option to load the app if it's not ./config/anycable.rb or ./config/environment.rb
+bundle exec anycable -r ./my_app.rb
 ```
 
-And then run this script along with your application. See [Sinatra example](https://github.com/palkan/litecable/tree/master/examples/sinatra) for more.
+See [Sinatra example](https://github.com/palkan/litecable/tree/master/examples/sinatra) for more.
 
 ### Configuration
 
@@ -123,9 +123,8 @@ See [config](https://github.com/palkan/litecable/blob/master/lib/lite_cable/conf
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/anycable/litecable.
+Bug reports and pull requests are welcome on GitHub at [https://github.com/palkan/litecable](https://github.com/palkan/litecable).
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-
+The gem is available as open source under the terms of the [MIT License](./LICENSE.txt).

data/lib/lite_cable.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "lite_cable/version"
 require "lite_cable/internal"
 require "lite_cable/logging"
@@ -14,6 +15,7 @@ module LiteCable
   require "lite_cable/channel"
   require "lite_cable/coders"
   require "lite_cable/config"
+  require "lite_cable/broadcast_adapters"
   require "lite_cable/anycable"
 
   class << self
@@ -22,8 +24,27 @@ module LiteCable
     end
 
     # Broadcast encoded message to the stream
-    def broadcast(*args)
-      LiteCable::Server.broadcast(*args)
+    def broadcast(stream, message, coder: LiteCable.config.coder)
+      broadcast_adapter.broadcast(stream, message, coder: coder)
+    end
+
+    def broadcast_adapter
+      return @broadcast_adapter if defined?(@broadcast_adapter)
+      self.broadcast_adapter = LiteCable.config.broadcast_adapter.to_sym
+      @broadcast_adapter
+    end
+
+    def broadcast_adapter=(adapter)
+      if adapter.is_a?(Symbol) || adapter.is_a?(Array)
+        adapter = BroadcastAdapters.lookup_adapter(adapter)
+      end
+
+      unless adapter.respond_to?(:broadcast)
+        raise ArgumentError, "BroadcastAdapter must implement #broadcast method. " \
+                              "#{adapter.class} doesn't implement it."
+      end
+
+      @broadcast_adapter = adapter
     end
   end
 end

data/lib/lite_cable/anycable.rb

@@ -1,20 +1,14 @@
 # frozen_string_literal: true
-module LiteCable
+
+module LiteCable # :nodoc:
   # 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)
+      def call(socket, **options)
         new(socket, **options)
       end
 
@@ -29,6 +23,7 @@ module LiteCable
           @request ||= Rack::Request.new(socket.env)
         end
 
+        # rubocop: disable Metrics/MethodLength
         def handle_channel_command(identifier, command, data)
           channel = subscriptions.add(identifier, false)
           case command
@@ -44,19 +39,33 @@ module LiteCable
             false
           end
         rescue LiteCable::Connection::Subscriptions::Error,
-               LiteCable::Channel::Error,
-               LiteCable::Channel::Registry::Error => e
+          LiteCable::Channel::Error,
+          LiteCable::Channel::Registry::Error => e
           log(:error, log_fmt("Connection command failed: #{e}"))
           close
           false
         end
+        # rubocop: enable Metrics/MethodLength
       end
     end
   end
 
-  # Patch Lite Cable  with AnyCable functionality
+  # 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
+
+if defined?(AnyCable)
+  AnyCable.configure_server do
+    # Make sure broadcast adapter is valid
+    require "lite_cable/broadcast_adapters/any_cable"
+    unless LiteCable::BroadcastAdapters::AnyCable === LiteCable.broadcast_adapter
+      raise "You should use :any_cable broadcast adapter (current: #{LiteCable.broadcast_adapter.class}). " \
+            "Set it via LITECABLE_BROADCAST_ADAPTER=any_cable or in the code/YML."
+    end
+
+    # Turn AnyCable compatibility mode for anycable RPC server automatically
+    LiteCable.anycable!
   end
 end

data/lib/lite_cable/broadcast_adapters.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "lite_cable/broadcast_adapters/base"
+
+module LiteCable
+  module BroadcastAdapters # :nodoc:
+    module_function
+
+    # rubocop: disable Metrics/AbcSize, Metrics/MethodLength
+    def lookup_adapter(args)
+      adapter, options = Array(args)
+      path_to_adapter = "lite_cable/broadcast_adapters/#{adapter}"
+      adapter_class_name = adapter.to_s.split("_").map(&:capitalize).join
+
+      unless BroadcastAdapters.const_defined?(adapter_class_name, false)
+        begin
+          require path_to_adapter
+        rescue LoadError => e
+          # We couldn't require the adapter itself.
+          if e.path == path_to_adapter
+            raise e.class, "Couldn't load the '#{adapter}' broadcast adapter for LiteCable",
+              e.backtrace
+          # Bubbled up from the adapter require.
+          else
+            raise e.class, "Error loading the '#{adapter}' broadcast adapter for LiteCable",
+              e.backtrace
+          end
+        end
+      end
+
+      BroadcastAdapters.const_get(adapter_class_name, false).new(**(options || {}))
+    end
+    # rubocop: enable Metrics/AbcSize, Metrics/MethodLength
+  end
+end

data/lib/lite_cable/broadcast_adapters/any_cable.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module LiteCable
+  module BroadcastAdapters
+    class AnyCable < Base
+      def broadcast(stream, message, coder:)
+        ::AnyCable.broadcast stream, coder.encode(message)
+      end
+    end
+  end
+end

data/lib/lite_cable/broadcast_adapters/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# frozen_string_literal: true
+
+module LiteCable
+  module BroadcastAdapters
+    class Base
+      def initialize(**options)
+        @options = options
+      end
+
+      private
+
+      attr_reader :options
+    end
+  end
+end

data/lib/lite_cable/broadcast_adapters/memory.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module LiteCable
+  module BroadcastAdapters
+    class Memory < Base
+      def broadcast(stream, message, coder:)
+        Server.subscribers_map.broadcast stream, message, coder
+      end
+    end
+  end
+end

data/lib/lite_cable/channel.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module LiteCable
   module Channel # :nodoc:
     require "lite_cable/channel/registry"

data/lib/lite_cable/channel/base.rb

@@ -1,9 +1,11 @@
 # 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.
@@ -62,7 +64,6 @@ module LiteCable
     # 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.
@@ -128,6 +129,7 @@ module LiteCable
         action = extract_action(data)
 
         raise UnproccessableActionError unless processable_action?(action)
+
         log(:debug) { log_fmt("Perform action #{action}(#{data})") }
         dispatch_action(action, data)
       end

data/lib/lite_cable/channel/registry.rb

@@ -1,15 +1,19 @@
 # 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
 
@@ -20,6 +24,7 @@ module LiteCable
         def find!(id)
           channel_class = find(id)
           raise UnknownChannelError unless channel_class
+
           channel_class
         end
 

data/lib/lite_cable/channel/streams.rb

@@ -1,6 +1,6 @@
 # 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.
@@ -28,7 +28,6 @@ module LiteCable
     #
     # 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