padrino-websockets 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 29fa2c66e13018259a69e4c31ae06bd65c6e636b
+  data.tar.gz: 65df06207d203791552bf15743e380a7236dd110
+SHA512:
+  metadata.gz: ad15ee0928289ec7ddb10c7d2f079ef42de8d43ac2935d8855d9e52c0e539d5ce31b4538037892020d1861a4c9c625e6778249211ba7199017c208fdcb5a978c
+  data.tar.gz: 7846d58a63850da913458687f0d2535d529d83b57ca39a986df9a5ed4325c4cd2549fcdf9d1cdef9080c4d878bd3c3c1ef6d5460741671dabae3ad663e032fa4

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/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Darío Javier Cravero (dario@uxtemple.com)
+
+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,89 @@
+# Padrino Websockets
+
+A WebSockets abstraction for the Padrino Ruby Web Framework to manage
+    channels, users and events regardless of the underlying WebSockets implementation.
+
+## Current support
+
+The current version supports [SpiderGazelle](https://github.com/cotag/spider-gazelle) as its
+backend working with LibUV.
+
+Feel free to implement your own backend using, say, EventMachine and submit it! :)
+
+## Installation
+
+Add this line to your application's `Gemfile`:
+
+```
+# It only works with SpiderGazelle for now, so this dependency is a must at the moment.
+gem 'spider-gazelle', github: 'cotag/spider-gazelle'
+gem 'uv-rays', github: 'cotag/uv-rays'
+
+gem 'padrino-websockets'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install padrino-websockets
+```
+
+## Usage
+
+Add this line to your main application's file (`app/app.rb`):
+
+```
+register Padrino::WebSockets
+```
+
+Then in any controller or in the app itself, define a WebSocket channel:
+
+```
+websocket :channel do
+  event :ping do |context, message|
+    send_message({pong: true, data: message})
+  end
+end
+```
+
+How to use it on a browser?
+
+```
+var connection = new WebSocket('ws://localhost:3000/channel');
+
+connection.onopen = function(message) {
+  console.log('connected to channel');
+  connection.send(JSON.stringify({event: 'ping', some: 'data'}));
+}
+
+connection.onmessage = function(message) {
+  console.log('message', JSON.parse(message.data));
+}
+
+// TODO Implement on the backend
+connection.onerror = function(message) {
+  console.error('channel', JSON.parse(message.data));
+}
+
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/padrino-websockets/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 new Pull Request
+
+
+## Contributors
+
+Made with <3 by @dariocravero at [UXtemple](http://uxtemple.com).
+
+Heavily inspired by @stakach's [example](https://github.com/cotag/spider-gazelle/issues/4).

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/examples/padrino-app/.components

@@ -0,0 +1,9 @@
+---
+:orm: none
+:test: none
+:mock: none
+:script: none
+:renderer: slim
+:stylesheet: none
+:namespace: PadrinoWebsocketsDemo
+:migration_format: number

data/examples/padrino-app/.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+log/**/*
+tmp/**/*
+bin/*
+vendor/gems/*
+!vendor/gems/cache/
+.sass-cache/*
+db/*.db
+.*.sw*

data/examples/padrino-app/Gemfile

@@ -0,0 +1,34 @@
+source 'https://rubygems.org'
+
+# Distribute your app as a gem
+# gemspec
+
+# Server requirements
+# gem 'thin' # or mongrel
+# gem 'trinidad', :platform => 'jruby'
+gem 'spider-gazelle', github: 'cotag/spider-gazelle'
+
+# Optional JSON codec (faster performance)
+gem 'oj'
+
+# Project requirements
+gem 'rake'
+gem 'uv-rays', github: 'cotag/uv-rays'
+gem 'padrino-websockets', path: '../..'
+# gem 'padrino-websockets', github: 'dariocravero/padrino-websockets'
+
+# Component requirements
+gem 'slim'
+
+# Test requirements
+
+# Padrino Stable Gem
+# gem 'padrino', '0.12.0.rc3'
+
+# Or Padrino Edge
+gem 'padrino', :github => 'padrino/padrino-framework'
+
+# Or Individual Gems
+# %w(core gen helpers cache mailer admin).each do |g|
+#   gem 'padrino-' + g, '0.12.0.rc3'
+# end

data/examples/padrino-app/Rakefile

@@ -0,0 +1,4 @@
+require 'bundler/setup'
+require 'padrino-core/cli/rake'
+
+PadrinoTasks.init

data/examples/padrino-app/app/app.rb

@@ -0,0 +1,19 @@
+module PadrinoWebsocketsDemo
+  class App < Padrino::Application
+    register Padrino::Rendering
+    register Padrino::WebSockets
+
+    enable :sessions
+
+    get :index do
+      render :index
+    end
+
+    websocket :channel do
+      event :test do |context, message|
+        "test on channel"
+        send_message message
+      end
+    end
+  end
+end

data/examples/padrino-app/app/views/index.slim

@@ -0,0 +1,19 @@
+h1 Padrino WebSockets demo
+
+p Watch out your developer's console. There's a <strong>connection</strong> variable ready to use.
+
+javascript:
+  !function(window) {
+    'use strict';
+
+    window.connection = new WebSocket('ws://localhost:3000/channel');
+
+    connection.onopen = function(message) {
+      console.log('connected to channel');
+      connection.send(JSON.stringify({event: 'test', some: 'data'}));
+    }
+
+    connection.onmessage = function(message) {
+      console.log('message', JSON.parse(message.data));
+    }
+  }(window);

data/examples/padrino-app/config/apps.rb

@@ -0,0 +1,36 @@
+##
+# This file mounts each app in the Padrino project to a specified sub-uri.
+# You can mount additional applications using any of these commands below:
+#
+#   Padrino.mount('blog').to('/blog')
+#   Padrino.mount('blog', :app_class => 'BlogApp').to('/blog')
+#   Padrino.mount('blog', :app_file =>  'path/to/blog/app.rb').to('/blog')
+#
+# You can also map apps to a specified host:
+#
+#   Padrino.mount('Admin').host('admin.example.org')
+#   Padrino.mount('WebSite').host(/.*\.?example.org/)
+#   Padrino.mount('Foo').to('/foo').host('bar.example.org')
+#
+# Note 1: Mounted apps (by default) should be placed into the project root at '/app_name'.
+# Note 2: If you use the host matching remember to respect the order of the rules.
+#
+# By default, this file mounts the primary app which was generated with this project.
+# However, the mounted app can be modified as needed:
+#
+#   Padrino.mount('AppName', :app_file => 'path/to/file', :app_class => 'BlogApp').to('/')
+#
+
+##
+# Setup global project settings for your apps. These settings are inherited by every subapp. You can
+# override these settings in the subapps as needed.
+#
+Padrino.configure_apps do
+  # enable :sessions
+  set :session_secret, '439d7a65623d358416f31a49fadefb9f449b6c5f472c887166c04365f2fe6534'
+  set :protection, :except => :path_traversal
+  set :protect_from_csrf, true
+end
+
+# Mounts the core application for this project
+Padrino.mount('PadrinoWebsocketsDemo::App', :app_file => Padrino.root('app/app.rb')).to('/')

data/examples/padrino-app/config/boot.rb

@@ -0,0 +1,46 @@
+# Defines our constants
+RACK_ENV = ENV['RACK_ENV'] ||= 'development'  unless defined?(RACK_ENV)
+PADRINO_ROOT = File.expand_path('../..', __FILE__) unless defined?(PADRINO_ROOT)
+
+# Load our dependencies
+require 'rubygems' unless defined?(Gem)
+require 'bundler/setup'
+Bundler.require(:default, RACK_ENV)
+
+##
+# ## Enable devel logging
+#
+# Padrino::Logger::Config[:development][:log_level]  = :devel
+# Padrino::Logger::Config[:development][:log_static] = true
+#
+# ## Configure your I18n
+#
+# I18n.default_locale = :en
+# I18n.enforce_available_locales = false
+#
+# ## Configure your HTML5 data helpers
+#
+# Padrino::Helpers::TagHelpers::DATA_ATTRIBUTES.push(:dialog)
+# text_field :foo, :dialog => true
+# Generates: <input type="text" data-dialog="true" name="foo" />
+#
+# ## Add helpers to mailer
+#
+# Mail::Message.class_eval do
+#   include Padrino::Helpers::NumberHelpers
+#   include Padrino::Helpers::TranslationHelpers
+# end
+
+##
+# Add your before (RE)load hooks here
+#
+Padrino.before_load do
+end
+
+##
+# Add your after (RE)load hooks here
+#
+Padrino.after_load do
+end
+
+Padrino.load!

data/examples/padrino-app/config.ru

@@ -0,0 +1,9 @@
+#!/usr/bin/env rackup
+# encoding: utf-8
+
+# This file can be used to start Padrino,
+# just execute it from the command line.
+
+require File.expand_path("../config/boot.rb", __FILE__)
+
+run Padrino.application

data/lib/padrino-websockets/base-event-manager.rb

@@ -0,0 +1,187 @@
+module Padrino
+  module WebSockets
+    class BaseEventManager
+      require 'oj'
+
+      ERRORS = {
+        parse_message: "Can't parse the WebSocket's message",
+        message_format: "Wrong message format. Expected: {event: 'ev', p1: 'p1', ...}",
+        unsupported_event: "The event you requested isn't supported",
+        runtime: "Error while running the event handler"
+      }
+
+      ##
+      # Creates a new WebSocket manager for a specific connection with a user on a channel.
+      #
+      # It will listen for specific events and run their blocks whenever a WebSocket call on
+      # that channel comes through.
+      #
+      # == Params
+      # * `channel`: The name of the channel
+      # * `user`: Unique string to ID the user. See the `set_websocket_user` helper.
+      # * `ws`: The WebSocket promise/reactor/etc - whatever keeps it alive for this user.
+      # * `event_context`: The Padrino application controller's context so that it can access the
+      #   helpers, mailers, settings, etc. Making it a first-class citizen as a regular HTTP 
+      #   action is. TODO Review it though, it's probably wrong.
+      # * `&block`: A block with supported events to manage.
+      #
+      def initialize(channel, user, ws, event_context, &block)
+        @channel = channel
+        @user = user
+        @ws = ws
+        @@connections ||= {}
+        @@connections[@channel] ||= {}
+        @@connections[@channel][@user] = @ws
+
+        @events = {}
+
+        @event_context = event_context
+
+        instance_eval &block if block_given?
+      end
+
+      ##
+      # DSL for adding events from the events block
+      #
+      def event(name, &block)
+        @events[name.to_sym] = block if block_given?
+      end
+
+      ##
+      # Message receiver
+      #
+      def on_message(data, ws)
+        # TODO Detect external ws hijack and drop it
+        begin
+          # Parse the message
+          message = ::Oj.load data
+
+          # Check if we have well formed message, i.e., it includes at least an event name.
+          event = message.delete 'event'
+
+          if event.nil?
+            logger.error ERRORS[:message_format]
+            logger.error e.message
+            logger.error e.backtrace.join("\n")
+
+            return send_message({error: {
+              name: :message_format,
+              message: ERRORS[:message_format]
+            }})
+          end
+
+          event = event.to_sym
+
+          # Check if it's a valid event
+          unless @events.include?(event)
+            logger.error ERRORS[:unsupported_event]
+            logger.error e.message
+            logger.error e.backtrace.join("\n")
+
+            return send_message({error: {
+              name: :unsupported_event,
+              message: ERRORS[:unsupported_event],
+              event: event
+            }})
+          end
+
+          # Call it
+          # TODO Run the event in the context of the app
+          # @events[event].bind(@event_context).call
+          # TODO Make the params (message) available through the params variable as we do
+          # in normal actions.
+          logger.debug "Calling event: #{event} as user: #{@user} on channel #{@channel}."
+          logger.debug message.inspect
+          @events[event].call(@event_context, message)
+        rescue Oj::ParseError => e
+          logger.error ERRORS[:parse_message]
+          logger.error e.message
+          logger.error e.backtrace.join("\n")
+
+          send_message({error: {
+            name: :parse_message,
+            message: ERRORS[:parse_message]
+          }})
+        rescue => e
+          logger.error ERRORS[:runtime]
+          logger.error e.message
+          logger.error e.backtrace.join("\n")
+
+          send_message({error: {
+            name: :runtime,
+            message: ERRORS[:runtime],
+            event: event,
+            exception: {
+              message: e.message,
+              backtrace: e.backtrace
+            }
+          }})
+        end
+      end
+
+      ##
+      # Manage the WebSocket's connection being closed.
+      #
+      def on_shutdown
+        logger.debug "Disconnecting user: #{@user} from channel: #{@channel}."
+        @@connections[@channel].delete(@ws)
+      end
+
+      ##
+      # Broadcast a message to the whole channel
+      #
+      def broadcast(message, except=[])
+        self.class.broadcast @channel, message, except
+      end
+
+      ##
+      # Send a message to a user on the channel
+      #
+      def send_message(message, user=@user)
+        self.class.send_message @channel, user, message
+      end
+
+      class << self
+        ##
+        # Broadcast a message to the whole channel.
+        # Can be used to access it outside the router's scope, for instance, in a background process.
+        #
+        def broadcast(channel, message, except=[])
+          logger.debug "Broadcasting message on channel: #{channel}. Message:"
+          logger.debug message
+          @@connections[channel].each do |user, ws|
+            next if except.include?(user)
+            write message, ws
+          end
+        end
+
+        ##
+        # Send a message to a user on the channel
+        # Can be used to access it outside the router's scope, for instance, in a background process.
+        #
+        def send_message(channel, user, message)
+          logger.debug "Sending message: #{message} to user: #{user} on channel: #{channel}. Message"
+          write message, @@connections[channel][user]
+        end
+
+        ##
+        # Write a message to the WebSocket.
+        #
+        # It's a wrapper around the different WS implementations.
+        # This has to be implemented for each backend.
+        def write(message, ws)
+          logger.error "Override the write method on the WebSocket-specific backend."
+          raise NotImplementedError
+        end
+      end
+
+      protected
+        ##
+        # Maintain the connection if ping frames are supported
+        #
+        def on_open(event)
+          logger.debug "Connection openned as user: #{@user} on channel: #{@channel}."
+        end
+    end
+  end
+end

data/lib/padrino-websockets/spider-gazelle/event-manager.rb

@@ -0,0 +1,50 @@
+module Padrino
+  module WebSockets
+    module SpiderGazelle
+      class EventManager < BaseEventManager
+        def initialize(channel, user, ws, event_context, &block)
+          ws.progress method(:on_message)
+          ws.finally method(:on_shutdown)
+          ws.on_open method(:on_open)
+
+          super channel, user, ws, event_context, &block
+        end
+
+        ##
+        # Manage the WebSocket's connection being closed.
+        #
+        def on_shutdown
+          @pinger.cancel if @pinger
+          super
+        end
+
+        ##
+        # Write a message to the WebSocket.
+        #
+        def self.write(message, ws)
+          ws.text ::Oj.dump(message)
+        end
+
+        protected
+          ##
+          # Maintain the connection if ping frames are supported
+          #
+          def on_open(event)
+            super event
+
+            if @ws.ping('pong')
+              variation = 1 + rand(20000)
+              @pinger = @ws.loop.scheduler.every 40000 + variation, method(:do_ping)
+            end
+          end
+
+          ##
+          # Ping the WebSocket connection
+          #
+          def do_ping(time1, time2)
+            @ws.ping 'pong'
+          end
+      end
+    end
+  end
+end

data/lib/padrino-websockets/spider-gazelle/helpers.rb

@@ -0,0 +1,14 @@
+module Padrino
+  module WebSockets
+    module SpiderGazelle
+      module Helpers
+        def send_message(channel, user, message)
+          Padrino::WebSockets::SpiderGazelle::EventManager.send_message channel, user, message
+        end
+        def broadcast(channel, message)
+          Padrino::WebSockets::SpiderGazelle::EventManager.broadcast channel, message
+        end
+      end
+    end
+  end
+end

data/lib/padrino-websockets/spider-gazelle/routing.rb

@@ -0,0 +1,36 @@
+module Padrino
+  module WebSockets
+    module SpiderGazelle
+      module Routing
+        require 'spider-gazelle/upgrades/websocket'
+
+        ##
+        # Creates a WebSocket endpoint using SpiderGazelle + libuv.
+        #
+        # It handles upgrading the HTTP connection for you.
+        # You can nest this inside controllers as you would do with regular actions in Padrino.
+        #
+        def websocket(channel, *args, &block)
+          get channel, *args do
+            # Let some other action try to handle the request if it's not a WebSocket.
+            throw :pass unless request.env['rack.hijack']
+
+            event_context = self
+
+            # It's a WebSocket. Get the libuv promise and manage its events
+            request.env['rack.hijack'].call.then do |hijacked|
+              ws = ::SpiderGazelle::Websocket.new hijacked.socket, hijacked.env
+
+              set_websocket_user
+
+              Padrino::WebSockets::SpiderGazelle::EventManager.new(
+                channel, session['websocket_user'], ws, event_context, &block)
+              ws.start
+            end
+          end
+        end
+        alias :ws :websocket
+      end
+    end
+  end
+end

data/lib/padrino-websockets/spider-gazelle.rb

@@ -0,0 +1,9 @@
+module Padrino
+  module WebSockets
+    module SpiderGazelle
+      require 'padrino-websockets/spider-gazelle/helpers'
+      require 'padrino-websockets/spider-gazelle/routing'
+      require 'padrino-websockets/spider-gazelle/event-manager'
+    end
+  end
+end

data/lib/padrino-websockets/version.rb

@@ -0,0 +1,5 @@
+module Padrino
+  module Websockets
+    VERSION = "0.0.1"
+  end
+end

data/lib/padrino-websockets.rb

@@ -0,0 +1,31 @@
+module Padrino
+  module WebSockets
+    module Helpers
+      require 'securerandom'
+
+      def set_websocket_user
+        session['websocket_user'] ||= SecureRandom.uuid
+      end
+    end
+    class << self
+      ##
+      # Main class that register this extension.
+      #
+      def registered(app)
+        require 'padrino-websockets/base-event-manager'
+
+        if defined?(::SpiderGazelle)
+          require 'padrino-websockets/spider-gazelle'
+          app.helpers Padrino::WebSockets::SpiderGazelle::Helpers
+          app.extend Padrino::WebSockets::SpiderGazelle::Routing
+        else
+          logger.error "Can't find a WebSockets backend. At the moment we only support SpiderGazelle."
+          raise NotImplementedError
+        end
+
+        app.helpers Padrino::WebSockets::Helpers
+      end
+      alias :included :registered
+    end
+  end
+end

data/padrino-websockets.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'padrino-websockets/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "padrino-websockets"
+  spec.version       = Padrino::Websockets::VERSION
+  spec.authors       = ["Darío Javier Cravero"]
+  spec.email         = ["dario@uxtemple.com"]
+  spec.summary       = %q{A WebSockets abstraction for Padrino}
+  spec.description   = %q{A WebSockets abstraction for the Padrino Ruby Web Framework to manage
+    channels, users and events regardless of the underlying WebSockets implementation.}
+  spec.homepage      = "https://github.com/dariocravero/padrino-websockets"
+  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_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: padrino-websockets
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Darío Javier Cravero
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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'
+description: |-
+  A WebSockets abstraction for the Padrino Ruby Web Framework to manage
+      channels, users and events regardless of the underlying WebSockets implementation.
+email:
+- dario@uxtemple.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/padrino-app/.components
+- examples/padrino-app/.gitignore
+- examples/padrino-app/Gemfile
+- examples/padrino-app/Rakefile
+- examples/padrino-app/app/app.rb
+- examples/padrino-app/app/views/index.slim
+- examples/padrino-app/config.ru
+- examples/padrino-app/config/apps.rb
+- examples/padrino-app/config/boot.rb
+- examples/padrino-app/public/favicon.ico
+- lib/padrino-websockets.rb
+- lib/padrino-websockets/base-event-manager.rb
+- lib/padrino-websockets/spider-gazelle.rb
+- lib/padrino-websockets/spider-gazelle/event-manager.rb
+- lib/padrino-websockets/spider-gazelle/helpers.rb
+- lib/padrino-websockets/spider-gazelle/routing.rb
+- lib/padrino-websockets/version.rb
+- padrino-websockets.gemspec
+homepage: https://github.com/dariocravero/padrino-websockets
+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.2.0
+signing_key: 
+specification_version: 4
+summary: A WebSockets abstraction for Padrino
+test_files: []