dexiecable 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b4a75838a91bf8b9ef988b1b2ef14f90e2148df75d80b15127487bb3b9efb8e
-  data.tar.gz: 99ca5b8a8cf6a4b12eca7d54753b0de8c35dc699c22bb172a62b7ca826fa9f6a
+  metadata.gz: 85944f789c9d0a2a10d718fbab783e4c9b89e00bb2ad0fe2cb5804648660447c
+  data.tar.gz: a17bc5ccd07702c90ea508b9261391980fbfa68e4bf1a5d1b9dc4f85f6a8c417
 SHA512:
-  metadata.gz: d77d14a92756f3a05c4c038f93f542953036d3df2e010952659a4833a48997fef2fcf4d145360f03d684a40b8fc25715a3aaf8f5624ff0f6bc3934568ff5806c
-  data.tar.gz: ae7f67b4bf0ab26883afd3ba7c17fc944b6f7fc66f0f862c0c6cec6ff9d494ed749b2436e47d80898dc86d11ed1c44235e679e68b4ff3e9c1b662552e2536b59
+  metadata.gz: 62b8fbad4ae8392ec0da800697247833a62cdd1dd8165f95ed05c6b81e4b97a4984e75eb3179481139e9bf8f2378641eecb50e2e7ba5503c94f445a9e30e7128
+  data.tar.gz: 17330cb1f871afb2b9599596e2d8f1cd882fe323c686f9464490b779e1f2fdfbb4c9b6a9bacca0bd2eb5751ff4001a93cea4f0cbb9dbacae4ab1a1d6489ac2a0

data/README.md

