tinker 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f35fd6efa911604ae7b1115bf22cd4111d49555a
+  data.tar.gz: 8118de83736f98bad6c5523bb6001bbaa7fe9da0
+SHA512:
+  metadata.gz: 7dae780939f9307a276780ec57562ed5ee7d4f631914e22657a0ddefe52c91f6da4ed1e487a8a40b0f20fd4d1638809b21a4debc4fd7a30f33d4ac5c0ab1763e
+  data.tar.gz: 034a46d13632d872c47d75cff47d9480132b9d47bd4897c72f4d28fe5deddc83a9e8c164789f6c3b61fd649e906e3096f39cd354e17a2a0a458ba1c55be3e24a

data/.gitignore

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

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--backtrace

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Guillaume Malette
+
+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,29 @@
+# Tinker
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'tinker'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tinker
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/tinker.rb

@@ -0,0 +1,34 @@
+require "tinker/version"
+
+require 'singleton'
+require 'socket'
+require 'em-websocket'
+require 'json'
+require 'set'
+require 'securerandom'
+
+require 'pry'
+
+require 'tinker/monkey_patch'
+
+require 'tinker/evented'
+require 'tinker/context'
+require 'tinker/context/roster'
+
+require 'tinker/reactor'
+require 'tinker/engine'
+require 'tinker/application'
+require 'tinker/room'
+require 'tinker/client'
+require 'tinker/websocket'
+require 'tinker/network/message'
+
+require 'tinker/event'
+require 'tinker/event/environment'
+
+
+module Tinker
+  class << self
+    attr_accessor :application
+  end
+end

data/lib/tinker/application.rb

@@ -0,0 +1,19 @@
+class Tinker::Application < Tinker::Engine
+  include Tinker::Reactor
+
+  on "meta.client.join", :on_client_join
+  on "meta.client.leave", :on_client_leave
+
+  def initialize
+    super
+    Tinker.application ||= self
+  end
+
+  def on_client_join(event)
+    add_client(event.environment.client)
+  end
+
+  def on_client_leave(event)
+    event.environment.client.disconnect
+  end
+end

data/lib/tinker/client.rb

@@ -0,0 +1,35 @@
+class Tinker::Client
+  attr_reader :socket, :id
+
+  def initialize(socket)
+    @socket = socket
+    @id = SecureRandom.uuid
+    @contexts = Set.new
+  end
+
+  def join(context)
+    @contexts.add context
+    send(action: 'meta.context.join', context: context.id, params: { type: context.class })
+  end
+
+  def leave(context)
+    @contexts.delete context
+    send(action: 'meta.context.leave', context: context.id, params: { type: context.class })
+  end
+
+  def disconnect
+    @contexts.each do |context|
+      context.remove_client(self)
+    end
+  end
+
+  def to_json(*a)
+    {
+      id: id
+    }.to_json(*a)
+  end
+
+  def send(params)
+    socket.send(params)
+  end
+end

data/lib/tinker/context.rb

