entangled 0.0.1 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7dd7732a7af0fdbc6a792eb242f507817adcfde
-  data.tar.gz: 0091ccff6cdad24ac350dace118ae33a5331bc5a
+  metadata.gz: 5061458f7fad47437868c5e5c445d05c1e25060a
+  data.tar.gz: 4a5ea5580591c4d01aba2686a1392d1257bd818f
 SHA512:
-  metadata.gz: f64204d586309f97651845b5a642a333a4f88d943608326d84063560b4f2ed180304433a7caa5810cb5ddb2eed9c296ab5e1f4c535ea6d05219215ed02385e93
-  data.tar.gz: 8573a37652353e3b32807bb653040036b2981927a74fa4565a9b51897f24d37ae3996b4720b689b4a791ad59e6933f624d0fe4d23d17b92e4bd9fee98f23832b
+  metadata.gz: eb26c2be5a2e95619dfae839f8929672fdc6e403cef4025212a1a992eac53fab21d81074b04f7ec1fc40a7caee96e83f244d70675da242ee3835d602a20e899a
+  data.tar.gz: 83a79396d556515b2a4124e15160fe513f2d12f87ef0ac0236f383a16633cdb01744b228817b4fa1d42a59b72db72d3ef3398f2eeddf1d22d81715ad03bac3c5

data/README.md

@@ -1,15 +1,24 @@
 # Entangled
+Services like Firebase are great because they provide real time data binding between client and server. But they come at a price: You give up control over your backend. Wouldn't it be great to have real time functionality but still keep your beloved Rails backend? That's where Entangled comes in.
 
-TODO: Write a gem description
+Entangled is a layer behind your controllers and models that pushes updates to clients subscribed to certain channels in real time. For example, if you display a list of five messages on a page, if anyone adds a sixth message, everyone who is currently looking at that page will instantly see that sixth message being added to the list.
 
-## Installation
+The idea is that real time data binding should be the default, not an add-on. Entangled aims at making real time features as easy to implement as possible, while at the same time making your restful controllers thinner.
 
+## Installation
 Add this line to your application's Gemfile:
 
 ```ruby
 gem 'entangled'
 ```
 
+Note that Redis and Puma are required as well. Redis is needed to build the channels clients subscribe to, Puma is needed to handle websockets concurrently.
+
+```ruby
+gem 'redis'
+gem 'puma'
+```
+
 And then execute:
 
     $ bundle
@@ -19,13 +28,121 @@ Or install it yourself as:
     $ gem install entangled
 
 ## Usage
+Entangled is needed in three parts of your app. Given the example of a `MessagesController` and a `Message` model for a chat app, you will need:
 
-TODO: Write usage instructions here
+### Routes
+Add the following to your routes file:
 
-## Contributing
+```ruby
+sockets_for :messages
+```
+
+Replace `messages` with your resource name.
+
+Under the hood, this creates the following routes:
+
+```ruby
+get '/messages', to: 'messages#index', as: :messages
+get '/messages/create', to: 'messages#create', as: :create_message
+get '/messages/:id', to: 'messages#show', as: :message
+get '/messages/:id/destroy', to: 'messages#destroy', as: :destroy_message
+get '/messages/:id/update', to: 'messages#update', as: :update_message
+```
+
+Note that Websockets don't speak HTTP, so only GET requests are available. That's why these routes deviate slightly from restful routes. Also note that there are no `edit` and `new` actions, since an Entangled controller is only concerned with rendering data, not views.
+
+### Model
+Add the following to the top inside your model (e.g., a `Message` model):
+
+```ruby
+class Message < ActiveRecord::Base
+  include Entangled::Model
+  entangle
+end
+```
+
+This will create the callbacks needed to push changes to data to all clients who are subscribed. This is essentially where the data binding is set up.
+
+### Controller
+Your controllers will be a little more lightweight than in a standard restful Rails app. A restful-style controller is expected and should look like this:
 
