feeder 0.3.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 22e1b2d7d889186ead64cdeda3bda95f03db5608
-  data.tar.gz: f4fcc534375a8010d0175406332ce0fbdf9fa34d
+  metadata.gz: 04e9d95c32a3be20252ca3365e9e3e9aa6d61599
+  data.tar.gz: d6765c13e947c4a5d30b6f30125b9afcbfc79106
 SHA512:
-  metadata.gz: 3b008831dc5207f16c7bf28bc3b6b5103de2c74d4bbd385a823ff5b44bfa8b93641b6bc298dff967eca4fae94f1ff59bf51799fb2f7f05a4ae79a59108519763
-  data.tar.gz: 42b34bff84ff71b0451fd4871c6aa15370d1d6a8c3068bcbec789e8c872dfb57f9766c98e646198404a13b952c85586ce9ead7c0b5c33249b1fb3db1a2c626fb
+  metadata.gz: 7bc92c030d928c6642485ca8dd2ecb2c74866bd5a630c3589bdd2d9aa50141cecf0ca0c71f98fef0a9d441a1ffa02d9d81fb45f4c348af385491b21621eee572
+  data.tar.gz: 527433e9fb8feae052f6b99e192d10064676bb303a3b69fda212ba1523e58d3f94b0c3f3c31e2251524119f68ef56d5d83c4cb0aaf5e21568b7524a3ae29b3e6

data/README.md