@@ -0,0 +1,141 @@
+module Tinker::Context
+  include Tinker::Evented
+
+  class << self
+    def contexts
+      @contexts ||= {}
+    end
+  end
+
+  def self.included(base)
+    base.send :include, InstanceMethods
+    base.send :extend, ClassMethods
+  end
+
+  module InstanceMethods
+    attr_reader :roster, :id
+
+    def initialize
+      @id = SecureRandom.uuid
+      @roster = Set.new
+      initialize_listeners
+      Tinker::Context.contexts[@id] = self
+      super
+    end
+
+
+    # Public: Removes this context from accessible contexts
+    #
+    #
+    # Examples
+    #
+    #     @room.release
+    #
+    # Returns self
+    def release
+      @roster.each do |client|
+        remove_client(client)
+      end
+
+      Tinker::Context.contexts.delete @id
+      self
+    end
+
+    # Public: Sends the message to all connected clients of this room
+    #
+    # params - The message to send to the clients
+    #
+    # Examples
+    #
+    #     @room.broadcast({:chat => "message"})
+    #
+    # options:
+    #   - except => list of clients to whom the message will not be sent
+    # Returns self
+    def broadcast(params)
+      except = Array(params.delete(:except)) || []
+      @roster.each{ |client| self.send_to_client(client, params) unless except.include?(client) }
+      self
+    end
+
+    # Public: Adds a client to the roster
+    #
+    # client - The client to add to the roster
+    #
+    # Examples
+    #
+    #     @room.add_client(client)
+    #
+    # Returns self
+    def add_client(client)
+      @roster.add(client)
+      client.join(self)
+
+      env = Tinker::Event::Environment.new(client, self)
+      dispatch Tinker::Event.new("client.join", env)
+
+      broadcast(:action => "meta.roster.add", :params => {:id => client.id}, :except => client)
+
+      self
+    end
+
+    # Public: Removes a client from the roster
+    #
+    # client - The client to remove
+    #
+    # Examples
+    #
+    #     @room.remove_client(client)
+    #
+    # Returns self
+    def remove_client(client)
+      @roster.delete client
+      client.leave(self)
+
+      env = Tinker::Event::Environment.new(client, self)
+      dispatch Tinker::Event.new("client.leave", env)
+
+      broadcast(:action => "meta.roster.remove", :params => {:id => client.id}, :except => client)
+
+      self
+    end
+
+    def send_to_client(client, reply_to = nil, params)
+      params = params.dup.merge({:context => @id, :reply_to => reply_to})
+      client.send(params)
+    end
+
+
+    def dispatch(event)
+      event.environment = Tinker::Event::Environment.new(event.environment.client, self)
+      super(event)
+    end
+
+    private
+    def initialize_listeners
+      self.class.ancestors_binding_definitions.each do |block|
+        self.instance_eval &block
+      end
+    end
+  end
+
+  module ClassMethods
+    def binding_definitions
+      @binding_definitions ||= []
+    end
+
+    def ancestors_binding_definitions
+      ancestors.select{|klass| klass < Tinker::Context}.reduce([]){|arr, klass| arr.push *klass.binding_definitions }
+    end
+
+    %w(on every).each do |m|
+      define_method(m.to_sym) do |*args, &block|
+        args << block if block
+        binding_definitions.push(Proc.new{
+          self.send(m, *args)
+        })
+      end
+    end
+
+  end
+end

data/lib/tinker/context/roster.rb

@@ -0,0 +1,18 @@
+module Tinker::Context::Roster
+  module Synchronize
+    def self.included(base)
+      raise ArgumentError, 'Must be included in a `Tinker::Context`' unless base < Tinker::Context
+
+      base.send :include, InstanceMethods
+
+      base.on "client.join", :synchronize_roster
+      base.on "client.leave", :synchronize_roster
+    end
+
+    module InstanceMethods
+      def synchronize_roster(event)
+        broadcast :action => "meta.roster.synchronize", :params => { :roster => @roster }
+      end
+    end
+  end
+end

data/lib/tinker/engine.rb

@@ -0,0 +1,39 @@
+class Tinker::Engine
+  include Singleton
+  include Tinker::Context
+
+  attr_accessor :config
+
+  def initialize
+    super
+  end
+
+  def self.configure
+    @singleton__mutex__.synchronize {
+      app = self.send(:allocate)
+      app.config = Configuration.new
+      yield app.config if block_given?
+      @singleton__instance__ = app
+    }
+  end
+
+  def self.release_singleton
+    @singleton__mutex__.synchronize {
+      @singleton__instance__ = nil
+    }
+    self
+  end
+
+  class Configuration
+    attr_accessor :port, :host
+
+    def initialize
+      {
+        port: "6202",
+        host: "0.0.0.0"
+      }.each do |k, v|
+        self.send("#{k}=", v)
+      end
+    end
+  end
+end

data/lib/tinker/event.rb

@@ -0,0 +1,13 @@
+class Tinker::Event
+  attr_accessor :environment, :params, :name
+
+  def initialize(name, environment, params = {})
+    @name = name
+    @environment = environment
+    @params = params
+  end
+
+  def env
+    environment
+  end
+end

data/lib/tinker/event/environment.rb

@@ -0,0 +1,9 @@
+class Tinker::Event::Environment < Hash
+  attr_reader :client, :context
+
+  def initialize(client, context, params = {})
+    @client = client
+    @context = context
+    super params
+  end
+end

