stream_rails 2.3.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0544b141236615c99034b6428926a2624697b422
-  data.tar.gz: d2df99be8a42f250b6545e7a91bfbb19f4ebf5ce
+  metadata.gz: 82fcbb047a9fc18b2f808bf7a0c9d24edc6fef5b
+  data.tar.gz: 8741b89406b037ea2b6be3769e5663395661d185
 SHA512:
-  metadata.gz: ae24b2785c725cbc1d86a6cc8499713f6c88cb10b4c79f481808de3e71df3ff7c05ef2d77a863a247d62fefeb3f5b15dd2162ad8eca39a2b25371e4faf4017df
-  data.tar.gz: ae51df815ab47598937026dcc56abda1a86926c987ea652e3c236416ead55514d951adc9195b38237e77bef9f9b004222d1b805259faf8a1dd97c4502922310a
+  metadata.gz: 675e198519664358583be4d42e5265a0b7d74c4b3e212ec1296e9d34bad68e7e2277a97fe51902d24a33031f9aa6965d9ed25b39f4e93c5e11c1a42c99e0b55b
+  data.tar.gz: 7b21994454b8f1c62e17f7a642738c9c725ef717f29776c97c5fbee17373b210ae94c9718d3b33f10bea0b6ddf30662ec87c06f516c40d634004a49551edb65f

data/README.md

