metybur 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2043abcd1c4c248fdf3e2a7981a4b68aed1c248d
+  data.tar.gz: a44a7514d74dcdbdb571d80804db938deba29bf8
+SHA512:
+  metadata.gz: bfded496cb0f109c29daac6a401001499ba7f698c47e9358a2d2e8116fdacf9f88cc807b4608786e6c079fb4a2099335f431babfc87c8825c492173dceca0d6b
+  data.tar.gz: 1bc3b6fc5afb48f64b552a7006ec84680bd0c6efa8b2df70ea4580db64fdb96e2db830dfb6de82851729392589c5bcf253e85890c06c9e5f66327d4c949fc46d

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 2.2.0
+  - 2.1.0
+  - 2.0.0
+  - 1.9.3
+  - jruby-19mode
+  - ruby-head
+  - jruby-head

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in metybur.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Clemens Helm
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,137 @@
+# Metybur
+[![Build Status](https://travis-ci.org/clemenshelm/metybur.svg?branch=master)](https://travis-ci.org/clemenshelm/metybur)
+
+A DDP client for Ruby to connect to Meteor apps.
+
+Metybur lets your Ruby application connect to a Meteor app. It allows you
+to subscribe to collections and to receive updates on them.
+You can also call Meteor methods from Ruby.
+
+> ## Caution!
+> 
+> This gem is just a few days old so far and doesn't include basic features like proper error handling. Also only a subset of the DDP protocol is implemented so far. Everything described in this README should work, though.
+> 
+> I'll keep working on it constantly, so I suppose there will be a complete and stable version soon. Stay tuned!
+> 
+> Clemens
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'metybur'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install metybur
+
+## Usage
+
+### 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.
+
+```ruby
+require 'eventmachine'
+
+EM.run do
+  meteor = Metybur.connect('http://my-meteor-app.org:80/websocket')
+end
+```
+
+will connect to your Meteor app. If you want to log in at your app, pass the credentials:
+
+```ruby
+require 'eventmachine'
+
+EM.run do
+  meteor = Metybur.connect(
+    'http://my-meteor-app.org:80/websocket',
+    email:    'rubyist@meteor.com',
+    password: 'twinkle twinkle'
+  )
+end
+```
+
+You can also pass a `:username` or `:id` instead of an `:email`. These arguments correspond to those described in [the Meteor docs](http://docs.meteor.com/#/full/meteor_loginwithpassword).
+
+Alternatively you can log in at a later point by calling the `login` method explicitly:
+
+```ruby
+require 'eventmachine'
+
+EM.run do
+  meteor = Metybur.connect('http://my-meteor-app.org:80/websocket')
+
+  # Do something unauthenticated...
+
+  meteor.login(user: {email: 'rubyist@meteor.com'}, password: 'twinkle twinkle'
+end
+```
+
+From now on I'll skip the `EM.run` block in code examples, but don't forget about it. Otherwise it won't work! Promise!
+
+### Subscribing to a Meteor record set
+
+After connecting to your Meteor app, you can subscribe to one of the published record sets:
+
+```ruby
+meteor = Metybur.connect('http://my-meteor-app.org:80/websocket')
+meteor.subscribe('my-chat-messages')
+```
+
+### Collections
+
+Once you've subscribed, you will receive all records that are already in the record set. The record set contains records from one or more collections. You can process these records as they arrive:
+
+```ruby
+@chat_messages = {}
+meteor.collection('chat-messages')
+  .on(:added) { |id, attributes| @chat_messages[id] = attributes }
+```
+
+### Remote Procedure Calls
+
+Call meteor methods to write back data to Meteor or to trigger actions in your Meteor app.
+
+```ruby
+meteor.post_chat_message('Hey there!', in_room: 'General')
+```
+
+This corresponds to the following method call in Meteor:
+
+```javascript
+// Javascript
+Meteor.call('postChatMessage', { inRoom: 'General' });
+```
+
+If you prefer the Meteor syntax, you can also call the method like this:
+
+```ruby
+meteor.call('postChatMessage', inRoom: 'General')
+```
+
+Note that you have to choose this syntax, if your Meteor method name collides with a Metybur method (like `collection` or `subscribe`).
+
+### Logging
+
+To debug your application, you can lower the log level to see all incoming websocket messages.
+
+```ruby
+Metybur.log_level = :debug
+```
+
+Make sure to set the log level before calling `Metybur.connect`, as it won't have any effect afterwards.
+
+## Contributing
+
+1. Fork it ( https://github.com/clemenshelm/metybur/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.ruby_opts = ['-Ilib -w']
+end
+
+task :default => [:spec]

data/lib/metybur/client.rb

@@ -0,0 +1,45 @@
+require 'active_support/inflector'
+require_relative 'collection'
+
+class Metybur::Client
+  def initialize(websocket)
+    @websocket = websocket
+  end
+
+  def subscribe(record_set_name)
+    message = {
+      msg: 'sub',
+      id: 'cde',
+      name: record_set_name
+    }.to_json
+    @websocket.send message
+  end
+
+  def collection(name)
+    Metybur::Collection.new(name, @websocket)
+  end
+
+  def call(method, params)
+    message = {
+      msg: 'method',
+      id: 'efg',
+      method: method,
+      params: params
+    }.to_json
+    @websocket.send message
+  end
+
+  def method_missing(method, *params)
+    method = method.to_s.camelize(:lower)
+    params.map! do |param|
+      case param
+      when Hash
+        param_array = param.map { |k, v| [k.to_s.camelize(:lower), v] }
+        Hash[param_array]
+      else
+        param
+      end
+    end
+    call(method, params)
+  end
+end

data/lib/metybur/collection.rb

@@ -0,0 +1,14 @@
+class Metybur::Collection
+  def initialize(collection_name, websocket)
+    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
+    end
+  end
+
+  def on(event, &block)
+    @added_callback = block 
+  end
+end

data/lib/metybur/version.rb

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

data/lib/metybur.rb

@@ -0,0 +1,77 @@
+require "metybur/version"
+require 'faye/websocket'
+require 'json'
+require 'logger'
+require_relative 'metybur/client'
+
+module Metybur
+  CONFIG = {
+    websocket_client_class: Faye::WebSocket::Client,
+    log_level: Logger::INFO,
+    log_stream: STDOUT
+  }
+
+  def self.connect(url, credentials = {})
+    websocket = CONFIG[:websocket_client_class].new(url)
+    client = Metybur::Client.new(websocket)
+
+    logger = Logger.new(CONFIG[:log_stream])
+    logger.level = CONFIG[:log_level]
+    websocket.on(:open) do |event|
+      logger.debug 'connection open'
+    end
+    websocket.on(:message) do |message|
+      logger.debug "received message #{message.data}"
+    end
+    websocket.on(:close) do |event|
+      logger.debug "connection closed (code #{event.code}). #{event.reason}"
+      EM.stop_event_loop
+    end
+
+    websocket.on(:message) do |event|
+      message = JSON.parse(event.data, symbolize_names: true)
+      if message[:msg] == 'ping'
+        websocket.send({msg: 'pong'}.to_json)
+      end
+    end
+
+    connect_message = {
+      msg: 'connect',
+      version: '1',
+      support: ['1']
+    }
+    websocket.send(connect_message.to_json)
+
+    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
+  end
+
+  def self.websocket_client_class=(klass)
+    CONFIG[:websocket_client_class] = klass
+  end
+  
+  def self.log_level=(level_symbol)
+    upcase_symbol = level_symbol.to_s.upcase.to_sym
+    CONFIG[:log_level] = Logger.const_get(upcase_symbol)
+  end
+
+  def self.log_stream=(io)
+    CONFIG[:log_stream] = io
+  end
+end

data/metybur.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'metybur/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "metybur"
+  spec.version       = Metybur::VERSION
+  spec.authors       = ["Clemens Helm"]
+  spec.email         = ["clemens.helm@gmail.com"]
+  spec.summary       = 'DDP client for Ruby to connect to Meteor apps.'
+  spec.description   = <<-description
+    Metybur lets your Ruby application connect to a Meteor app. It allows you
+    to subscribe to collections and to receive updates on them.
+    You can also call Meteor methods from Ruby.
+  description
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "faye-websocket", "~> 0.9"
+  spec.add_runtime_dependency "activesupport", ">= 2.2.1"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "ffaker"
+  spec.add_development_dependency "pry"
+end

data/spec/metybur_spec.rb

@@ -0,0 +1,222 @@
+require_relative '../lib/metybur'
+require_relative 'mocks/websocket_mock'
+require 'ffaker'
+require 'json'
+
+describe Metybur do
+  before :all do
+    Metybur.websocket_client_class = WebsocketMock
+  end
+
+  let(:url) { FFaker::Internet.http_url }
+  let(:websocket) { WebsocketMock.instance }
+
+  def parse(string_data)
+    JSON.parse(string_data, symbolize_names: true)
+  end
+
+  it 'connects to a Meteor URL' do
+    Metybur.connect url
+
+    expect(websocket.url).to eq url
+    connect_message = parse(websocket.sent.first)
+    expect(connect_message)
+      .to eq msg: 'connect',
+             version: '1',
+             support: ['1']
+  end
+
+  context 'logging in' do
+    it 'calls the login method with email and password' do
+      email = FFaker::Internet.email
+      password = FFaker::Internet.password
+
+      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])
+        .to eq user: { email: email },
+               password: password
+    end
+
+    it 'calls the login method with username and password' do
+      username = FFaker::Internet.user_name
+      password = FFaker::Internet.password
+
+      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])
+        .to eq user: { username: username },
+               password: password
+    end
+
+    it 'calls the login method with user id and password' do
+      userid = FFaker::Guid.guid
+      password = FFaker::Internet.password
+
+      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])
+        .to eq user: { id: userid },
+               password: password
+    end
+
+    it "doesn't log in without credentials" do
+      Metybur.connect url
+
+      last_message = parse(websocket.sent.last)
+      expect(last_message[:msg]).to eq 'connect'
+    end
+  end
+
+  context 'ping pong' do
+    it 'responds with pong to a ping' do
+      Metybur.connect url
+
+      websocket.receive({msg: 'ping'}.to_json)
+
+      last_message = parse(websocket.sent.last)
+      expect(last_message[:msg]).to eq 'pong'
+    end
+  end
+
+
+  context 'logging' do
+    it "doesn't log any messages by default" do
+      output = StringIO.new
+      Metybur.log_stream = output
+      Metybur.connect url
+
+      websocket.receive({msg: 'logged_message'}.to_json)
+
+      expect(output.string).to be_empty
+    end
+
+    it 'logs a message when the log level is set to debug' do
+      output = StringIO.new
+      Metybur.log_level = :debug
+      Metybur.log_stream = output
+      Metybur.connect url
+      
+      websocket.receive({msg: 'logged_message'}.to_json)
+
+      expect(output.string).not_to be_empty
+    end
+  end
+
+  context 'subscription' do
+    it 'subscribes to a published record set' do
+      record_set = FFaker::Internet.user_name
+
+      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
+    end
+  end
+
+  context 'collections' do
+    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
+      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
+
+      fail("Callback didn't get called.") unless callback_called
+    end
+
+    it "doesn't get notified of a ping message" do
+      meteor = Metybur.connect(url)
+      meteor.collection('my-collection')
+        .on(:added) { fail('Callback got called') }
+
+      websocket.receive({msg: 'ping'}.to_json)
+    end
+  
+    it "doesn't get notified of a record from another collection" do
+      meteor = Metybur.connect(url)
+      meteor.collection('my-collection')
+        .on(:added) { fail('Callback got called') }
+
+      message = {
+        msg: 'added',
+        collection: 'another-collection',
+        id: 'xyz',
+        fields: {country: 'Belarus'}
+      }.to_json
+      websocket.receive message
+    end
+  end
+
+  context 'methods' do
+    it 'calls a method through the call method' do
+      method = %w(postChatMessage sendEmail submitOrder).sample
+      params = %w(35 Vienna true).sample(2)
+      hashParams = {emailAddress: 'myemail@example.com', myMessage: 'Alright!', userId: 'rtnilctrniae'}
+        .to_a.sample(2)
+      params << Hash[hashParams]
+
+      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
+    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'}]
+    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}]
+    end
+  end
+end

