markable 0.0.4

data/lib/markable/acts_as_marker.rb

@@ -0,0 +1,62 @@
+module Markable
+  module ActsAsMarker
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    module ClassMethods
+      def acts_as_marker(options = {})
+        Markable.set_models ActiveRecord::Base.connection.tables.collect{|t| t.classify rescue nil }.compact
+
+        cattr_accessor :marker_name
+        self.marker_name = self.name.downcase.to_sym
+
+        class_eval do
+          has_many :marker_marks, :class_name => 'Markable::Mark', :as => :marker
+        end
+        class_eval do
+          include Markable::ActsAsMarker::MarkerInstanceMethods
+        end
+        Markable.add_marker self
+      end
+    end
+
+    module MarkerInstanceMethods
+      def method_missing( method_sym, *args )
+        Markable.models.each { |model_name|
+          if method_sym.to_s =~ Regexp.new("^[\\w_]+_#{model_name.downcase.pluralize}$") ||
+              method_sym.to_s =~ Regexp.new("^#{model_name.downcase.pluralize}_marked_as(_[\\w_]+)?$")
+            model_name.constantize # ping model
+            if self.methods.include? method_sym # method has appear
+              return self.method(method_sym).call(args) if args.count > 0 # call this method
+              return self.method(method_sym).call
+            end
+          end
+        }
+        super
+      rescue
+        super
+      end
+
+      def set_mark mark, markables
+        markables = [ markables ] unless markables.kind_of? Array
+        markables.each do |markable|
+          Markable.can_mark_or_raise? self, markable, mark
+          markable.mark_as mark, self
+        end
+      end
+
+      def remove_mark mark, markables
+        markables = [ markables ] unless markables.kind_of? Array
+        Markable.can_mark_or_raise? self, markables, mark
+        markables.each do |markable|
+          markable.unmark mark, :by => self
+        end
+      end
+    end
+
+  end
+end
+
+ActiveRecord::Base.send :include, Markable::ActsAsMarker

data/lib/markable/exceptions.rb

@@ -0,0 +1,7 @@
+module Markable
+  class WrongMarkableType < Exception
+    def initialize()
+      super 'Wrong markable type'
+    end
+  end
+end

data/lib/markable/version.rb

@@ -0,0 +1,3 @@
+module Markable
+  VERSION = "0.0.4"
+end

data/lib/models/mark.rb

@@ -0,0 +1,6 @@
+module Markable
+  class Mark < ActiveRecord::Base
+    belongs_to :markable, :polymorphic => true
+    belongs_to :marker, :polymorphic => true
+  end
+end

data/test/acts_as_markable_test.rb

@@ -0,0 +1,219 @@
+require 'test_helper'
+
+class ActsAsMarkableTest < ActiveSupport::TestCase
+
+  # Config tests
+
+  test "a drink's markable_marks[:favorite] should not be nil" do
+    assert_not_nil Drink.markable_marks[:favorite]
+  end
+
+  test "a food's markable_marks[:favorite] should not be nil" do
+    assert_not_nil Food.markable_marks[:favorite]
+    assert_not_nil Food.markable_marks[:hated]
+  end
+
+  test "a food's markable_marks[:favorite][:allowed_markers] should be :all" do
+    assert_equal :all, Food.markable_marks[:favorite][:allowed_markers]
+  end
+
+  test "a drink's markable_marks[:favorite][:allowed_markers] should be [:admin]" do
+    assert_equal [:admin], Drink.markable_marks[:favorite][:allowed_markers]
+  end
+
+  test "a user favorite 2 types of food and 1 drink, favorite_foods should contain both foods, favorite_drinks should contain 1 drink" do
+    admin1 = Admin.create :name => 'Admin1'
+    food1 = Food.create :name => 'Food1'
+    food2 = Food.create :name => 'Food2'
+    drink1 = Drink.create :name => 'Drink1'
+
+    admin1.favorite_foods << [food1, food2]
+    admin1.favorite_drinks << drink1
+
+    assert_equal [food1, food2], admin1.favorite_foods
+    assert_equal [drink1], admin1.favorite_drinks
+  end
+
+  # Methods
+
+  test "food.mark_as" do
+    u1, u2 = get(User, 2)
+    f1, f2 = get(Food, 2)
+    assert_equal [], f1.users_have_marked_as(:favorite)
+    f1.mark_as :favorite, u1
+    assert_equal [ u1 ], f1.users_have_marked_as(:favorite)
+    assert_equal [ f1 ], u1.favorite_foods
+    f2.mark_as :favorite, [u1, u2]
+    assert_equal [ u1, u2 ], f2.users_have_marked_as(:favorite)
+    assert_equal [ f1, f2 ], u1.favorite_foods
+    assert_equal [ f2 ], u2.favorite_foods
+  end
+
+  test "food.users_have_marked_as_favorite" do
+    u1, u2 = get(User, 2)
+    f1, f2 = get(Food, 2)
+    assert_equal [], f1.users_have_marked_as_favorite
+    f1.users_have_marked_as_favorite << u1
+    assert_equal [ u1 ], f1.users_have_marked_as_favorite
+    assert_equal [ f1 ], u1.favorite_foods
+    f2.users_have_marked_as_favorite << [u1, u2]
+    assert_equal [ u1, u2 ], f2.users_have_marked_as_favorite
+    assert_equal [ f1, f2 ], u1.favorite_foods
+    assert_equal [ f2 ], u2.favorite_foods
+  end
+
+  test "food.users_have_marked_as" do
+    u1, u2 = get(User, 2)
+    f1, f2 = get(Food, 2)
+    assert_equal [], f1.users_have_marked_as(:favorite)
+    f1.users_have_marked_as(:favorite) << u1
+    assert_equal [ u1 ], f1.users_have_marked_as(:favorite)
+    assert_equal [ f1 ], u1.favorite_foods
+    f2.users_have_marked_as(:favorite) << [u1, u2]
+    assert_equal [ u1, u2 ], f2.users_have_marked_as(:favorite)
+    assert_equal [ f1, f2 ], u1.favorite_foods
+    assert_equal [ f2 ], u2.favorite_foods
+  end
+
+  test "Food.marked_as" do
+    u1, u2 = get(User, 2)
+    f1, f2, f3 = get(Food, 3)
+    assert_equal [], Food.marked_as(:favorite)
+    u1.favorite_foods << [ f1, f3 ]
+    u2.favorite_foods << f2
+    assert_equal [ f1, f2, f3 ], Food.marked_as(:favorite)
+    assert_equal [ f1, f3 ], Food.marked_as(:favorite, :by => u1)
+    assert_equal [ f2 ], Food.marked_as(:favorite, :by => u2)
+  end
+
+  test "Food.marked_as_favorite" do
+    u1, u2 = get(User, 2)
+    f1, f2, f3 = get(Food, 3)
+    assert_equal [], Food.marked_as_favorite
+    u1.favorite_foods << [ f1, f3 ]
+    u2.favorite_foods << f2
+    assert_equal [ f1, f2, f3 ], Food.marked_as_favorite
+    assert_equal [ f1, f3 ], Food.marked_as_favorite(:by => u1)
+    assert_equal [ f2 ], Food.marked_as_favorite(:by => u2)
+  end
+
+  test "food.marked_as?" do
+    u1, u2 = get(User, 2)
+    f1, f2 = get(Food, 2)
+
+    assert !f1.marked_as_favorite?
+
+    u1.favorite_foods << [f1]
+    u2.favorite_foods << [f2]
+
+    assert f1.marked_as?(:favorite)
+    assert f1.marked_as_favorite?
+    assert f1.marked_as_favorite?(:by => u1)
+    assert !f1.marked_as_favorite?(:by => u2)
+  end
+
+  test "admin should have proper methods" do
+    admin = Admin.create :name => 'Admin'
+    assert_nothing_raised(NoMethodError) {
+      admin.favorite_foods
+    }
+    assert_nothing_raised(NoMethodError) {
+      admin.favorite_drinks
+    }
+  end
+
+  test "a drink marked as favorite with << by user, should be in favorite_drinks list of this user" do
+    admin1 = Admin.create :name => 'Admin1'
+    drink1 = Drink.create :name => 'Drink1'
+    admin1.favorite_drinks << drink1
+    assert_equal [drink1], admin1.favorite_drinks
+  end
+
+  test "a drink marked as favorite with mark_as by user, should be in favorite_drinks list of this user" do
+    admin1 = Admin.create :name => 'Admin1'
+    drink1 = Drink.create :name => 'Drink1'
+    admin1.set_mark :favorite, drink1
+    assert_equal [drink1], admin1.favorite_drinks
+  end
+
+  test "user.mark_as_favorite should mark food as favorite" do
+    user1 = User.create :name => 'User1'
+    food1 = Food.create :name => 'Food1'
+    food2 = Food.create :name => 'Food2'
+    user1.mark_as_favorite [food1, food2]
+
+    assert_equal [food1, food2], user1.favorite_foods
+  end
+
+  test "user.mark_as_favorite should not mark drink as favorite" do
+    user1 = User.create :name => 'User1'
+    drink1 = Drink.create :name => 'Drink1'
+
+    assert_raise(Markable::WrongMarkableType) {
+      user1.mark_as_favorite drink1
+    }
+  end
+
+  test "admin.mark_as_favorite" do
+    admin1 = Admin.create :name => 'Admin1'
+    food1 = Food.create :name => 'Food1'
+    drink1 = Drink.create :name => 'Drink1'
+    admin1.mark_as_favorite [food1, drink1]
+  end
+
+  test "food.remove_mark" do
+    u1, u2 = get(User, 2)
+    f1, f2 = get(Food, 2)
+    u1.favorite_foods << [f1, f2]
+    u2.favorite_foods << [f1, f2]
+    assert_equal [f1, f2], u1.favorite_foods
+    assert_equal [f1, f2], u2.favorite_foods
+    f1.unmark :favorite, :by => u1
+    assert_equal [u2], f1.users_have_marked_as_favorite
+    assert_equal [u1, u2], f2.users_have_marked_as_favorite
+    f2.unmark :favorite
+    assert_equal [u2], f1.users_have_marked_as_favorite
+    assert_equal [], f2.users_have_marked_as_favorite
+  end
+  test "food.users_have_marked_as_favorite.delete" do
+    u1, u2 = get(User, 2)
+    f1, f2 = get(Food, 2)
+    u1.favorite_foods << [f1, f2]
+    u2.favorite_foods << [f1, f2]
+    assert_equal [f1, f2], u1.favorite_foods
+    assert_equal [f1, f2], u2.favorite_foods
+    f1.users_have_marked_as_favorite.delete(u1)
+    f2.users_have_marked_as_favorite.delete(u2)
+    assert_equal [u2], f1.users_have_marked_as_favorite
+    assert_equal [u1], f2.users_have_marked_as_favorite
+  end
+
+  # Errors
+
+  test "markables can't be marked by not allowed markers" do
+    marker = User.create :name => 'marker'
+    markable = Drink.create :name => 'markable'
+
+    assert_raise(NoMethodError) {
+      marker.favorite_drinks
+    }
+    assert_raise(NoMethodError) {
+      markable.users_have_marked_as_favorite
+    }
+    assert_raise(Markable::WrongMarkableType) {
+      markable.admins_have_marked_as_favorite << marker
+    }
+    assert_raise(Markable::WrongMarkableType) {
+      markable.mark_as :favorite, marker
+    }
+  end
+
+  test "markables can be marked by allowed markers" do
+    marker = User.create :name => 'marker'
+    markable = Food.create :name => 'markable'
+
+    markable.users_have_marked_as_favorite << marker
+    assert_equal [ markable ], marker.favorite_foods
+    assert_equal [ marker ], markable.users_have_marked_as_favorite
+  end
+end