@@ -31,10 +31,20 @@ You can check out our example app built using this library on Github [https://gi
 - [Table of Contents](#table-of-contents)
 - [Gem installation](#gem-installation)
 - [Setup](#setup)
+- [Supported ORMs](#supported-orms)
+  - [ActiveRecord](#active-record)
+  - [Sequel](#sequel)
 - [Model configuration](#model-configuration)
   - [Activity fields](#activity-fields)
   - [Activity extra data](#activity-extra-data)
+  - [Activity creation](#activity-creation)
 - [Feed manager](#feed-manager)
+- [Showing the newsfeed](#showing-the-newsfeed)
+  - [Activity enrichment](#activity-enrichment)
+  - [Templating](#templating)
+  - [Pagination](#pagination)
+- [Disable model tracking](#disable-model-tracking)
+- [Running specs](#running-specs)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
@@ -55,13 +65,51 @@ Login with Github on getstream.io and get your ```api_key``` and ```api_secret``
 
 Then you can add the StreamRails configuration in ```config/initializers/stream_rails.rb```
 
-```
+```ruby
 require 'stream_rails'
 
 StreamRails.configure do |config|
   config.api_key     = "YOUR API KEY"
   config.api_secret  = "YOUR API SECRET"
-  config.timeout     = 30
+  config.timeout     = 30                # Optional, defaults to 3
+  config.location    = 'us-east'         # Optional, defaults to 'us-east'
+  # If you use custom feed names, e.g.: timeline_flat, timeline_aggregated,
+  # use this, otherwise omit:
+  config.news_feeds = { flat: "timeline_flat", aggregated: "timeline_aggregated" }
+end
+```
+
+###Supported ORMs
+
+####ActiveRecord
+
+The integration will look as follows:
+
+```ruby
+class Pin < ActiveRecord::Base
+  include StreamRails::Activity
+  as_activity
+
+  def activity_object
+    self.item
+  end
+end
+```
+
+####Sequel
+
+Please, use Sequel `~4`.
+
+The integration will look as follows:
+
+```ruby
+class Pin < Sequel::Model
+  include StreamRails::Activity
+  as_activity
+
+  def activity_object
+    self.item
+  end
 end
 ```
 
@@ -141,6 +189,32 @@ class Pin < ActiveRecord::Base
 end
 ```
 
+####Activity creation
+
+If you want to control when to create an activity you should implement
+the ```#activity_should_sync?``` method in your model.
+
+```ruby
+class Pin < ActiveRecord::Base
+  belongs_to :author
+  belongs_to :item
+
+  include StreamRails::Activity
+  as_activity
+
+  def activity_should_sync?
+    self.published
+  end
+
+  def activity_object
+    self.item
+  end
+
+end
+```
+
+This will create an activity only when `self.published` is true.
+
 ###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```.
@@ -292,6 +366,16 @@ eg. adds the extra_var to the partial scope
 <%= render_activity activity, :locals => {:extra_var => 42} %>
 ```
 
+####Pagination
+
+For simple pagination you can use the [stream-ruby API](https://github.com/getstream/stream-ruby),
+as follows in your controller:
+
+```ruby
+  StreamRails.feed_manager.get_news_feeds(current_user.id)[:flat] # Returns a Stream::Feed object
+  results = feed.get(limit: 5, offset: 5)['results']
+```
+
 ### Disable model tracking
 
 You can disable model tracking (eg. when you run tests) via StreamRails.configure
@@ -301,3 +385,11 @@ require 'stream_rails'
 
 StreamRails.enabled = false
 ```
+
+###Running specs
+
+From the project root directory:
+
+```
+./bin/run_tests.sh
+```

data/lib/stream_rails.rb

@@ -9,17 +9,17 @@ module StreamRails
 
   autoload :Activity
   autoload :Config
-  autoload :FeedManager,  'stream_rails/feed_manager'
+  autoload :FeedManager, 'stream_rails/feed_manager'
   autoload :Renderable
   autoload :VERSION
 
   def self.client
     Stream::Client.new(
-      self.config.api_key,
-      self.config.api_secret,
-      self.config.api_site_id,
-      :location => self.config.location,
-      :default_timeout => self.config.timeout
+      config.api_key,
+      config.api_secret,
+      config.api_site_id,
+      location: config.location,
+      default_timeout: config.timeout
     )
   end
 
@@ -38,12 +38,12 @@ module StreamRails
   # Enabled by default.
   # @return [Boolean]
   def self.enabled?
-    !!StreamRails.config.enabled
+    StreamRails.config.enabled
   end
 
   # Returns StreamRails's configuration object.
   def self.feed_manager
-    @feed_manager ||= StreamRails::FeedManager.new(self.client, self.config.feed_configs)
+    @feed_manager ||= StreamRails::FeedManager.new(client, config.feed_configs)
   end
 
   # Lets you set global configuration options.
@@ -57,10 +57,9 @@ module StreamRails
   #     config.location    = "us-east"
   #     config.enabled     = true
   #   end
-  def self.configure(&block)
+  def self.configure(&_block)
     yield(config) if block_given?
   end
-
 end
 
 require 'stream_rails/utils/view_helpers'

data/lib/stream_rails/activity.rb

@@ -2,10 +2,9 @@ require 'active_record'
 require 'stream_rails/sync_policies'
 
 module StreamRails
-
   class << self
     def create_reference(record)
-      if record.is_a? ActiveRecord::Base
+      if record.is_a?(ActiveRecord::Base) || (Object.const_defined?('Sequel') && record.is_a?(Sequel::Model))
         "#{record.class.model_name}:#{record.id}"
       else
         record.to_s unless record.nil?
@@ -14,34 +13,29 @@ module StreamRails
   end
 
   module ClassMethods
-
     def as_activity(opts = {})
-      default_opts = {:track_deletes => true, :sync_policy => nil}
+      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
+        include StreamRails::SyncPolicy::SyncDestroy if options[:track_deletes]
       else
         include options[:sync_policy]
       end
     end
-
   end
 
   module Activity
-
-    def self.included base
+    def self.included(base)
       base.extend ClassMethods
     end
 
     def activity_owner_id
-      self.user_id
+      activity_actor.id
     end
 
     def activity_actor
-      self.user
+      user
     end
 
     def activity_owner_feed
@@ -49,11 +43,11 @@ module StreamRails
     end
 
     def activity_actor_id
-      StreamRails.create_reference(self.activity_actor)
+      StreamRails.create_reference(activity_actor)
     end
 
     def activity_object
-      raise NotImplementedError, "Activity models must define `#activity_object`"
+      fail NotImplementedError, 'Activity models must define `#activity_object`'
     end
 
     def activity_verb
@@ -61,7 +55,7 @@ module StreamRails
     end
 
     def activity_object_id
-      StreamRails.create_reference(self.activity_object)
+      StreamRails.create_reference(activity_object)
     end
 
     def activity_foreign_id
@@ -76,22 +70,23 @@ module StreamRails
     end
 
     def activity_time
-      self.created_at.iso8601
+      created_at.iso8601
+    end
+
+    def activity_should_sync?
+      true
     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,
+        actor: activity_actor_id,
+        verb: activity_verb,
+        object: activity_object_id,
+        foreign_id: activity_foreign_id,
+        time: activity_time
       }
-      if !self.activity_notify.nil?
-        activity[:to] = self.activity_notify.map{|f| f.id}
-      end
-      activity.merge(self.activity_extra_data)
+      activity[:to] = activity_notify.map(&:id) unless activity_notify.nil?
+      activity.merge(activity_extra_data)
     end
-
   end
 end

data/lib/stream_rails/config.rb

@@ -7,24 +7,23 @@ module StreamRails
     attr_accessor :api_site_id
     attr_accessor :enabled
     attr_accessor :timeout
-    
+
     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'
+      @news_feeds = { flat: 'flat', aggregated: 'aggregated' }
+      @notification_feed = 'notification'
+      @user_feed = 'user'
       @timeout = 3
     end
 
     def feed_configs
-        {:news_feeds=>@news_feeds,
-        :notification_feed=>@notification_feed,
-        :user_feed=>@user_feed}
+      { news_feeds: @news_feeds,
+        notification_feed: @notification_feed,
+        user_feed: @user_feed }
     end
-
   end
 end

data/lib/stream_rails/enrich.rb

@@ -1,18 +1,17 @@
 require 'active_record'
 
 module StreamRails
-
   class ActivityResult < Hash
     attr_accessor :enriched
     attr_reader :failed_to_enrich
 
     def initialize
-      @failed_to_enrich = Hash.new
+      @failed_to_enrich = {}
       super
     end
 
     def from_activity(h)
-      self.merge(h)
+      merge(h)
     end
 
     def enriched?
@@ -26,23 +25,17 @@ module StreamRails
     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]
+      @fields = fields || [:actor, :object]
     end
 
     def model_field?(field_value)
-      if !field_value.respond_to?("split")
-        return false
-      end
+      return false unless field_value.respond_to?('split')
       bits = field_value.split(':')
-      if bits.length < 2
-        return false
-      end
+      return false if bits.length < 2
       begin
         bits[0].classify.constantize
       rescue NameError
@@ -53,28 +46,28 @@ module StreamRails
     end
 
     def enrich_activities(activities)
-      references = self.collect_references(activities)
-      objects = self.retrieve_objects(references)
-      self.inject_objects(activities, objects)
+      references = collect_references(activities)
+      objects = retrieve_objects(references)
+      inject_objects(activities, objects)
     end
 
     def enrich_aggregated_activities(aggregated_activities)
-      references = Hash.new
+      references = {}
       aggregated_activities.each do |aggregated|
-        refs = self.collect_references(aggregated['activities'])
-        references = references.merge(refs){|key, v1, v2| v1.merge(v2)}
+        refs = collect_references(aggregated['activities'])
+        references = references.merge(refs) { |_key, v1, v2| v1.merge(v2) }
       end
-      objects = self.retrieve_objects(references)
+      objects = retrieve_objects(references)
       aggregated_activities.each do |aggregated|
-        aggregated['activities'] = self.inject_objects(aggregated['activities'], objects)
+        aggregated['activities'] = inject_objects(aggregated['activities'], objects)
       end
-      aggregated_activities.map {|a| ActivityResult.new().from_activity(a)}
+      create_activity_results(aggregated_activities)
     end
 
     def collect_references(activities)
-      model_refs = Hash.new{ |h,k| h[k] = Hash.new}
+      model_refs = Hash.new { |h, k| h[k] = {} }
       activities.each do |activity|
-        activity.select{|k,v| @fields.include? k.to_sym}.each do |field, value|
+        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
@@ -84,24 +77,24 @@ module StreamRails
     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]}] ] }]
+      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|
+      create_activity_results(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
+          activity.track_not_enriched_field(field, value) if objects[model][id].nil?
         end
       end
-      activities
     end
 
-  end
+    private
 
+    def create_activity_results(activities)
+      return activities.map { |a| ActivityResult.new.from_activity(a) }
+    end
+  end
 end

data/lib/stream_rails/feed_manager.rb

@@ -3,11 +3,11 @@ module StreamRails
   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]
+    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)
@@ -15,7 +15,7 @@ module StreamRails
     end
 
     def get_news_feeds(user_id)
-      Hash[@news_feeds.map{ |k,v| [k, self.get_feed(k, user_id)] }]
+      Hash[@news_feeds.map { |feed_name, feed_slug| [feed_name, get_feed(feed_slug, user_id)] }]
     end
 
     def get_notification_feed(user_id)
@@ -27,39 +27,38 @@ module StreamRails
     end
 
     def follow_user(user_id, target_id)
-      target_feed = self.get_user_feed(target_id)
+      return unless StreamRails.enabled?
+      target_feed = get_user_feed(target_id)
       @news_feeds.each do |_, feed|
-        news_feed = self.get_feed(feed, user_id)
+        news_feed = get_feed(feed, user_id)
         news_feed.follow(target_feed.slug, target_feed.user_id)
       end
     end
 
     def unfollow_user(user_id, target_id)
-      target_feed = self.get_user_feed(target_id)
+      return unless StreamRails.enabled?
+      target_feed = get_user_feed(target_id)
       @news_feeds.each do |_, feed|
-        news_feed = self.get_feed(feed, user_id)
+        news_feed = get_feed(feed, user_id)
         news_feed.unfollow(target_feed.slug, target_feed.user_id)
       end
     end
 
     def get_owner_feed(instance)
-      self.get_feed(instance.activity_owner_feed, instance.activity_owner_id)
+      get_feed(instance.activity_owner_feed, instance.activity_owner_id)
     end
 
     def created_activity(instance)
-      if StreamRails::enabled?
-        activity = instance.create_activity
-        feed = self.get_owner_feed(instance)
-        feed.add_activity(activity)
-      end
+      return unless StreamRails.enabled? && instance.activity_should_sync?
+      activity = instance.create_activity
+      feed = get_owner_feed(instance)
+      feed.add_activity(activity)
     end
 
     def destroyed_activity(instance)
-      if StreamRails::enabled?
-        feed = self.get_owner_feed(instance)
-        feed.remove(instance.activity_foreign_id, foreign_id=true)
-      end
+      return unless StreamRails.enabled?
+      feed = get_owner_feed(instance)
+      feed.remove(instance.activity_foreign_id, true)
     end
-
   end
 end

data/lib/stream_rails/railtie.rb

@@ -2,10 +2,8 @@ require 'rails'
 
 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

@@ -1,11 +1,9 @@
 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'
+        aggregated = activity.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)
@@ -27,7 +25,7 @@ module StreamRails
       end
 
       def render_aggregated(activity, context, params)
-        if !activity['activities'].map {|a| !a.enriched?}.all?
+        if !activity['activities'].map { |a| !a.enriched? }.all?
           context.render params
         else
           first_activity = activity['activities'][0]
@@ -37,30 +35,30 @@ module StreamRails
       end
 
       def layout_path(path = nil, root = nil)
-        path.nil? and return
+        path.nil? && 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)
+        root ||= (aggregated ? 'aggregated_activity' : 'activity')
         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 = params.delete(:locals) || {}
         locals.merge\
           activity:     activity,
           parameters:   params
       end
 
       private
-      def select_path path, root
+
+      def select_path(path, root)
         [root, path].map(&:to_s).join('/')
       end
     end
   end
-
 end

data/lib/stream_rails/sync_policies.rb

@@ -1,40 +1,55 @@
 module StreamRails
-
   module SyncPolicy
-
     module SyncCreate
-
       def self.included(base)
-        base.after_commit :add_to_feed, on: :create
+        if base.respond_to? :after_commit
+          base.after_commit :add_to_feed, on: :create
+        elsif Object.const_defined?('Sequel') && base < Sequel::Model
+          base.class_eval do
+            define_method(:_after_create) do |*args|
+              super(*args)
+              add_to_feed
+            end
+          end
+        else
+          fail 'Your ORM is not supported'
+        end
       end
 
       private
+
       def add_to_feed
-        begin
-          StreamRails.feed_manager.created_activity(self)
-        rescue Exception => e
-          StreamRails.logger.error "Something went wrong creating an activity: #{e}"
-          raise
-        end
+        StreamRails.feed_manager.created_activity(self)
+      rescue StandardError => e
+        StreamRails.logger.error "Something went wrong creating an activity: #{e}"
+        raise
       end
     end
 
     module SyncDestroy
-
       def self.included(base)
-        base.after_commit :remove_from_feed, on: :destroy
+        if base.respond_to? :after_commit
+          base.after_commit :remove_from_feed, on: :destroy
+        elsif Object.const_defined?('Sequel') && base < Sequel::Model
+          base.instance_eval do
+            define_method(:before_destroy) do |*args|
+              remove_from_feed
+              super(*args)
+            end
+          end
+        else
+          fail 'Your ORM is not supported'
+        end
       end
 
       private
+
       def remove_from_feed
-        begin
-          StreamRails.feed_manager.destroyed_activity(self)
-        rescue Exception => e
-          StreamRails.logger.error "Something went wrong deleting an activity: #{e}"
-          raise
-        end
+        StreamRails.feed_manager.destroyed_activity(self)
+      rescue StandardError => e
+        StreamRails.logger.error "Something went wrong deleting an activity: #{e}"
+        raise
       end
     end
-
   end
 end

data/lib/stream_rails/utils/view_helpers.rb

@@ -3,12 +3,13 @@ module StreamRails
   # Module extending ActionView::Base and adding `render_activity` helper.
   module ViewHelpers
     # View helper for rendering an activity
-    def render_activity activity, options = {}
+    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
+    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 }

data/lib/stream_rails/version.rb

@@ -1,3 +1,3 @@
 module StreamRails
-  VERSION = '2.3.1'
-end
+  VERSION = '2.4.0'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stream_rails
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.4.0
 platform: ruby
 authors:
 - Tommaso Barbugli
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-28 00:00:00.000000000 Z
+date: 2016-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.3
+        version: 2.2.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.3
+        version: 2.2.5
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -136,6 +136,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.7.1
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.29'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.29'
 description: 
 email: tbarbugli@gmail.com
 executables: []