metybur 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2043abcd1c4c248fdf3e2a7981a4b68aed1c248d
-  data.tar.gz: a44a7514d74dcdbdb571d80804db938deba29bf8
+  metadata.gz: 16de5f618ad1003be841607f85eba295cf4bb6ae
+  data.tar.gz: bd1dc5ca319577920cf96f22109eb61446b07b24
 SHA512:
-  metadata.gz: bfded496cb0f109c29daac6a401001499ba7f698c47e9358a2d2e8116fdacf9f88cc807b4608786e6c079fb4a2099335f431babfc87c8825c492173dceca0d6b
-  data.tar.gz: 1bc3b6fc5afb48f64b552a7006ec84680bd0c6efa8b2df70ea4580db64fdb96e2db830dfb6de82851729392589c5bcf253e85890c06c9e5f66327d4c949fc46d
+  metadata.gz: 0c9ddb24c0714374d16e2d55b92721127e65c3a7603aa78e86ae6a8148a66d870867f99ff539088558acadc836023d7be75fbf7009327c9138f7289326ef493f
+  data.tar.gz: 36b0c96d11d27111276dc932387987280409b72011e2a2f585ce75887da72ff44d0929977c39a1b3c5c5905c9da42a157dd0f9e8d371e50bf7a1830bfcbb0860

data/README.md

@@ -34,7 +34,7 @@ Or install it yourself as:
 ### Connecting to a Meteor app
 
 Metybur runs in an [EventMachine](http://eventmachine.rubyforge.org/) loop.
-Therefore all our code must be wrapped in an `EM.run` block.
+Therefore all your code must be wrapped in an `EM.run` block.
 
 ```ruby
 require 'eventmachine'
@@ -93,6 +93,23 @@ Once you've subscribed, you will receive all records that are already in the rec
 @chat_messages = {}
 meteor.collection('chat-messages')
   .on(:added) { |id, attributes| @chat_messages[id] = attributes }
+  .on(:changed) { |id, attributes, cleared|
+    chat_message = @chat_messages[id]
+    chat_message.merge!(attributes)
+    cleared.each { |field| chat_message.delete(field) }
+  }
+  .on(:removed) { |id| @chat_messages.delete(id) }
+```
+
+You can also assign multiple callbacks to one event:
+
+```ruby
+@chat_messages = {}
+collection = meteor.collection('chat-messages')
+
+collection.on(:added) { |id, attributes| @chat_messages[id] = attributes }
+
+collection.on(:added) { |id, attributes| puts "received message #{attributes[:text]}" }
 ```
 
 ### Remote Procedure Calls
@@ -107,9 +124,11 @@ This corresponds to the following method call in Meteor:
 
 ```javascript
 // Javascript
-Meteor.call('postChatMessage', { inRoom: 'General' });
+Meteor.call('postChatMessage', ['Hey there!', { inRoom: 'General' }]);
 ```
 
+Methods and hash keys will be camel-cased for you, so you can stick to the Ruby naming convention.
+
 If you prefer the Meteor syntax, you can also call the method like this:
 
 ```ruby

data/lib/metybur/collection.rb

@@ -1,14 +1,24 @@
 class Metybur::Collection
   def initialize(collection_name, websocket)
+    @callbacks = {}
+
     websocket.on(:message) do |event|
       attributes = JSON.parse(event.data, symbolize_names: true)
-      if attributes[:msg] == 'added' && attributes[:collection] == collection_name
-        @added_callback.call(attributes[:id], attributes[:fields])
-      end
+      handle_message(attributes) if attributes[:collection] == collection_name
     end
   end
 
   def on(event, &block)
-    @added_callback = block 
+    @callbacks[event] ||= []
+    @callbacks[event] << block
+    self
+  end
+
+  private
+
+  def handle_message(attributes)
+    event = attributes[:msg].to_sym
+    arguments = attributes.slice(:id, :fields, :cleared).values
+    @callbacks[event].each { |callback| callback.call(*arguments) }
   end
 end

data/lib/metybur/version.rb

@@ -1,3 +1,3 @@
 module Metybur
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/metybur.rb

@@ -44,20 +44,7 @@ module Metybur
 
     password = credentials.delete(:password)
     return client unless password
-
-    login_message = {
-      msg: 'method',
-      id: 'abc',
-      method: 'login',
-      params: [
-        {
-          user: credentials,
-          password: password
-        }
-      ]
-    }
-
-    websocket.send(login_message.to_json)
+    client.login(user: credentials, password: password)
 
     client
   end

data/spec/metybur_spec.rb

@@ -10,6 +10,7 @@ describe Metybur do
 
   let(:url) { FFaker::Internet.http_url }
   let(:websocket) { WebsocketMock.instance }
+  let(:last_sent_message) { parse(websocket.sent.last) }
 
   def parse(string_data)
     JSON.parse(string_data, symbolize_names: true)
@@ -33,11 +34,10 @@ describe Metybur do
 
       Metybur.connect url, email: email, password: password
 
-      login_message = parse(websocket.sent.last)
-      expect(login_message[:msg]).to eq 'method'
-      expect(login_message).to have_key :id # we don't care about the value here
-      expect(login_message[:method]).to eq 'login'
-      expect(login_message[:params][0])
+      expect(last_sent_message[:msg]).to eq 'method'
+      expect(last_sent_message).to have_key :id # we don't care about the value here
+      expect(last_sent_message[:method]).to eq 'login'
+      expect(last_sent_message[:params][0])
         .to eq user: { email: email },
                password: password
     end
@@ -48,11 +48,10 @@ describe Metybur do
 
       Metybur.connect url, username: username, password: password
 
-      login_message = parse(websocket.sent.last)
-      expect(login_message[:msg]).to eq 'method'
-      expect(login_message).to have_key :id # we don't care about the value here
-      expect(login_message[:method]).to eq 'login'
-      expect(login_message[:params][0])
+      expect(last_sent_message[:msg]).to eq 'method'
+      expect(last_sent_message).to have_key :id # we don't care about the value here
+      expect(last_sent_message[:method]).to eq 'login'
+      expect(last_sent_message[:params][0])
         .to eq user: { username: username },
                password: password
     end
@@ -63,11 +62,10 @@ describe Metybur do
 
       Metybur.connect url, id: userid, password: password
 
-      login_message = parse(websocket.sent.last)
-      expect(login_message[:msg]).to eq 'method'
-      expect(login_message).to have_key :id # we don't care about the value here
-      expect(login_message[:method]).to eq 'login'
-      expect(login_message[:params][0])
+      expect(last_sent_message[:msg]).to eq 'method'
+      expect(last_sent_message).to have_key :id # we don't care about the value here
+      expect(last_sent_message[:method]).to eq 'login'
+      expect(last_sent_message[:params][0])
         .to eq user: { id: userid },
                password: password
     end
@@ -75,8 +73,7 @@ describe Metybur do
     it "doesn't log in without credentials" do
       Metybur.connect url
 
-      last_message = parse(websocket.sent.last)
-      expect(last_message[:msg]).to eq 'connect'
+      expect(last_sent_message[:msg]).to eq 'connect'
     end
   end
 
@@ -86,8 +83,7 @@ describe Metybur do
 
       websocket.receive({msg: 'ping'}.to_json)
 
-      last_message = parse(websocket.sent.last)
-      expect(last_message[:msg]).to eq 'pong'
+      expect(last_sent_message[:msg]).to eq 'pong'
     end
   end
 
@@ -122,38 +118,125 @@ describe Metybur do
       meteor = Metybur.connect url
       meteor.subscribe(record_set)
 
-      last_message = parse(websocket.sent.last)
-      expect(last_message[:msg]).to eq 'sub'
-      expect(last_message).to have_key :id # we don't care about the value here
-      expect(last_message[:name]).to eq record_set
+      expect(last_sent_message[:msg]).to eq 'sub'
+      expect(last_sent_message).to have_key :id # we don't care about the value here
+      expect(last_sent_message[:name]).to eq record_set
     end
   end
 
   context 'collections' do
+    def wait_for_callback(calls: 1)
+      times_called = 0
+      done = -> { times_called += 1 }
+      yield done
+      fail("Callback only got called #{times_called} time(s).") if times_called < calls
+    end
+
     it 'gets notified when a record is added' do
       collection = FFaker::Internet.user_name
-      callback_called = false
+      id = FFaker::Guid.guid
+      fields = {city: FFaker::Address.city}
+
+      meteor = Metybur.connect url
+
+      wait_for_callback do |done|
+        meteor.collection(collection)
+          .on(:added) do |added_id, added_fields|
+            done.call()
+            expect(added_id).to eq id
+            expect(added_fields).to eq fields
+          end
+
+        message = {
+          msg: 'added',
+          collection: collection,
+          id: id,
+          fields: fields
+        }.to_json
+        websocket.receive message
+      end
+    end
 
+    it 'gets notified when a record is changed' do
+      collection = FFaker::Internet.user_name
       id = FFaker::Guid.guid
       fields = {city: FFaker::Address.city}
+      cleared = [FFaker::Guid.guid]
 
       meteor = Metybur.connect url
-      meteor.collection(collection)
-        .on(:added) do |added_id, added_fields|
-          callback_called = true
-          expect(added_id).to eq id
-          expect(added_fields).to eq fields
-        end
 
-      message = {
-        msg: 'added',
-        collection: collection,
-        id: id,
-        fields: fields
-      }.to_json
-      websocket.receive message
+      wait_for_callback do |done|
+        meteor.collection(collection)
+          .on(:changed) do |changed_id, changed_fields, cleared_fields|
+            done.call()
+            expect(changed_id).to eq id
+            expect(changed_fields).to eq fields
+            expect(cleared_fields).to eq cleared
+          end
+
+        message = {
+          msg: 'changed',
+          collection: collection,
+          id: id,
+          fields: fields,
+          cleared: cleared
+        }.to_json
+        websocket.receive message
+      end
+    end
+
+    it 'gets notified when a record is removed' do
+      collection = FFaker::Internet.user_name
+      id = FFaker::Guid.guid
+
+      meteor = Metybur.connect url
+
+      wait_for_callback do |done|
+        meteor.collection(collection)
+          .on(:removed) do |removed_id|
+            done.call()
+            expect(removed_id).to eq id
+          end
+
+        message = {
+          msg: 'removed',
+          collection: collection,
+          id: id
+        }.to_json
+        websocket.receive message
+      end
+    end
+
+    it 'lets the `on` method be chainable' do
+      meteor = Metybur.connect(url)
+      meteor.collection('my-collection')
+        .on(:added) { anything }
+        .on(:changed) { anything }
+        .on(:removed) { anything }
+
+      # Succeeds if there is no error
+    end
+
+    it 'registers multiple added callbacks' do
+      collection = FFaker::Internet.user_name
+      id = FFaker::Guid.guid
+      fields = {city: FFaker::Address.city}
+
+      meteor = Metybur.connect url
 
-      fail("Callback didn't get called.") unless callback_called
+      wait_for_callback(calls: 2) do |done|
+        meteor.collection(collection)
+          .on(:added) { |added_id, added_fields| done.call() }
+          .on(:added) { |added_id, added_fields| done.call() }
+
+        message = {
+          msg: 'added',
+          collection: collection,
+          id: id,
+          fields: fields
+        }.to_json
+        websocket.receive message
+      end
     end
 
     it "doesn't get notified of a ping message" do
@@ -190,33 +273,30 @@ describe Metybur do
       meteor = Metybur.connect(url)
       meteor.call(method, params)
 
-      last_message = parse(websocket.sent.last)
-      expect(last_message[:msg]).to eq 'method'
-      expect(last_message[:method]).to eq method
-      expect(last_message).to have_key :id # we don't care about the value here
-      expect(last_message[:params]).to eq params
+      expect(last_sent_message[:msg]).to eq 'method'
+      expect(last_sent_message[:method]).to eq method
+      expect(last_sent_message).to have_key :id # we don't care about the value here
+      expect(last_sent_message[:params]).to eq params
     end
 
     it 'calls a method called on the client directly' do
       meteor = Metybur.connect(url)
       meteor.activate('user', id: 'utrtrvlc')
 
-      last_message = parse(websocket.sent.last)
-      expect(last_message[:msg]).to eq 'method'
-      expect(last_message[:method]).to eq 'activate'
-      expect(last_message).to have_key :id # we don't care about the value here
-      expect(last_message[:params]).to eq ['user', {id: 'utrtrvlc'}]
+      expect(last_sent_message[:msg]).to eq 'method'
+      expect(last_sent_message[:method]).to eq 'activate'
+      expect(last_sent_message).to have_key :id # we don't care about the value here
+      expect(last_sent_message[:params]).to eq ['user', {id: 'utrtrvlc'}]
     end
 
     it 'camel-cases methods and parameters called on the client directly' do
       meteor = Metybur.connect(url)
       meteor.activate_user('Hans', user_id: 'utrtrvlc', is_admin: false)
 
-      last_message = parse(websocket.sent.last)
-      expect(last_message[:msg]).to eq 'method'
-      expect(last_message[:method]).to eq 'activateUser'
-      expect(last_message).to have_key :id # we don't care about the value here
-      expect(last_message[:params]).to eq ['Hans', {userId: 'utrtrvlc', isAdmin: false}]
+      expect(last_sent_message[:msg]).to eq 'method'
+      expect(last_sent_message[:method]).to eq 'activateUser'
+      expect(last_sent_message).to have_key :id # we don't care about the value here
+      expect(last_sent_message[:params]).to eq ['Hans', {userId: 'utrtrvlc', isAdmin: false}]
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metybur
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Clemens Helm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-05 00:00:00.000000000 Z
+date: 2015-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faye-websocket
@@ -153,7 +153,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: DDP client for Ruby to connect to Meteor apps.