activerecord-publishable 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7996fc0dec2bf180ae15316bbd309cc3d769d26e
+  data.tar.gz: ba8319dbb4a8b5d18f1258db438eae2ef9fd3264
+SHA512:
+  metadata.gz: 7b9d8a175f343875fe6ee22096cdb2aa764ca3d94ae818958b48b4876c2458013876d6b6e0f8f1b16094b5d8ef1532d69fb1043965a45027be5c2ef621d9ec2d
+  data.tar.gz: cbf93e800ba381ab97238478e58c983bb60bb53dc521f0342fdb1d396307811f1f2383aed73d89878540778715a2527201b934b9f9656ec6c18edcaff6afc09f

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.sqlite3

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'activerecord', '~> 4.2.0', require: 'active_record'
+gem 'sqlite3'
+gem 'active_model_serializers'
+
+group :examples do
+  gem 'angelo'
+  gem 'celluloid-redis'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Ray Zane
+
+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,87 @@
+# ActiveRecord::Publishable
+
+Publish changes to your ActiveRecord models to Redis for use with PubSub. This allows you to easily implement Server-Sent events.
+
+![Preview](examples/sse/public/streaming.gif?raw=true)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activerecord-publishable'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install activerecord-publishable
+
+## Usage
+
+To start publishing changes to your models, include the module and call `publishable`.
+
+```ruby
+class Post < ActiveRecord::Base
+  include ActiveRecord::Publishable
+
+  publishable
+end
+```
+
+The `publishable` method creates an `after_commit` hook on create, update, and destroy. You can pass the `:on` option to only push certain events. It accepts all of the options you can pass to an `after_commit` hook, like `:if` and `:unless`.
+
+```ruby
+publishable on: [:update, :destroy]
+publishable on: :create, if: :some_condition?
+publishable on: :create, unless: ->{ dont_push? }
+```
+
+When pushing to Redis, your model will be serialized as JSON. If you have `ActiveModel::Serializers` loaded, your serializer will be looked up. Otherwise, `as_json` will be used.
+
+You can pass options for serialization by using the `:serialize` option. The `:with` option allows you to override the serializer that is used.
+
+```ruby
+publishable serialize: { with: OtherPostSerializer }
+publishable serialize: { only: [:title, :content] }
+```
+
+By default, events will be published to `<collection>:create`, `<collection>:update`, and `<collection>:destroy`, where collection is the plural name of your model. To override this behavior, you can pass the `:channel` option:
+
+```ruby
+publishable on: :create, channel: "custom:create"
+```
+
+Alternatively, you can override `channel_for_publishing`:
+
+```ruby
+class Post < ActiveRecord::Base
+  include ActiveRecord::Publishable
+
+  publishable
+
+  def channel_for_publishing(action)
+    "posts:#{user.id}:#{action}"
+  end
+end
+```
+
+## Running the demo app
+
+The demo app provides an example of streaming changes to your models using Server-Sent events.
+
+1. Clone the repository
+2. Run `bundle install`
+3. Run `rake example`
+4. Open your browser to localhost:4567
+
+## Contributing
+
+1. Fork it ( https://github.com/rzane/activerecord-publishable/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

data/Rakefile

@@ -0,0 +1,43 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'PublicActivityAggregate'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require "bundler/gem_tasks"
+
+Bundler::GemHelper.install_tasks
+
+require "rake/testtask"
+
+Rake::TestTask.new :spec do |t|
+  t.libs << 'lib' << 'spec'
+  t.test_files = FileList['spec/**/*_spec.rb']
+  t.verbose = false
+end
+
+task :default => :spec
+
+namespace :examples do
+  namespace :sse do
+    task :app do
+      ruby 'examples/sse/app.rb'
+    end
+
+    task :data do
+      ruby 'examples/sse/change_data.rb'
+    end
+  end
+
+  multitask :sse => ['sse:app', 'sse:data']
+end

data/activerecord-publishable.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_record/publishable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "activerecord-publishable"
+  spec.version       = ActiveRecord::Publishable::VERSION
+  spec.authors       = ["Ray Zane"]
+  spec.email         = ["raymondzane@gmail.com"]
+  spec.summary       = %q{Redis PubSub for ActiveRecord models.}
+  spec.description   = %q{Publish events to Redis when your models change.}
+  spec.homepage      = "https://github.com/rzane/activerecord-publishable"
+  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_dependency "redis"
+  spec.add_dependency "activerecord"
+  spec.add_dependency "activesupport"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "mocha"
+end

data/examples/sse/app.rb

@@ -0,0 +1,28 @@
+require 'bundler'
+Bundler.require(:default, :examples)
+
+ActiveRecord::Publishable.redis = Redis.new(driver: :celluloid)
+
+class Angelo::Server
+  def report_errors?
+    true
+  end
+end
+
+class App < Angelo::Base
+  report_errors!
+
+  get '/' do
+    erb :index
+  end
+
+  eventsource '/events/posts' do |sse|
+    ActiveRecord::Publishable.redis.psubscribe('posts:*') do |on|
+      on.pmessage do |_, channel, message|
+        sse.event channel.split(':').last, message
+      end
+    end
+  end
+end
+
+App.run!

data/examples/sse/change_data.rb

@@ -0,0 +1,44 @@
+require 'bundler'
+Bundler.require :default
+
+require_relative './post'
+
+# Running this file will create/update/delete records for demonstration purposess.
+module Changer
+  extend self
+
+  def change action = nil
+    @index = index + 1
+    send action || [:create, :update, :destroy].sample
+  end
+
+  def create
+    post = Post.create content: "Post ##{index}"
+    puts "[Model]  Created ##{post.id}"
+  end
+
+  def update
+    with_random_post 'Updated' do |post|
+      post.increment! :update_count
+    end
+  end
+
+  def destroy
+    with_random_post('Deleted') { |post| post.destroy }
+  end
+
+  private
+
+  def index; @index || 0 end
+
+  def with_random_post action
+    if post = Post.offset(rand(Post.count)).first
+      yield post
+      puts "[Model]  #{action} ##{post.id}"
+    end
+  end
+end
+
+Post.delete_all
+5.times { Changer.change :create }
+loop    { Changer.change; sleep 1 }

data/examples/sse/post.rb

@@ -0,0 +1,22 @@
+require 'bundler'
+Bundler.require :default
+
+# Connect to an inmemory database
+ActiveRecord::Base.establish_connection adapter: 'sqlite3',
+                                        database: 'db.sqlite3'
+
+ActiveRecord::Base.raise_in_transactional_callbacks = true
+
+conn = ActiveRecord::Base.connection
+conn.create_table :posts do |t|
+  t.string :content
+  t.integer :update_count, default: 0
+  t.timestamps null: false
+end unless conn.table_exists?(:posts)
+
+# Here's the important part. Define our model and enable streaming.
+class Post < ActiveRecord::Base
+  include ActiveRecord::Publishable
+
+  publishable
+end

data/examples/sse/public/app.js

@@ -0,0 +1,70 @@
+'use strict';
+
+window.App = function(url, verbs) {
+  this.verbs = verbs;
+  this.stream = new EventSource(url);
+  this.el = $('#posts');
+};
+
+$.extend(App.prototype, {
+  start: function() {
+    var post,
+        that = this;
+
+    this.stream.addEventListener('open', function() {
+      console.log('Listening to ' + this.url);
+    });
+
+    // Bind create, update, and destroy
+    $.each(this.verbs, function(index, verb) {
+      that.stream.addEventListener(verb, function(event) {
+        post = JSON.parse(event.data);
+        console.log(verb, post);
+        that[verb](post);
+      });
+    });
+  },
+
+  attributes: ['id', 'content', 'update_count', 'lastUpdated'],
+
+  render: function(post) {
+    post.lastUpdated = new Date(post.updated_at).toLocaleString();
+
+    var cols = $.map(this.attributes, function(attr) {
+      return $('<td>').text(post[attr]);
+    });
+
+    return $('<tr>').attr('id', 'post' + post.id).append(cols);
+  },
+
+  find: function(post) {
+    return this.el.find('#post' + post.id);
+  },
+
+  create: function(post) {
+    this.el.prepend(this.animate(this.render(post), 'bounceInLeft'));
+  },
+
+  update: function(post) {
+    var tmpl = this.render(post), row = this.find(post);
+    if (!row.length) { return this.create(post); }
+
+    this.animate(row, 'shake', function() {
+      row.replaceWith(tmpl);
+    });
+  },
+
+  destroy: function(post) {
+    var row = this.find(post);
+    this.animate(row, 'bounceOutRight', function(){ row.remove(); });
+  },
+
+  animate: function(el, name, callback) {
+    el.removeClass().addClass('animated ' + name);
+    return callback ? setTimeout(callback, 600) : el;
+  }
+});
+
+$(document).ready(function() {
+  new App('/events/posts', ['create', 'update', 'destroy']).start();
+});

data/examples/sse/views/index.html.erb

@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <title>Streaming Demo Page</title>
+    <link href="https://fonts.googleapis.com/css?family=Raleway:400,300,600" rel="stylesheet" type="text/css">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/animate.css/3.2.6/animate.min.css" rel="stylesheet" type="text/css">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/skeleton/2.0.4/skeleton.min.css" rel="stylesheet" type="text/css">
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/2.1.3/jquery.min.js"></script>
+    <script src="./app.js"></script>
+    <style>
+      h1 { margin-top: 5rem; }
+    </style>
+  </head>
+
+  <body>
+    <div class="container">
+      <h1 class="title">Streaming Demo Page</h1>
+
+      <table class="u-full-width">
+        <thead>
+          <tr>
+            <th>#</th>
+            <th>Content</th>
+            <th>Number of updates</th>
+            <th>Last updated</th>
+          </tr>
+        </thead>
+
+        <tbody id="posts"></tbody>
+      </table>
+    </div>
+  </body>
+</html>

data/lib/active_record/publishable.rb

@@ -0,0 +1,68 @@
+require 'redis'
+require 'active_record/publishable/version'
+
+module ActiveRecord
+  module Publishable
+    class << self
+      attr_writer :redis
+
+      def included(base)
+        base.extend ClassMethods
+      end
+
+      def disable!
+        @disabled = true
+      end
+
+      def enable!
+        @disabled = nil
+      end
+
+      def disabled?
+        !!@disabled
+      end
+
+      def redis
+        @redis ||= Redis.new
+      end
+
+      def publish(channel, message)
+        redis.publish(channel, message) unless disabled?
+      end
+    end
+
+    module ClassMethods
+      def publishable(options = {})
+        Array(options.fetch(:on, [:create, :update, :destroy])).each do |verb|
+          after_commit options.merge(on: verb) do
+            unless ActiveRecord::Publishable.disabled?
+              publish_action(verb, options)
+            end
+          end
+        end
+      end
+    end
+
+    def publish_action(action, options = {})
+      channel = options[:channel] || channel_for_publishing(action)
+      data = serialize_for_publishing(options.fetch(:serialize, {}))
+
+      ActiveRecord::Publishable.publish(channel, data.to_json)
+    end
+
+    def serialize_for_publishing(options = {})
+      opts = options.reverse_merge(root: false).except(:with)
+
+      serializer = options.fetch :with do
+        next unless defined? ActiveModel::Serializer
+        ActiveModel::Serializer.serializer_for self
+      end
+
+      serializer ? serializer.new(self, opts) : as_json(opts)
+    end
+
+    def channel_for_publishing(action)
+      "#{self.class.model_name.collection}:#{action}"
+    end
+  end
+end

data/lib/active_record/publishable/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module Publishable
+    VERSION = "0.0.1"
+  end
+end

data/lib/activerecord-publishable.rb

@@ -0,0 +1 @@
+require 'active_record/publishable'

data/spec/active_record/publishable_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+module ActiveRecord
+  describe Publishable do
+    describe '.disable!' do
+      after { Publishable.enable! }
+
+      it 'can be disabled' do
+        Publishable.enable!
+        Publishable.disable!
+        Publishable.disabled?.must_equal true
+      end
+    end
+
+    describe '.enable!' do
+      it 'can be re-enabled' do
+        Publishable.disable!
+        Publishable.enable!
+        Publishable.disabled?.must_equal false
+      end
+    end
+
+    describe '.redis=' do
+      it 'can be assigned' do
+        Publishable.redis = 'fake'
+        Publishable.redis.must_equal 'fake'
+      end
+    end
+
+    describe '.publish' do
+      let(:redis) { mock('Redis') }
+
+      before { Publishable.redis = redis }
+      after  { Publishable.enable! }
+
+      it 'provides a convience publish method' do
+        redis.expects(:publish).at_least_once
+        Publishable.publish('channel', msg: 'yo')
+      end
+
+      it 'does nothing when Publishable.disabled?' do
+        Publishable.disable!
+
+        redis.expects(:publish).times(0)
+        Publishable.publish('channel', msg: 'yo')
+      end
+    end
+
+    describe 'ClassMethods' do
+      describe '.publishable' do
+        before do
+          Foo._commit_callbacks.clear
+          Foo.must_have_commit_callbacks 0
+        end
+
+        it 'should define default after_commit callbacks' do
+          Foo.publishable
+          Foo.must_have_commit_callbacks 3
+        end
+
+        it 'should allow specifying :on action' do
+          Foo.publishable on: [:create, :update]
+          Foo.must_have_commit_callbacks 2
+        end
+
+        it 'should allow :on to be a symbol' do
+          Foo.publishable on: :create
+          Foo.must_have_commit_callbacks 1
+        end
+
+        it 'should accept :if option' do
+          Foo.expects(:after_commit).with(on: :create, if: :something?)
+          Foo.publishable on: :create, if: :something?
+        end
+
+        it 'should accept :unless option' do
+          Foo.expects(:after_commit).with(on: :create, unless: :something?)
+          Foo.publishable on: :create, unless: :something?
+        end
+      end
+    end
+
+    let(:foo) { Foo.new name: 'foo' }
+    let(:bar) { Bar.new name: 'bar' }
+
+    describe '#publish_action' do
+      let(:channel) { foo.channel_for_publishing :create }
+      let(:data)    { foo.serialize_for_publishing }
+
+      it 'should publish the event and data' do
+        Publishable.expects(:publish).with(channel, data.to_json)
+        foo.publish_action(:create)
+      end
+
+      it 'should pass :serialize option to #serialize_for_publishing' do
+        Publishable.stubs :publish
+        foo.expects(:serialize_for_publishing).with only: [:name]
+        foo.publish_action :create, serialize: { only: [:name] }
+      end
+
+      it 'should not do anything when disabled' do
+        Publishable.stubs(:disabled?).returns(true)
+        Publishable.expects(:redis).never
+        foo.publish_action :create
+      end
+    end
+
+    describe '#serialize_for_publishing' do
+      it 'should infer an active model serializer' do
+        foo.serialize_for_publishing.must_be_instance_of FooSerializer
+      end
+
+      it 'should use serializer from :with option' do
+        serialized = foo.serialize_for_publishing with: OtherFooSerializer
+        serialized.must_be_instance_of OtherFooSerializer
+      end
+
+      it 'should default to root: false element' do
+        FooSerializer.expects(:new).with foo, root: false
+        foo.serialize_for_publishing
+      end
+
+      it 'should pass :serialize option to the serializer' do
+        FooSerializer.expects(:new).with foo, root: 'foo', only: [:name]
+        foo.serialize_for_publishing root: 'foo', only: [:name]
+      end
+
+      it 'should serialize with as_json when serializer not found' do
+        bar.expects(:as_json).with root: false, only: [:name]
+        bar.serialize_for_publishing root: false, only: [:name]
+      end
+    end
+
+    describe '#channel_for_publishing' do
+      it 'should infer a reasonable default' do
+        foo.channel_for_publishing(:create).must_equal 'foos:create'
+        foo.channel_for_publishing(:update).must_equal 'foos:update'
+        foo.channel_for_publishing(:destroy).must_equal 'foos:destroy'
+      end
+
+      it 'should allow non-standard events' do
+        foo.channel_for_publishing(:custom).must_equal 'foos:custom'
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+require 'bundler'
+Bundler.require :default
+
+require 'active_record'
+require 'minitest/autorun'
+require 'mocha/mini_test'
+
+FileUtils.rm_rf File.expand_path('../test.sqlite3', __FILE__)
+ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: 'test.sqlite3'
+ActiveRecord::Base.raise_in_transactional_callbacks = true
+
+conn = ActiveRecord::Base.connection
+
+[:foos, :bars].each do |table|
+  conn.create_table table, force: true do |t|
+    t.string :name
+  end
+end
+
+class Foo < ActiveRecord::Base
+  include ActiveRecord::Publishable
+end
+
+class Bar < ActiveRecord::Base
+  include ActiveRecord::Publishable
+end
+
+# Create some ActiveModel::Serializers (for integration testing)
+class FooSerializer < ActiveModel::Serializer
+  attributes :id, :name
+end
+
+class OtherFooSerializer < FooSerializer; end
+
+
+module MiniTest::Assertions
+  def assert_commit_callbacks(expected, klass)
+    assert_equal expected, klass._commit_callbacks.select { |cb|
+      cb.kind == :after && cb.name == :commit
+    }.size
+  end
+end
+
+Class.infect_an_assertion :assert_commit_callbacks, :must_have_commit_callbacks

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-publishable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ray Zane
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  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: activerecord
+  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: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Publish events to Redis when your models change.
+email:
+- raymondzane@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activerecord-publishable.gemspec
+- examples/sse/app.rb
+- examples/sse/change_data.rb
+- examples/sse/post.rb
+- examples/sse/public/app.js
+- examples/sse/public/streaming.gif
+- examples/sse/views/index.html.erb
+- lib/active_record/publishable.rb
+- lib/active_record/publishable/version.rb
+- lib/activerecord-publishable.rb
+- spec/active_record/publishable_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/rzane/activerecord-publishable
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Redis PubSub for ActiveRecord models.
+test_files:
+- spec/active_record/publishable_spec.rb
+- spec/spec_helper.rb