y-rb_actioncable 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4f5ed9889a1aa6f7fbb3aeaa6d41342a595aa3ca603f654ada833973e656985c
+  data.tar.gz: e019eeda236b1260b0b68d1fb375ce82b91a58be48ffec5f040d4b62b268d119
+SHA512:
+  metadata.gz: '0231899eca54164befbd7d6bd7d151058e57f388ff45e4b126827c45e6b7bdca6ca103a4f3c63ce95d3bf2452b2c09319d8bbb731b9356639e5a783212377e12'
+  data.tar.gz: 424848bdee2d1658227871c4cbf72aa6d6ddcd30b759108a8f3d9a75c9b80447d23300ff7153091940b566ef8e4896cd38f07272e9fdf0b640433b22806d7cbf

data/README.md

@@ -0,0 +1,28 @@
+# yrb-actioncable
+
+> An ActionCable companion for Y.js clients
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "y-rb_actioncable"
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install y-rb_actioncable
+```
+
+## License
+
+The gem is available as *open source* under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+
+load "rails/tasks/engine.rake"
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+
+begin
+  require "rspec/core"
+  require "rspec/core/rake_task"
+
+  desc "Run all specs in spec directory (excluding plugin specs)"
+  RSpec::Core::RakeTask.new(spec: "app:db:test:prepare")
+
+  task test: :spec
+  task default: %i[test]
+rescue LoadError
+  # Ok
+end
+
+begin
+  require "rubocop/rake_task"
+
+  RuboCop::RakeTask.new
+rescue LoadError
+  # Ok
+end
+
+begin
+  require "yard"
+
+  YARD::Rake::YardocTask.new
+
+  task docs: :environment do
+    `yard server --reload`
+  end
+rescue LoadError
+  # Ok
+end
+
+namespace :app do
+  task template: "app:app:template"
+end

data/app/assets/config/yrb_actioncable_manifest.js

@@ -0,0 +1 @@
+//= link_directory ../stylesheets/yrb/actioncable .css

data/app/assets/stylesheets/yrb/actioncable/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/helpers/yrb/actioncable/application_helper.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Y
+  module Actioncable
+    module ApplicationHelper
+    end
+  end
+end

data/app/jobs/yrb/actioncable/application_job.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Y
+  module Actioncable
+    class ApplicationJob < ActiveJob::Base
+    end
+  end
+end

data/app/models/yrb/actioncable/application_record.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Y
+  module Actioncable
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

data/lib/tasks/yrb/actioncable_tasks.rake

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+# desc "Explaining what the task does"
+# task :yrb_actioncable do
+#   # Task goes here
+# end

data/lib/y/actioncable/config/abstract_builder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Y
+  module Actioncable
+    class Config
+      # Abstract base class for y-rb_actioncable and it's extensions
+      # configuration builder. Instantiates and validates gem configuration.
+      class AbstractBuilder
+        attr_reader :config
+
+        # @param [Class] config class
+        #
+        def initialize(config = Config.new, &block)
+          @config = config
+          instance_eval(&block)
+        end
+
+        # Builds and validates configuration.
+        #
+        # @return [Y::Actioncable::Config] config instance
+        #
+        def build
+          @config.validate! if @config.respond_to?(:validate!)
+          @config
+        end
+      end
+    end
+  end
+end

data/lib/y/actioncable/config/option.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Y
+  module Actioncable
+    class Config
+      # Configuration option DSL
+      module Option
+        # Defines configuration option
+        #
+        # When you call option, it defines two methods. One method will take place
+        # in the +Config+ class and the other method will take place in the
+        # +Builder+ class.
+        #
+        # The +name+ parameter will set both builder method and config attribute.
+        # If the +:as+ option is defined, the builder method will be the specified
+        # option while the config attribute will be the +name+ parameter.
+        #
+        # If you want to introduce another level of config DSL you can
+        # define +builder_class+ parameter.
+        # Builder should take a block as the initializer parameter and respond to function +build+
+        # that returns the value of the config attribute.
+        #
+        # ==== Options
+        #
+        # * [:+as+] Set the builder method that goes inside +configure+ block
+        # * [+:default+] The default value in case no option was set
+        # * [+:builder_class+] Configuration option builder class
+        #
+        # ==== Examples
+        #
+        #    option :name
+        #    option :name, as: :set_name
+        #    option :name, default: 'My Name'
+        #    option :scopes builder_class: ScopesBuilder
+        #
+        def option(name, options = {}) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+          attribute = options[:as] || name
+          attribute_builder = options[:builder_class]
+
+          builder_class.instance_eval do
+            if method_defined?(name)
+              Kernel.warn "[ISORUN] Option #{name} already defined and will be overridden"
+              remove_method name
+            end
+
+            define_method name do |*args, &block| # rubocop:disable Metrics/MethodLength
+              if (deprecation_opts = options[:deprecated])
+                warning = "[ISORUN] #{name} has been deprecated and will soon be removed"
+                warning = "#{warning}\n#{deprecation_opts.fetch(:message)}" if deprecation_opts.is_a?(Hash)
+
+                Kernel.warn(warning)
+              end
+
+              value = if attribute_builder
+                        attribute_builder.new(&block).build
+                      else
+                        block || args.first
+                      end
+
+              @config.instance_variable_set(:"@#{attribute}", value)
+            end
+          end
+
+          define_method attribute do |*_args|
+            if instance_variable_defined?(:"@#{attribute}")
+              instance_variable_get(:"@#{attribute}")
+            else
+              options[:default]
+            end
+          end
+
+          public attribute
+        end
+
+        def self.extended(base)
+          return if base.respond_to?(:builder_class)
+
+          raise Y::Actioncable::MissingConfigurationBuilderClass,
+                "Define `self.builder_class` method for #{base} that returns " \
+                "your custom Builder class to use options DSL!"
+        end
+      end
+    end
+  end
+end

data/lib/y/actioncable/config/validations.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Y
+  module Actioncable
+    class Config
+      # Configuration validator
+      module Validations
+        # Validates configuration options to be set properly.
+        def validate!; end
+      end
+    end
+  end
+end

data/lib/y/actioncable/config.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "y/actioncable/config/abstract_builder"
+require "y/actioncable/config/option"
+require "y/actioncable/config/validations"
+
+# inspired by https://github.com/doorkeeper-gem/doorkeeper/blob/main/lib/doorkeeper/config.rb
+module Y
+  module Actioncable
+    class MissingConfiguration < StandardError
+      def initialize
+        super("Configuration for y-rb_actioncable is missing. " \
+              "Do you have an initializer?")
+      end
+    end
+
+    class MissingConfigurationBuilderClass < StandardError; end
+
+    class << self
+      def configure(&block)
+        @config = Config::Builder.new(&block).build
+      end
+
+      def configuration
+        @config || (raise MissingConfiguration)
+      end
+
+      alias config configuration
+    end
+
+    class Config
+      class Builder < AbstractBuilder
+      end
+
+      # Replace with `default: Builder` when we drop support of Rails < 5.2
+      mattr_reader(:builder_class) { Builder }
+
+      extend Option
+      include Validations
+
+      option :redis, default: lambda {
+        raise "A Redis client must be configured at initialization time"
+      }
+    end
+  end
+end

data/lib/y/actioncable/engine.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Y
+  module Actioncable
+    class Engine < ::Rails::Engine
+      isolate_namespace Y::Actioncable
+
+      config.generators do |g|
+        g.test_framework :rspec
+        g.assets false
+        g.helper false
+      end
+    end
+  end
+end

data/lib/y/actioncable/reliable.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Y
+  module Actioncable
+    module Reliable # rubocop:disable Metrics/ModuleLength
+      extend ActiveSupport::Concern
+
+      KEY_PREFIX = "reliable_stream"
+      STREAM_INACTIVE_TIMEOUT = 1.hour
+      USER_INACTIVE_TIMEOUT = 15.minutes
+      LAST_ID_FIELD = "last_id"
+      CLOCK_FIELD = "clock"
+
+      private_constant(
+        :KEY_PREFIX,
+        :STREAM_INACTIVE_TIMEOUT,
+        :USER_INACTIVE_TIMEOUT,
+        :LAST_ID_FIELD
+      )
+
+      included do
+        unless method_defined? :current_user
+          raise "`current_user` is not defined. A ReliableChannel requires " \
+                "current_user to be an instance of a `User` model."
+        end
+      end
+
+      class_methods do
+        attr_reader :registered_reliable_actions
+
+        def reliable_broadcast(method) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          method_name = if method.is_a? Symbol
+                          method.to_s
+                        else
+                          method
+                        end
+          method_sym = method_name.to_sym
+
+          @registered_reliable_actions ||= Set.new
+          @registered_reliable_actions.add(method_name)
+
+          # broadcast received data to all clients
+          define_method method_sym do |data| # rubocop:disable Metrics/MethodLength
+            key = stream_key(method_name)
+
+            # add new entry to stream
+            last_id = with_redis do |redis|
+              redis.xadd(key, { data: data[:data] })
+            end
+
+            # broadcast new entry to all clients
+            ActionCable.server.broadcast(
+              key,
+              {
+                last_id: last_id,
+                clock: data[CLOCK_FIELD],
+                data: data[:data]
+              }
+            )
+          end
+
+          # acknowledge last known ID (by current user)
+          define_method "ack_#{method_name}".to_sym do |data|
+            key = stream_ack_key(method_name)
+            with_redis do |redis|
+              score = map_entry_id_to_score(data[LAST_ID_FIELD])
+              redis.zadd(key, [score, current_user.id], gt: true)
+            end
+          end
+        end
+      end
+
+      # we need to override this method to inject our own callback for subscribe
+      # without forcing the user to know about calling super() for #subscribe
+      def subscribe_to_channel
+        run_callbacks :subscribe do
+          reliable_subscribed
+        end
+
+        super
+      end
+
+      def unsubscribe_from_channel # :nodoc:
+        run_callbacks :unsubscribe do
+          reliable_unsubscribed
+        end
+
+        super
+      end
+
+      protected
+
+      def id
+        params[:id]
+      end
+
+      private
+
+      def reliable_subscribed # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        # reject subscription if there is no ID present
+        if id.blank?
+          Rails.logger.error("`id` is not present. The parameter :id must be " \
+                             "present in order for ReliableChannel to work.")
+
+          reject_subscription
+        end
+
+        # create a reliable stream for all registered actions
+        self.class.registered_reliable_actions.each do |reliable_action|
+          key = stream_key(reliable_action)
+          stream_from key
+        end
+
+        # create a stream for the current user
+        stream_for current_user
+
+        # initialize per-user and per-stream state
+        with_redis do |redis|
+          redis.pipelined do |pipeline|
+            self.class.registered_reliable_actions
+                .map do |reliable_action|
+              key = stream_ack_key(reliable_action)
+              pipeline.zadd(key, [-1, current_user.id])
+            end.flatten
+          end
+        end
+      end
+
+      def reliable_unsubscribed
+        # remove all user state from registered reliable streams
+        with_redis do |redis|
+          redis.pipelined do |pipeline|
+            self.class.registered_reliable_actions.map do |reliable_action|
+              key = stream_ack_key(reliable_action)
+              pipeline.zrem(key, current_user.id)
+            end
+          end
+        end
+      end
+
+      def user_key
+        "user:#{current_user.id}"
+      end
+
+      def stream_key(method)
+        "#{KEY_PREFIX}:#{method}:#{id}"
+      end
+
+      def stream_ack_key(method)
+        "#{stream_key(method)}:ack"
+      end
+
+      # Trim stream up to the minimum commonly shared entry ID across all
+      # registered clients.
+      def trim_stream(key, min_id)
+        with_redis do |redis|
+          redis.xtrim(key, min_id)
+        end
+      end
+
+      # Maps a Redis stream entry ID to a value that can be used as a score
+      # value in a Redis sorted set. The max score value is 2^53
+      # (https://redis.io/commands/zadd/). A Unix epoch represented in ms, and
+      # calculated in 2022 is around 2^40. If we pad the counter by a max value
+      # of 2^10, we can safely store values up to the year 2248 (2^43).
+      #
+      # This allows us to store up to a max of 999 concurrent messages for a
+      # given ID, within a given channel, within the same millisecond. The
+      # method will raise if the counter part of the entry_id exceeds the limit.
+      def map_entry_id_to_score(entry_id)
+        ts, c = entry_id.split("-")
+        if c.to_i > 999
+          raise "concurrent message counter exceeds 99 and cannot be " \
+                "concat with the timestamp"
+        end
+        # pad counter, this allows up to 9999 concurrent messages within the
+        # same ms
+        c.rjust(3, "0")
+        "#{ts}#{c}".to_i
+      end
+
+      # Reverse the mapping done in Reliable#map_entry_id_to_score
+      def map_score_to_entry_id(score)
+        score = score.to_s
+        c_padded, ts = score.slice!(-3..), score # rubocop:disable Style/ParallelAssignment
+        "#{ts}-#{c_padded.to_i}"
+      end
+
+      # Provide access to a Redis client
+      #
+      # @return [Redis] The Redis client
+      def with_redis(&block)
+        raise "no block given" if block.blank?
+
+        Y::Actioncable.configuration.redis.call(block)
+      end
+    end
+  end
+end

data/lib/y/actioncable/sync.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Y
+  module Actioncable
+    module Sync # rubocop:disable Metrics/ModuleLength
+      extend ActiveSupport::Concern
+
+      MESSAGE_SYNC = 0
+      MESSAGE_AWARENESS = 1
+      private_constant :MESSAGE_SYNC, :MESSAGE_AWARENESS
+
+      # Initiate synchronization. Encodes the current state_vector and transmits
+      # to the connecting client.
+      def initiate
+        encoder = Y::Lib0::Encoding.create_encoder
+        Y::Lib0::Encoding.write_var_uint(encoder, MESSAGE_SYNC)
+        Y::Sync.write_sync_step1(encoder, doc)
+        update = Y::Lib0::Encoding.to_uint8_array(encoder)
+        update = Y::Lib0::Encoding.encode_uint8_array_to_base64(update)
+
+        transmit({ update: update })
+        # TODO: implement awareness https://github.com/yjs/y-websocket/blob/master/bin/utils.js#L278-L284
+      end
+
+      # This methods should be passed as a block to stream subscription, and not
+      # be put into a generic #receive method.
+      #
+      # @param [Y::Doc] doc
+      # @param [Hash] message The encoded message must include a field named
+      #   exactly like the field argument. The field value must be a Base64
+      #   binary.
+      # @param [String] field The field that the encoded update should be
+      #   extracted from.
+      def integrate(message, field: "update")
+        origin = message["origin"]
+        update = Y::Lib0::Decoding.decode_base64_to_uint8_array(message["update"])
+
+        encoder = Y::Lib0::Encoding.create_encoder
+        decoder = Y::Lib0::Decoding.create_decoder(update)
+        message_type = Y::Lib0::Decoding.read_var_uint(decoder)
+        case message_type
+        when MESSAGE_SYNC
+          Y::Lib0::Encoding.write_var_uint(encoder, MESSAGE_SYNC)
+          Y::Sync.read_sync_message(decoder, encoder, doc, nil)
+
+          # If the `encoder` only contains the type of reply message and no
+          # message, there is no need to send the message. When `encoder` only
+          # contains the type of reply, its length is 1.
+          if Y::Lib0::Encoding.length(encoder) > 1
+            update = Y::Lib0::Encoding.to_uint8_array(encoder)
+            update = Y::Lib0::Encoding.encode_uint8_array_to_base64(update)
+
+            transmit({ update: update })
+          end
+        when MESSAGE_AWARENESS
+          # TODO: implement awareness https://github.com/yjs/y-websocket/blob/master/bin/utils.js#L179-L181
+        end
+
+        # do not transmit message back to current connection if the connection
+        # is the origin of the message
+        transmit(message) if origin != connection.connection_identifier
+      end
+
+      def sync_to(to, message, field: "update")
+        update = message["update"]
+
+        # we broadcast to all connected clients, but provide the
+        # connection_identifier as origin so that the [#integrate] method is
+        # able to filter sending back the update to its origin.
+        self.class.broadcast_to(
+          to,
+          { update: update, origin: connection.connection_identifier }
+        )
+      end
+
+      # Produce a canonical key for this channel and its parameters. This allows
+      # us to create unique documents for separate use cases. e.g. an Issue is
+      # the document scope, but has multiple fields that are synchronized, the
+      # title, description, labels, …
+      #
+      # By default, the key is the same as the channel identifier.
+      #
+      # @example Create a new IssueChannel that sync updates for issue ID
+      #   # issue_channel.rb
+      #   class IssueChannel
+      #     include Y::Actionable::SyncChannel
+      #   end
+      #
+      #   # issue_subscription.js
+      #   const params = { id: 1 }
+      #   consumer.subscriptions.create(
+      #       {channel: "IssueChannel", ...params}
+      #   );
+      #
+      #   # example for a resulting canonical key
+      #   "issue_channel:id:1"
+      def canonical_channel_key
+        @canonical_channel_key ||= begin
+          pairs = JSON.parse!(identifier)
+          params_part = pairs.map do |k, v|
+            "#{k.to_s.parameterize}-#{v.to_s.parameterize}"
+          end
+
+          "sync:#{params_part.join(":")}"
+        end
+      end
+
+      def load(&block)
+        full_diff = yield(canonical_channel_key)
+        doc.sync(full_diff) unless full_diff.nil?
+      end
+
+      def persist(&block)
+        yield(canonical_channel_key, doc.diff)
+      end
+
+      def doc
+        @doc ||= Y::Doc.new
+      end
+    end
+  end
+end

data/lib/y/actioncable/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Y
+  module Actioncable
+    VERSION = "0.1.1"
+  end
+end

data/lib/y/actioncable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "y/actioncable/config"
+require "y/actioncable/engine"
+require "y/actioncable/reliable"
+require "y/actioncable/sync"
+require "y/actioncable/version"
+
+module Y
+  module Actioncable
+    # Your code goes here...
+  end
+end

data/lib/y/lib0/binary.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Y
+  module Lib0
+    module Binary
+      BIT1 = 1
+      BIT2 = 2
+      BIT3 = 4
+      BIT4 = 8
+      BIT5 = 16
+      BIT6 = 32
+      BIT7 = 64
+      BIT8 = 128
+      BIT9 = 256
+      BIT10 = 512
+      BIT11 = 1024
+      BIT12 = 2048
+      BIT13 = 4096
+      BIT14 = 8192
+      BIT15 = 16_384
+      BIT16 = 32_768
+      BIT17 = 65_536
+      BIT18 = 1 << 17
+      BIT19 = 1 << 18
+      BIT20 = 1 << 19
+      BIT21 = 1 << 20
+      BIT22 = 1 << 21
+      BIT23 = 1 << 22
+      BIT24 = 1 << 23
+      BIT25 = 1 << 24
+      BIT26 = 1 << 25
+      BIT27 = 1 << 26
+      BIT28 = 1 << 27
+      BIT29 = 1 << 28
+      BIT30 = 1 << 29
+      BIT31 = 1 << 30
+      BIT32 = 1 << 31
+
+      BITS0 = 0
+      BITS1 = 1
+      BITS2 = 3
+      BITS3 = 7
+      BITS4 = 15
+      BITS5 = 31
+      BITS6 = 63
+      BITS7 = 127
+      BITS8 = 255
+      BITS9 = 511
+      BITS10 = 1023
+      BITS11 = 2047
+      BITS12 = 4095
+      BITS13 = 8191
+      BITS14 = 16_383
+      BITS15 = 32_767
+      BITS16 = 65_535
+      BITS17 = BIT18 - 1
+      BITS18 = BIT19 - 1
+      BITS19 = BIT20 - 1
+      BITS20 = BIT21 - 1
+      BITS21 = BIT22 - 1
+      BITS22 = BIT23 - 1
+      BITS23 = BIT24 - 1
+      BITS24 = BIT25 - 1
+      BITS25 = BIT26 - 1
+      BITS26 = BIT27 - 1
+      BITS27 = BIT28 - 1
+      BITS28 = BIT29 - 1
+      BITS29 = BIT30 - 1
+      BITS30 = BIT31 - 1
+
+      BITS31 = 0x7FFFFFFF
+
+      BITS32 = 0xFFFFFFFF
+    end
+  end
+end

data/lib/y/lib0/buffer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Y
+  module Lib0
+    module Buffer
+      def self.create_uint8_array_view_from_buffer(enumerable, offset, size)
+        TypedArray.new(enumerable, offset, size)
+      end
+    end
+  end
+end

data/lib/y/lib0/decoding.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Y
+  module Lib0
+    module Decoding
+      class Decoder
+        attr_accessor :arr, :pos
+
+        def initialize(uint8_array)
+          @arr = uint8_array
+          @pos = 0
+        end
+      end
+
+      def self.create_decoder(uint8_array)
+        Decoder.new(uint8_array)
+      end
+
+      def self.has_content(decoder)
+        decoder.pos != decoder.arr.size
+      end
+
+      def self.clone(decoder, new_pos = decoder.pos)
+        decoder = create_decoder(decoder.arr)
+        decoder.pos = new_pos
+        decoder
+      end
+
+      def self.read_uint8_array(decoder, size)
+        view = Buffer.create_uint8_array_view_from_buffer(decoder.arr, decoder.pos + 0, size)
+      end
+
+      def self.read_var_uint8_array(decoder)
+        read_uint8_array(decoder, read_var_uint(decoder))
+      end
+
+      def self.read_var_uint(decoder)
+        num = 0
+        mult = 1
+        size = decoder.arr.size
+        while decoder.pos < size
+          r = decoder.arr[decoder.pos]
+          decoder.pos += 1
+          num = num + (r & Binary::BITS7) * mult
+          mult *= 128 # next iteration, shift 7 "more" to the left
+          if r < Binary::BIT8
+            return num
+          end
+          if num > Integer::MAX
+            raise "integer out of range"
+          end
+        end
+        raise "unexpected end of array"
+      end
+
+      def self.decode_base64_to_uint8_array(str)
+        Base64.strict_decode64(str).unpack("C*")
+      end
+    end
+  end
+end

data/lib/y/lib0/encoding.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Y
+  module Lib0
+    module Encoding
+      class Encoder
+        attr_accessor :bufs, :cpos, :cbuf
+
+        def initialize
+          @cpos = 0
+          @cbuf = TypedArray.new(100)
+          @bufs = []
+        end
+      end
+
+      def self.create_encoder
+        Encoder.new
+      end
+
+      def self.length(encoder)
+        size = encoder.cpos
+        i = 0
+        while i < encoder.bufs.size
+          size += encoder.bufs[i].size
+          i += 1
+        end
+        return size
+      end
+
+      def self.to_uint8_array(encoder) # rubocop:disable Metrics/MethodLength
+        typed_arr = TypedArray.new(length(encoder))
+        cur_pos = 0
+        i = 0
+        while i < encoder.bufs.size
+          d = encoder.bufs[i]
+          typed_arr.replace_with(d, cur_pos)
+          cur_pos += d.size
+          i += 1
+        end
+        typed_arr.replace_with(
+          Buffer.create_uint8_array_view_from_buffer(
+            encoder.cbuf,
+            0,
+            encoder.cpos
+          ),
+          cur_pos
+        )
+        typed_arr
+      end
+
+      def self.verify_size(encoder, size)
+        buffer_size = encoder.cbuf.size
+
+        return unless buffer_size - encoder.cpos < size
+
+        encoder.bufs << Buffer.create_uint8_array_view_from_buffer(encoder.cbuf, 0, encoder.cpos)
+        encoder.cbuf = TypedArray.new([buffer_size, size].max * 2)
+        encoder.cpos = 0
+      end
+
+      def self.write(encoder, num)
+        buffer_size = encoder.cbuf.size
+        if encoder.cpos == buffer_size
+          encoder.bufs << encoder.cbuf
+          encoder.cbuf = TypedArray.new(buffer_size * 2)
+          encoder.cpos = 0
+        end
+
+        encoder.cbuf[encoder.cpos] = num
+        encoder.cpos += 1
+      end
+
+      def self.set(encoder, pos, num) # rubocop:disable Metrics/MethodLength
+        buffer = nil
+        i = 0
+        while i < encoder.bufs.size && buffer.nil?
+          b = encoder.bufs[i]
+          if pos < b.size
+            buffer = b
+          else
+            pos -= b.size
+          end
+
+          i += 1
+        end
+
+        buffer = encoder.cbuf if buffer.nil?
+        buffer[pos] = num
+      end
+
+      def self.write_uint8(encoder, num)
+        write(encoder, num)
+      end
+
+      def self.set_uint8(encoder, pos, num)
+        set(encoder, pos, num)
+      end
+
+      def self.write_var_uint(encoder, num)
+        while num > Binary::BITS7
+          write(encoder, Binary::BIT8 | (Binary::BITS7 & num))
+          num = (num / 128.0).floor # shift >>> 7
+        end
+        write(encoder, Binary::BITS7 & num)
+      end
+
+      def self.write_uint8_array(encoder, uint8_array) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        buffer_size = encoder.cbuf.size
+        cpos = encoder.cpos
+        left_copy_size = [buffer_size - cpos, uint8_array.size].min
+        right_copy_size = uint8_array.size - left_copy_size
+        encoder.cbuf.replace_with(uint8_array.slice(0, left_copy_size), cpos)
+        encoder.cpos += left_copy_size
+
+        return unless right_copy_size.positive?
+
+        # Still something to write, write right half..
+        # Append new buffer
+        encoder.bufs.push(encoder.cbuf)
+        # must have at least size of remaining buffer
+        encoder.cbuf = TypedArray.new([buffer_size * 2, right_copy_size].max)
+        # copy array
+        encoder.cbuf.replace_with(uint8_array[left_copy_size..])
+        encoder.cpos = right_copy_size
+      end
+
+      def self.write_var_uint8_array(encoder, uint8_array)
+        write_var_uint(encoder, uint8_array.size)
+        write_uint8_array(encoder, uint8_array)
+      end
+
+      def self.unsigned_right_shift(value, amount)
+        mask = (1 << (32 - amount)) - 1
+        (value >> amount) & mask
+      end
+
+      def self.encode_uint8_array_to_base64(arr)
+        Base64.strict_encode64(arr.pack("C*"))
+      end
+    end
+  end
+end

data/lib/y/lib0/integer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Y
+  module Lib0
+    module Integer
+      N_BYTES = [42].pack('i').size
+      N_BITS = N_BYTES * 16
+      MAX = 2 ** (N_BITS - 2) - 1
+      MIN = -MAX - 1
+    end
+  end
+end

data/lib/y/lib0/sync.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Y
+  module Lib0
+    module Sync
+      def self.read_sync_step1(decoder, encoder, doc)
+        write_sync_step2(encoder, doc, Decoding.read_var_uint8_array(decoder))
+      end
+
+      def self.read_sync_step2(decoder, doc, transaction_origin)
+        update = Decoding.read_var_uint8_array(decoder)
+        doc.sync(update)
+      end
+    end
+  end
+end

data/lib/y/lib0/typed_array.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Y
+  module Lib0
+    class TypedArray < ::Array
+      # @overload initialize()
+      #   Initialize a TypedArray of size=0
+      # @overload initialize(size)
+      #   Initialize a TypedArray of given size and initialize with 0's
+      #   @param size [Integer]
+      # @overload initialize(typed_array)
+      #   Create a new TypedArray from an existing
+      # @overload initialize(buffer)
+      #   Create a new TypedArray from a buffer. All elements must be valid
+      #   integers that fit into a single byte (unsigned int). This is not
+      #   checked at runtime.
+      # @overload initialize(buffer, offset)
+      #   Create a new TypedArray from a buffer and offset. The projected
+      # @overload initialize(buffer, offset, size)
+      def initialize(*args) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        if args.size.zero?
+          super()
+        elsif args.size == 1 && args.first.is_a?(Numeric)
+          super(args.first, 0)
+        elsif args.size == 1 && args.first.is_a?(TypedArray)
+          super(args.first)
+        elsif args.size == 1 && args.first.is_a?(Enumerable)
+          super(args.first.to_a)
+        elsif args.size == 2 && args.first.is_a?(Enumerable) && args.last.is_a?(Numeric)
+          super(args.first.to_a[(args.last)..-1])
+        elsif args.size == 3 && args.first.is_a?(Enumerable) && args[1].is_a?(Numeric) && args.last.is_a?(Numeric)
+          super(args.first.to_a[args[1], args.last])
+        else
+          raise "invalid arguments: [#{args.join(", ")}"
+        end
+      end
+
+      def replace_with(array, offset = 0)
+        array.each_with_index do |element, index|
+          self[offset + index] = element
+        end
+      end
+    end
+  end
+end

data/lib/y/lib0.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "y/lib0/binary"
+require "y/lib0/buffer"
+require "y/lib0/decoding"
+require "y/lib0/encoding"
+require "y/lib0/integer"
+require "y/lib0/typed_array"

data/lib/y/sync.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Y
+  module Sync
+    MESSAGE_YJS_SYNC_STEP_1 = 0
+    MESSAGE_YJS_SYNC_STEP_2 = 1
+    MESSAGE_YJS_UPDATE = 2
+
+    # @param [Y::Lib0::Encoding::Encoder] encoder
+    # @param [Y::Doc] doc
+    def self.write_sync_step1(encoder, doc)
+      Y::Lib0::Encoding.write_var_uint(encoder, MESSAGE_YJS_SYNC_STEP_1)
+      state_vector = doc.state
+      Y::Lib0::Encoding.write_var_uint8_array(encoder, state_vector)
+    end
+
+    # @param [Y::Lib0::Encoding::Encoder] encoder
+    # @param [Y::Doc] doc
+    # @param [Array<Integer>] encoded_state_vector
+    def self.write_sync_step2(encoder, doc, encoded_state_vector)
+      Y::Lib0::Encoding.write_var_uint(encoder, MESSAGE_YJS_SYNC_STEP_2)
+      Y::Lib0::Encoding.write_var_uint8_array(encoder, doc.diff(encoded_state_vector))
+    end
+
+    # @param [Y::Lib0::Decoding::Decoder] decoder
+    # @param [Y::Lib0::Encoding::Encoder] encoder
+    # @param [Y::Doc] doc
+    def self.read_sync_step1(decoder, encoder, doc)
+      write_sync_step2(encoder, doc, Y::Lib0::Decoding.read_var_uint8_array(decoder))
+    end
+
+    # @param [Y::Lib0::Decoding::Decoder] decoder
+    # @param [Y::Doc] doc
+    # @param [Object] transaction_origin
+    # TODO: y-rb sync does not support transaction origins
+    def self.read_sync_step2(decoder, doc, _transaction_origin)
+      update = Y::Lib0::Decoding.read_var_uint8_array(decoder)
+      doc.sync(update)
+    end
+
+    # @param [Y::Lib0::Encoding::Encoder] encoder
+    # @param [Array<Integer>] update
+    def self.write_update(encoder, update)
+      Y::Lib0::Encoding.write_var_uint(encoder, MESSAGE_YJS_UPDATE)
+      Y::Lib0::Encoding.write_var_uint8_array(encoder, update)
+    end
+
+    # @param [Y::Lib0::Decoding::Decoder] decoder
+    # @param [Y::Doc] doc
+    # @param [Object] transaction_origin
+    def self.read_update(decoder, doc, _transaction_origin)
+      read_sync_step2(decoder, doc, _transaction_origin)
+    end
+
+    # @param [Y::Lib0::Decoding::Decoder] decoder
+    # @param [Y::Lib0::Encoding::Encoder] encoder
+    # @param [Y::Doc] doc
+    # @param [Object] transaction_origin
+    # TODO: y-rb sync does not support transaction origins
+    def self.read_sync_message(decoder, encoder, doc, transaction_origin)
+      message_type = Y::Lib0::Decoding.read_var_uint(decoder)
+
+      case message_type
+      when MESSAGE_YJS_SYNC_STEP_1
+        read_sync_step1(decoder, encoder, doc)
+      when MESSAGE_YJS_SYNC_STEP_2
+        read_sync_step2(decoder, doc, transaction_origin)
+      when MESSAGE_YJS_UPDATE
+        read_update(decoder, doc, transaction_origin)
+      else
+        raise "unknown message type"
+      end
+
+      message_type
+    end
+  end
+end

data/lib/yrb-actioncable.rb

@@ -0,0 +1,7 @@
+# rubocop:disable Naming/FileName
+# frozen_string_literal: true
+
+require "y/actioncable"
+require "y/lib0"
+require "y/sync"
+# rubocop:enable Naming/FileName

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: y-rb_actioncable
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Hannes Moser
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-01-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.4
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Reliable message transmission between one or more Y.js clients.
+email:
+- box@hannesmoser.at
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- app/assets/config/yrb_actioncable_manifest.js
+- app/assets/stylesheets/yrb/actioncable/application.css
+- app/helpers/yrb/actioncable/application_helper.rb
+- app/jobs/yrb/actioncable/application_job.rb
+- app/models/yrb/actioncable/application_record.rb
+- lib/tasks/yrb/actioncable_tasks.rake
+- lib/y/actioncable.rb
+- lib/y/actioncable/config.rb
+- lib/y/actioncable/config/abstract_builder.rb
+- lib/y/actioncable/config/option.rb
+- lib/y/actioncable/config/validations.rb
+- lib/y/actioncable/engine.rb
+- lib/y/actioncable/reliable.rb
+- lib/y/actioncable/sync.rb
+- lib/y/actioncable/version.rb
+- lib/y/lib0.rb
+- lib/y/lib0/binary.rb
+- lib/y/lib0/buffer.rb
+- lib/y/lib0/decoding.rb
+- lib/y/lib0/encoding.rb
+- lib/y/lib0/integer.rb
+- lib/y/lib0/sync.rb
+- lib/y/lib0/typed_array.rb
+- lib/y/sync.rb
+- lib/yrb-actioncable.rb
+homepage: https://github.com/y-crdt/yrb-actioncable
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/y-crdt/yrb-actioncable
+  source_code_uri: https://github.com/y-crdt/yrb-actioncable
+  documentation_uri: https://y-crdt.github.io/yrb-actioncable/
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.1
+signing_key:
+specification_version: 4
+summary: An ActionCable companion for Y.js clients.
+test_files: []