hotsock-turbo 0.1.0

data/lib/hotsock/turbo/streams_channel.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Hotsock
+  module Turbo
+    class StreamsChannel
+      def self.enabled?
+        defined?(::Turbo::StreamsChannel)
+      end
+
+      def self.turbo_stream_action_tag(
+        action,
+        target: nil,
+        targets: nil,
+        template: nil,
+        **attributes
+      )
+        target_attr = target ? %(target="#{ERB::Util.html_escape(target)}") : nil
+        targets_attr = targets ? %(targets="#{ERB::Util.html_escape(targets)}") : nil
+        attrs = [target_attr, targets_attr]
+        attributes.each { |k, v| attrs << %(#{k}="#{ERB::Util.html_escape(v)}") }
+        attrs_str = attrs.compact.join(" ")
+        inner = template || ""
+        %(<turbo-stream action="#{ERB::Util.html_escape(action)}" #{attrs_str}><template>#{inner}</template></turbo-stream>)
+      end
+
+      def self.render_broadcast_action(rendering)
+        rendering = rendering.dup
+        content = rendering.delete(:content)
+        html = rendering.delete(:html)
+        render = rendering.delete(:render)
+
+        return nil if render == false
+        return content if content
+        return html if html
+        return ApplicationController.render(formats: [:html], **rendering) if rendering.present?
+
+        nil
+      end
+
+      # This is designed this way to be consistent with Action Cable.
+      # We can extend this to allow for multiple channels on a single model in the future.
+      def broadcasting_for(model)
+        self.class.serialize_broadcasting(model)
+      end
+
+      def self.broadcast_action_to(
+        *streamables,
+        action:,
+        target: nil,
+        targets: nil,
+        attributes: {},
+        timestamp: nil,
+        **rendering
+      )
+        timestamp ||= Time.current.to_f
+        attributes = attributes.merge(timestamp: timestamp)
+
+        options = {
+          action: :"#{target}_#{action}",
+          timestamp: timestamp
+        }
+
+        broadcast_to(
+          *streamables,
+          turbo_stream_action_tag(
+            action,
+            target: target,
+            targets: targets,
+            template: render_broadcast_action(rendering),
+            **attributes
+          ),
+          options
+        )
+      end
+
+      def self.broadcast_to(stream_or_streamable, content, options = {})
+        unless enabled?
+          fail "Turbo Streams is not enabled. Please install turbo-rails to use this method."
+        end
+
+        channel = serialize_broadcasting(stream_or_streamable)
+        event = "turbo_stream"
+        data = {
+          html: content,
+          action: options[:action],
+          timestamp: options[:timestamp]
+        }.compact
+
+        Hotsock.publish_message(channel:, event:, data:)
+      end
+
+      def self.broadcast_append_to(stream, target:, partial:, locals: {}, timestamp: nil)
+        broadcast_action_to(
+          stream,
+          action: :append,
+          target: target,
+          partial: partial,
+          locals: locals,
+          timestamp: timestamp
+        )
+      end
+
+      def self.broadcast_replace_to(stream, target:, partial:, locals: {}, timestamp: nil)
+        broadcast_action_to(
+          stream,
+          action: :replace,
+          target: target,
+          partial: partial,
+          locals: locals,
+          timestamp: timestamp
+        )
+      end
+
+      def self.broadcast_prepend_to(stream, target:, partial:, locals: {}, timestamp: nil)
+        broadcast_action_to(
+          stream,
+          action: :prepend,
+          target: target,
+          partial: partial,
+          locals: locals,
+          timestamp: timestamp
+        )
+      end
+
+      def self.broadcast_remove_to(stream, target:)
+        html =
+          %(<turbo-stream action="remove" target="#{ERB::Util.html_escape(target)}"></turbo-stream>)
+        broadcast_to(stream, html)
+      end
+
+      def self.broadcast_refresh_to(*streamables, request_id: nil, **attributes)
+        broadcast_to(
+          *streamables,
+          turbo_stream_refresh_tag(request_id: request_id, **attributes),
+          {action: :refresh}
+        )
+      end
+
+      def self.turbo_stream_refresh_tag(request_id: nil, **attributes)
+        attrs = attributes.dup
+        attrs[:"request-id"] = request_id if request_id.present?
+        attrs_str = attrs.map { |k, v| %(#{k}="#{ERB::Util.html_escape(v)}") }.join(" ")
+        attrs_str = " #{attrs_str}" if attrs_str.present?
+        %(<turbo-stream action="refresh"#{attrs_str}></turbo-stream>)
+      end
+
+      def self.broadcast_refresh_later_to(*streamables, request_id: nil)
+        stream_name = serialize_broadcasting(streamables)
+        Hotsock::Turbo::BroadcastRefreshJob.perform_later(stream_name, request_id: request_id)
+      end
+
+      def self.broadcast_action_later_to(*streamables, action:, target: nil, targets: nil, attributes: {}, **rendering)
+        stream_name = serialize_broadcasting(streamables)
+        Hotsock::Turbo::ActionBroadcastJob.perform_later(
+          stream_name,
+          action: action,
+          target: target,
+          targets: targets,
+          attributes: attributes,
+          **rendering
+        )
+      end
+
+      def self.broadcast_replace_later_to(*streamables, **opts)
+        broadcast_action_later_to(*streamables, action: :replace, **opts)
+      end
+
+      def self.broadcast_update_later_to(*streamables, **opts)
+        broadcast_action_later_to(*streamables, action: :update, **opts)
+      end
+
+      def self.broadcast_append_later_to(*streamables, **opts)
+        broadcast_action_later_to(*streamables, action: :append, **opts)
+      end
+
+      def self.broadcast_prepend_later_to(*streamables, **opts)
+        broadcast_action_later_to(*streamables, action: :prepend, **opts)
+      end
+
+      def self.broadcast_before_later_to(*streamables, **opts)
+        broadcast_action_later_to(*streamables, action: :before, **opts)
+      end
+
+      def self.broadcast_after_later_to(*streamables, **opts)
+        broadcast_action_later_to(*streamables, action: :after, **opts)
+      end
+
+      def self.broadcast_render_to(*streamables, **rendering)
+        broadcast_to(
+          *streamables,
+          ApplicationController.render(formats: [:turbo_stream], **rendering),
+          {}
+        )
+      end
+
+      def self.broadcast_render_later_to(*streamables, **rendering)
+        stream_name = serialize_broadcasting(streamables)
+        Hotsock::Turbo::BroadcastJob.perform_later(stream_name, **rendering)
+      end
+
+      def self.broadcast_update_to(stream, target:, partial:, locals: {}, timestamp: nil)
+        broadcast_action_to(
+          stream,
+          action: :update,
+          target: target,
+          partial: partial,
+          locals: locals,
+          timestamp: timestamp
+        )
+      end
+
+      # Convert the method to a class method to be used by both instance and class methods
+      def self.serialize_broadcasting(streamable)
+        if streamable.is_a?(String)
+          streamable
+        elsif streamable.is_a?(Array)
+          streamable.map { |s| serialize_broadcasting(s) }.join(",")
+        elsif streamable.respond_to?(:to_gid_param)
+          streamable.to_gid_param
+        elsif streamable.respond_to?(:to_param)
+          streamable.to_param
+        else
+          fail ArgumentError, "Invalid streamable object: #{streamable.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/hotsock/turbo/streams_helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Hotsock
+  module Turbo
+    module StreamsHelper
+      def hotsock_turbo_meta_tags(connect_token_path: nil, wss_url: nil, log_level: nil)
+        config = Hotsock::Turbo.config
+        tags = [
+          tag(:meta, name: "hotsock:connect-token-path", content: connect_token_path || config.connect_token_path),
+          tag(:meta, name: "hotsock:log-level", content: log_level || config.log_level),
+          tag(:meta, name: "hotsock:wss-url", content: wss_url || config.wss_url)
+        ]
+        safe_join(tags, "\n")
+      end
+
+      def hotsock_turbo_stream_from(*streamables, **attributes)
+        channel = Hotsock::Turbo::StreamsChannel.new
+        channel_name = channel.broadcasting_for(streamables)
+        token = create_subscription_token(channel_name)
+        set_attributes(attributes, token, channel_name)
+
+        tag.hotsock_turbo_stream_source(**attributes)
+      end
+
+      private
+
+      def create_subscription_token(channel_name)
+        Hotsock.issue_token(
+          scope: "subscribe",
+          channels: {channel_name => {omitSubCount: true, subscribe: true}},
+          uid:,
+          exp: 1.week.from_now.to_i
+        )
+      end
+
+      def set_attributes(attributes, token, channel_name)
+        attributes[:"data-token"] = token
+        attributes[:"data-channel"] = channel_name
+        attributes[:"data-user-id"] = uid
+      end
+
+      def uid
+        respond_to?(:hotsock_uid, true) ? hotsock_uid : session.id.to_s
+      end
+    end
+  end
+end

data/lib/hotsock/turbo/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Hotsock
+  module Turbo
+    VERSION = "0.1.0"
+  end
+end

data/lib/hotsock-turbo.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "hotsock"
+require "hotsock/turbo/version"
+require "hotsock/turbo/config"
+require "hotsock/turbo/streams_channel"
+require "hotsock/turbo/streams_helper"
+require "hotsock/turbo/broadcastable"
+require "hotsock/turbo/engine" if defined?(Rails)
+
+module Hotsock
+  module Turbo
+    class << self
+      def configure
+        yield config
+      end
+
+      def config
+        @config ||= Config.new
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: hotsock-turbo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- James Miller
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hotsock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Provides Turbo Streams integration for Hotsock, enabling real-time updates
+  in Rails applications using Hotsock's WebSocket infrastructure.
+email:
+- support@hotsock.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- Gemfile
+- README.md
+- Rakefile
+- app/assets/javascripts/hotsock-turbo.js
+- app/controllers/hotsock/turbo/tokens_controller.rb
+- app/jobs/hotsock/turbo/action_broadcast_job.rb
+- app/jobs/hotsock/turbo/broadcast_job.rb
+- app/jobs/hotsock/turbo/broadcast_refresh_job.rb
+- config/routes.rb
+- hotsock-turbo.gemspec
+- lib/hotsock-turbo.rb
+- lib/hotsock/turbo/broadcastable.rb
+- lib/hotsock/turbo/config.rb
+- lib/hotsock/turbo/engine.rb
+- lib/hotsock/turbo/streams_channel.rb
+- lib/hotsock/turbo/streams_helper.rb
+- lib/hotsock/turbo/version.rb
+homepage: https://www.hotsock.io
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://www.hotsock.io
+  bug_tracker_uri: https://github.com/hotsock/hotsock-turbo/issues
+  documentation_uri: https://github.com/hotsock/hotsock-turbo/blob/main/README.md
+  changelog_uri: https://github.com/hotsock/hotsock-turbo/releases
+  source_code_uri: https://github.com/hotsock/hotsock-turbo
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Turbo Streams integration for Hotsock
+test_files: []