data/lib/tinker/evented.rb

@@ -0,0 +1,48 @@
+module Tinker::Evented
+  def on(event_name, *callbacks, &block)
+    raise ArgumentError, 'No callbacks given' unless callbacks.any? || block
+    _dispatchers[event_name].push(*callbacks) if callbacks.any?
+    _dispatchers[event_name].push(&block) if block
+  end
+
+  def every(time, *callbacks, &block)
+    callbacks << block if block
+    EventMachine.add_periodic_timer(time) do
+      env = Tinker::Event::Environment.new(nil, self)
+      event = Tinker::Event.new("meta.timer.tick", env)
+      callbacks.each do |callback|
+        event_callback(event, callback)
+      end
+    end
+  end
+
+  # Internal: Disatches an event
+  #
+  # event - The event to dispatch to the listeners
+  #
+  # Examples
+  #
+  #     @room.dispatch(Event.new("event_name", nil, :param1 => "value1"))
+  def dispatch(event)
+    _dispatchers[event.name].each do |callback|
+      event_callback event, callback
+    end
+  end
+
+  protected
+
+  def event_callback(event, callback)
+    if callback.respond_to? :call
+      callback.call(event)
+    elsif callback.is_a?(Class) && callback.instance_methods.include?(:call)
+      callback.new.call(event)
+    elsif callback.is_a?(Symbol) && self.respond_to?(callback)
+      self.send(callback, event)
+    end
+  end
+
+  private
+  def _dispatchers
+    @dispatchers ||= Hash.new{|h,k| h[k] = []}
+  end
+end

data/lib/tinker/monkey_patch.rb

@@ -0,0 +1,5 @@
+class Set
+  def to_json(*a)
+    to_a.to_json(*a)
+  end
+end

data/lib/tinker/network/message.rb

@@ -0,0 +1,11 @@
+module Tinker::Network
+  class Message
+    attr_reader :socket, :body
+
+    def initialize(params)
+      [:socket, :body].each do |param|
+        instance_variable_set("@#{param}", params[param])
+      end
+    end
+  end
+end

data/lib/tinker/reactor.rb

@@ -0,0 +1,105 @@
+module Tinker::Reactor
+  include Tinker::Evented
+
+  attr_reader :event_queue, :message_queue
+
+  def trap_sigint
+    Signal.trap("INT"){ stop }
+  end
+
+  def stop
+    EventMachine.stop_server @websocket_server
+    EventMachine.add_periodic_timer(1){ wait_for_connections_and_stop  }
+  end
+
+  def clients
+    @clients ||= {}
+  end
+
+  def run
+    return if @event_queue
+
+    trap_sigint
+
+    @event_queue = Queue.new
+    @message_queue = Queue.new
+
+    @event_thread = Thread.new do
+      Thread.current.abort_on_exception = true
+      loop do
+        event = @event_queue.pop
+        # puts "Processing event: #{event.inspect}"
+        event.env.context.dispatch event
+      end
+    end
+
+    @message_thread = Thread.new do
+      Thread.current.abort_on_exception = true
+      loop do
+        message = @message_queue.pop
+        # puts "Sending message: #{message.inspect}"
+        message.socket.send(message.body)
+      end
+    end
+
+    EventMachine.run do
+      Backro::Application.instance.send(:initialize)
+
+      puts "Starting EventMachine on port #{self.config.port}"
+
+      @websocket_server = EventMachine::start_server(self.config.host, self.config.port, EventMachine::WebSocket::Connection, {}) do |ws|
+        websocket = Tinker::WebSocket.new(ws)
+
+        client = Tinker::Client.new(websocket)
+        clients[ws] = client
+        port, ip = Socket.unpack_sockaddr_in(ws.get_peername)
+
+        ws.onopen do
+          puts "WebSocket Connection open (#{ip}:#{port})"
+
+          env = Tinker::Event::Environment.new(client, Tinker.application)
+          @event_queue.push(Tinker::Event.new("meta.client.join", env))
+        end
+
+        ws.onmessage do |message|
+          begin
+            # puts "Incoming message (#{ip}:#{port}): #{message}"
+            json = JSON(message)
+
+            env = Tinker::Event::Environment.new(client, (Tinker::Context.contexts[json['context']] || Tinker.application))
+            event = Tinker::Event.new("client.message.#{json['action']}", env, json['params'])
+
+            @event_queue.push(event)
+          rescue JSON::ParserError
+            # puts "Invalid message (#{ip}:#{port})"
+            ws.send({:type => :error, :action => :message, :errors => ["Invalid message format"]}.to_json)
+          end
+        end
+
+        ws.onclose do
+          puts "WebSocket Connection closed (#{ip}:#{port})"
+
+          env = Tinker::Event::Environment.new(client, Tinker.application)
+          @event_queue.push(Tinker::Event.new("meta.client.leave", env))
+
+          clients.delete ws
+        end
+      end
+    end
+
+    @event_thread.terminate
+    @message_thread.terminate
+
+  end
+
+  private
+  def wait_for_connections_and_stop
+    if clients.empty?
+      EventMachine.stop
+      true
+    else
+      puts "Waiting for #{clients.size} connection(s) to finish"
+      false
+    end
+  end
+end