@@ -1,4 +1,10 @@
-# Mingle
+# Feeder
+
+[![Gem Version](https://img.shields.io/gem/v/feeder.svg)](https://rubygems.org/gems/feeder)
+[![Build Status](https://img.shields.io/travis/hyperoslo/feeder.svg)](https://travis-ci.org/hyperoslo/feeder)
+[![Dependency Status](https://img.shields.io/gemnasium/hyperoslo/feeder.svg)](https://gemnasium.com/hyperoslo/feeder)
+[![Code Climate](https://img.shields.io/codeclimate/github/hyperoslo/feeder.svg)](https://codeclimate.com/github/hyperoslo/feeder)
+[![Coverage Status](https://img.shields.io/coveralls/hyperoslo/feeder.svg)](https://coveralls.io/r/hyperoslo/feeder)
 
 Feeder gives you a mountable engine that provides a route to a feed page in your
 Ruby on Rails application.
@@ -20,11 +26,122 @@ Or install it yourself as:
 Install the migrations:
 
     rake feeder:install:migrations
-    
+
 Run the migrations:
 
     rake db:migrate
 
+## Usage
+
+To make Feeder available, mount it to a route by adding the following somewhere
+in your _config/routes.rb_:
+
+```ruby
+mount Feeder::Engine => "/feed"
+```
+
+You will now be able to display a feed on _/feed_ in your application. In order
+for Feeder to display anything in your feed, however, you will need to make
+views per item type in the feed. Feeder looks up these views in
+_app/views/feeder/types_ by default, and then checks for a partial with the same
+name as your item type. As an example, if you have a `Message` model that you
+wish to list out on your feed, you would make a file called *_message.html.erb*
+in _app/views/feeder/types_.
+
+Feeder also comes with an observer for automatically generating wrapper items
+for your feedables (e.g. messages). In order to use it, you only need to register
+`Feeder::FeedableObserver` into your app, which can be done in
+_config/application.rb_ like this:
+
+```ruby
+config.active_record.observers = [ 'Feeder::FeedableObserver' ]
+```
+
+Then, all you need to do is tell Feeder what to
+observe, which is done through an initializer, like this:
+
+```ruby
+Feeder.configure do |config|
+  config.observe Message
+end
+```
+
+... and declare that your `Message` model is feedable:
+
+```ruby
+class Message < ActiveRecord::Base
+  feedable
+end
+```
+
+If you don't want to publish every message in the feed, you can supply a condition
+to `observe`:
+
+```ruby
+Feeder.configure do |config|
+  config.observe Message, if: -> message { message.show_in_feed? }
+end
+```
+
+Pretty neat.
+
+### Filtering
+
+Want to filter out what feedables to display in your feed? We've got you covered
+through the all-powerful `filter` scope!  Give it a hash of feedables and the
+IDs that you want to fetch, and Feeder makes sure to only return feed items with
+the specified feedables. You may also pass in the symbol `:all` instead of a
+list of IDs, which would fetch each of them. For example: say you have the
+following feedables:
+
+- `ShortMessage`
+- `Tweet`
+- `NewsArticle`
+
+To get `Feeder::Item`s with news articles having IDs `[1, 2, 3, 4, 5]`, tweets
+`[2, 4, 6, 7]` and all short message, you could do like this:
+
+```ruby
+Feeder::Item.filter(
+  NewsArticle => [1, 2, 3, 4, 5],
+  Tweet => [2, 4, 6, 7],
+  ShortMessage => :all,
+)
+```
+
+**NOTE:** The `filter` scope is _exclusive_, meaning that anything you _do not_
+pass in to it will also not be brought back. With the above feedables, if you
+only want short messages `[1, 3, 4]`, but all of the tweets and news articles,
+you would have to specify them as well, like this:
+
+```ruby
+Feeder::Item.filter(
+  ShortMessage => [1, 3, 4],
+  Tweet => :all,
+  NewsArticle => :all
+)
+```
+
+The following would only return feed items with short messages:
+
+```ruby
+Feeder::Item.filter(ShortMessage => [1, 3, 4])
+```
+
+### Configuration
+
+```ruby
+Feeder.configure do |config|
+  # A list of scopes that will be applied to the feed items in the controller.
+  config.scopes << proc { limit 5 }
+end
+```
+
+### Stickies
+
+You can "sticky" messages in your feed so they're pinned at the top regardless of when
+they were created. Just set the `sticky` attribute and Feeder will take care of the rest.
+
 ## Contributing
 
 1. Fork it

data/app/controllers/feeder/application_controller.rb

@@ -1,4 +1,4 @@
 module Feeder
-  class ApplicationController < ActionController::Base
+  class ApplicationController < ::ApplicationController
   end
 end

data/app/controllers/feeder/items_controller.rb

@@ -0,0 +1,7 @@
+require_dependency "feeder/application_controller"
+
+module Feeder
+  class ItemsController < ApplicationController
+    include Feeder::Concerns::Controllers::ItemsController
+  end
+end

data/app/models/feeder/feedable_observer.rb

@@ -1,13 +1,49 @@
 module Feeder
-  class FeedableObserver < ActiveRecord::Observer
-    observe Feeder.config.observables
+  class FeedableObserver < ::ActiveRecord::Observer
+    observe Feeder.config.observables.keys
 
     def after_create(feedable)
-      Feeder::Item.create!(
-        feedable: feedable,
-        created_at: feedable.created_at,
-        published_at: Time.zone.now
-      )
+      options = options_for feedable
+
+      if condition = options[:if]
+        if condition.respond_to? :call
+          return unless condition.call feedable
+        else
+          return unless feedable.send condition
+        end
+      end
+
+      feedable.create_feeder_item! do |item|
+        item.feedable     = feedable
+        item.created_at   = feedable.created_at
+        item.published_at = Time.zone.now
+
+        if feedable.respond_to? :sticky
+          item.sticky = feedable.sticky
+        end
+      end
+    end
+
+    def after_save(feedable)
+      item = feedable.feeder_item
+
+      if item
+        if feedable.respond_to? :sticky
+          item.sticky = feedable.sticky
+        end
+
+        item.save!
+      end
+    end
+
+    private
+
+    def options_for(feedable)
+      (observables[feedable.class] || observables[feedable.class.to_s]) or raise StandardError, "#{feedable} is not observed"
+    end
+
+    def observables
+      Feeder.config.observables
     end
   end
 end

data/app/models/feeder/item.rb

@@ -1,9 +1,5 @@
 module Feeder
-  class Item < ActiveRecord::Base
-    belongs_to :feedable, polymorphic: true
-
-    def type
-      feedable_type.underscore
-    end
+  class Item < ::ActiveRecord::Base
+    include Feeder::Concerns::Models::Item
   end
 end

data/app/views/feeder/items/_item.html.erb

@@ -1,3 +1,3 @@
-<div class="feed_item <%= item.type %>">
+<div class="feed-item <%= item.type.parameterize %>">
   <%= render "feeder/types/#{item.type}", feedable: item.feedable %>
 </div>

data/app/views/feeder/items/_item.json.jbuilder

@@ -0,0 +1 @@
+json.partial! "feeder/types/#{item.type}", feedable: item.feedable

data/app/views/feeder/{feeds → items}/index.html.erb

@@ -1,3 +1,3 @@
-<div class="feed_items">
+<div class="feed-items">
   <%= render @items %>
 </div>

data/app/views/feeder/items/index.json.jbuilder

@@ -0,0 +1 @@
+json.array! @items, partial: "feeder/items/item", as: :item

data/config/routes.rb

@@ -1,3 +1,3 @@
 Feeder::Engine.routes.draw do
-  root to: 'feeds#index', via: :get
+  resources :items, path: '/(.:format)', only: :index
 end

data/db/migrate/20140321085409_add_sticky_to_feeder_items.rb

@@ -0,0 +1,5 @@
+class AddStickyToFeederItems < ActiveRecord::Migration
+  def change
+    add_column :feeder_items, :sticky, :boolean, default: false
+  end
+end

data/db/migrate/20140401131911_prohibit_null_on_feeder_item_stickies.rb

@@ -0,0 +1,13 @@
+class ProhibitNullOnFeederItemStickies < ActiveRecord::Migration
+  class Feeder::Item < ActiveRecord::Base; end
+
+  def up
+    Feeder::Item.where(sticky: nil).update_all sticky: false
+
+    change_column :feeder_items, :sticky, :boolean, null: false
+  end
+
+  def down
+    change_column :feeder_items, :sticky, :boolean, null: true
+  end
+end

data/db/migrate/20140526110451_add_blocked_to_feeder_items.rb

@@ -0,0 +1,5 @@
+class AddBlockedToFeederItems < ActiveRecord::Migration
+  def change
+    add_column :feeder_items, :blocked, :boolean, null: false, default: false
+  end
+end

data/db/migrate/20140526110501_add_reported_to_feeder_items.rb

@@ -0,0 +1,5 @@
+class AddReportedToFeederItems < ActiveRecord::Migration
+  def change
+    add_column :feeder_items, :reported, :boolean, null: false, default: false
+  end
+end

data/lib/feeder.rb

@@ -1,5 +1,8 @@
 require "feeder/engine"
 require "feeder/configuration"
+require "feeder/concerns"
+require "feeder/active_record"
+require "kaminari"
 
 module Feeder
 
@@ -9,9 +12,22 @@ module Feeder
     end
 
     def configure
-      raise ArgumentError, "No block provided" unless block_given?
+      yield config if block_given?
+    end
+
+    # Set temporary configuration options for the duration of the given block.
+    #
+    # options - A Hash describing temporary configuration options.
+    def temporarily options = {}
+      original = @configuration.dup
+
+      options.each do |key, value|
+        @configuration.send "#{key}=", value
+      end
 
-      yield config
+      yield
+    ensure
+      @configuration = original
     end
   end
 

data/lib/feeder/active_record.rb

@@ -0,0 +1,9 @@
+module Feeder::ActiveRecord
+  module Extensions
+    def feedable
+      include Feeder::Concerns::Feedable
+    end
+  end
+end
+
+::ActiveRecord::Base.send :extend, Feeder::ActiveRecord::Extensions if defined?(ActiveRecord)

data/lib/feeder/concerns.rb

@@ -0,0 +1,6 @@
+module Feeder::Concerns
+  require 'feeder/concerns/controllers'
+  require 'feeder/concerns/helpers'
+  require 'feeder/concerns/feedable'
+  require 'feeder/concerns/models'
+end

data/lib/feeder/concerns/controllers.rb

@@ -0,0 +1,5 @@
+module Feeder
+  module Concerns::Controllers
+    require 'feeder/concerns/controllers/items_controller'
+  end
+end

data/lib/feeder/concerns/controllers/items_controller.rb

@@ -0,0 +1,22 @@
+module Feeder
+  module Concerns::Controllers::ItemsController
+    extend ActiveSupport::Concern
+
+    included do
+      respond_to :html, :json
+
+      def index
+        @items = Item.order(sticky: :desc)
+
+        Feeder.config.scopes.each do |scope|
+          @items = @items.instance_eval &scope
+        end
+
+        @items = @items.page(params[:page] || 1)
+        @items = @items.per(params[:limit] || 25)
+
+        respond_with @items
+      end
+    end
+  end
+end

data/lib/feeder/concerns/feedable.rb

@@ -0,0 +1,27 @@
+module Feeder::Concerns::Feedable
+  extend ActiveSupport::Concern
+
+  included do
+    attr_accessor :sticky
+
+    has_one :feeder_item, as: :feedable, class_name: 'Feeder::Item', dependent: :destroy
+
+    def sticky
+      if feeder_item
+        feeder_item.sticky
+      else
+        !!@sticky
+      end
+    end
+
+    def sticky= value
+      @sticky = value
+
+      if feeder_item
+        feeder_item.sticky = value
+      end
+    end
+
+    delegate :block, :unblock, :blocked?, :report, :unreport, :reported?, to: :feeder_item
+  end
+end

data/lib/feeder/concerns/helpers.rb

@@ -0,0 +1,5 @@
+module Feeder
+  module Concerns::Helpers
+    require 'feeder/concerns/helpers/filter'
+  end
+end

data/lib/feeder/concerns/helpers/filter.rb

@@ -0,0 +1,20 @@
+module Feeder
+  module Concerns::Helpers::Filter
+    extend ActiveSupport::Concern
+
+    included do
+      scope :filter, ->(options) {
+        args = []
+        wheres = options.each.map do |feedable, ids|
+          ids = feedable.pluck :id if ids == :all
+
+          args << feedable << ids
+
+          "(feedable_type = ? AND feedable_id IN (?))"
+        end.join " OR "
+
+        where(wheres, *(args))
+      }
+    end
+  end
+end

data/lib/feeder/concerns/models.rb

@@ -0,0 +1,5 @@
+module Feeder
+  module Concerns::Models
+    require 'feeder/concerns/models/item'
+  end
+end

data/lib/feeder/concerns/models/item.rb

@@ -0,0 +1,31 @@
+module Feeder
+  module Concerns::Models::Item
+    extend ActiveSupport::Concern
+
+    included do
+      include Feeder::Concerns::Helpers::Filter
+
+      belongs_to :feedable, polymorphic: true
+
+      def type
+        feedable_type.underscore
+      end
+
+      def report
+        self.update reported: true
+      end
+
+      def block
+        self.update blocked: true
+      end
+
+      def unreport
+        self.update reported: false
+      end
+
+      def unblock
+        self.update blocked: false
+      end
+    end
+  end
+end