entangled 0.0.23 → 0.0.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7c388678aa588a1f547b713feb70dbd9f5aaa44
-  data.tar.gz: 5c4baa78c2e13abb9fdce0aabbd132698a474af4
+  metadata.gz: 1a88ff7623ddae9fbcfe0b93bc7080f309a48bf5
+  data.tar.gz: 179aa9cd196ea36f70ba8f4baf3d2d6cfc0c5dfe
 SHA512:
-  metadata.gz: a740b57b3679899c1c3bde3d2b969f00a5457f826af461626119fdb4083a08eba5c5115b433fc8c243736a00a6c7c074fa9b8c8673c561fd2cf6c18cef72c134
-  data.tar.gz: 17eb36090addf15cc12ea4a9c346dcb70411ac7273ce613ebfcf08143f9d47c15d0ee02ee8c1185a5b3200febabc2bb8fb13ac17538d205bb4a0b06daa0645e3
+  metadata.gz: 26935b60d39af34abfb60595102825d41a85188373bee4c5ac24b04392ceeb5ff8571f35229ef6ecb5432fca0626ac17286534256c3f4e9c9e5216cf4ad092e1
+  data.tar.gz: 2440601fc453c11adebee76f0c1bc061bfe74ad4d0c0b996d93b01f433e120d66bf916e528f447b54fd48d9da7e420bca46352a8f540bc4c15d9dc524b8477d4

data/README.md

@@ -413,7 +413,8 @@ The gem relies heavily on convention over configuration and currently only works
 ## Development Priorities
 The following features are to be implemented next:
 
-- Support more than one `belongs_to` association in back end
+- Check if routes really allow options right now. For example, what if I pass in shallow: true? Run rake routes to check!
+- Allow for more than one level of nesting of `#channels` in `Entangled::Model`
 - Support `belongsTo` in front end
 - Support deeply nested `belongs_to`, e.g. `Parent > Child > Grandchild`
 - Support `has_one` association in back end and front end
@@ -430,6 +431,7 @@ The following features are to be implemented next:
 - Freeze destroyed object
 - Set `$persisted()` to false on a destroyed object
 - Add `.destroyAll()` function to `Resources`
