favourite_object 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 10e8aa16ee8823e7a4ee8e63bd9e03f4ec599f2e
-  data.tar.gz: 9ece4107df4043ef93b43a2458a4fdde13453ff8
+  metadata.gz: e27704e25abb1b02018b0ba69c02b0af493123b2
+  data.tar.gz: 0958d771a5ad4a2241361d02436023cdb378bd85
 SHA512:
-  metadata.gz: f61b9e5f3c8dddeecc66f7cea433d882709b8ea963a65507f2b1b8320b841c8760351c1fc8d367e883622e1a439a4e606aa06f743b914b88531aa47c367310cf
-  data.tar.gz: c608eca028fea05206c72928394917d7db4a97ae17cdb35b74771c34f35ab064eadc6d480191357b33d471421da67f41ac7cae07b1c40a1c5880ecdf5ab9e0c8
+  metadata.gz: c329fd5c05b62984903606d9b5b01a4f77aad64b9a52484a095640c0859388edb6e73fa34e8840d038e62481de36785c0334c15b4be64b44fe8a33b736d12354
+  data.tar.gz: 7ac833d5cba4aad23823c1969f443f78f14df94fa4863f769cb28a5ddfbc8ceea7cf43c34310bbe837233dc9fb4e6386d0d5e0cbca7f597f8ddd6f23ed829622

data/app/controllers/favourite_object/base_favourites_controller.rb

@@ -1,100 +1,92 @@
-class FavouriteObject::BaseFavouritesController < ApplicationController
+module FavouriteObject
+	class BaseFavouritesController < ApplicationController
+		respond_to :json
+		responders :json
 
-	before_filter :authenticate!
-	#remove before commiting
-	skip_before_filter :verify_authenticity_token  
+		before_filter :authenticate!
 
-	def index
-		collection
+		def index
+			collection
 
-		respond_to_method
-	end
+			respond_to_method(params[:serializer])
+		end
 
-	def collection
-		@favourites = FavouriteObject::Favourite.for_owner(@user)
-													  .where(is_favourited: true)
-		                                              .order("created_at DESC")
-		@favourites = @favourites.with_type(params[:type]) if params[:type]
-		collection_pagination    
-	end
+		def collection
+			@favourites = Favourite.for_owner(@user)
+											.where(is_favourited: true).order("created_at DESC")
 
-	def collection_pagination
-		@favourites = @favourites.page(params[:page]).per(params[:per_page])
-	end
+			@favourites = @favourites.where(target_type: params[:target_type]) if params[:target_type]
+			@favourites = @favourites.where(target_id: params[:target_ids]) if params[:target_ids]
 
-	def respond_to_method
-		respond_to do |format|
-		  format.html
-		  format.json {render :json => @favourites, meta: { pagination: { per_page: @favourites.limit_value, total_pages: @favourites.total_pages, total_objects: @favourites.total_count } }}
+			collection_pagination
 		end
-	end
 
-	def query
-		if params[:third_party_flag] == 'true' || params[:third_party_flag] == '1'	
-			@favourite = FavouriteObject::Favourite.where(owner: @user, third_party_id: params[:target_id], 
-				third_party_type: params[:target_type], third_party_flag: true).first_or_initialize
-		else
-			@favourite = FavouriteObject::Favourite.where(owner: @user, target_id: params[:target_id], 
-				target_type: params[:target_type]).first_or_initialize
-		end	
-
-		if @favourite.is_favourited == false
-			@favourite = {} 
-			@favourite[:favourite] = nil 
+		def collection_pagination
+			@favourites = @favourites.page(params[:page]).per(params[:per_page])
 		end
 
-		render :json => @favourite, root: 'favourite'
-	end
+		def respond_to_method(serializer)
+			if serializer == 'lite'
+				return respond_with @favourites, each_serializer: LiteFavouriteSerializer
+			end
+			respond_with @favourites
+		end
+
+		def show
+			@favourite = Favourite.find_with_target(@user, params[:target_id],
+				params[:target_type], params[:third_party_flag])
 
-	def update
-		#endpoint for favouriting an object
-		if params[:third_party_flag] == 'true' || params[:third_party_flag] == '1'	
-			favourite = FavouriteObject::Favourite.where(owner: @user, third_party_id: params[:target_id], 
-				third_party_type: params[:target_type], third_party_flag: true).first_or_initialize
-		else
-			favourite = FavouriteObject::Favourite.where(owner: @user, target_id: params[:target_id], 
-				target_type: params[:target_type]).first_or_initialize
-		end	
-
-		# favourite.params = params[:data] if params[:data]
-		favourite.params = params[:data] if params[:data]
-		favourite.params[:description] = params[:description] if params[:description]
-
-		if params[:favourite] == 'true' || params[:favourite] == '1'
-			favourite.is_favourited = true
-			favourite.save
-		else
-			favourite.is_favourited = false
-			favourite.destroy
-			favourite = {} 
-			favourite[:favourite] = nil 
+			respond_with @favourite, serializer: LiteFavouriteSerializer
 		end
 
+		def update
+			@favourite = Favourite.find_with_target(@user, params[:target_id],
+				params[:target_type], params[:third_party_flag])
 
-		render :json => favourite, root: 'favourite'
-	end
+			@favourite.update(permitted_params[:favourite])
 
-	def toggle
-		# toggle for web interface 
-		# DOES NOT ACCOUNT FOR THIRDPARTY FAVOURITES YET
-		if params[:third_party_flag] == 'true' || params[:third_party_flag] == '1'	
-			favourite = FavouriteObject::Favourite.where(owner: @user, third_party_id: params[:target_id], 
-				third_party_type: params[:target_type], third_party_flag: true).first_or_initialize
-			favourite.params = eval(params[:params]) if params[:params]
-		else
-			favourite = FavouriteObject::Favourite.where(owner: @user, target_id: params[:target_id], 
-				target_type: params[:target_type]).first_or_initialize
-		end	
-		favourite.toggle
-		
-		render :json => favourite, root: 'favourite'
-	end
+			respond_with @favourite, serializer: LiteFavouriteSerializer
+		end
+
+		def toggle
+			# toggle for web interface
+			@favourite = Favourite.find_with_target(@user, params[:target_id],
+				params[:target_type], params[:third_party_flag])
 
-	private 
+			@favourite.toggle
 
-	def authenticate!
-		#fix before commiting
-	  method(FavouriteObject.authentication_method).call
-	  @user = method(FavouriteObject.current_user_method).call
+			respond_with @favourite
+		end
+
+		def meta
+		  if action_name == 'index'
+		  	{
+		  		pagination: {
+		  			per_page: @favourites.limit_value,
+		  			total_pages: @favourites.total_pages,
+		  			total_objects: @favourites.total_count
+		  		}
+		  	}
+		  end
+		end
+
+		private
+
+		def permitted_params
+		  params.permit(favourite: [
+		  	:is_favourited,
+		  	:target_id,
+		  	:target_type,
+		  	:third_party_flag,
+		  	:third_party_id,
+		  	:third_party_type,
+		  	:params
+		  ])
+		end
+
+		def authenticate!
+		  method(FavouriteObject.authentication_method).call
+		  @user = method(FavouriteObject.current_user_method).call
+		end
 	end
 end

data/app/models/favourite_object/favourite.rb

@@ -1,73 +1,76 @@
 module FavouriteObject
   class Favourite < ActiveRecord::Base
-    self.table_name = "favourite_object_favourites"
+	self.table_name = "favourite_object_favourites"
 
-    belongs_to :target, polymorphic: true
-    belongs_to :owner, polymorphic: true
+	belongs_to :target, polymorphic: true
+	belongs_to :owner, polymorphic: true
 
-    # Params for creating the notification message.
-    serialize :params, Hash
+	# Params for creating the notification message.
+	serialize :params, Hash
 
-    mattr_accessor :views
-    @@views = {
-      message: {
-        template_path: Proc.new {|n| "favourite_object/#{n.target_type.underscore}/message" }
-      }
-    }
+	mattr_accessor :views
+	@@views = {
+	  message: {
+		template_path: Proc.new {|n| "favourite_object/#{n.target_type.underscore}/message" }
+	  }
+	}
 
-    if ActiveRecord::VERSION::MAJOR < 4
-      attr_accessible :target, :owner
-    end
+	if ActiveRecord::VERSION::MAJOR < 4
+	  attr_accessible :target, :owner
+	end
 
-    def self.for_owner(owner)
-    	where(owner_id: owner.id)
-    	.where(owner_type: owner.class.base_class)
-    end
+	def self.find_with_target(owner, target_id, target_type, third_party_flag=false)
+		if third_party_flag
+			 return Favourite.for_owner(owner).find_or_initialize_by(third_party_id: target_id,
+				third_party_type: target_type, third_party_flag: true)
+		end
 