data/spec/mocks/websocket_mock.rb

@@ -0,0 +1,31 @@
+class WebsocketMock
+  class << self
+    attr_accessor :instance
+  end
+
+  MessageEvent = Struct.new(:data)
+
+  attr_reader :url, :sent
+  
+  def initialize(url)
+    WebsocketMock.instance = self
+    @url = url
+    @sent = []
+    @message_handlers = []
+  end
+
+  def on(event, &handler)
+    if event == :message
+      @message_handlers << handler
+    end
+  end
+
+  def send(string_data)
+    @sent << string_data
+  end
+
+  def receive(string_data)
+    event = MessageEvent.new(string_data)
+    @message_handlers.each { |handler| handler.call(event) }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,91 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: metybur
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Clemens Helm
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: ffaker
+  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'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: |2
+      Metybur lets your Ruby application connect to a Meteor app. It allows you
+      to subscribe to collections and to receive updates on them.
+      You can also call Meteor methods from Ruby.
+email:
+- clemens.helm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/metybur.rb
+- lib/metybur/client.rb
+- lib/metybur/collection.rb
+- lib/metybur/version.rb
+- metybur.gemspec
+- spec/metybur_spec.rb
+- spec/mocks/websocket_mock.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: DDP client for Ruby to connect to Meteor apps.
+test_files:
+- spec/metybur_spec.rb
+- spec/mocks/websocket_mock.rb
+- spec/spec_helper.rb