data/test/acts_as_marker_test.rb

@@ -0,0 +1,165 @@
+require 'test_helper'
+
+class ActsAsMarkerTest < ActiveSupport::TestCase
+
+  # Config
+
+  test "a_users_marker_name_should_be_user" do
+    assert_equal :user, User.marker_name
+  end
+
+  # Methods
+
+  test "user.favorite_foods" do
+    u1, u2 = get(User, 2)
+    f1, f2 = get(Food, 2)
+    assert_equal [], u1.favorite_foods
+    u1.favorite_foods << f1
+    assert_equal [ f1 ], u1.favorite_foods
+    u2.favorite_foods << [f1, f2]
+    assert_equal [ f1, f2 ], u2.favorite_foods
+  end
+
+  test "user.foods_marked_as" do
+    u1, u2 = get(User, 2)
+    f1, f2 = get(Food, 2)
+    assert_equal [], u1.foods_marked_as(:favorite)
+    u1.foods_marked_as(:favorite) << f1
+    assert_equal [ f1 ], u1.foods_marked_as(:favorite)
+    u2.foods_marked_as(:favorite) << [f1, f2]
+    assert_equal [ f1, f2 ], u2.foods_marked_as(:favorite)
+  end
+
+  test "user.foods_marked_as_favorite" do
+    u1, u2 = get(User, 2)
+    f1, f2 = get(Food, 2)
+    assert_equal [], u1.foods_marked_as_favorite
+    u1.foods_marked_as_favorite << f1
+    assert_equal [ f1 ], u1.foods_marked_as_favorite
+    u2.foods_marked_as_favorite << [f1, f2]
+    assert_equal [ f1, f2 ], u2.foods_marked_as_favorite
+  end
+
+  test "user.set_mark_to" do
+    u1, u2 = get(User, 2)
+    f1, f2 = get(Food, 2)
+    assert_equal [], u1.favorite_foods
+    u1.set_mark :favorite, f1
+    assert_equal [ f1 ], u1.favorite_foods
+    u2.set_mark :favorite, [f1, f2]
+    assert_equal [ f1, f2 ], u2.favorite_foods
+  end
+
+  test "user.remove_mark_from" do
+    u1 = get(User)
+    f1, f2 = get(Food, 2)
+    u1.favorite_foods << [f1, f2]
+    assert_equal [f1, f2], u1.favorite_foods
+    u1.remove_mark :favorite, f1
+    assert_equal [f2], u1.favorite_foods
+  end
+  test "user.favorite_foods.delete" do
+    u1 = get(User)
+    f1, f2 = get(Food, 2)
+    u1.favorite_foods << [f1, f2]
+    assert_equal [f1, f2], u1.favorite_foods
+    u1.favorite_foods.delete f1
+    assert_equal [f2], u1.favorite_foods
+  end
+
+  test "user.hated_food" do
+    u1 = get(User)
+    f1, f2 = get(Food, 2)
+
+    u1.hated_foods << f1
+    u1.favorite_foods << f2
+    assert_equal [ f1 ], u1.hated_foods
+    assert_equal [ f2 ], u1.favorite_foods
+  end
+
+  # Errors
+
+  test "markers can mark allowed markables" do
+    marker = User.create :name => 'marker'
+    markable = Food.create :name => 'markable'
+
+    marker.favorite_foods << markable
+    assert_equal [ markable ], marker.favorite_foods
+    assert_equal [ marker ], markable.users_have_marked_as_favorite
+  end
+
+  test "markers can't mark not allowed markables" do
+    marker = User.create :name => 'marker'
+    markable = Drink.create :name => 'markable'
+
+    assert_raise(NoMethodError) {
+      marker.favorite_drinks
+    }
+    assert_raise(NoMethodError) {
+      markable.users_have_marked_as_favorite
+    }
+    assert_raise(Markable::WrongMarkableType) {
+      marker.favorite_foods << markable
+    }
+    assert_raise(Markable::WrongMarkableType) {
+      marker.set_mark :favorite, markable
+    }
+  end
+
+  test "marker can't mark not markable" do
+    marker1 = User.create :name => 'marker'
+    marker2 = User.create :name => 'marker'
+
+    assert_raise(Markable::WrongMarkableType) {
+      marker1.set_mark :favorite, marker2
+    }
+    assert_raise(Markable::WrongMarkableType) {
+      marker1.set_mark :favorite, 'STRING'
+    }
+    assert_raise(Markable::WrongMarkableType) {
+      marker1.favorite_foods << marker2
+    }
+    assert_raise(Markable::WrongMarkableType) {
+      marker1.favorite_foods << 'STRING'
+    }
+  end
+
+  test "errors in mark removal" do
+    u1, u2 = get(User, 2)
+    f1, f2 = get(Food, 2)
+    u1.favorite_foods << [f1, f2]
+    u2.favorite_foods << [f1, f2]
+    assert_equal [f1, f2], u1.favorite_foods
+    assert_equal [f1, f2], u2.favorite_foods
+
+    assert_raise(Markable::WrongMarkableType) {
+      f1.users_have_marked_as_favorite.delete(f2)
+    }
+    assert_raise(Markable::WrongMarkableType) {
+      f1.users_have_marked_as_favorite.delete('STRING')
+    }
+    assert_raise(NoMethodError) {
+      u1.users_have_marked_as_favorite.delete(u2)
+    }
+
+    assert_raise(Markable::WrongMarkableType) {
+      f1.unmark :favorite, :by => f2
+    }
+    assert_raise(Markable::WrongMarkableType) {
+      f1.unmark :favorite, :by => 'STRING'
+    }
+    assert_raise(Markable::WrongMarkableType, NoMethodError) {
+      u1.remove_mark :favorite, :by => f1
+    }
+
+    assert_raise(Markable::WrongMarkableType) {
+      u1.favorite_foods.delete u2
+    }
+    assert_raise(Markable::WrongMarkableType) {
+      u1.favorite_foods.delete 'STRING'
+    }
+    assert_raise(NoMethodError) {
+      f1.favorite_foods.delete f2
+    }
+  end
+end