@@ -2,7 +2,7 @@
 
 Run [Dexie.js](https://dexie.org) IndexedDB operations from your Rails ActionCable channels.
 
-DexieCable augments ActionCable channels with a query DSL that mirrors the Dexie.js API, letting you push database mutations from the server to the client in real time. It also gives you a `syncs_to_dexie` ActiveRecord macro for automatic change syncing.
+DexieCable augments ActionCable channels with a query DSL that mirrors the Dexie.js API, letting you push database mutations from the server to the client in real time. It also gives you a [`syncs_to_dexie`](#syncs_to_dexie--automatic-model-syncing) ActiveRecord macro for automatic change syncing.
 
 You can run any Dexie table update directly inside a channel:
 
@@ -29,11 +29,11 @@ class NotificationsController < ApplicationController
 end
 ```
 
-An even more convenient way is to use the `syncs_to_dexie` macro:
+An even more convenient way is to use the `syncs_to_dexie` macro (more info [below](#syncs_to_dexie--automatic-model-syncing))
 
 ```ruby
 class Notification < ApplicationRecord
-  syncs_to_dexie via: UserChannel, subject: :user
+  syncs_to_dexie via: UserChannel, to: :user
 end
 ```
 
@@ -89,7 +89,7 @@ This gives you:
 
 | Method | Description |
 |---|---|
-| `self.[](subject)` | Returns a `ScopedChannel` bound to a subject. `UserChannel[current_user]` |
+| `self.[](to)` | Returns a `ScopedChannel` bound to a recipient. `UserChannel[current_user]` |
 | `table(name)` | Starts a query chain. `table("messages")` |
 
 ### Chaining Dexie operations
@@ -125,34 +125,36 @@ The full query chain is serialized as JSON and sent over ActionCable. The JS cli
 
 ### `syncs_to_dexie` — automatic model syncing
 
-Add to any ActiveRecord model. `subject` is what gets passed to `broadcast_to` as the stream target:
+Add to any ActiveRecord model. Just provide the channel class and the broadcast target.
 
 ```ruby
 class Message < ApplicationRecord
-  # Calls send(:receiver), then broadcasts: broadcast_to(receiver, ...)
-  syncs_to_dexie via: UserChannel, subject: :receiver
+  # Calls send(:receiver), then broadcasts: UserChannel.broadcast_to(receiver, ...)
+  syncs_to_dexie via: UserChannel, to: :receiver
 
-  # String used directly: broadcast_to("global_feed", ...)
-  syncs_to_dexie via: UserChannel, subject: "global_feed"
+  # String used directly: UserChannel.broadcast_to("global_feed", ...)
+  syncs_to_dexie via: UserChannel, to: "global_feed"
 
   # Procs are also supported. If an array is returned, multiple broadcasts are made
-  # conversation.users.each { |u| broadcast_to(u, ...) }
-  syncs_to_dexie via: UserChannel, subject: -> { conversation.users }
+  # conversation.users.each { |u| UserChannel.broadcast_to(u, ...) }
+  syncs_to_dexie via: UserChannel, to: -> { conversation.users }
 end
 ```
 
+Internally, `syncs_to_dexie` sets up the following ActiveRecord callbacks:
+
 | Event | Action |
 |---|---|
-| `after_commit on: :create` | `channel.table("messages").add(record.as_json_for_dexie)` |
-| `after_commit on: :update` | `channel.table("messages").put(record.as_json_for_dexie)` |
-| `after_commit on: :destroy` | `channel.table("messages").delete(record.id)` |
+| `after_commit on: :create` | `channel.table(table).add(record.as_json_for_dexie)` |
+| `after_commit on: :update` | `channel.table(table).put(record.as_json_for_dexie)` |
+| `after_commit on: :destroy` | `channel.table(table).delete(record.id)` |
 
 #### Options
 
 | Option | Default | Description |
 |---|---|---|
 | `via:` | *(required)* | A DexieCable channel class |
-| `subject:` | *(none)* | The stream target passed to `broadcast_to`. Symbol → calls `send`. String → used as-is. Proc → evaluated in record context. Returns a single subject or collection. |
+| `to:` | *(none)* | The stream target passed to `broadcast_to`. Symbol → calls `send`. String → used as-is. Proc → evaluated in record context. Returns a single recipient or collection. |
 | `table:` | model's `table_name` | Override the Dexie table name. A Proc is evaluated in the record's context. |
 | `only:` | `[:create, :update, :destroy]` | Limit which events trigger a sync |
 | `if:` | *(none)* | Symbol (method name) or Proc — only sync when it returns truthy |
@@ -162,7 +164,7 @@ You can combine multiple `syncs_to_dexie` declarations, each with different cond
 
 ```ruby
 class Message < ApplicationRecord
-  syncs_to_dexie via: UserChannel, subject: -> { sender },
+  syncs_to_dexie via: UserChannel, to: -> { sender },
                  if: :published?
 
   syncs_to_dexie via: AdminChannel,
@@ -176,7 +178,7 @@ Override `as_json_for_dexie` in your model:
 
 ```ruby
 class Message < ApplicationRecord
-  syncs_to_dexie via: UserChannel, subject: :sender
+  syncs_to_dexie via: UserChannel, to: :sender
 
   def as_json_for_dexie
     super.merge(room_name: room.name)

data/lib/dexiecable/active_record_ext.rb

@@ -9,22 +9,22 @@ module DexieCable
       # DexieCable channel.
       #
       #   class Message < ApplicationRecord
-      #     syncs_to_dexie via: UserChannel, subject: :sender
-      #     syncs_to_dexie via: UserChannel, subject: "global_feed"
-      #     syncs_to_dexie via: UserChannel, subject: -> { conversation.users }
+      #     syncs_to_dexie via: UserChannel, to: :sender
+      #     syncs_to_dexie via: UserChannel, to: "global_feed"
+      #     syncs_to_dexie via: UserChannel, to: -> { conversation.users }
       #     syncs_to_dexie via: PublicChannel
       #   end
       #
-      # @param via     [Class] A DexieCable channel class. When +subject+
-      #                  is given, each subject is mapped through
-      #                  +via[subject]+ to produce scoped channels.
-      #                  Without +subject+, +via+ is used directly as an
+      # @param via     [Class] A DexieCable channel class. When +to+
+      #                  is given, each recipient is mapped through
+      #                  +via[to]+ to produce scoped channels.
+      #                  Without +to+, +via+ is used directly as an
       #                  unscoped channel.
-      # @param subject [Proc, Symbol, String] A Proc evaluated in record
+      # @param to      [Proc, Symbol, String] A Proc evaluated in record
       #                  context, a Symbol to call via +send+, or a String
       #                  used directly as the stream name for +broadcast_to+.
-      #                  Must return a single subject or collection of
-      #                  subjects.
+      #                  Must return a single recipient or collection of
+      #                  recipients.
       # @param table   [String, Symbol, Proc] Override the Dexie table name
       #                 (defaults to the model's table_name). A Proc is
       #                 evaluated in the record's context.
@@ -34,18 +34,18 @@ module DexieCable
       #                 returns truthy (evaluated in the record's context).
       # @param unless  [Symbol, Proc] Skip sync if the given method or proc
       #                 returns truthy (evaluated in the record's context).
-      def syncs_to_dexie(via:, subject: nil, table: nil, only: nil, **options)
+      def syncs_to_dexie(via:, to: nil, table: nil, only: nil, **options)
         events     = Array(only || %i[create update destroy])
         conditions = options.slice(:if, :unless)
 
         @dexie_sync_configs ||= []
-        @dexie_sync_configs << { via: via, subject: subject, table: table, only: events, **conditions }
+        @dexie_sync_configs << { via: via, to: to, table: table, only: events, **conditions }
 
         if events.include?(:destroy)
           before_destroy :dexie_sync_before_destroy
 
           after_commit on: :destroy, **conditions do
-            Array(resolve_channel(via, subject)).each do |channel|
+            Array(resolve_channel(via, to)).each do |channel|
               next unless channel
               channel.table(resolve_table(table)).delete(dexie_destroy_id)
             end
@@ -54,7 +54,7 @@ module DexieCable
 
         if events.include?(:create)
           after_commit on: :create, **conditions do
-            Array(resolve_channel(via, subject)).each do |channel|
+            Array(resolve_channel(via, to)).each do |channel|
               next unless channel
               channel.table(resolve_table(table)).add(as_json_for_dexie)
             end
@@ -63,7 +63,7 @@ module DexieCable
 
         if events.include?(:update)
           after_commit on: :update, **conditions do
-            Array(resolve_channel(via, subject)).each do |channel|
+            Array(resolve_channel(via, to)).each do |channel|
               next unless channel
 
               changes = as_json_for_dexie.slice(*saved_changes.keys)
@@ -76,20 +76,20 @@ module DexieCable
 
     private
 
-    def resolve_channel(via, subject = nil)
-      if subject
-        subjects = resolve_subject(subject)
-        Array(subjects).map { |s| via[s] }
+    def resolve_channel(via, to = nil)
+      if to
+        recipients = resolve_recipient(to)
+        Array(recipients).map { |r| via[r] }
       else
         via
       end
     end
 
-    def resolve_subject(subject)
-      case subject
-      when Proc   then instance_exec(&subject)
-      when Symbol then send(subject)
-      else subject
+    def resolve_recipient(to)
+      case to
+      when Proc   then instance_exec(&to)
+      when Symbol then send(to)
+      else to
       end
     end
 

data/lib/dexiecable/concern.rb

@@ -6,12 +6,12 @@ module DexieCable
   included do
     public :transmit
 
-    # Open a scoped channel for broadcasting to a specific subject.
+    # Open a scoped channel for broadcasting to a specific recipient.
     #
     #   UserChannel[current_user].table("notifications").add(notification)
     #
-    def self.[](subject)
-      ScopedChannel.new(self, subject)
+    def self.[](recipient)
+      ScopedChannel.new(self, recipient)
     end
 
     # Build a query against a Dexie table, transmitted to all subscribers

data/lib/dexiecable/scoped_channel.rb

@@ -2,9 +2,9 @@
 
 module DexieCable
   class ScopedChannel
-    def initialize(klass, subject)
-      @klass   = klass
-      @subject = subject
+    def initialize(klass, recipient)
+      @klass     = klass
+      @recipient = recipient
     end
 
     def table(name)
@@ -12,7 +12,7 @@ module DexieCable
     end
 
     def transmit(data)
-      @klass.broadcast_to @subject, data
+      @klass.broadcast_to @recipient, data
     end
   end
 end

data/lib/dexiecable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DexieCable
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dexiecable
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Stefan Buhrmester