data/lib/tinker/room.rb

@@ -0,0 +1,3 @@
+class Tinker::Room
+  include Tinker::Context
+end

data/lib/tinker/version.rb

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

data/lib/tinker/websocket.rb

@@ -0,0 +1,12 @@
+class Tinker::WebSocket
+  attr_reader :socket
+  
+  def initialize(websocket)
+    @socket = websocket
+  end
+
+  def send(params)
+    message = params.to_json
+    Tinker.application.message_queue << Tinker::Network::Message.new(:body => message, :socket => socket)
+  end
+end

data/spec/context_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+require 'pry'
+class MockSocket 
+  attr_reader :messages
+
+  def initialize
+    @messages = []
+  end
+
+  def send(params)
+    messages << params
+  end
+end
+
+
+shared_examples "a context" do
+  
+  context "#add_client" do
+    before {
+      context.add_client(client_1)
+      context.add_client(client_2)
+    }
+
+    it "adds the client to the roster" do
+      context.roster.should include(client_1)
+    end
+
+    it "sends a 'meta.context.join' message" do
+      message = client_1.socket.messages.first
+      message[:action].should == 'meta.context.join'
+    end
+
+    it "sends the event to other clients" do
+      message = client_1.socket.messages.last
+      message[:action].should == 'meta.roster.add'
+      message[:params][:id].should == client_2.id
+    end
+
+    it "doesn't send the event to self" do
+      client_2.socket.messages.each do |message|
+        if message[:action] == 'meta.roster.add'
+          message[:params][:id].should_not == client_2.id
+        end
+      end
+    end
+  end
+
+  context "#send_to_client" do
+    before {
+      context.send_to_client(client_1, :action => :test, :params => {})
+    }
+
+    it "sends the message to the client"  do
+      client_1.socket.messages.last[:action].should == :test
+    end
+  end
+
+  context "#remove_client" do
+    before {
+      context.add_client(client_1)
+      context.add_client(client_2)
+
+      context.remove_client(client_1)
+    }
+
+    it "removes the client from the roster" do
+      context.roster.should_not include(client_1)
+    end
+
+    it "sends a message to the removed client" do
+      client_1.socket.messages.last[:action].should == "meta.context.leave"
+    end
+
+    it "sends a message to the other clients" do
+      client_2.socket.messages.last[:action].should == "meta.roster.remove"
+    end
+  end
+
+  context "#release" do
+    before {
+      context.add_client(client_1)
+      context.release
+    }
+
+    it "removes itself from the global roster" do
+      Tinker::Context.contexts.should_not include(context)
+    end
+
+    it "disconnects all clients" do
+      client_1.socket.messages.last[:action].should == "meta.context.leave"
+    end
+  end
+
+  context "#broadcast" do
+    let(:message) { {:action => "test.broadcast", :params => {}, :context => context.id, :reply_to => nil } }
+
+    before {
+      context.add_client(client_1)
+      context.add_client(client_2)
+      context.broadcast(message)
+    }
+
+    it "sends the message to all clients" do
+      client_1.socket.messages.last.should == message
+      client_2.socket.messages.last.should == message
+    end
+  end
+end
+
+
+
+describe "Tinker::Context" do
+  let(:socket_1) { MockSocket.new }
+  let(:client_1) { Tinker::Client.new(socket_1) }
+
+  let(:socket_2) { MockSocket.new }
+  let(:client_2) { Tinker::Client.new(socket_2) }
+
+  context "Tinker::Room" do
+    let(:context) { Tinker::Room.new }
+
+    it_behaves_like "a context"
+  end
+
+  context "Tinker::Application" do
+    before { Tinker::Application.release_singleton }
+    let(:context) { Tinker::Application.instance }
+
+    it_behaves_like "a context"
+  end
+
+  describe "Tinker::Context::Roster::Synchronized" do
+    let(:context) { SynchronizedContext.new }
+    before {
+      context.add_client(client_1)
+      context.add_client(client_2)
+    }
+
+    it "sends the roster to all clients upon connection" do
+      message = client_2.socket.messages.detect{ |m| m[:action] == "meta.roster.synchronize" }
+      message[:action].should == "meta.roster.synchronize"
+      
+      message[:params][:roster].should have(2).members
+      
+       message[:params][:roster].select{ |c| c.id == client_1.id }.should have(1).member
+       message[:params][:roster].select{ |c| c.id == client_2.id }.should have(1).member
+    end
+  end
+end