-1. Fork it ( https://github.com/[my-github-username]/entangled/fork )
+```ruby
+class MessagesController < ApplicationController
+  include Entangled::Controller
+
+  def index
+    broadcast do
+      @messages = Message.all
+    end
+  end
+
+  def show
+    broadcast do
+      @message = Message.find(params[:id])
+    end
+  end
+
+  def create
+    broadcast do
+      Message.create(message_params)
+    end
+  end
+
+  def update
+    broadcast do
+      Message.find(params[:id]).update(message_params)
+    end
+  end
+
+  def destroy
+    broadcast do
+      Message.find(params[:id]).destroy
+    end
+  end
+
+private
+  def message_params
+    # params logic here
+  end
+end
+```
+
+Note the following:
+
+- All methods are wrapped in a new `broadcast` block needed to send messages to connected clients
+- The `index` method will expect an instance variable with the same name as your controller in the plural form (e.g. `@messages` in a `MessagesController`)
+- The `show` method will expect an instance variable with the singular name of your controller (e.g. `@message` in a `MessagesController`)
+- Instance variables only need to be assigned in `index` and `show` since these are the only methods that should be concerned with sending data to clients. All other methods only publish updates to the data clients are subscribed to through the callbacks added to the model, so no instance variables are needed
+- Data sent to clients arrives as stringified JSON
+- Strong parameters are expected
+
+## Server
+Remember to run Redis whenever you run your server:
+
+```shell
+$ redis-server
+```
+
+Otherwise the channels won't work.
+
+### Database
+Depending on your app's settings, you might have to increase the pool size in your database.yml configuration file, since every new socket will open a new connection to your database.
+
+### The Client
+You will need to configure your client to create Websockets and understand incoming requests on those sockets. If you use Angular for your frontend, you can use [this library](https://github.com/so-entangled/angular). The use of Angular as counterpart of this gem is highly recommended, since its inherent two way data binding complements the real time functionality of this gem nicely.
+
+## Planning Your Infrastructure
+This gem is best used for Rails apps that serve as APIs only and are not concerned with rendering views. A frontend separate from your Rails app, such as Angular with Grunt, is recommended.
+
+## Limitations
+The gem rely's heavily on convention over configuration and currently only works with restful style controllers as shown above. More customization will be available soon.
+
+## Contributing
+1. Fork it ( https://github.com/so-entangled/rails/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
+
+## Credits
+Thanks to [Ilias Tsangaris](https://github.com/iliastsangaris) for inspiring the name "Entanglement" based on [Quantum Entanglement](http://en.wikipedia.org/wiki/Quantum_entanglement) where pairs or groups of particles always react to changes as a whole, i.e. changes to one particle will result in immediate change of all particles in the group.

data/entangled.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'rspec', '~> 3.2'
   spec.add_dependency 'tubesock', '~> 0.2'
   spec.add_dependency 'rails', '~> 4.2'
 end

data/lib/entangled.rb

@@ -1,269 +1,26 @@
-require "entangled/version"
-require 'tubesock'
-
-module Entangled
-	module Model
-		module ClassMethods
-			# Create after_ callbacks for options
-			def entangle(options = {})
-
-				# If :only is specified, the options can either
-				# be an array or a symbol
-				if options[:only].present?
-
-					# If it is a symbol, something like only: :create
-					# was passed in, and we need to create a hook
-					# only for that one option
-					if options[:only].is_a?(Symbol)
-						create_hook options[:only]
-
-					# If it is an array, something like only: [:create, :update]
-					# was passed in, and we need to create hook for each
-					# of these options
-					elsif options[:only].is_a?(Array)
-						options[:only].each { |option| create_hook option }
-					end
-
-				# Instead of :only, :except can be specified; similarly,
-				# the options can either be an array or a symbol
-				elsif options[:except].present?
-
-					# If it is a symbol, it has to be taken out of the default
-					# options. A callback has to be defined for each of the
-					# remaining options
-					if options[:except].is_a?(Symbol)
-						(default_options - [options[:except]]).each do |option|
-							create_hook option
-						end
-
-					# If it is an array, it also has to be taen out of the
-					# default options. A callback then also has to be defined
-					# for each of the remaining options
-					elsif options[:except].is_a?(Array)
-						(default_options - options[:except]).each do |option|
-							create_hook option
-						end
-					end
-				else
-
-					# If neither :only nor :except is specified, simply create
-					# a callback for each default option
-					default_options.each { |option| create_hook option }
-				end
-			end
-
-			# By default, model updates will be published after_create,
-			# after_update, and after_destroy. This behavior can be
-			# modified by passing :only or :except options to the
-			# entangle class method
-			def default_options
-				[:create, :update, :destroy]
-			end
-
-			# The inferred channel name. For example, if the class name
-			# is DeliciousTaco, the inferred channel name is "delicious_tacos"
-			def inferred_channel_name
-				name.underscore.pluralize
-			end
-
-			# Creates callbacks in the extented model
-			def create_hook(name)
-				send :"after_#{name}", proc { publish(name) }
-			end
-		end
-		
-		module InstanceMethods
-			private
-
-			# Publishes to client. Whoever is subscribed
-			# to the model's channel or the record's channel
-			# gets the message
-			def publish(action)
-				Redis.new.publish(
-					self.class.inferred_channel_name,
-					json(action)
-				)
-
-				Redis.new.publish(
-					inferred_channel_name_for_single_record,
-					json(action)
-				)
-			end
-
-			# The inferred channel name for a single record
-			# containing the inferred channel name from the class
-			# and the record's id. For example, if it's a
-			# DeliciousTaco with the id 1, the inferred channel
-			# name for the single record is "delicious_tacos/1"
-			def inferred_channel_name_for_single_record
-				"#{self.class.inferred_channel_name}/#{id}"
-			end
-
-			# JSON containing the type of action (:create, :update
-			# or :destroy) and the record itself. This is eventually
-			# broadcast to the client
-			def json(action)
-				{
-					action: action,
-					resource: self
-				}.to_json
-			end
-		end
-		
-		def self.included(receiver)
-			receiver.extend         ClassMethods
-			receiver.send :include, InstanceMethods
-		end
-	end
-	
-  module Controller
-  	include Tubesock::Hijack
-
-  	module ClassMethods
-  		
-  	end
-  	
-  	module InstanceMethods
-  		private
-
-  		# The plural name of the resource, inferred from the
-  		# controller's name. For example, if it's the TacosController,
-  		# the resources_name will be "tacos". This is used to
-  		# infer the instance variable name for collections assigned
-  		# in the controller action
-  		def resources_name
-  			controller_name
-  		end
-
-  		# The singular name of the resource, inferred from the
-  		# resources_name. This is used to infer the instance
-  		# variable name for a single record assigned in the controller
-  		# action
-  		def resource_name
-  			resources_name.singularize
-  		end
-
-  		# Broadcast events to every connected client
-  		def broadcast(&block)
-  			# Use hijack to handle sockets
-  			hijack do |tubesock|
-  				# Assuming restful controllers, the behavior of
-  				# this method has to change depending on the action
-  				# it's being used in
-  				case action_name
-
-  				# If the controller action is 'index', a collection
-  				# of records should be broadcast
-  				when 'index'
-  					yield
-
-  					# The following code will run if an instance
-  					# variable with the plural resource name has been
-  					# assigned in yield. For example, if a
-  					# TacosController's index action looked something
-  					# like this:
-
-  					# def index
-  					#   broadcast do
-  					#     @tacos = Taco.all
-  					#   end
-  					# end
-
-  					# ...then @tacos will be broadcast to all connected
-  					# clients. The variable name, in this example,
-  					# has to be "@tacos"
-  					if instance_variable_get(:"@#{resources_name}")
-  						redis_thread = Thread.new do
-  							Redis.new.subscribe resources_name do |on|
-  								on.message do |channel, message|
-  									tubesock.send_data message
-  								end
-
-  								# Broadcast collection to all connected clients
-  								tubesock.send_data({
-  									resources: instance_variable_get(:"@#{resources_name}")
-  								}.to_json)
-  							end
-  						end
-
-  						# When client disconnects, kill the thread
-  						tubesock.onclose do
-  							redis_thread.kill
-  						end
-  					end
-
-  				# If the controller's action name is 'show', a single record
-  				# should be broadcast
-  				when 'show'
-  					yield
-
-  					# The following code will run if an instance variable
-  					# with the singular resource name has been assigned in
-  					# yield. For example, if a TacosController's show action
-  					# looked something like this:
-
-  					# def show
-  					#   broadcast do
-  					#     @taco = Taco.find(params[:id])
-  					#   end
-  					# end
-
-  					# ...then @taco will be broadcast to all connected clients.
-  					# The variable name, in this example, has to be "@taco"
-  					if instance_variable_get(:"@#{resource_name}")
-  						redis_thread = Thread.new do
-  							Redis.new.subscribe "#{resources_name}/#{instance_variable_get(:"@#{resource_name}").id}" do |on|
-  								on.message do |channel, message|
-  									tubesock.send_data message
-  								end
-
-  								# Broadcast single resource to all connected clients
-  								tubesock.send_data({ resource: instance_variable_get(:"@#{resource_name}") }.to_json)
-  							end
-  						end
-
-  						# When client disconnects, kill the thread
-  						tubesock.onclose do
-  							redis_thread.kill
-  						end
-  					end
-
-  				# If the controller's action name is 'create', a record should be
-  				# created. Before yielding, the params hash has to be prepared
-  				# with attributes sent to the socket. The actual publishing
-  				# happens in the model's callback
-  				when 'create'
-  					tubesock.onmessage do |m|
-  						params[resource_name.to_sym] = JSON.parse(m).symbolize_keys
-  						yield
-  					end
-
-  				# If the controller's action name is 'update', a record should be
-  				# updated. Before yielding, the params hash has to be prepared
-  				# with attributes sent to the socket. The default attributes
-  				# id, created_at, and updated_at should not be included in params.
-  				when 'update'
-  					tubesock.onmessage do |m|
-  						params[resource_name.to_sym] = JSON.parse(m).except('id', 'created_at', 'updated_at', 'webSocketUrl').symbolize_keys
-  						yield
-  					end
-
-  				# For every other controller action, simply wrap whatever is
-  				# yielded in the tubesock block to execute it in the context
-  				# of the socket. The delete action is automatically covered
-  				# by this, and other custom action can be added through this.
-  				else
-  					tubesock.onmessage do |m|
-  						yield
-  					end
-  				end
-  			end
-  		end
-  	end
-  	
-  	def self.included(receiver)
-  		receiver.extend         ClassMethods
-  		receiver.send :include, InstanceMethods
-  	end
+require 'entangled/version'
+require 'entangled/model'
+require 'entangled/controller'
+require 'action_dispatch/routing'
+require 'active_support/concern'
+
+module ActionDispatch::Routing
+  class Mapper
+    def sockets_for(resource, &block)
+      resources = resource.to_s.underscore.pluralize.to_sym
+      resource = resource.to_s.underscore.singularize.to_sym
+
+      get :"/#{resources}", to: "#{resources}#index", as: resources
+      get :"/#{resources}/create", to: "#{resources}#create", as: :"create_#{resource}"
+      get :"/#{resources}/:id", to: "#{resources}#show", as: resource
+      get :"/#{resources}/:id/destroy", to: "#{resources}#destroy", as: :"destroy_#{resource}"
+      get :"/#{resources}/:id/update", to: "#{resources}#update", as: :"update_#{resource}"
+
+      if block_given?
+        namespace resources do
+          yield
+        end
+      end
+    end
   end
 end

data/lib/entangled/controller.rb

@@ -0,0 +1,154 @@
+require 'tubesock'
+
+module Entangled
+  module Controller
+    include Tubesock::Hijack
+
+    module ClassMethods
+      
+    end
+    
+    module InstanceMethods
+      private
+
+      # The plural name of the resource, inferred from the
+      # controller's name. For example, if it's the TacosController,
+      # the resources_name will be "tacos". This is used to
+      # infer the instance variable name for collections assigned
+      # in the controller action
+      def resources_name
+        controller_name
+      end
+
+      # The singular name of the resource, inferred from the
+      # resources_name. This is used to infer the instance
+      # variable name for a single record assigned in the controller
+      # action
+      def resource_name
+        resources_name.singularize
+      end
+
+      # Broadcast events to every connected client
+      def broadcast(&block)
+        # Use hijack to handle sockets
+        hijack do |tubesock|
+          # Assuming restful controllers, the behavior of
+          # this method has to change depending on the action
+          # it's being used in
+          case action_name
+
+          # If the controller action is 'index', a collection
+          # of records should be broadcast
+          when 'index'
+            yield
+
+            # The following code will run if an instance
+            # variable with the plural resource name has been
+            # assigned in yield. For example, if a
+            # TacosController's index action looked something
+            # like this:
+
+            # def index
+            #   broadcast do
+            #     @tacos = Taco.all
+            #   end
+            # end
+
+            # ...then @tacos will be broadcast to all connected
+            # clients. The variable name, in this example,
+            # has to be "@tacos"
+            if instance_variable_get(:"@#{resources_name}")
+              redis_thread = Thread.new do
+                Redis.new.subscribe resources_name do |on|
+                  on.message do |channel, message|
+                    tubesock.send_data message
+                  end
+
+                  # Broadcast collection to all connected clients
+                  tubesock.send_data({
+                    resources: instance_variable_get(:"@#{resources_name}")
+                  }.to_json)
+                end
+              end
+
+              # When client disconnects, kill the thread
+              tubesock.onclose do
+                redis_thread.kill
+              end
+            end
+
+          # If the controller's action name is 'show', a single record
+          # should be broadcast
+          when 'show'
+            yield
+
+            # The following code will run if an instance variable
+            # with the singular resource name has been assigned in
+            # yield. For example, if a TacosController's show action
+            # looked something like this:
+
+            # def show
+            #   broadcast do
+            #     @taco = Taco.find(params[:id])
+            #   end
+            # end
+
+            # ...then @taco will be broadcast to all connected clients.
+            # The variable name, in this example, has to be "@taco"
+            if instance_variable_get(:"@#{resource_name}")
+              redis_thread = Thread.new do
+                Redis.new.subscribe "#{resources_name}/#{instance_variable_get(:"@#{resource_name}").id}" do |on|
+                  on.message do |channel, message|
+                    tubesock.send_data message
+                  end
+
+                  # Broadcast single resource to all connected clients
+                  tubesock.send_data({ resource: instance_variable_get(:"@#{resource_name}") }.to_json)
+                end
+              end
+
+              # When client disconnects, kill the thread
+              tubesock.onclose do
+                redis_thread.kill
+              end
+            end
+
+          # If the controller's action name is 'create', a record should be
+          # created. Before yielding, the params hash has to be prepared
+          # with attributes sent to the socket. The actual publishing
+          # happens in the model's callback
+          when 'create'
+            tubesock.onmessage do |m|
+              params[resource_name.to_sym] = JSON.parse(m).symbolize_keys
+              yield
+            end
+
+          # If the controller's action name is 'update', a record should be
+          # updated. Before yielding, the params hash has to be prepared
+          # with attributes sent to the socket. The default attributes
+          # id, created_at, and updated_at should not be included in params.
+          when 'update'
+            tubesock.onmessage do |m|
+              params[resource_name.to_sym] = JSON.parse(m).except('id', 'created_at', 'updated_at', 'webSocketUrl').symbolize_keys
+              yield
+            end
+
+          # For every other controller action, simply wrap whatever is
+          # yielded in the tubesock block to execute it in the context
+          # of the socket. The delete action is automatically covered
+          # by this, and other custom action can be added through this.
+          else
+            tubesock.onmessage do |m|
+              yield
+            end
+          end
+        end
+      end
+    end
+    
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+end

data/lib/entangled/model.rb

@@ -0,0 +1,115 @@
+module Entangled
+  module Model
+    module ClassMethods
+      # Create after_ callbacks for options
+      def entangle(options = {})
+
+        # If :only is specified, the options can either
+        # be an array or a symbol
+        if options[:only].present?
+
+          # If it is a symbol, something like only: :create
+          # was passed in, and we need to create a hook
+          # only for that one option
+          if options[:only].is_a?(Symbol)
+            create_hook options[:only]
+
+          # If it is an array, something like only: [:create, :update]
+          # was passed in, and we need to create hook for each
+          # of these options
+          elsif options[:only].is_a?(Array)
+            options[:only].each { |option| create_hook option }
+          end
+
+        # Instead of :only, :except can be specified; similarly,
+        # the options can either be an array or a symbol
+        elsif options[:except].present?
+
+          # If it is a symbol, it has to be taken out of the default
+          # options. A callback has to be defined for each of the
+          # remaining options
+          if options[:except].is_a?(Symbol)
+            (default_options - [options[:except]]).each do |option|
+              create_hook option
+            end
+
+          # If it is an array, it also has to be taen out of the
+          # default options. A callback then also has to be defined
+          # for each of the remaining options
+          elsif options[:except].is_a?(Array)
+            (default_options - options[:except]).each do |option|
+              create_hook option
+            end
+          end
+        else
+
+          # If neither :only nor :except is specified, simply create
+          # a callback for each default option
+          default_options.each { |option| create_hook option }
+        end
+      end
+
+      # By default, model updates will be published after_create,
+      # after_update, and after_destroy. This behavior can be
+      # modified by passing :only or :except options to the
+      # entangle class method
+      def default_options
+        [:create, :update, :destroy]
+      end
+
+      # The inferred channel name. For example, if the class name
+      # is DeliciousTaco, the inferred channel name is "delicious_tacos"
+      def inferred_channel_name
+        name.underscore.pluralize
+      end
+
+      # Creates callbacks in the extented model
+      def create_hook(name)
+        send :"after_#{name}", proc { publish(name) }
+      end
+    end
+    
+    module InstanceMethods
+      private
+
+      # Publishes to client. Whoever is subscribed
+      # to the model's channel or the record's channel
+      # gets the message
+      def publish(action)
+        Redis.new.publish(
+          self.class.inferred_channel_name,
+          json(action)
+        )
+
+        Redis.new.publish(
+          inferred_channel_name_for_single_record,
+          json(action)
+        )
+      end
+
+      # The inferred channel name for a single record
+      # containing the inferred channel name from the class
+      # and the record's id. For example, if it's a
+      # DeliciousTaco with the id 1, the inferred channel
+      # name for the single record is "delicious_tacos/1"
+      def inferred_channel_name_for_single_record
+        "#{self.class.inferred_channel_name}/#{id}"
+      end
+
+      # JSON containing the type of action (:create, :update
+      # or :destroy) and the record itself. This is eventually
+      # broadcast to the client
+      def json(action)
+        {
+          action: action,
+          resource: self
+        }.to_json
+      end
+    end
+    
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+end

data/lib/entangled/version.rb

@@ -1,3 +1,3 @@
 module Entangled
-  VERSION = "0.0.1"
+  VERSION = "0.0.6"
 end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'rspec'
+require 'entangled'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: entangled
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.6
 platform: ruby
 authors:
 - Dennis Charles Hackethal
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-12 00:00:00.000000000 Z
+date: 2015-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: tubesock
   requirement: !ruby/object:Gem::Requirement
@@ -79,9 +93,17 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- entangled-0.0.1.gem
+- entangled-0.0.2.gem
+- entangled-0.0.3.gem
+- entangled-0.0.4.gem
+- entangled-0.0.5.gem
 - entangled.gemspec
 - lib/entangled.rb
+- lib/entangled/controller.rb
+- lib/entangled/model.rb
 - lib/entangled/version.rb
+- spec/spec_helper.rb
 homepage: https://github.com/so-entangled/rails
 licenses:
 - MIT
@@ -102,8 +124,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Makes Rails real time through websockets.
-test_files: []
+test_files:
+- spec/spec_helper.rb