-    def message
-      ActionView::Base.new(
-             Rails.configuration.paths["app/views"]).render(
-             :template => self.class.views[:message][:template_path].call(self), :formats => [:html], 
-             :locals => {object: self.target }, :layout => false)
-    end
+		Favourite.for_owner(owner).find_or_initialize_by(target_id: target_id,
+			target_type: target_type)
+	end
 
-    #toggles the is_favourited status
-    def toggle
-    	if is_favourited
-    		self.is_favourited = false
-    	else
-    		self.is_favourited = true
-    	end
-    	self.save
-    end
+	def self.for_owner(owner)
+		where(owner_id: owner.id)
+		.where(owner_type: owner.class.base_class)
+	end
 
-    def favourite
-    	self.is_favourited = true
-    	self.save
-    end
+	def message
+	  ActionView::Base.new(
+			 Rails.configuration.paths["app/views"]).render(
+			 :template => self.class.views[:message][:template_path].call(self), :formats => [:html],
+			 :locals => {object: self.target }, :layout => false)
+	end
 
-    def un_favourite
-    	self.is_favourited = false
-    	self.save
-    end
+	#toggles the is_favourited status
+	def toggle
+		if is_favourited
+			self.is_favourited = false
+		else
+			self.is_favourited = true
+		end
+		self.save
+	end
 
-    def self.is_favourited?(owner, target_id, target_type, third_party_flag=false)
-        if third_party_flag 
-            favourite = FavouriteObject::Favourite.where(owner: owner, third_party_id: target_id.to_s,
-                            third_party_type: target_type).first
-        else
-            favourite = FavouriteObject::Favourite.where(owner: owner, target_id: target_id,
-                            target_type: target_type).first
-        end
+	def favourite
+		self.is_favourited = true
+		self.save
+	end
 
-        return false if favourite.blank? || favourite.is_favourited == false
+	def un_favourite
+		self.is_favourited = false
+		self.save
+	end
 
-        return true
-    end    
+	def self.is_favourited?(owner, target_id, target_type, third_party_flag=false)
+		favourite = self.find_with_target(owner, target_id, target_type, third_party_flag)
 
-    def self.with_type(type)
-        where('target_type = ?', type)
-    end
+		return false if favourite.blank? || favourite.is_favourited == false
+		true
+	end
+
+	def self.with_type(type)
+		where('target_type = ?', type)
+	end
 
   end
 end

data/app/serializer/favourite_object/favourite_serializer.rb

@@ -1,9 +1,7 @@
 class FavouriteObject::FavouriteSerializer < ActiveModel::Serializer
-  root :favourites
-
   attributes :id, :target_id, :target_type, :is_favourited, :description, :third_party_flag, :data
   embed :ids, :include => true
-  has_one :target, polymorphic: true
+  # has_one :target, polymorphic: true
 
   def include_target?
     (self.object.third_party_flag != true)
@@ -14,7 +12,7 @@ class FavouriteObject::FavouriteSerializer < ActiveModel::Serializer
   		self.object.params[:description]
   	else
   		self.object.message
-  	end 
+  	end
   end
 
   def data
@@ -22,7 +20,7 @@ class FavouriteObject::FavouriteSerializer < ActiveModel::Serializer
   		self.object.params
   	else
   		[]
-  	end 
+  	end
   end
 
   def target_id

data/app/serializer/favourite_object/lite_favourite_serializer.rb

@@ -0,0 +1,22 @@
+class FavouriteObject::LiteFavouriteSerializer < ActiveModel::Serializer
+  root :favourite
+
+  attributes :id, :target_id, :target_type, :is_favourited, :third_party_flag
+
+  def target_id
+    if self.object.third_party_flag == true
+      self.object.third_party_id
+    else
+      self.object.target_id
+    end
+  end
+
+  def target_type
+    if self.object.third_party_flag == true
+      self.object.third_party_type
+    else
+      self.object.target_type
+    end
+  end
+
+end

data/config/routes.rb

@@ -1,8 +1,8 @@
-Rails.application.routes.draw do
-	namespace :favourite_object do
-	  resources :favourites, only: [:index]
-	  get 'favourites/:target_type/:target_id' => 'favourites#query'
-	  put 'favourites/:target_type/:target_id' => 'favourites#update'
-	  put 'favourites/:target_type/:target_id/toggle' => 'favourites#toggle'
-	end
-end
+FavouriteObject::Engine.routes.draw do
+  namespace :favourite_object do
+    resources :favourites, only: [:index]
+    get 'favourites/:target_type/:target_id' => 'favourites#show'
+    put 'favourites/:target_type/:target_id' => 'favourites#update'
+    put 'favourites/:target_type/:target_id/toggle' => 'favourites#toggle'
+  end
+end