data/spec/events_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+shared_examples "a callback" do
+  before { context.on "event", callback }
+
+  it "sends the event" do
+    event = Tinker::Event.new("event", Tinker::Event::Environment.new(nil, context))
+    callback.should_receive(:call).with(event)
+    context.dispatch(event)
+  end
+
+  describe "#every" do
+    it "is called periodically" do
+      EM.run {
+        count = 0
+        callback.should_receive(:call).at_least(2).times
+        context.every(0.01, callback) do
+          EM.stop if (count += 1) >= 2
+        end
+      }
+    end
+  end
+end
+
+describe "Evented" do
+  class Tester
+    def call(*params)
+    end
+  end
+
+  let(:context) { Tinker::Room.new }
+
+  context "with a Proc" do
+    let(:callback) { Proc.new{} }
+
+    it_behaves_like "a callback"
+  end
+
+  context "with a class instance" do
+    let(:callback) { Tester.new }
+
+    it_behaves_like "a callback"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'tinker'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  #config.mock_framework = :mocha
+
+  # 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'
+end
+
+class SynchronizedContext < Tinker::Room
+  include Tinker::Context::Roster::Synchronize
+end

data/tinker.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/tinker/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Guillaume Malette"]
+  gem.email         = ["gmalette@gmail.com"]
+  gem.description   = %q{Tinker is a prototype for realtime games}
+  gem.summary       = %q{Tinker is a prototype for realtime games}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "tinker"
+  gem.require_paths = ["lib"]
+  gem.version       = Tinker::VERSION
+
+  gem.add_dependency "activesupport"
+  gem.add_dependency "em-websocket"
+  gem.add_dependency "rake"
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "mocha"
+  gem.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: tinker
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Guillaume Malette
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  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: mocha
+  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: Tinker is a prototype for realtime games
+email:
+- gmalette@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/tinker.rb
+- lib/tinker/application.rb
+- lib/tinker/client.rb
+- lib/tinker/context.rb
+- lib/tinker/context/roster.rb
+- lib/tinker/engine.rb
+- lib/tinker/event.rb
+- lib/tinker/event/environment.rb
+- lib/tinker/evented.rb
+- lib/tinker/monkey_patch.rb
+- lib/tinker/network/message.rb
+- lib/tinker/reactor.rb
+- lib/tinker/room.rb
+- lib/tinker/version.rb
+- lib/tinker/websocket.rb
+- readme
+- spec/context_spec.rb
+- spec/events_spec.rb
+- spec/spec_helper.rb
+- tinker.gemspec
+homepage: ''
+licenses: []
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Tinker is a prototype for realtime games
+test_files:
+- spec/context_spec.rb
+- spec/events_spec.rb
+- spec/spec_helper.rb