stream_rails 1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YTMwN2JiNjM1YTNhYjQwZjBkNmNlMTc2YTM3ZjQ0NTllOTRjMjI3Yg==
+  data.tar.gz: !binary |-
+    OTY1NjJkMzc2YTJjZDI0ZjIwZTY3YjIxYTI3NWVlY2FlNTc1N2NhMg==
+SHA512:
+  metadata.gz: !binary |-
+    MGQ3YWE0NjI5M2I0NzdlMDcyZjhmN2ExMjFjOWU4ZTY2MTc4NzBjYTkyZTI5
+    Nzg4ZTNiMTU2OWE3NzI0ZGM2ZmZmNDRjYTNlNzQ3MDA0MTU0ZDFmZDBmOThi
+    MzI5YjQ0M2U2NzljNjQ1MjQxNDI0ZmY2Yjg1MzZjNmI1YmZlZWI=
+  data.tar.gz: !binary |-
+    M2Y4ODA5YWQ0OTZjZjllNjRkYjkyZTNkMmFkYzY2NGFmYmYyZjIzZmQ1ODE4
+    YmE1OTk1MzAyMTNlOTUwMGM1NGNlYWE2ZjE3ODIxZDAwMTljMWU0Y2VhZWRi
+    NjU0ZjYxZTUwMzQ4MGRhY2UxNjE2YzM4MjEzMWJkZTc5MmNkMWY=

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2014, Tommaso Barbugli
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the {organization} nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,262 @@
+Stream Rails
+============
+
+[![image](https://secure.travis-ci.org/GetStream/stream-rails.png?branch=master)](http://travis-ci.org/GetStream/stream-rails)
+
+
+This package helps you create activity streams & newsfeeds with Ruby on Rails and [GetStream.io](https://getstream.io).
+
+###Activity Streams & Newsfeeds
+
+![](https://dvqg2dogggmn6.cloudfront.net/images/mood-home.png)
+
+What you can build:
+
+* Activity streams such as seen on Github
+* A twitter style newsfeed
+* A feed like instagram/ pinterest
+* Facebook style newsfeeds
+* A notification system
+
+###Table of Contents
+
+### Gem installation
+
+You can install ```stream_rails``` as you would any other gem:
+
+```gem install stream_rails```
+
+or in your Gemfile:
+
+```gem 'stream_rails'```
+
+
+### Setup
+
+Login with Github on getstream.io and get your ```api_key``` and ```api_secret``` from your app configuration (Dashboard screen).
+
+Then you can add the StreamRails configuration in ```config/initializers/stream_rails.rb```
+
+```
+require 'stream_rails'
+
+StreamRails.configure do |config|
+  config.api_key     = "YOUR API KEY"
+  config.api_secret  = "YOUR API SECRET"
+end
+```
+
+### Model configuration
+
+Include StreamRails::Activity and add as_activity to the model you want to integrate with your feeds.
+
+```ruby
+class Pin < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :item
+
+  validates :item, presence: true
+  validates :user, presence: true
+
+  include StreamRails::Activity
+  as_activity
+end
+```
+Everytime a Pin is created it will be stored in the feed of the user that created it, and when a Pin instance is deleted than it will get removed as well.
+
+####Activity fields
+
+Models are stored in feeds as activities. An activity is composed of at least the following data fields: **actor**, **verb**, **object**, **time**. You can also add more custom data if needed.
+
+**object** is a reference to the model instance itself
+**actor** is a reference to the user attribute of the instance
+**verb** is a string representation of the class name
+
+In order to work out-of-the-box, the Activity class makes makes few assumptions:
+
+1. the Model class belongs to a user
+2. the model table has timestamp columns (created_at is required)
+
+You can change this behaviour by overriding ```#activity_actor```.
+
+Below shows an example how to change your class if the model belongs to an author instead of to a user.
+
+```ruby
+class Pin < ActiveRecord::Base
+  belongs_to :author
+  belongs_to :item
+
+  include StreamRails::Activity
+  as_activity
+
+  def activity_actor
+    self.author
+  end
+
+end
+```
+
+####Activity extra data
+
+Often you'll want to store more data than just the basic fields. You achieve this by implementing ```#activity_extra_data``` in your model.
+
+
+```ruby
+class Pin < ActiveRecord::Base
+  belongs_to :author
+  belongs_to :item
+
+  include StreamRails::Activity
+  as_activity
+
+  def activity_extra_data
+    {'is_retweet' => self.is_retweet}
+  end
+
+end
+```
+
+###Feed manager
+
+```stream_rails``` comes with a Feed Manager class that helps with all common feed operations. You can get an instance of the manager with ```StreamRails.feed_manager```.
+
+```ruby
+feed = StreamRails.feed_manager.get_user_feed(current_user.id)
+```
+
+####Feeds bundled with feed_manager
+
+To get you started the manager has 4 feeds pre configured. You can add more feeds if your application needs it.
+Feeds are divided in three categories.
+
+#####User feed:
+The user feed stores all activities for a user. Think of it as your personal Facebook page. You can easily get this feed from the manager.
+```ruby
+feed = StreamRails.feed_manager.get_user_feed(current_user.id)
+```
+
+#####News feeds:
+The news feeds store the activities from the people you follow.
+There is both a flat newsfeed (similar to twitter) and an aggregated newsfeed (like facebook).
+
+```php
+feed = StreamRails.feed_manager.get_news_feeds(current_user.id)[:flat]
+aggregated_feed = StreamRails.feed_manager.get_news_feeds(current_user.id)[:aggregated]
+```
+
+#####Notification feed:
+The notification feed can be used to build notification functionality.
+
+![Notification feed](http://feedly.readthedocs.org/en/latest/_images/fb_notification_system.png)
+
+Below we show an example of how you can read the notification feed.
+```ruby
+notification_feed = StreamRails.feed_manager.get_notification_feed(current_user.id)
+
+```
+By default the notification feed will be empty. You can specify which users to notify when your model gets created. In the case of a retweet you probably want to notify the user of the parent tweet.
+
+```ruby
+class Pin < ActiveRecord::Base
+  belongs_to :author
+  belongs_to :item
+
+  include StreamRails::Activity
+  as_activity
+
+  def activity_notify
+    if self.is_retweet
+      [feed_manager.get_notification_feed(self.parent.user_id)]
+    end
+  end
+
+end
+```
+
+Another example would be following a user. You would commonly want to notify the user which is being followed.
+
+```ruby
+class Follow < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :target
+
+  validates :target_id, presence: true
+  validates :user, presence: true
+
+  include StreamRails::Activity
+  as_activity
+
+  def activity_notify
+    [feed_manager.get_notification_feed(self.target_id)]
+  end
+
+end
+```
+
+####Follow a feed
+The create the newsfeeds you need to notify the system about follow relationships. The manager comes with APIs to let a user's news feeds follow another user's feed. This code lets the current user's flat and aggregated feeds follow the target_user's personal feed.
+
+```
+StreamRails.feed_manager.follow_user(user_id, target_id)
+```
+
+### Showing the newsfeed
+
+####Activity enrichment
+
+When you read data from feeds, a pin activity will look like this:
+
+```json
+{"actor": "User:1", "verb": "like", "object": "Pin:42"}
+```
+
+This is far from ready for usage in your template. We call the process of loading the references from the database enrichment. An example is shown below:
+
+```ruby
+enricher = StreamRails::Enrich.new
+
+feed = StreamRails.feed_manager.get_news_feeds(current_user.id)[:flat]
+results = feed.get()['results']
+activities = enricher.enrich_activities(results)
+```
+
+####Templating
+
+Now that you've enriched the activities you can render them in a view.
+For convenience we includes a basic view:
+
+```
+<div class="container">
+    <div class="container-pins">
+        <% for activity in @activities %>
+            <%= render_activity activity %>
+        <% end %>
+    </div>
+</div>
+```
+
+The ```render_activity``` view helper will render the activity by picking the partial ```activity/_pin``` for a pin activity, ```aggregated/_follow``` for an aggregated activity with verb follow.
+
+The helper will automatically send ```activity``` to the local scope of the partial; additional parameters can be send as well as use different layouts, and prefix the name
+
+
+eg. renders the activity partial using the ```small_activity``` layout.
+
+```
+<%= render_activity activity, :layout => "small_activity" %>
+```
+
+
+eg. prefixes the name of the template with "notification_"
+
+```
+<%= render_activity activity, :prefix => "notification_" %>
+```
+
+eg. adds the extra_var to the partial scope
+
+```
+<%= render_activity activity, :locals => {:extra_var => 42} %>
+```
+
+

data/lib/stream_rails.rb

@@ -0,0 +1,47 @@
+require 'active_support'
+require 'action_view'
+require 'stream'
+require 'stream_rails/enrich'
+require 'stream_rails/logger'
+
+module StreamRails
+  extend ActiveSupport::Autoload
+
+  autoload :Activity
+  autoload :Config
+  autoload :FeedManager,  'stream_rails/feed_manager'
+  autoload :Renderable
+  autoload :VERSION
+
+  def self.client
+    Stream::Client.new(self.config.api_key, self.config.api_secret)
+  end
+
+  # Returns StreamRails's configuration object.
+  def self.config
+    @config ||= StreamRails::Config.new
+  end
+
+  # Returns StreamRails's configuration object.
+  def self.feed_manager
+    @feed_manager ||= StreamRails::FeedManager.new(self.client, self.config.feed_configs)
+  end
+
+  # Lets you set global configuration options.
+  #
+  # All available options and their defaults are in the example below:
+  # @example Initializer for Rails
+  #   StreamRails.configure do |config|
+  #     config.api_key     = "key"
+  #     config.api_secret  = "secret"
+  #     config.api_site_id = "42"
+  #     config.enabled     = true
+  #   end
+  def self.configure(&block)
+    yield(config) if block_given?
+  end
+
+end
+
+require 'stream_rails/utils/view_helpers'
+require 'stream_rails/railtie' if defined?(Rails)

data/lib/stream_rails/activity.rb

@@ -0,0 +1,93 @@
+require 'active_record'
+require 'stream_rails/sync_policies'
+
+module StreamRails
+
+  class << self
+    def create_reference(record)
+      if record.is_a? ActiveRecord::Base
+        "#{record.class.model_name}:#{record.id}"
+      else
+        record.to_s unless record.nil?
+      end
+    end
+  end
+
+  module ClassMethods
+
+    def as_activity(opts = {})
+      default_opts = {:track_deletes => true, :sync_policy => nil}
+      options = default_opts.merge(opts)
+      if options[:sync_policy].nil?
+        include StreamRails::SyncPolicy::SyncCreate
+        if options[:track_deletes]
+          include StreamRails::SyncPolicy::SyncDestroy
+        end
+      else
+        include options[:sync_policy]
+      end
+    end
+
+  end
+
+  module Activity
+
+    def self.included base
+      base.extend ClassMethods
+    end
+
+    def activity_owner_id
+      self.user_id
+    end
+
+    def activity_actor
+      self.user
+    end
+
+    def activity_owner_feed
+      'user'
+    end
+
+    def activity_actor_id
+      StreamRails.create_reference(self.activity_actor)
+    end
+
+    def activity_verb
+      self.class.model_name.to_s
+    end
+
+    def activity_object_id
+      StreamRails.create_reference(self)
+    end
+
+    def activity_foreign_id
+      StreamRails.create_reference(self)
+    end
+
+    def activity_notify
+    end
+
+    def activity_extra_data
+      {}
+    end
+
+    def activity_time
+      self.created_at
+    end
+
+    def create_activity
+      activity = {
+        :actor => self.activity_actor_id,
+        :verb => self.activity_verb,
+        :object => self.activity_object_id,
+        :foreign_id => self.activity_foreign_id,
+        :time => self.activity_time,
+      }
+      if !self.activity_notify.nil?
+        activity[:to] = self.activity_notify.map{|f| f.feed_id}
+      end
+      activity.merge(self.activity_extra_data)
+    end
+
+  end
+end

data/lib/stream_rails/config.rb

@@ -0,0 +1,27 @@
+module StreamRails
+  # Class used to initialize configuration object.
+  class Config
+    attr_accessor :api_key
+    attr_accessor :api_secret
+    attr_accessor :api_site_id
+    attr_accessor :enabled
+    
+    attr_accessor :news_feeds
+    attr_accessor :notification_feed
+    attr_accessor :user_feed
+
+    def initialize
+      @enabled    = true
+      @news_feeds = {:flat=>'flat', :aggregated=>'aggregated'}
+      @notification_feed  = 'notification'
+      @user_feed  = 'user'
+    end
+
+    def feed_configs
+        {:news_feeds=>@news_feeds,
+        :notification_feed=>@notification_feed,
+        :user_feed=>@user_feed}
+    end
+
+  end
+end

data/lib/stream_rails/enrich.rb

@@ -0,0 +1,104 @@
+require 'active_record'
+
+module StreamRails
+
+  class ActivityResult < Hash
+    attr_accessor :enriched
+    attr_reader :failed_to_enrich
+
+    def initialize
+      @failed_to_enrich = Hash.new
+      super
+    end
+
+    def from_activity(h)
+      self.merge(h)
+    end
+
+    def enriched?
+      @failed_to_enrich.keys.length == 0
+    end
+
+    def not_enriched_fields
+      @failed_to_enrich.keys
+    end
+
+    def track_not_enriched_field(field, value = nil)
+      @failed_to_enrich[field] = value
+    end
+
+  end
+
+  class Enrich
+
+    def initialize(fields = nil)
+        @fields = fields || [:actor, :object]
+    end
+
+    def model_field?(field_value)
+      bits = field_value.split(':')
+      if bits.length < 2
+        return false
+      end
+      begin
+        bits[0].classify.constantize
+      rescue NameError
+        return false
+      else
+        return true
+      end
+    end
+
+    def enrich_activities(activities)
+      references = self.collect_references(activities)
+      objects = self.retrieve_objects(references)
+      self.inject_objects(activities, objects)
+    end
+
+    def enrich_aggregated_activities(aggregated_activities)
+      references = Hash.new
+      aggregated_activities.each do |aggregated|
+        refs = self.collect_references(aggregated['activities'])
+        references = references.merge(refs){|key, v1, v2| v1.merge(v2)}
+      end
+      objects = self.retrieve_objects(references)
+      aggregated_activities.each do |aggregated|
+        aggregated['activities'] = self.inject_objects(aggregated['activities'], objects)
+      end
+      aggregated_activities.map {|a| ActivityResult.new().from_activity(a)}
+    end
+
+    def collect_references(activities)
+      model_refs = Hash.new{ |h,k| h[k] = Hash.new}
+      activities.each do |activity|
+        activity.select{|k,v| @fields.include? k.to_sym}.each do |field, value|
+          next unless self.model_field?(value)
+          model, id = value.split(':')
+          model_refs[model][id] = 0
+        end
+      end
+      model_refs
+    end
+
+    def retrieve_objects(references)
+      Hash[references.map{ |model, ids| [model, Hash[model.classify.constantize.where(id: ids.keys).map {|i| [i.id.to_s, i]}] ] }]
+    end
+
+    def inject_objects(activities, objects)
+      activities = activities.map {|a| ActivityResult.new().from_activity(a)}
+      activities.each do |activity|
+        activity.select{|k,v| @fields.include? k.to_sym}.each do |field, value|
+          next unless self.model_field?(value)
+          model, id = value.split(':')
+          activity[field] = objects[model][id] || value
+          if objects[model][id].nil?
+            activity.track_not_enriched_field(field, value)
+          end
+        end
+      end
+      activities
+    end
+
+  end
+
+end

data/lib/stream_rails/feed_manager.rb

@@ -0,0 +1,61 @@
+module StreamRails
+  # Class used to manage feeds
+  class FeedManager
+    attr_reader :client
+
+    def initialize(client, opts={})
+        @client = client
+        @user_feed = opts[:user_feed]
+        @news_feeds = opts[:news_feeds]
+        @notification_feed = opts[:notification_feed]
+    end
+
+    def get_user_feed(user_id)
+      @client.feed("#{@user_feed}:#{user_id}")
+    end
+
+    def get_news_feeds(user_id)
+      Hash[@news_feeds.map{ |k,v| [k, self.get_feed(k, user_id)] }]
+    end
+
+    def get_notification_feed(user_id)
+      @client.feed("#{@notification_feed}:#{user_id}")
+    end
+
+    def get_feed(feed_type, user_id)
+      @client.feed("#{feed_type}:#{user_id}")
+    end
+
+    def follow_user(user_id, target_id)
+      target_feed = self.get_user_feed(target_id)
+      @news_feeds.each do |_, feed|
+        news_feed = self.get_feed(feed, user_id)
+        news_feed.follow(target_feed.feed_id)
+      end
+    end
+
+    def unfollow_user(user_id, target_id)
+      target_feed = self.get_user_feed(target_id)
+      @news_feeds.each do |_, feed|
+        news_feed = self.get_feed(feed, user_id)
+        news_feed.unfollow(target_feed.feed_id)
+      end
+    end
+
+    def get_owner_feed(instance)
+      self.get_feed(instance.activity_owner_feed, instance.activity_owner_id)
+    end
+
+    def created_activity(instance)
+      activity = instance.create_activity
+      feed = self.get_owner_feed(instance)
+      feed.add_activity(activity)
+    end
+
+    def destroyed_activity(instance)
+      feed = self.get_owner_feed(instance)
+      feed.remove(instance.activity_foreign_id, foreign_id=true)
+    end
+
+  end
+end

data/lib/stream_rails/logger.rb

@@ -0,0 +1,6 @@
+module StreamRails
+  class << self
+    attr_accessor :logger
+  end
+  self.logger = Logger.new(STDOUT)
+end

data/lib/stream_rails/railtie.rb

@@ -0,0 +1,7 @@
+module StreamRails
+  class Railtie < ::Rails::Railtie
+    initializer 'stream_rails.setup_logging' do
+      StreamRails.logger = Rails.logger
+    end
+  end
+end

data/lib/stream_rails/renderable.rb

@@ -0,0 +1,66 @@
+module StreamRails
+  # Provides logic for rendering activities. (different templates per activity verb).
+  module Renderable
+
+    class << self
+
+      def render(activity, context, params = {})
+        aggregated = activity.has_key? 'activities'
+        partial = partial_path(activity, aggregated, *params.values_at(:prefix, :partial, :partial_root))
+        layout  = layout_path(*params.values_at(:layout, :layout_root))
+        locals  = prepare_locals(activity, params)
+        params = params.merge(partial: partial, locals: locals, layout: layout)
+        if aggregated
+          render_aggregated(activity, context, params)
+        else
+          render_simple(activity, context, params)
+        end
+      end
+
+      def render_simple(activity, context, params)
+        if activity.enriched?
+          context.render params
+        else
+          StreamRails.logger.warn "trying to display a non enriched activity #{activity.inspect} #{activity.failed_to_enrich}"
+          return ''
+        end
+      end
+
+      def render_aggregated(activity, context, params)
+        if !activity['activities'].map {|a| !a.enriched?}.all?
+          context.render params
+        else
+          first_activity = activity['activities'][0]
+          StreamRails.logger.warn "trying to display a non enriched activity #{first_activity.inspect} #{first_activity.failed_to_enrich}"
+          return ''
+        end
+      end
+
+      def layout_path(path = nil, root = nil)
+        path.nil? and return
+        root ||= 'layouts'
+        select_path path, root
+      end
+
+      def partial_path(activity, aggregated, prefix = '', path = nil, root = nil)
+        root ||= (if aggregated then 'aggregated_activity' else 'activity' end)
+        path ||= "#{activity['verb']}".downcase
+        path = "#{prefix}_#{path}" if prefix
+        select_path path, root
+      end
+
+      def prepare_locals(activity, params)
+        locals = params.delete(:locals) || Hash.new
+        locals.merge\
+          activity:     activity,
+          parameters:   params
+      end
+
+      private
+      def select_path path, root
+        [root, path].map(&:to_s).join('/')
+      end
+    end
+  end
+
+end

data/lib/stream_rails/sync_policies.rb

@@ -0,0 +1,30 @@
+module StreamRails
+
+  module SyncPolicy
+
+    module SyncCreate
+
+      def self.included(base)
+        base.after_commit :add_to_feed, on: [:create]
+      end
+
+      private
+      def add_to_feed
+        StreamRails.feed_manager.created_activity(self)
+      end
+    end
+
+    module SyncDestroy
+
+      def self.included(base)
+        base.after_commit :remove_from_feed, on: [:destroy]
+      end
+
+      private
+      def remove_from_feed
+        StreamRails.feed_manager.destroyed_activity(self)
+      end
+    end
+
+  end
+end

data/lib/stream_rails/utils/view_helpers.rb

@@ -0,0 +1,15 @@
+# Provides a shortcut from views to the rendering method.
+module StreamRails
+  # Module extending ActionView::Base and adding `render_activity` helper.
+  module ViewHelpers
+    # View helper for rendering an activity
+    def render_activity activity, options = {}
+      Renderable.render(activity, self, options)
+    end
+    # View helper for rendering many activities
+    def render_activities activities, options = {}
+      activities.map {|activity| Renderable.render(activity, self, options.dup) }.join.html_safe
+    end
+  end
+  ActionView::Base.class_eval { include ViewHelpers }
+end

data/lib/stream_rails/version.rb

@@ -0,0 +1,3 @@
+module StreamRails
+  VERSION = '1.0'
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: stream_rails
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- Tommaso Barbugli
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: stream-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  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: sqlite3
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.10'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+description: 
+email: tbarbugli@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- LICENSE
+- README.md
+- lib/stream_rails.rb
+- lib/stream_rails/activity.rb
+- lib/stream_rails/config.rb
+- lib/stream_rails/enrich.rb
+- lib/stream_rails/feed_manager.rb
+- lib/stream_rails/logger.rb
+- lib/stream_rails/railtie.rb
+- lib/stream_rails/renderable.rb
+- lib/stream_rails/sync_policies.rb
+- lib/stream_rails/utils/view_helpers.rb
+- lib/stream_rails/version.rb
+homepage: http://github.com/tbarbugli/stream-ruby
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A gem that provides a client interface for getstream.io
+test_files: []
+has_rdoc: true