feedable 0.0.1 → 0.9.0

data/README.md

@@ -16,9 +16,13 @@ Requires Ruby version **>= 1.9.2** and ActiveRecord version **>= 3.0**
 Installation
 ------------
 
-Feedable should be installed as a gem in your app.  Currently, it is only available as the latest-build on github.  Fixed versions forth-coming.
+Feedable should be installed as a gem in your app.
 
-For now, you have to live on the bleeding-edge:
+Include the gem in your Gemfile:
+
+    gem "feedable"
+
+Or, if you like to live on the bleeding-edge:
 
     gem "feedable", :git => "https://github.com/cavis/feedable"
 
@@ -26,14 +30,63 @@ For now, you have to live on the bleeding-edge:
 Getting Started
 ---------------
 
-### TODO
+### In your models, indicate a datetime column to sort by:
+
+    class Alligator < ActiveRecord::Base
+      feedable :created_at
+    end
+
+    class Grizzly < ActiveRecord::Base
+      feedable :last_fed_at
+    end
+
+
+Usage
+-----
+
+### In your controller, or wherever you want to sort these records:
+
+    def activity
+      @recent_activity = feedable Alligator, Grizzly, :limit => 10
+    end
+
+This will return an array of `ActiveRecords`, ordered by the specified datetime columns.  The most recent activity will
+be first, with a limit of 10.  Keep reading... the advanced options will explain more about this.
+
+
+Advanced Options
+----------------
+
+Ah, you made it.  Welcome!
+
+When calling `feedable`, the first thing to pass is 1-or-more `ActiveRecord` queries.  *Just make sure* you don't pass in something like `Alligator.all`, as this executes sql right away, and doesn't give `feedable` a chance to interject ordering.
+
+However, you can pass in some fancy shmancy `ActiveRecord` conditions, includes, selects, and joins.
+
+    @recent = feedable Alligator.where('name = ?', 'charles').includes(:garden),
+      Grizzly.select('name', 'height'),
+      Walleye.joins(:guns).where('guns.type = "smart"'),
+      :limit => 10
+
+Note that if you don't pass a limit, you get the default limit of 100 things returned.  Additionally, you can specify an offset to `feedable`:
+
+    @recent = feedable Alligator, Grizzly, :limit => 10, :offset => 20
+
+Finally, even though you usually want activity in a descending datetime order, you can also flip that around:
+
+    @recent = feedable Alligator, Grizzly, :limit => 10, :order => 'desc'
+    @oldest = feedable Alligator, Grizzly, :limit => 10, :order => 'asc'
+
 
 Issues and Contributing
 -----------------------
 
 Please, let me know about any bugs/feature-requests via the issues tracker.  And if you'd like to contribute, send me a note!  Thanks.
 
+
 License
 -------
 
 Feedable is free software, and may be redistributed under the MIT-LICENSE.
+
+Thanks for listening!

data/lib/feedable.rb

@@ -1,2 +1,77 @@
 module Feedable
 end
+
+# main function
+def feedable(*args)
+  opts = { :limit => 100, :offset => 0, :order => :desc }
+
+  # look for options hash (and remove)
+  args.delete_if do |x|
+    if x.class == Hash
+      opts.merge!(x)
+    end
+  end
+
+  # abort if empty
+  clauses = []
+  return clauses unless args.length > 0
+
+  # generate clauses from args
+  args.each do |q|
+    tmp = (q.class == Class) ? q.select('*') : q.clone
+
+    unless tmp.class == ActiveRecord::Relation
+      raise "Invalid class #{tmp.klass} - should be an ActiveRecord::Relation"
+    end
+    unless tmp.attribute_method?(:feedable_col)
+      raise "Class #{tmp.klass} isn't feedable!"
+    end
+
+    # unset any order, limit and offset
+    tmp.order_values = []
+    tmp.limit_value = nil
+    tmp.offset_value = nil
+
+    # add to unions
+    tmp.select_values = ["#{tmp.primary_key} as key", "#{tmp.feedable_col} as dtim", "'#{tmp.klass}' as type"]
+    clauses.push tmp.to_sql
+  end
+
+  # join together and execute
+  unions = clauses.join(' UNION ')
+  paging = "order by dtim #{opts[:order]} limit #{opts[:limit]} offset #{opts[:offset]}"
+  query = "select * from (#{unions}) " + paging
+  all_ids = ActiveRecord::Base.connection.select_all(query)
+  all_recs = []
+
+  # fetch the database objects
+  args.each do |q|
+    q = q.select('*') if (q.class == Class)
+
+    # remove unnecessary clauses
+    q.where_values = []
+    q.order_values = []
+    q.limit_value = nil
+    q.offset_value = nil
+
+    # collect ids
+    ids = all_ids.select{|x| x['type'] == q.klass.name}.collect{|x| x['key']}
+    recs = q.find(ids)
+
+    # attach to the output
+    recs.each do |r|
+      idx = all_ids.index {|x| x['key'] == r.id}
+      all_recs[idx] = r
+    end
+  end
+
+  # return just the records, in order
+  return all_recs
+end
+
+# activerecord "blameable"
+if defined?(ActiveRecord)
+  require 'feedable/active_record'
+else
+  raise "feedable only works with active_record"
+end

data/lib/feedable/active_record.rb

@@ -0,0 +1,16 @@
+require 'active_record'
+
+module Feedable
+  module FeedableRecord
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def feedable(col)
+        class_attribute :feedable_col
+        self.feedable_col = col
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, Feedable::FeedableRecord

data/lib/feedable/version.rb

@@ -1,3 +1,3 @@
 module Feedable
-  VERSION = "0.0.1"
+  VERSION = "0.9.0"
 end

data/test/dummy/app/assets/stylesheets/scaffold.css

@@ -0,0 +1,56 @@
+body { background-color: #fff; color: #333; }
+
+body, p, ol, ul, td {
+  font-family: verdana, arial, helvetica, sans-serif;
+  font-size:   13px;
+  line-height: 18px;
+}
+
+pre {
+  background-color: #eee;
+  padding: 10px;
+  font-size: 11px;
+}
+
+a { color: #000; }
+a:visited { color: #666; }
+a:hover { color: #fff; background-color:#000; }
+
+div.field, div.actions {
+  margin-bottom: 10px;
+}
+
+#notice {
+  color: green;
+}
+
+.field_with_errors {
+  padding: 2px;
+  background-color: red;
+  display: table;
+}
+
+#error_explanation {
+  width: 450px;
+  border: 2px solid red;
+  padding: 7px;
+  padding-bottom: 0;
+  margin-bottom: 20px;
+  background-color: #f0f0f0;
+}
+
+#error_explanation h2 {
+  text-align: left;
+  font-weight: bold;
+  padding: 5px 5px 5px 15px;
+  font-size: 12px;
+  margin: -7px;
+  margin-bottom: 0px;
+  background-color: #c00;
+  color: #fff;
+}
+
+#error_explanation ul li {
+  font-size: 12px;
+  list-style: square;
+}

data/test/dummy/app/controllers/alligators_controller.rb

@@ -0,0 +1,83 @@
+class AlligatorsController < ApplicationController
+  # GET /alligators
+  # GET /alligators.json
+  def index
+    @alligators = Alligator.all
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.json { render json: @alligators }
+    end
+  end
+
+  # GET /alligators/1
+  # GET /alligators/1.json
+  def show
+    @alligator = Alligator.find(params[:id])
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.json { render json: @alligator }
+    end
+  end
+
+  # GET /alligators/new
+  # GET /alligators/new.json
+  def new
+    @alligator = Alligator.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.json { render json: @alligator }
+    end
+  end
+
+  # GET /alligators/1/edit
+  def edit
+    @alligator = Alligator.find(params[:id])
+  end
+
+  # POST /alligators
+  # POST /alligators.json
+  def create
+    @alligator = Alligator.new(params[:alligator])
+
+    respond_to do |format|
+      if @alligator.save
+        format.html { redirect_to @alligator, notice: 'Alligator was successfully created.' }
+        format.json { render json: @alligator, status: :created, location: @alligator }
+      else
+        format.html { render action: "new" }
+        format.json { render json: @alligator.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /alligators/1
+  # PUT /alligators/1.json
+  def update
+    @alligator = Alligator.find(params[:id])
+
+    respond_to do |format|
+      if @alligator.update_attributes(params[:alligator])
+        format.html { redirect_to @alligator, notice: 'Alligator was successfully updated.' }
+        format.json { head :no_content }
+      else
+        format.html { render action: "edit" }
+        format.json { render json: @alligator.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /alligators/1
+  # DELETE /alligators/1.json
+  def destroy
+    @alligator = Alligator.find(params[:id])
+    @alligator.destroy
+
+    respond_to do |format|
+      format.html { redirect_to alligators_url }
+      format.json { head :no_content }
+    end
+  end
+end

data/test/dummy/app/controllers/posts_controller.rb

@@ -0,0 +1,83 @@
+class PostsController < ApplicationController
+  # GET /posts
+  # GET /posts.json
+  def index
+    @posts = Post.all
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.json { render json: @posts }
+    end
+  end
+
+  # GET /posts/1
+  # GET /posts/1.json
+  def show
+    @post = Post.find(params[:id])
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.json { render json: @post }
+    end
+  end
+
+  # GET /posts/new
+  # GET /posts/new.json
+  def new
+    @post = Post.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.json { render json: @post }
+    end
+  end
+
+  # GET /posts/1/edit
+  def edit
+    @post = Post.find(params[:id])
+  end
+
+  # POST /posts
+  # POST /posts.json
+  def create
+    @post = Post.new(params[:post])
+
+    respond_to do |format|
+      if @post.save
+        format.html { redirect_to @post, notice: 'Post was successfully created.' }
+        format.json { render json: @post, status: :created, location: @post }
+      else
+        format.html { render action: "new" }
+        format.json { render json: @post.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /posts/1
+  # PUT /posts/1.json
+  def update
+    @post = Post.find(params[:id])
+
+    respond_to do |format|
+      if @post.update_attributes(params[:post])
+        format.html { redirect_to @post, notice: 'Post was successfully updated.' }
+        format.json { head :no_content }
+      else
+        format.html { render action: "edit" }
+        format.json { render json: @post.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /posts/1
+  # DELETE /posts/1.json
+  def destroy
+    @post = Post.find(params[:id])
+    @post.destroy
+
+    respond_to do |format|
+      format.html { redirect_to posts_url }
+      format.json { head :no_content }
+    end
+  end
+end

data/test/dummy/app/controllers/roosters_controller.rb

@@ -0,0 +1,83 @@
+class RoostersController < ApplicationController
+  # GET /roosters
+  # GET /roosters.json
+  def index
+    @roosters = Rooster.all
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.json { render json: @roosters }
+    end
+  end
+
+  # GET /roosters/1
+  # GET /roosters/1.json
+  def show
+    @rooster = Rooster.find(params[:id])
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.json { render json: @rooster }
+    end
+  end
+
+  # GET /roosters/new
+  # GET /roosters/new.json
+  def new
+    @rooster = Rooster.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.json { render json: @rooster }
+    end
+  end
+
+  # GET /roosters/1/edit
+  def edit
+    @rooster = Rooster.find(params[:id])
+  end
+
+  # POST /roosters
+  # POST /roosters.json
+  def create
+    @rooster = Rooster.new(params[:rooster])
+
+    respond_to do |format|
+      if @rooster.save
+        format.html { redirect_to @rooster, notice: 'Rooster was successfully created.' }
+        format.json { render json: @rooster, status: :created, location: @rooster }
+      else
+        format.html { render action: "new" }
+        format.json { render json: @rooster.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /roosters/1
+  # PUT /roosters/1.json
+  def update
+    @rooster = Rooster.find(params[:id])
+
+    respond_to do |format|
+      if @rooster.update_attributes(params[:rooster])
+        format.html { redirect_to @rooster, notice: 'Rooster was successfully updated.' }
+        format.json { head :no_content }
+      else
+        format.html { render action: "edit" }
+        format.json { render json: @rooster.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /roosters/1
+  # DELETE /roosters/1.json
+  def destroy
+    @rooster = Rooster.find(params[:id])
+    @rooster.destroy
+
+    respond_to do |format|
+      format.html { redirect_to roosters_url }
+      format.json { head :no_content }
+    end
+  end
+end