data/lib/favourite_object/engine.rb

@@ -1,11 +1,14 @@
 module FavouriteObject
   class Engine < ::Rails::Engine
+    isolate_namespace FavouriteObject
+
   	config.generators do |g|
   	  g.test_framework      :rspec,        :fixture => false
   	  g.fixture_replacement :factory_girl, :dir => 'spec/factories'
   	  g.assets false
   	  g.helper false
   	end
-  	
+
+    config.autoload_paths += %W(#{config.root}/lib)
   end
 end

data/lib/favourite_object/version.rb

@@ -1,3 +1,3 @@
 module FavouriteObject
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/lib/favourite_object.rb

@@ -1,7 +1,7 @@
 require "favourite_object/engine"
 require "kaminari"
 require "active_model_serializers"
-
+require 'responders'
 
 module FavouriteObject
 

data/lib/generators/favourite_object/install/install_generator.rb

@@ -31,23 +31,18 @@ class FavouriteObject::InstallGenerator < Rails::Generators::Base
   # This is defined in ActiveRecord::Generators::Base, but that inherits from NamedBase, so it expects a name argument
   # which we don't want here. So we redefine it here. Yuck.
   def self.next_migration_number(dirname)
-    if ActiveRecord::Base.timestamped_migrations
-      Time.now.utc.strftime("%Y%m%d%H%M%S%L")
-    else
-      "%.3d" % (current_migration_number(dirname) + 1)
-    end
+    next_migration_number = current_migration_number(dirname) + 1
+    ActiveRecord::Migration.next_migration_number(next_migration_number)
   end
 
-
-
   protected
 
-    def copy_migration(filename)
-      if self.class.migration_exists?("db/migrate", "#{filename}")
-        say_status("skipped", "Migration #{filename}.rb already exists")
-      else
-        migration_template "#{filename}.rb", "db/migrate/#{filename}.rb"
-      end
+  def copy_migration(filename)
+    if self.class.migration_exists?("db/migrate", "#{filename}")
+      say_status("skipped", "Migration #{filename}.rb already exists")
+    else
+      migration_template "#{filename}.rb", "db/migrate/#{filename}.rb"
     end
+  end
 
 end

data/lib/responders/json_responder.rb

@@ -0,0 +1,15 @@
+module Responders::JsonResponder
+  protected
+
+  # simply render the resource even on POST instead of redirecting for ajax
+  def api_behavior(error)
+    if post?
+      display resource, status: :created
+    # render resource instead of 204 no content
+    elsif put?
+      display resource, status: :ok
+    else
+      super
+    end
+  end
+end

data/spec/controllers/favourite_object/favourites_controller_spec.rb

@@ -1,68 +1,83 @@
 require 'spec_helper'
 
-
-describe FavouriteObject::FavouritesController do
-
-	let(:user) { User.create({email: "user@example.com" })}
-	let(:arbitrary_object) { ArbitraryObject.create() }
-
-	before :each do
-	  FavouriteObject::FavouritesController.any_instance.stub(:current_user).and_return(user)
-	  FavouriteObject::FavouritesController.any_instance.stub(:authenticate_user!).and_return(true)
-	  FavouriteObject::Favourite.any_instance.stub(:message).and_return("Mr. Blobby")
-
-	end
-
-  	describe "listing favourites" do
-  		let(:favourite) { FavouriteObject::Favourite.create(owner: user, target: arbitrary_object) }
-
-  		before :each do
-  			favourite.is_favourited = true
-  			favourite.save
-  		end
-
-  		it "displays favourites as json" do
-  			get :index, format: :json
-  			response.body.should have_json_path "favourites/0/id"
-  		end
-
-  		it "displays favourites filtered by type" do
-  			get :index, format: :json, type: "ArbitraryObject"
-  			response.body.should have_json_path "favourites/0/id"
-  			expect(json(response.body)["favourites"].length).to eq 1
-  		end
-
-  		it "displays favourites web template" do
-  			get :index
-  		end
-	end
-
-	describe "unfavouriting an object" do
-		it "returns null if favourited is equal to false" do
-			put :update, target_type: arbitrary_object.class, target_id: arbitrary_object.id
-			expect(json(response.body)["favourite"]).to eq nil
-		end
-
-		it "if already exists exists and is_favourited is set to false the object gets deleted" do
-			favourite_object = FavouriteObject::Favourite.create(owner: user, target: arbitrary_object)
-			favourite_object.is_favourited = true
-			favourite_object.save
-
-			put :update, target_type: arbitrary_object.class.name, target_id: arbitrary_object.id, favourite: false
-
-			expect(json(response.body)["favourite"]).to eq nil
-
-		end
-	end
-
-	describe "favourite a third_party object" do
-		it "assigns third_party values" do
-			put :update, target_type: "RandomClass", target_id: "object_1", third_party_flag: 'true', favourite: 'true'
-
-			favourite = FavouriteObject::Favourite.last
-			favourite.third_party_flag.should eq true
-			favourite.third_party_id.should eq "object_1"
-			favourite.third_party_type.should eq "RandomClass"
-		end
-	end
+module FavouriteObject
+  describe FavouritesController do
+
+    let(:user) { User.create({email: "user@example.com" })}
+    let(:arbitrary_object) { ArbitraryObject.create() }
+    let(:favourite) { Favourite.create(owner: user, target: arbitrary_object) }
+
+    before :each do
+      FavouritesController.any_instance.stub(:current_user).and_return(user)
+      FavouritesController.any_instance.stub(:authenticate_user!).and_return(true)
+      Favourite.any_instance.stub(:message).and_return("Mr. Blobby")
+    end
+
+    describe 'GET show' do
+      it "returns 200" do
+        get :show, target_type: arbitrary_object.class.name, target_id: arbitrary_object.id, format: :json, use_route: :favourite_object
+        expect(response.response_code).to eq 200
+      end
+
+      it "returns favourite status" do
+        favourite.update(is_favourited: true)
+
+        get :show, target_type: arbitrary_object.class.name, target_id: arbitrary_object.id, format: :json, use_route: :favourite_object
+        expect(json[:favourite][:is_favourited]).to eq true
+      end
+    end
+
+    describe "PUT update" do
+      it "favouriting object returns is_favourite true" do
+        put :update, target_type: arbitrary_object.class.name, target_id: arbitrary_object.id, favourite: {is_favourited: true}, format: :json, use_route: :favourite_object
+        expect(json[:favourite][:is_favourited]).to eq true
+      end
+
+      it "unfavouriting object returns is_favourite false" do
+        put :update, target_type: arbitrary_object.class.name, target_id: arbitrary_object.id, favourite: {is_favourited: false}, format: :json, use_route: :favourite_object
+        expect(json[:favourite][:is_favourited]).to eq false
+      end
+    end
+
+    ## Index is used to display a list view of favourites
+    describe "GET index" do
+      it "returns 200" do
+        get :index, format: :json, use_route: :favourite_object
+        expect(response.response_code).to eq 200
+      end
+
+      ## doesn't include message data, which adds response_time due to rendering n templates
+      it "returns lite payload" do
+        favourite.update(is_favourited: true)
+
+        get :index, format: :json, use_route: :favourite_object, serializer: 'lite'
+        expect(json[:favourites][0][:description]).to be_nil
+      end
+
+      it "filter by type only" do
+        favourite.update(is_favourited: true)
+        Favourite.create(owner: user, target_type: 'FakeObject', target_id: 5, is_favourited: true)
+
+        get :index, format: :json, use_route: :favourite_object, target_type: 'FakeObject'
+        expect(json[:favourites].count).to eq 1
+      end
+
+      it "returns favourite filtered by type and id" do
+        favourite.update(is_favourited: true)
+        Favourite.create(owner: user, target_type: 'FakeObject', target_id: 5, is_favourited: true)
+
+        get :index, format: :json, use_route: :favourite_object, target_type: 'FakeObject', target_ids: [5]
+        expect(json[:favourites].count).to eq 1
+      end
+
+      it "doesn't return favourite with another id" do
+        favourite.update(is_favourited: true)
+        Favourite.create(owner: user, target_type: 'FakeObject', target_id: 5, is_favourited: true)
+
+        get :index, format: :json, use_route: :favourite_object, target_type: 'FakeObject', target_ids: [6]
+        expect(json[:favourites].count).to eq 0
+      end
+    end
+
+  end
 end