+- Add support for plain JavaScript usage (without Angular) and add section about that to Readme
 
 ## Contributing
 1. [Fork it](https://github.com/dchacke/entangled/fork) - you will notice that the repo comes with a back end and a front end part to test both parts of the gem

data/lib/entangled/model.rb

@@ -73,59 +73,54 @@ module Entangled
         attributes.merge(errors: errors).as_json
       end
 
-      # The channel name for a single record containing the
-      # inferred channel name from the class and the record's
-      # id. For example, if it's a DeliciousTaco with the id 1,
-      # the member channel for the single record is "delicious_tacos/1".
-      # Nesting is automatically applied through the use of
-      # the collection channel.
+      # Build channels. Channels always at least include
+      # a collection channel, i.e. /tacos, and a member
+      # channel, i.e. /tacos/1, for direct access.
       # 
-      # The member channel has to be the same as the path to
-      # the resource's show action, including a leading
-      # forward slash
-      def member_channel
-        "#{collection_channel}/#{self.to_param}"
-      end
+      # If the model belongs_to other models, two nested
+      # channels are added for each belongs_to association.
+      # E.g., if child belongs_to parent, the two channels
+      # that are added are parents/1/children, and
+      # parents/1/children/1, leaving a total of four channels
+      def channels
+        channels = []
+        plural_name = self.class.name.underscore.pluralize
 
-      # The inferred channel name for the collection. For example,
-      # if the class name is DeliciousTaco, the collection channel
-      # is "delicious_tacos".
-      # 
-      # If the model belongs to another model, the channel is nested
-      # accordingly. For example, if a child belongs to a parent,
-      # the child's collection channel is "parents/1/children".
-      # 
-      # The collection channel has to be the same as the path to
-      # the resource's index action, including a leading forward slash
-      def collection_channel
-        belongs_to_assocations = self.class.reflect_on_all_associations(:belongs_to)
-        own_channel = self.class.name.underscore.pluralize
-
-        if belongs_to_assocations.any?
-          parent = send(belongs_to_assocations.first.name)
-          "#{parent.member_channel}/#{own_channel}"
-        else
-          "/#{own_channel}"
+        # Add collection's channel
+        channels << "/#{plural_name}"
+
+        # Add member's channel
+        channels << "/#{plural_name}/#{to_param}"
+
+        # Find parent names from belongs_to associations
+        parents = self.class.reflect_on_all_associations(:belongs_to)
+
+        # Add nested channels for each parent
+        parents.map(&:name).each do |parent_name|
+          # Get parent record from name
+          parent = send(parent_name)
+
+          # Get parent class's plural underscore name
+          parent_plural_name = parent_name.to_s.underscore.pluralize
+
+          # Add collection's channel nested under parent's member channel
+          channels << "/#{parent_plural_name}/#{parent.to_param}/#{plural_name}"
+
+          # Add member's channel nested under parent's member channel
+          channels << "/#{parent_plural_name}/#{parent.to_param}/#{plural_name}/#{to_param}"
         end
+
+        channels
       end
 
       private
 
       # Publishes to client. Whoever is subscribed
-      # to the model's channel or the record's channel
-      # gets the message
+      # to the model's channels gets the message
       def publish(action)
-        # Publish to model's channel
-        redis.publish(
-          collection_channel,
-          json(action)
-        )
-
-        # Publish to record#s channel
-        redis.publish(
-          member_channel,
-          json(action)
-        )
+        channels.each do |channel|
+          redis.publish(channel, json(action))
+        end
       end
 
       # JSON containing the type of action (:create, :update

data/lib/entangled/version.rb

@@ -1,3 +1,3 @@
 module Entangled
-  VERSION = "0.0.23"
+  VERSION = "0.0.24"
 end

data/spec/models/inclusion_exclusion_spec.rb

@@ -14,21 +14,15 @@ RSpec.describe 'Inclusion/exclusion', type: :model do
     it 'publishes creation' do
       redis = stub_redis
 
-      # Publishing to collection channel
-      expect(redis).to have_received(:publish).with(
-        foo.collection_channel, {
-          action: :create,
-          resource: foo
-        }.to_json
-      )
-
-      # Publishing to member channel
-      expect(redis).to have_received(:publish).with(
-        foo.member_channel, {
-          action: :create,
-          resource: foo
-        }.to_json
-      )
+      # Publishing to channels
+      foo.channels.each do |channel|
+        expect(redis).to have_received(:publish).with(
+          channel, {
+            action: :create,
+            resource: foo
+          }.to_json
+        )
+      end
     end
 
     it 'does not publish update' do
@@ -36,19 +30,14 @@ RSpec.describe 'Inclusion/exclusion', type: :model do
 
       foo.update(body: 'bar')
 
-      expect(redis).to have_received(:publish).with(
-        'foos', {
-          action: :update,
-          resource: foo
-        }.to_json
-      ).never
-
-      expect(redis).to have_received(:publish).with(
-        foo.member_channel, {
-          action: :update,
-          resource: foo
-        }.to_json
-      ).never
+      foo.channels.each do |channel|
+        expect(redis).to have_received(:publish).with(
+          channel, {
+            action: :update,
+            resource: foo
+          }.to_json
+        ).never
+      end
     end
 
     it 'does not publish destruction' do
@@ -56,19 +45,14 @@ RSpec.describe 'Inclusion/exclusion', type: :model do
 
       foo.destroy
 
-      expect(redis).to have_received(:publish).with(
-        'foos', {
-          action: :destroy,
-          resource: foo
-        }.to_json
-      ).never
-
-      expect(redis).to have_received(:publish).with(
-        foo.member_channel, {
-          action: :destroy,
-          resource: foo
-        }.to_json
-      ).never
+      foo.channels.each do |channel|
+        expect(redis).to have_received(:publish).with(
+          channel, {
+            action: :destroy,
+            resource: foo
+          }.to_json
+        ).never
+      end
     end
   end
 
@@ -79,20 +63,14 @@ RSpec.describe 'Inclusion/exclusion', type: :model do
       redis = stub_redis
 
       # Publishing to collection channel
-      expect(redis).to have_received(:publish).with(
-        bar.collection_channel, {
-          action: :create,
-          resource: bar
-        }.to_json
-      )
-
-      # Publishing to member channel
-      expect(redis).to have_received(:publish).with(
-        bar.member_channel, {
-          action: :create,
-          resource: bar
-        }.to_json
-      )
+      bar.channels.each do |channel|
+        expect(redis).to have_received(:publish).with(
+          channel, {
+            action: :create,
+            resource: bar
+          }.to_json
+        )
+      end
     end
 
     it 'publishes the update' do
@@ -100,19 +78,14 @@ RSpec.describe 'Inclusion/exclusion', type: :model do
 
       bar.update(body: 'bar')
 
-      expect(redis).to have_received(:publish).with(
-        bar.collection_channel, {
-          action: :update,
-          resource: bar
-        }.to_json
-      )
-
-      expect(redis).to have_received(:publish).with(
-        bar.member_channel, {
-          action: :update,
-          resource: bar
-        }.to_json
-      )
+      bar.channels.each do |channel|
+        expect(redis).to have_received(:publish).with(
+          channel, {
+            action: :update,
+            resource: bar
+          }.to_json
+        )
+      end
     end
 
     it 'does not publish destruction' do
@@ -120,19 +93,14 @@ RSpec.describe 'Inclusion/exclusion', type: :model do
 
       bar.destroy
 
-      expect(redis).to have_received(:publish).with(
-        bar.collection_channel, {
-          action: :destroy,
-          resource: bar
-        }.to_json
-      ).never
-
-      expect(redis).to have_received(:publish).with(
-        bar.member_channel, {
-          action: :destroy,
-          resource: bar
-        }.to_json
-      ).never
+      bar.channels.each do |channel|
+        expect(redis).to have_received(:publish).with(
+          channel, {
+            action: :destroy,
+            resource: bar
+          }.to_json
+        ).never
+      end
     end
   end
 
@@ -142,21 +110,14 @@ RSpec.describe 'Inclusion/exclusion', type: :model do
     it 'does not publish the creation' do
       redis = stub_redis
 
-      # Publishing to collection channel
-      expect(redis).to have_received(:publish).with(
-        foobar.collection_channel, {
-          action: :create,
-          resource: foobar
-        }.to_json
-      ).never
-
-      # Publishing to member channel
-      expect(redis).to have_received(:publish).with(
-        foobar.member_channel, {
-          action: :create,
-          resource: foobar
-        }.to_json
-      ).never
+      foobar.channels.each do |channel|
+        expect(redis).to have_received(:publish).with(
+          channel, {
+            action: :create,
+            resource: foobar
+          }.to_json
+        ).never
+      end
     end
 
     it 'publishes the update' do
@@ -164,19 +125,14 @@ RSpec.describe 'Inclusion/exclusion', type: :model do
 
       foobar.update(body: 'foobar')
 
-      expect(redis).to have_received(:publish).with(
-        foobar.collection_channel, {
-          action: :update,
-          resource: foobar
-        }.to_json
-      )
-
-      expect(redis).to have_received(:publish).with(
-        foobar.member_channel, {
-          action: :update,
-          resource: foobar
-        }.to_json
-      )
+      foobar.channels.each do |channel|
+        expect(redis).to have_received(:publish).with(
+          channel, {
+            action: :update,
+            resource: foobar
+          }.to_json
+        )
+      end
     end
 
     it 'publishes the destruction' do
@@ -184,19 +140,14 @@ RSpec.describe 'Inclusion/exclusion', type: :model do
 
       foobar.destroy
 
-      expect(redis).to have_received(:publish).with(
-        foobar.collection_channel, {
-          action: :destroy,
-          resource: foobar
-        }.to_json
-      )
-
-      expect(redis).to have_received(:publish).with(
-        foobar.member_channel, {
-          action: :destroy,
-          resource: foobar
-        }.to_json
-      )
+      foobar.channels.each do |channel|
+        expect(redis).to have_received(:publish).with(
+          channel, {
+            action: :destroy,
+            resource: foobar
+          }.to_json
+        )
+      end
     end
   end
 
@@ -206,21 +157,14 @@ RSpec.describe 'Inclusion/exclusion', type: :model do
     it 'publishes the creation' do
       redis = stub_redis
 
-      # Publishing to collection channel
-      expect(redis).to have_received(:publish).with(
-        barfoo.collection_channel, {
-          action: :create,
-          resource: barfoo
-        }.to_json
-      )
-
-      # Publishing to member channel
-      expect(redis).to have_received(:publish).with(
-        barfoo.member_channel, {
-          action: :create,
-          resource: barfoo
-        }.to_json
-      )
+      barfoo.channels.each do |channel|
+        expect(redis).to have_received(:publish).with(
+          channel, {
+            action: :create,
+            resource: barfoo
+          }.to_json
+        )
+      end
     end
 
     it 'dpes not publish the update' do
@@ -228,19 +172,14 @@ RSpec.describe 'Inclusion/exclusion', type: :model do
 
       barfoo.update(body: 'barfoo')
 
-      expect(redis).to have_received(:publish).with(
-        barfoo.collection_channel, {
-          action: :update,
-          resource: barfoo
-        }.to_json
-      ).never
-
-      expect(redis).to have_received(:publish).with(
-        barfoo.member_channel, {
-          action: :update,
-          resource: barfoo
-        }.to_json
-      ).never
+      barfoo.channels.each do |channel|
+        expect(redis).to have_received(:publish).with(
+          channel, {
+            action: :update,
+            resource: barfoo
+          }.to_json
+        ).never
+      end
     end
 
     it 'does not publish the destruction' do
@@ -248,19 +187,14 @@ RSpec.describe 'Inclusion/exclusion', type: :model do
 
       barfoo.destroy
 
-      expect(redis).to have_received(:publish).with(
-        barfoo.collection_channel, {
-          action: :destroy,
-          resource: barfoo
-        }.to_json
-      ).never
-
-      expect(redis).to have_received(:publish).with(
-        barfoo.member_channel, {
-          action: :destroy,
-          resource: barfoo
-        }.to_json
-      ).never
+      barfoo.channels.each do |channel|
+        expect(redis).to have_received(:publish).with(
+          channel, {
+            action: :destroy,
+            resource: barfoo
+          }.to_json
+        ).never
+      end
     end
   end
 end

data/spec/models/item_spec.rb

@@ -21,15 +21,25 @@ RSpec.describe Item, type: :model do
     let(:list) { List.create(name: 'foo') }
     let(:item) { list.items.create(name: 'bar') }
 
-    describe '#member_channel' do
-      it 'has a nested member channel' do
-        expect(item.member_channel).to eq "/lists/#{list.to_param}/items/#{item.to_param}"
+    describe '#channels' do
+      it 'is an array of channels' do
+        expect(item.channels).to be_an Array
+      end
+
+      it "includes the collection's channel" do
+        expect(item.channels).to include '/items'
+      end
+
+      it "includes the item's direct channel" do
+        expect(item.channels).to include "/items/#{item.to_param}"
+      end
+
+      it "includes the collection's nested channel" do
+        expect(item.channels).to include "/lists/#{list.to_param}/items"
       end
-    end
 
-    describe '#collection_channel' do
-      it 'has a nested collection channel' do
-        expect(item.collection_channel).to eq "/lists/#{list.to_param}/items"
+      it "includes the item's nested channel" do
+        expect(item.channels).to include "/lists/#{list.to_param}/items/#{item.to_param}"
       end
     end
   end

data/spec/models/list_spec.rb

@@ -16,15 +16,17 @@ RSpec.describe List, type: :model do
   describe 'Methods' do
     let(:list) { List.create(name: 'foo') }
 
-    describe '#member_channel' do
-      it 'has the right channel' do
-        expect(list.member_channel).to eq "/lists/#{list.to_param}"
+    describe '#channels' do
+      it 'is an array of channels' do
+        expect(list.channels).to be_an Array
+      end
+
+      it "includes the collection's channel" do
+        expect(list.channels).to include '/lists'
       end
-    end
 
-    describe '#collection_channel' do
-      it 'has the right channel' do
-        expect(list.collection_channel).to eq '/lists'
+      it "includes the member's channel" do
+        expect(list.channels).to include "/lists/#{list.to_param}"
       end
     end
   end
@@ -43,23 +45,27 @@ RSpec.describe List, type: :model do
       it 'broadcasts the creation to the collection channel' do
         redis = stub_redis
 
-        expect(redis).to have_received(:publish).with(
-          list.collection_channel, {
-            action: :create,
-            resource: list
-          }.to_json
-        )
+        list.channels.each do |channel|
+          expect(redis).to have_received(:publish).with(
+            channel, {
+              action: :create,
+              resource: list
+            }.to_json
+          )
+        end
       end
 
       it 'broadcasts the creation to the member channel' do
         redis = stub_redis
 
-        expect(redis).to have_received(:publish).with(
-          list.member_channel, {
-            action: :create,
-            resource: list
-          }.to_json
-        )
+        list.channels.each do |channel|
+          expect(redis).to have_received(:publish).with(
+            channel, {
+              action: :create,
+              resource: list
+            }.to_json
+          )
+        end
       end
     end
 
@@ -71,12 +77,14 @@ RSpec.describe List, type: :model do
 
         list.update(name: 'bar')
 
-        expect(redis).to have_received(:publish).with(
-          list.collection_channel, {
-            action: :update,
-            resource: list
-          }.to_json
-        )
+        list.channels.each do |channel|
+          expect(redis).to have_received(:publish).with(
+            channel, {
+              action: :update,
+              resource: list
+            }.to_json
+          )
+        end
       end
 
       it 'broadcasts the update to the member channel' do
@@ -84,12 +92,14 @@ RSpec.describe List, type: :model do
 
         list.update(name: 'bar')
 
-        expect(redis).to have_received(:publish).with(
-          list.member_channel, {
-            action: :update,
-            resource: list
-          }.to_json
-        )
+        list.channels.each do |channel|
+          expect(redis).to have_received(:publish).with(
+            channel, {
+              action: :update,
+              resource: list
+            }.to_json
+          )
+        end
       end
     end
 
@@ -101,12 +111,14 @@ RSpec.describe List, type: :model do
 
         list.destroy
 
-        expect(redis).to have_received(:publish).with(
-          list.collection_channel, {
-            action: :destroy,
-            resource: list
-          }.to_json
-        )
+        list.channels.each do |channel|
+          expect(redis).to have_received(:publish).with(
+            channel, {
+              action: :destroy,
+              resource: list
+            }.to_json
+          )
+        end
       end
 
       it 'broadcasts the destruction to the member channel' do
@@ -114,12 +126,14 @@ RSpec.describe List, type: :model do
         
         list.destroy
 
-        expect(redis).to have_received(:publish).with(
-          list.member_channel, {
-            action: :destroy,
-            resource: list
-          }.to_json
-        )
+        list.channels.each do |channel|
+          expect(redis).to have_received(:publish).with(
+            channel, {
+              action: :destroy,
+              resource: list
+            }.to_json
+          )
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: entangled
 version: !ruby/object:Gem::Version
-  version: 0.0.23
+  version: 0.0.24
 platform: ruby
 authors:
 - Dennis Charles Hackethal
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-16 00:00:00.000000000 Z
+date: 2015-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler