socket_helpers 0.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 36c61cb6e3be55c48bd004f38081e240aa5e7600
+  data.tar.gz: a2941755e1dbeb379da83026e0cdfb3c631bf107
+SHA512:
+  metadata.gz: 779830e38084229a64dd617cdcefa0e673d729d15263f52a92c34bba6a06cef83711f107c3f28e19f8a1fe529181572191e01a25772add638ba42ac472412482
+  data.tar.gz: 2ab2e5ea8ba1efedfa175abd4a47f9d9990bbe0b8e2e5739ebc778cb81033d8717e4e351c0dc30259ed1cab1d88b82977d79246daa6e67db5b0036d188ca77b6

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at maxpleaner@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gem "rails"
+gem 'jquery-rails'
+gem "jquery-turbolinks"
+gem "websocket-rails"
+gem "faye-websocket", '0.10.0'
+gem "nokogiri"
+gem 'oj'
+# Specify your gem's dependencies in socket_helpers.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 maxpleaner
+
+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,207 @@
+# SocketHelpers
+
+### Usage /Installation
+
+_(these instructions can be seen implemented in the [socket_helpers_example](http://github.com/maxpleaner/socket_helpers_example) repo_ or seen [on a live site](http://socket-helpers-example.herokuapp.com)
+
+---
+
+####
+**create rails app** `rails new App; cd App;`
+
+**create a model** `rails g scaffold Todo content:string; rake db:migrate;`
+
+**add gems** `gem 'socket_helpers'` and `gem 'websocket-rails'`
+
+**add javascript requires to application.js**
+
+- `//= require websocket_rails/main`
+- `//= require socket_helpers`
+
+**add jquery initializer** for whatever models you need websocket resources for (singular, snake case).
+
+ ```javascript
+   $(function(){
+    SocketHelpers.initialize(["todo"], "http://localhost:3000/websocket")
+   })
+ ```
+- the default websocket url (from the websocket-rails gem) is "/websocket"
+
+**include the controller helpers to application_controller**
+ 
+ ```ruby
+   class ApplicationController < ActionController::Base
+     include SocketHelpers::ControllerHelpers
+   end
+ ```
+
+**Remove the default scaffold routes** (`resources :todos`). This gem supports only query parameters, not path parameters. This limitation only applies to `websocket_response` endpoints. Other endpoints can use path parameters.
+
+- i.e. parameters are never declared in the routes.rb file, but they are declared in controllers. For example, routes like `DELETE /todos/MY_TODO_ID` are not supported, but `DELETE /todos?id=MY_TODO_ID` are.
+
+**Create a HTML-serving endpoint** `rails g controller HtmlPages root`
+
+**Create websocket API endpoints and write routes**
+ 
+ ```ruby
+   # routes.rb
+   get "/", to: "html_pages#root"
+   post "todos", to: "todos#create"
+   delete "todos", to: "todos#destroy"
+ ```
+
+ ```ruby
+   # app/controllers/todos_controller.rb
+   # all the default scaffold stuff can be deleted
+   class TodosController < ApplicationController
+     def create
+       todo = Todo.create(todo_params)
+       websocket_response(todo, "create")
+       return false
+     end
+     def destroy
+       todo = Todo.find_by(id: params[:id])
+       todo.destroy
+       websocket_response(todo, "destroy")
+       return false
+     end
+     def todo_params
+       params.permit(:content)
+     end
+   end
+ ```
+- the first argument of `websocket_response` can be a single record or an array. _It cannot be a query_. The second can be either `create`, `destroy`, or `update` (these values hard-coded into the app. The receiver-hooks for these events are automatically created by the javascript client. 
+
+- make sure to add a 'return' or 'render' after `websocket_response` to avoid "template not found" errors.
+
+**use the DSL for HTML** in html_pages/root.html.erb. See below for a list of HTML components available.
+
+  ```html
+    <h3>Create todo</h3>
+    <form action="todos" method="POST">
+      <input type="text" name="content" placeholder="content">
+      <input type="submit" value="submit">
+    </form>
+    <div class="todo_index">
+      <h3>Todos</h3>
+      <p template>
+        <span template-attr="content"></span>
+        <form action="/todos" method="POST"
+          <input type="hidden" name="_method" value="DELETE"
+          <input type="hidden" name="id" template-attr="id"
+          <input type="submit" value="remove"></input>
+        </form>
+        <br>
+      </p>
+      </ul>
+    </div>
+    <div init="todo">
+      <%= Oj.dump [Todo.first] %>
+    </div>
+  ```
+
+- This provides working 'index, 'create', and 'destroy' websocket functionality in quite few lines of HTML, which is mainly the point of this gem. 'update' is automatic as well. When a record is added to the page, a `record-id` attribute is automatically set to `<record_class>,<id>` on the newly-added template. This is used to lookup records. 
+
+**remove CSRF token check**
+
+comment out the `protect_from_forgery with: :exception` line in application_controller
+
+**start rails server** `rails s;`, open [localhost:3000](http://localhost:3000)
+
+It is a working todo-app with websockets. Try opening two browser windows at once. 
+
+---
+
+### **List of HTML components**
+
+- elements with a class of `<model_name>-index` become lists, with elements auto-removed and added in response to websocket events. For example, `<div class="todo-index"></div>`. These sections correspond to a single ActiveRecord class (underscore, singular i.e. `todo_list_item` for `TodoListItem`)
+
+- inside a `<model_name>-index` element, an element with a `template` attribute becomes the template for added records. For example, `<div template></div>`
+
+- inside a `[template]` element, the `template-attr` attribute is used to establish two-way databinding on an element. Its value is the name of the attribute. This can be used to set the value of form inputs or to change text nodes. For example,
+
+```html
+  <input type="text" name="content" template-attr="content">
+  <!-- or alternatively -->
+  <span template-attr="content">
+```
+
+- **all form submits are intercepted** by event listeners by default. To override this, add the "skip-sockets" attribute to the form element. They submit AJAX requests using the url in the form's `action` attribute and the method in the form's `method` attribute (i.e. `action="/todos" method="POST"`). This works for `GET` and `POST` only, but `PUT` and `DELETE` can be used by adding a hidden input method i.e. `input type="hidden" name="_method" value="PUT"`. This is the default Rails behavior anyway.
+
+- To submit an id with a form, bind a hidden attribute i.e. `<input type="hidden" name="id" template-attr='id'>`
+
+- Outside of `[template]`s, binding tags are a bit more verbose. `<span binding-tag='todos,1,content'></span>` where the three comma-separated arguments are `<model_class>`, `<id>`, and `<attribute>`. `template-attr` tags are automatically converted to `binding-tag` once new records are added to the page. 
+
+---
+
+### **Other notes**
+
+#### **Changing a classes' published class name
+
+- Say I created a `LocationCategorization` scaffold but
+  realized that I would rather publish the data  using 
+  a `record_class` value of `category` instead of `location_categorization`.
+  I don't want to undo the scaffold, so I add a method to the `LocationCategorization` class:
+
+  ```ruby
+    class LocationCategorization < ActiveRecord::Base
+      def published_class
+        "category"
+      end
+    end
+  ```
+
+This particular method name is used as an optional override
+for the default published class name (`record.class.to_s.underscore`)
+
+#### **Loading initial data on the page**
+
+Without doing this, the page will be empty every time it is refreshed. The page needs to start out with a list of records loaded.
+
+Create an html element with an `init` attribute set to a model class, i.e. `todo`. This element will be auto-hidden. In the html-serving controller method, make an instance variable for whatever data is going to be included (expects an array, not a single object or query). On the html page, use ERB to set the content of the `[init]` element to a JSON stringified version of your instance variable. For example, `<div init="todo"><%= Oj.dump([User.first]) %></div>`
+
+#### **How to do links with params**
+
+i.e. how to do
+
+```html
+<a href="/my_link?with=params">My Link </a>
+```
+
+The way to do this is by building a form and disguising it as a link. Basically come up with some CSS style so the form looks like a link. I don't really know how to do the CSS, but the form HTML code is below. This has the effect of creating a button on the page with the desired link follow-through when clicked. In this example, the 'link-style' class has to be externally implemented.
+
+```html
+<form skip-sockets class="link-style" action="/notepad" method="GET">
+  <input type="hidden" name="name" template-attr='name'>
+  <input type="submit" template-attr='name'>
+</form>
+
+```
+
+
+
+### **Additional Helpers**
+
+you can make one html element toggle another open / close very easily.
+
+Just make them 'siblings (share the same parent element) and give the trigger a `toggles` attribute with a value set to the CSS selector of the target. The target will be initially closed. 
+
+---
+
+### **Use of OJ gem for JSON**
+
+- I use the OJ gem here and `Oj.dump` because of a recursion bug in `to_json`. I'm still not sure what the cause is, perhaps a naming conflict somewhere. Also, `Oj.dump` only works with single elements / arrays, not active record queries i.e. `Oj.dump Todo.all.limit(5)` wouldnt work.
+- However Oj seems pretty legit.
+- The way to Json-stringify records for a websocket-publish action is:
+  ```ruby
+    Oj.dump(
+      records.map do |record|
+        record.attributes.merge(
+          'record_class' => record.class.to_s.underscore,
+        )
+      end
+    )
+  ```
+- This is done automatically when using `websocket_response`,
+but needs to be added otherwise (like when using server seeded data 
+to set a page's initial state)

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/app/assets/javascripts/socket_helpers.js

@@ -0,0 +1,267 @@
+$(function(){
+
+  curry = function (fn) {
+    var slice = [].slice,
+        args  = slice.call(arguments, 1);
+    return function () {
+      return fn.apply(this, args.concat(slice.call(arguments)));
+    };
+  };
+
+  
+  Style = {
+    createStylesheet: function(){
+      var style = document.createElement("style")
+      // Add a media (and/or media query) here if you'd like!
+      // style.setAttribute("media", "screen")
+      // style.setAttribute("media", "only screen and (max-width : 1024px)")
+      style.appendChild(document.createTextNode(""));
+      document.head.appendChild(style)
+      return style.sheet
+    },
+    stylesheet: function(){
+      if(this._stylesheet){return this._stylesheet}
+        else {
+          this._stylesheet = this.createStylesheet();
+          return this._stylesheet
+        }
+    },
+    addCSSRule: function(selector, rules, index) {
+      var sheet = this.stylesheet()
+      if("insertRule" in sheet) {
+        sheet.insertRule(selector + "{" + rules + "}", index);
+      }
+      else if("addRule" in sheet) {
+        sheet.addRule(selector, rules, index);
+      }
+    }
+  }
+
+  // uses 'binding-tag' attr
+  // format: binding-tag='class_name,id,attribute'
+  getBindingTags = function (css_selector){
+    var bindings = []
+    bindingTags = $(css_selector).find("[binding-tag]")
+    $.each(bindingTags, function(index, tag){
+      var $tagElement = $(tag)
+      var tagName = $tagElement.attr("binding-tag")
+      var components = tagName.split(",")
+      var model_name = components[0]
+      var id = components[1]
+      var attribute = components[2]
+      bindings.push({
+        dom_elements: $("*[binding-tag='"+tagName+"']"),
+          model_name: model_name,
+                  id: id,
+           attribute: attribute,
+      })
+    })
+    return bindings
+  }
+
+  initBindings = function(bindings) {
+    $.each(bindings, function(index, binding){
+      var $dom_elements = binding['dom_elements']
+      var model_name    = binding['model_name']
+      var id            = binding['id']
+      var attribute     = binding['attribute']
+      var channel       = channels[model_name]
+      channel.bind(
+        (model_name+'-'+id+'-'+attribute+'-update'),
+        curry(updateElement, $dom_elements)
+      )
+    })
+  }
+
+  updateElement = function($dom_elements, new_value) {
+    $dom_elements.val(new_value)
+    $dom_elements.attr("value", new_value)
+    $dom_elements.text(new_value)
+  }
+
+  addElement = function($container, $completedTemplate){
+    $container.append(
+      $("<div>").append($completedTemplate.clone()).html()
+    )
+  }
+
+  deserialize = function(record){
+    return JSON.parse(record)
+  }
+  
+  processNewRecords = function(serializedRecords){
+    serializedRecords = $.makeArray(serializedRecords)
+    serializedRecords.forEach(function(record){
+      record         = deserialize(record)
+      model_name     = record['record_class']   
+      $container     = $("."+model_name+'-index')
+      $template      = $container.find("[template]")
+      $templateClone = cloneTemplate($template, record)
+      $templateClone.removeAttr("template")
+      $templateClone.attr(
+        "record-id",
+        (model_name+","+record['id'])
+      )
+      addElement($container, $templateClone)
+      initBindings(getBindingTags($templateClone))
+      initToggleInitialState($templateClone)
+      processUpdateRecords(JSON.stringify(record))
+    })
+  }
+
+  cloneTemplate = function($template, record){
+    $template = $template.clone()
+    templateAttrs = $template.find("[template-attr]")
+    var id = record['id']
+    $.each(templateAttrs, function(index, elem){
+      var $elem = $(elem)
+      var model_name = record['record_class']
+      var attr = $elem.attr('template-attr')
+      $elem.text(record[attr])
+      $elem.val(record[attr])
+      $elem.removeAttr('template-attr')
+      $elem.attr("binding-tag", model_name+','+id+','+attr)
+    })
+    return $template
+  }
+  
+  findMatchingNodes = function(record_class, id){
+    return $("*[record-id='"+record_class+","+id)
+  }
+
+  processUpdateRecords = function(serializedRecords){
+    serializedRecords = $.makeArray(serializedRecords)
+    serializedRecords.forEach(function(record){
+      record = deserialize(record)
+      model_name = record['record_class']
+      id = record['id']
+      for (var key in record){
+        var new_val = record[key]
+        console.log(record)
+        var bindingTag = model_name+','+id+','+key        
+        channels[model_name].trigger(
+          (model_name+'-'+id+'-'+key+'-update'),
+          new_val   
+        )
+        // for some reason this is also necessary when
+        // the binding elements are not in a [template]
+        // although this should be called by the above 'trigger'
+          updateElement(
+            $("[binding-tag='"+bindingTag+"']"),
+            new_val
+          )
+      }
+    })
+  }
+  
+  processDestroyRecords = function(serializedRecords){
+  serializedRecords = $.makeArray(serializedRecords)
+   serializedRecords.forEach(function(record){
+     record = deserialize(record)
+     $matchingNodes = findMatchingNodes(
+        record['record_class'],
+        record['id']
+      )
+     $matchingNodes.remove()
+   })
+  }
+
+
+  initFormBindings = function(selector){
+    if (!selector){
+      selector = "*"
+    }
+    $(document).on("submit", (selector+" form"), function(e){
+      var $form = $(e.currentTarget)
+      if ($form[0].hasAttribute("skip-sockets")) {
+        return true
+      }
+      e.preventDefault();
+      var serializedAttrs = $form.serialize()
+      var action = $form.attr("action")
+      var method = $form.attr("method")
+      var $methodOverride = $form.find("[name=_method]")
+      if ($methodOverride.length > 0){
+        method = $methodOverride.val()
+      }
+      $.ajax({
+        url: action,
+        method: method,
+        data: serializedAttrs
+      })
+      return false
+    })
+  }
+
+
+  initToggleInitialState = function(selector){
+    var $togglers = $(selector).find("[toggles]")
+    $.each($togglers, function(index, e){
+      var $toggler = $(e)
+      var target = $toggler.attr("toggles")
+      var $target = $toggler.siblings(target)
+      $target.hide()
+      $toggler.attr("hiding", "")
+    })
+  }
+
+  initTogglerListeners = function(selector){
+    $(document).on("click", (selector+" [toggles]"), function(e){
+      var $toggler = $(e.currentTarget)
+      var target = $toggler.attr("toggles")
+      var $target = $toggler.siblings(target)
+      if ($toggler[0].hasAttribute('hiding')){
+        $toggler.removeAttr('hiding')
+        $target.show()
+      } else {
+        $toggler.attr("hiding", "")
+        $target.hide()
+      }
+    })
+  }
+
+  initServerSeeds = function(){
+    $.each($("[init]"), function(index, init){
+      var $init = $(init)
+      var model_name = $init.attr("init")
+      var serialized_records = $init.text()
+      var records = deserialize(serialized_records)
+      records.forEach(function(record){
+        processNewRecords(JSON.stringify(record))
+      })
+      $init.hide()
+    }) 
+  }
+
+  SocketHelpers = {
+    addedHooks: [],
+    initialize: function(classes, websocketBaseurl){
+      // hide templates
+      Style.addCSSRule("[template]", "display: none")
+      // server hooks
+      dispatcher = new WebSocketRails(websocketBaseurl)
+      channels   = {}
+      classes.forEach(function(class_name){
+        var name = class_name
+        channels[name] = dispatcher.subscribe(name)
+        var channel = channels[name]
+        channel.bind('create', processNewRecords)
+        channel.bind('update', processUpdateRecords)
+        channel.bind('destroy', processDestroyRecords)
+        // SocketHelpers.addedHooks.forEach(function(hook){
+        //   var channelName = hook['channelName'],
+        //       callback    = hook['callback']
+        //   channels
+        // })
+      })
+
+      // client hooks
+      initBindings(getBindingTags("*"))
+      initFormBindings("*")
+      initToggleInitialState("*")
+      initTogglerListeners("*")
+      initServerSeeds()
+      return dispatcher
+    }
+  }
+})

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "socket_helpers"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/socket_helpers/version.rb

@@ -0,0 +1,3 @@
+module SocketHelpers
+  VERSION = "0.0.9"
+end

data/lib/socket_helpers.rb

@@ -0,0 +1,31 @@
+require "socket_helpers/version"
+require 'rails'
+
+module SocketHelpers
+  class MyRailtie < Rails::Railtie
+  end
+  module ControllerHelpers
+    require 'oj'
+    def public_attrs(record)
+      attrs = record.attributes.merge('record_class' => record.try(:published_class) || record.class.to_s.underscore)
+      return Oj.dump(attrs)
+    end
+    def websocket_response(records, action)
+      records = [records] unless records.is_a?(Array)
+      records.each do |record|
+        class_name = record.try(:published_class) || record.class.to_s.underscore
+        puts "triggered #{class_name} #{action}"
+        WebsocketRails[class_name].trigger(action, public_attrs(record))
+      end
+    end   
+  end
+  class Engine < Rails::Engine
+    initializer "my_engine.remove_rack_lock" do |app|
+      app.middleware.delete Rack::Lock
+    end
+    initializer :assets do |config|
+      Rails.application.config.assets.precompile += %w{ socket_helpers.js }
+      Rails.application.config.assets.paths << root.join("app", "assets", "javascripts")
+    end
+  end
+end

data/socket_helpers.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+# require 'socket_helpers/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "socket_helpers"
+  spec.version       = "0.0.9"
+  spec.authors       = ["maxpleaner"]
+  spec.email         = ["maxpleaner@gmail.com"]
+
+  spec.summary       = %q{websocket helpers for rails}
+  spec.description   = %q{websocket helpers for rails}
+  spec.homepage      = "http://github.com/maxpleaner/socket_helpers"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(socket_helpers-0.0.9.gem|socket_helpers.gemspec|test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib", "app/controllers"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_runtime_dependency "rails"
+  spec.add_runtime_dependency 'jquery-rails'
+  spec.add_runtime_dependency "jquery-turbolinks"
+  spec.add_runtime_dependency "websocket-rails"
+  spec.add_runtime_dependency "faye-websocket", '0.10.0'
+  spec.add_runtime_dependency "nokogiri"
+  spec.add_runtime_dependency 'oj'
+end

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification
+name: socket_helpers
+version: !ruby/object:Gem::Version
+  version: 0.0.9
+platform: ruby
+authors:
+- maxpleaner
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-01-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  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: jquery-rails
+  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: jquery-turbolinks
+  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: websocket-rails
+  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: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  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: oj
+  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'
+description: websocket helpers for rails
+email:
+- maxpleaner@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/assets/javascripts/socket_helpers.js
+- bin/console
+- bin/setup
+- lib/socket_helpers.rb
+- lib/socket_helpers/version.rb
+- socket_helpers.gemspec
+homepage: http://github.com/maxpleaner/socket_helpers
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- app/controllers
+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.5.1
+signing_key: 
+specification_version: 4
+summary: websocket helpers for rails
+test_files: []
+has_rdoc: