active_model_pusher 0.0.1

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# Version 0.0.1 (December 26, 2012)
+* Initial release

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 TODO: Write your name
+
+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,210 @@
+# Active Model Pusher
+
+`ActiveModel::Pusher` makes using [Pusher](https://github.com/pusher/pusher-gem) in your app much easier.
+The purpose of this gem is to use the convention over configuration principle to reduce amount of code needed to interact with Pusher.
+
+## Basic Usage
+```ruby
+@post = Post.create
+
+PostPusher.new(@post).push!
+```
+
+This will push the following json to Pusher:
+
+```
+channel: 'posts',
+event: 'created',
+data: { id: 1 }
+```
+The original Pusher gem needs 4 things to be triggered: `channel`, `event`, `data` and optional `params`. They will be discussed below.
+
+## Channels
+A `channel` value for a `Post` model will be one of the following:
+
+1. `posts` when a record has just been created
+2. `posts-1` for any other event: `updated`, `destroyed`, etc
+
+### Customizing channels
+Sometimes you might want to have a general channel name -  like `dashboard` - to which you will be pushing several models.
+
+There are two ways to do that.
+
+* Define a `channel` method in your model:
+
+```ruby
+class Post
+  def channel
+    "dashboard"
+  end
+end
+```
+
+* Define a `channel` method in your pusher:
+
+```ruby
+class PostPusher < ActiveModel::Pusher
+  def channel(event)
+    "dashboard"
+  end
+end
+```
+
+## Events
+A newly generated pusher will look like this:
+
+```ruby
+# app/pushers/post_pusher.rb
+class PostPusher < ActiveModel::Pusher
+  events :created, :updated, :destroyed
+end
+```
+
+The `events` method is a whitelist of events. If you try to push a non-whitelisted event, an exception will be raised:
+```ruby
+def publish
+  @post = Post.find(1).publish!
+  PostPusher.new(@post).push! :published
+end
+```
+will result in `InvalidEventError: 'Event :published is not allowed'`.
+
+
+The three default events can be guessed by the gem automatically, you don't actually have to specify them:
+
+```ruby
+def create
+  @post = Post.create
+  PostPusher.new(@post).push!
+end
+```
+The gem will recognize that the record was just created and will set the event to `:created`
+
+If you have custom actions in your controller - like `publish` - then you should specify the event manually:
+```ruby
+def publish
+  @post = Post.find(1).publish!
+
+  PostPusher.new(@post).push! :published
+end
+```
+
+This will produce the following (given you whitelisted the `published` event in your pusher):
+```
+channel: 'posts-1',
+event: 'published',
+data: { id: 1 }
+```
+
+### Customizing events
+
+Customizing event names may be useful when you are using a general purpose channel.
+
+Using the example from the `Customizing channels` section:
+
+```ruby
+class PostPusher < ActiveModel::Pusher
+  def channel(event)
+    "dashboard"
+  end
+end
+class CommentPusher < ActiveModel::Pusher
+  def channel(event)
+    "dashboard"
+  end
+end
+```
+
+We then push two different models into the general `dashboard` channel:
+```ruby
+@post = Post.create
+@comment = Comment.create
+
+PostPusher.new(@post).push!
+CommentPusher.new(@comment).push!
+```
+
+They both will be pushed with the same event `created`. Depending on your client-side architecture it might be fine, but sometimes you might want to have namespaced events: `post-created`, `comment-created`, etc.
+
+You can achieve this by overriding the `event(event)` method in your pusher:
+
+```ruby
+class PostPusher < ActiveModel::Pusher
+  def event(event)
+    "post-#{event.underscore.dasherize}"
+  end
+end
+```
+
+## Data
+The `data` method simply serializes your record.
+
+By default, it will try to serialize the record with the `active_model_serializers` gem.
+
+If `active_model_serializers` is not used in your application, it will fallback to the `as_json` method on your record.
+
+But seriously, just use `active_model_serializers`.
+
+## Params
+You can specify the params when calling the `push!` method:
+
+```ruby
+def create
+  @post = Post.create
+  PostPusher.new(@post).push! { socket_id: params[:socket_id] }
+end
+```
+
+If you need to specify an event as well, it should go first:
+```ruby
+def publish
+  @post = Post.publish!
+  PostPusher.new(@post).push! :published, { socket_id: params[:socket_id] }
+end
+```
+A more fancier way of doing the same:
+```ruby
+def publish
+  @post = Post.publish!
+  PostPusher.new(@post).push! :published, params.slice(:socket_id)
+end
+```
+
+## Creating a new pusher
+```
+rails generate pusher Post created published
+```
+
+Will result in:
+
+```ruby
+# app/pushers/post_pusher.rb
+class PostPusher < ActiveModel::Pusher
+  events :created, :published
+end
+```
+
+## Notice
+This is sort of an alpha version, so things may break. If you have any ideas on improving the gem, you are very welcome to contribute.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'active_model_pusher'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_model_pusher
+
+## 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/active_model_pusher.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/active_model/pusher/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Alexander Zaytsev"]
+  gem.email         = ["alexander@say26.com"]
+  gem.description   = %q{Making it easy to use Pusher with your models}
+  gem.summary       = %q{Push your models with Pusher easily}
+  gem.homepage      = "https://github.com/AlexanderZaytsev/active_model_pusher"
+
+  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          = "active_model_pusher"
+  gem.require_paths = ["lib"]
+  gem.version       = ActiveModel::Pusher::VERSION
+
+  gem.add_dependency 'activemodel', '>= 3.0'
+  gem.add_dependency 'pusher'
+  gem.add_development_dependency "rspec"
+end

data/lib/active_model/pusher.rb

@@ -0,0 +1,71 @@
+module ActiveModel
+  class Pusher
+
+    class_attribute :_events
+    self._events = nil
+
+    class << self
+      def events(*events)
+        self._events = events
+      end
+    end
+
+    def initialize(record)
+      @record = record
+    end
+
+    def push!(event_or_params = nil, params = {})
+      event, params = parse_push_params(event_or_params, params)
+
+      event ||= RecordEventRecognizer.new(record).event
+
+      events.validate! event
+
+      ::Pusher.trigger channel(event), event(event), data, params
+    end
+
+    private
+      def events
+        @events ||= Events.new self._events
+      end
+
+      def record
+        @record
+      end
+
+      def channel(event)
+        @channel ||= RecordChannel.new(record, event).channel
+      end
+
+      def event(event)
+        event.to_s.underscore.dasherize
+      end
+
+      def data
+        @data ||= RecordSerializer.new(record).serialize!
+      end
+
+      def parse_push_params(event_or_params = nil, params = {})
+        # Tell me if there is a better way of doing this
+
+        if event_or_params && params
+          event = event_or_params
+          params = params
+        end
+
+        if event_or_params && params.none?
+          if events.validate(event_or_params)
+            event = event_or_params
+            params = {}
+          else
+            event = nil
+            params = event_or_params
+          end
+        end
+
+        [event, params]
+      end
+
+
+  end
+end

data/lib/active_model/pusher/events.rb

@@ -0,0 +1,45 @@
+module ActiveModel
+  class Pusher
+    class Events
+      class InvalidEventError < StandardError
+        attr_reader :event
+
+        def initialize(event)
+          @event = event
+        end
+
+        def to_s
+          "Event `#{@event}` is not allowed. Add it into your pusher's `events` class attribute"
+        end
+      end
+
+
+      def initialize(*events)
+        @events = Array(events).flatten
+      end
+
+      def validate(event)
+        # Allow strings and symbols only
+        # Return true if there are no whitelisted events
+
+        return false unless event.respond_to? :to_sym
+
+        return true unless @events.any?
+
+        @events.include?(event)
+      end
+
+      def any?
+        @events.any?
+      end
+
+      def validate!(event)
+        if validate(event) == false
+          raise InvalidEventError.new(event)
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/active_model/pusher/record_channel.rb

@@ -0,0 +1,30 @@
+module ActiveModel
+  class Pusher
+    class RecordChannel
+      CHANNEL_COLUMN = :channel
+
+      def initialize(record, event)
+        @record = record
+        @event = event
+      end
+
+      def channel
+        from_record_channel_column || from_record_class_name
+      end
+
+      private
+        def from_record_channel_column
+          @record.send(CHANNEL_COLUMN) if @record.respond_to?(CHANNEL_COLUMN)
+        end
+
+        def from_record_class_name
+          if @event == :created
+            @record.class.name.pluralize.underscore.dasherize
+          else
+            [@record.class.name.pluralize.underscore.dasherize, @record.id].join('-')
+          end
+        end
+
+    end
+  end
+end

data/lib/active_model/pusher/record_event_recognizer.rb

@@ -0,0 +1,41 @@
+module ActiveModel
+  class Pusher
+    class RecordEventRecognizer
+      def initialize(record)
+        @record = record
+      end
+
+      def event
+        return nil unless can_be_recognized?
+
+        if created?
+          :created
+        elsif updated?
+          :updated
+        elsif destroyed?
+          :destroyed
+        else
+          nil
+        end
+      end
+
+    private
+      def can_be_recognized?
+        @record.respond_to? :previous_changes
+      end
+
+      def created?
+        @record.previous_changes.include? 'id'
+      end
+
+      def updated?
+        @record.previous_changes.any?
+      end
+
+      def destroyed?
+        @record.destroyed?
+      end
+    end
+
+  end
+end

data/lib/active_model/pusher/record_serializer.rb

@@ -0,0 +1,41 @@
+module ActiveModel
+  class Pusher
+    class RecordSerializer
+      class RecordCannotBeSerializedError < StandardError
+        attr_reader :record
+
+        def initialize(record)
+          @record = record
+        end
+
+        def to_s
+          "#{@record} cannot be serialized."
+        end
+      end
+
+      def initialize(record)
+        @record = record
+      end
+
+      def serialize!
+        raise RecordCannotBeSerializedError.new(@record) unless can_be_serialized?
+
+        serializer.as_json
+      end
+
+      private
+        def serializer
+          if @record.respond_to?(:active_model_serializer)
+            serializer = @record.active_model_serializer
+            serializer.new @record
+          elsif @record.respond_to?(:as_json)
+            @record
+          end
+        end
+
+        def can_be_serialized?
+          @record.respond_to?(:active_model_serializer) || @record.respond_to?(:as_json)
+        end
+    end
+  end
+end

data/lib/active_model/pusher/version.rb

@@ -0,0 +1,5 @@
+module ActiveModel
+  class Pusher
+    VERSION = "0.0.1"
+  end
+end

data/lib/active_model_pusher.rb

@@ -0,0 +1,9 @@
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/object/try"
+require "active_model/pusher"
+require "active_model/pusher/record_channel"
+require "active_model/pusher/record_event_recognizer"
+require "active_model/pusher/record_serializer"
+require "active_model/pusher/events"
+

data/lib/generators/pusher/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generates a pusher for the give resource
+
+Example:
+    rails generate pusher Post created updated destroyed
+
+    This will create:
+        app/pushers/post_pusher.rb

data/lib/generators/pusher/pusher_generator.rb

@@ -0,0 +1,10 @@
+class PusherGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path('../templates', __FILE__)
+  check_class_collision suffix: "Pusher"
+  argument :events, type: :array, default: [:created, :updated, :destroyed], banner: "event event"
+
+
+  def create_pusher_file
+    template 'pusher.rb', File.join('app/pushers', class_path, "#{file_name}_pusher.rb")
+  end
+end

data/lib/generators/pusher/templates/pusher.rb

@@ -0,0 +1,5 @@
+<% module_namespacing do -%>
+class <%= class_name %>Pusher < ActiveModel::Pusher
+  events <%= events.map(&:to_sym).map(&:inspect).join(", ") %>
+end
+<% end -%>

data/spec/active_model_pusher/events_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe ActiveModel::Pusher::Events do
+
+  it 'accepts nothing' do
+    expect { ActiveModel::Pusher::Events.new }.to_not raise_error
+  end
+
+  it 'accepts individual events' do
+    events = ActiveModel::Pusher::Events.new :created
+
+    events.validate!(:created).should be_true
+  end
+
+
+  it 'accepts array' do
+    events = ActiveModel::Pusher::Events.new [:created, :updated]
+
+    events.validate!(:updated).should be_true
+  end
+
+
+  it 'accepts indefinite params' do
+    events = ActiveModel::Pusher::Events.new :created, :updated
+
+    events.validate!(:updated).should be_true
+  end
+
+
+  describe '#validate!' do
+    it 'returns true if event is valid' do
+      ActiveModel::Pusher::Events.new([:created, :updated]).validate!(:created).should be_true
+    end
+
+    it 'always returns true when there are no whitelisted events' do
+      ActiveModel::Pusher::Events.new.validate!(:created).should be_true
+    end
+
+    it 'raises an exception if event is invalid' do
+      events = ActiveModel::Pusher::Events.new(:created)
+      expect { events.validate!(:updated) }.to raise_error(ActiveModel::Pusher::Events::InvalidEventError)
+    end
+  end
+end

data/spec/active_model_pusher/pusher_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe ActiveModel::Pusher do
+
+
+  describe '#parse_push_params' do
+    before do
+      @pusher = AlienPusher.new(Class.new)
+      @event = :created
+      @params = { socket_id: 1234 }
+    end
+
+    it { @pusher.send(:parse_push_params, @event).should eq([@event, {}]) }
+    it { @pusher.send(:parse_push_params, @event, @params).should eq([@event, @params]) }
+    it { @pusher.send(:parse_push_params, @params).should eq([nil, @params]) }
+  end
+
+  describe '#push!' do
+    it 'can be called with the event and params' do
+      alien = Alien.new
+      pusher = AlienPusher.new(alien)
+      params = { socket_id: 1234 }
+      Pusher.should_receive(:trigger).with('aliens', 'created', alien.as_json, params)
+
+      pusher.push!(:created, params)
+    end
+
+    it 'can be called without the event' do
+      alien = CreatedAlien.new
+      pusher = AlienPusher.new(alien)
+
+      Pusher.should_receive(:trigger).with('created-aliens', 'created', alien.as_json, {})
+
+      pusher.push!
+    end
+
+    it 'can be called with params only' do
+      alien = CreatedAlien.new
+      pusher = AlienPusher.new(alien)
+      params = { socket_id: 1234 }
+
+      Pusher.should_receive(:trigger).with('created-aliens', 'created', alien.as_json, params)
+
+      pusher.push! params
+    end
+
+    it 'allows overriding the `event` and `channel` method' do
+      alien = Alien.new
+      pusher = Class.new(AlienPusher) do
+        def event(event)
+          "custom-#{event}"
+        end
+
+        def channel(event)
+          "custom-channel"
+        end
+      end.new(alien)
+
+      Pusher.should_receive(:trigger).with('custom-channel', 'custom-created', alien.as_json, {})
+
+      pusher.push! :created
+    end
+  end
+end

data/spec/active_model_pusher/record_channel_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe ActiveModel::Pusher::RecordChannel do
+  describe '#channel' do
+    it "gets channel from record's channel column" do
+
+      record = Class.new do
+        def channel
+          'custom-channel'
+        end
+      end.new
+
+      record_channel = ActiveModel::Pusher::RecordChannel.new(record, nil)
+      record_channel.channel.should == 'custom-channel'
+    end
+
+    it 'defaults to class name and record id if the record has no channel column' do
+      record = Alien.new
+      record_channel = ActiveModel::Pusher::RecordChannel.new(record, :updated)
+      record_channel.channel.should == 'aliens-1'
+    end
+
+    it 'defaults to pluralized class name if the record was just created and has no channel column' do
+      record = Alien.new
+      record_channel = ActiveModel::Pusher::RecordChannel.new(record, :created)
+
+      record_channel.channel.should == 'aliens'
+    end
+  end
+end

data/spec/active_model_pusher/record_event_recognizer.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe ActiveModel::Pusher::RecordEventRecognizer do
+  before do
+    @recognizer = ActiveModel::Pusher::RecordEventRecognizer
+  end
+
+  it 'recognizes :created event' do
+    @recognizer.new(CreatedAlien.new).event.should == :created
+  end
+
+  it 'recognizes :updated event' do
+    @recognizer.new(UpdatedAlien.new).event.should == :updated
+  end
+
+  it 'recognizes :destroyed event' do
+    @recognizer.new(DestroyedAlien.new).event.should == :destroyed
+  end
+
+  it 'returns nil when event cannot be recognized' do
+    @recognizer.new(Class.new).event.should be_nil
+  end
+end

data/spec/active_model_pusher/record_serializer.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe ActiveModel::Pusher::RecordSerializer do
+  before do
+    @serializer = ActiveModel::Pusher::RecordSerializer
+  end
+
+  it 'serializes record with active_model_serializers gem' do
+    record = ActiveModelAlienWithSerializer.new
+
+    @serializer.new(record).serialize!.should eq({ id: 2 })
+  end
+
+  it 'serializes record by calling as_json on it' do
+    record = Alien.new
+
+    @serializer.new(record).serialize!.should eq({ id: 1 })
+  end
+
+  it 'prefers active_model_serializer to as_json' do
+    record = Class.new(ActiveModelAlienWithSerializer) do
+      def as_json
+        { id: 1 }
+      end
+    end.new
+
+    @serializer.new(record).serialize!.should eq({ id: 2 })
+  end
+
+  it 'raises an exception when record cannot be serialized' do
+    expect { @serializer.new(Class.new).serialize! }.to raise_error(ActiveModel::Pusher::RecordSerializer::RecordCannotBeSerializedError)
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,62 @@
+require 'active_model_pusher'
+
+class Pusher
+  def self.trigger(channel, event, json, params = {})
+    true
+  end
+end
+
+class AlienPusher < ActiveModel::Pusher
+  events :created
+end
+
+class Alien
+  def id
+    1
+  end
+
+  def as_json
+    { id: 1 }
+  end
+end
+
+class ActiveModelAlien < Alien
+  def previous_changes
+    []
+  end
+end
+
+
+
+class ActiveModelAlienWithSerializer < ActiveModelAlien
+  class ActiveModelSerializer
+    def initialize(record)
+    end
+    def as_json
+      { id: 2 }
+    end
+  end
+
+  def active_model_serializer
+    ActiveModelSerializer
+  end
+end
+
+
+class CreatedAlien < ActiveModelAlien
+  def previous_changes
+    { 'id' => [nil, 1] }
+  end
+end
+
+class UpdatedAlien < ActiveModelAlien
+  def previous_changes
+    { 'planet_id' => [1, 2] }
+  end
+end
+
+class DestroyedAlien < ActiveModelAlien
+  def destroyed?
+    true
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: active_model_pusher
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alexander Zaytsev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: &2152717000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152717000
+- !ruby/object:Gem::Dependency
+  name: pusher
+  requirement: &2152716580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152716580
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2152716120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2152716120
+description: Making it easy to use Pusher with your models
+email:
+- alexander@say26.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- active_model_pusher.gemspec
+- lib/active_model/pusher.rb
+- lib/active_model/pusher/events.rb
+- lib/active_model/pusher/record_channel.rb
+- lib/active_model/pusher/record_event_recognizer.rb
+- lib/active_model/pusher/record_serializer.rb
+- lib/active_model/pusher/version.rb
+- lib/active_model_pusher.rb
+- lib/generators/pusher/USAGE
+- lib/generators/pusher/pusher_generator.rb
+- lib/generators/pusher/templates/pusher.rb
+- spec/active_model_pusher/events_spec.rb
+- spec/active_model_pusher/pusher_spec.rb
+- spec/active_model_pusher/record_channel_spec.rb
+- spec/active_model_pusher/record_event_recognizer.rb
+- spec/active_model_pusher/record_serializer.rb
+- spec/spec_helper.rb
+homepage: https://github.com/AlexanderZaytsev/active_model_pusher
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Push your models with Pusher easily
+test_files:
+- spec/active_model_pusher/events_spec.rb
+- spec/active_model_pusher/pusher_spec.rb
+- spec/active_model_pusher/record_channel_spec.rb
+- spec/active_model_pusher/record_event_recognizer.rb
+- spec/active_model_pusher/record_serializer.rb
+- spec/spec_helper.rb