interest 0.0.1

data/lib/interest/follow_requestable/follow_request.rb

@@ -0,0 +1,45 @@
+require "active_support"
+
+module Interest
+  module FollowRequestable
+    module FollowRequest
+      extend ActiveSupport::Concern
+
+      included do
+        validate :validate_follow_request_relationships, if: :should_validate_follow_request_relationships?
+      end
+
+      def accept
+        update status: "accepted"
+      end
+
+      def accept!
+        update! status: "accepted"
+      end
+
+      def accept_mutual_follow
+        transaction { accept and mutual }
+      end
+
+      def accept_mutual_follow!
+        transaction { accept! and mutual! }
+      end
+
+      def reject
+        destroy
+      end
+
+      alias_method :reject!, :reject
+
+      def should_validate_follow_request_relationships?
+        pending? and follower.is_a?(ActiveRecord::Base) and followee.is_a?(ActiveRecord::Base)
+      end
+
+      def validate_follow_request_relationships
+        errors.add :follower, :invalid unless follower.follow_requester?
+        errors.add :followee, :invalid unless followee.follow_requestee?
+        errors.add :followee, :rejected if follower.follow_requester? and not follower.valid_follow_request_for?(followee)
+      end
+    end
+  end
+end

data/lib/interest/follow_requestable/follow_requestee.rb

@@ -0,0 +1,45 @@
+require "active_support"
+require "interest/utils"
+require "interest/definition"
+
+module Interest
+  module FollowRequestable
+    module FollowRequestee
+      extend ActiveSupport::Concern
+
+      include Interest::Definition.instance_methods_for(:follow_requestee, :follow_requester)
+
+      def requires_request_to_follow?(requester)
+        raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+      end
+
+      def has_been_requested_to_follow?(requester)
+        follow_requestee_collection_for(requester).include? requester
+      end
+
+      module ClassMethods
+        include Interest::Definition.class_methods_for(:follow_requestee, :follow_requester)
+
+        def define_follow_requestee_association_methods
+          has_many :incoming_follow_requests,
+            -> { where(followings: {status: "pending"}).uniq },
+            as:          :followee,
+            dependent:   :destroy,
+            class_name:  "Following" do
+              include Interest::Definition.collection_methods_for(:follower)
+            end
+        end
+
+        def define_follow_requestee_association_method(source_type)
+          association_method_name = follow_requestee_association_method_name_for source_type
+
+          has_many association_method_name,
+            -> { uniq },
+            through:     :incoming_follow_requests,
+            source:      :follower,
+            source_type: source_type
+        end
+      end
+    end
+  end
+end

data/lib/interest/follow_requestable/follow_requester.rb

@@ -0,0 +1,92 @@
+require "active_support"
+require "active_record"
+require "interest/utils"
+require "interest/definition"
+require "interest/follow_requestable/exceptions"
+require "interest/follow_requestable/follow_requestee"
+
+module Interest
+  module FollowRequestable
+    module FollowRequester
+      extend ActiveSupport::Concern
+
+      include Interest::Definition.instance_methods_for(:follow_requester, :follow_requestee)
+
+      def required_request_to_follow?(requestee)
+        requestee.follow_requestee? and requestee.requires_request_to_follow?(self)
+      end
+
+      def request_to_follow(requestee, raise_record_invalid = false)
+        outgoing_follow_requests.create!(followee: requestee)
+      rescue ActiveRecord::RecordInvalid => exception
+        raise_record_invalid ? (raise exception) : nil
+      rescue ActiveRecord::RecordNotUnique
+        outgoing_follow_requests.find_by(followee: requestee)
+      end
+
+      def request_to_follow!(requestee)
+        request_to_follow(requestee, true)
+      rescue ActiveRecord::RecordInvalid => exception
+        raise Interest::FollowRequestable::Rejected.new(exception)
+      end
+
+      def cancel_request_to_follow(requestee)
+        follow_requester_collection_for(requestee).delete requestee
+      end
+
+      def has_requested_to_follow?(requestee)
+        follow_requester_collection_for(requestee).include? requestee
+      end
+
+      def valid_follow_request_for?(requestee)
+        not (self == requestee or not follow_requestable?(requestee) or (follower? and following? requestee))
+      end
+
+      def follow_or_request_to_follow!(other)
+        if required_request_to_follow? other
+          returned = request_to_follow! other
+          which    = :request_to_follow
+        else
+          returned = follow! other
+          which    = :follow
+        end
+
+        FollowOrRequestToFollow.new which, returned, other
+      end
+
+      class FollowOrRequestToFollow < Struct.new(:which, :returned, :target)
+        def followed?
+          which == :follow
+        end
+
+        def requested_to_follow?
+          which == :request_to_follow
+        end
+      end
+
+      module ClassMethods
+        include Interest::Definition.class_methods_for(:follow_requester, :follow_requestee)
+
+        def define_follow_requester_association_methods
+          has_many :outgoing_follow_requests,
+            -> { where(followings: {status: "pending"}).uniq },
+            as:          :follower,
+            dependent:   :destroy,
+            class_name:  "Following" do
+              include Interest::Definition.collection_methods_for(:followee)
+            end
+        end
+
+        def define_follow_requester_association_method(source_type)
+          association_method_name = follow_requester_association_method_name_for source_type
+
+          has_many association_method_name,
+            -> { uniq },
+            through:     :outgoing_follow_requests,
+            source:      :followee,
+            source_type: source_type
+        end
+      end
+    end
+  end
+end

data/lib/interest/followable.rb

@@ -0,0 +1,25 @@
+require "interest/followable/exceptions"
+require "interest/followable/following"
+require "interest/followable/follower"
+require "interest/followable/followee"
+
+module Interest
+  module Followable
+    module Extension
+      def acts_as_follower
+        include Follower
+        define_follower_association_methods
+      end
+
+      def acts_as_followee
+        include Followee
+        define_followee_association_methods
+      end
+
+      def acts_as_followable
+        acts_as_follower
+        acts_as_followee
+      end
+    end
+  end
+end

data/lib/interest/followable/exceptions.rb

@@ -0,0 +1,12 @@
+require "interest/exception"
+
+module Interest
+  module Followable
+    module Exceptions
+      class Exception < Interest::Exception; end
+      class Rejected < Exception; end
+    end
+
+    include Exceptions
+  end
+end

data/lib/interest/followable/followee.rb

@@ -0,0 +1,41 @@
+require "active_support"
+require "interest/utils"
+require "interest/definition"
+
+module Interest
+  module Followable
+    module Followee
+      extend ActiveSupport::Concern
+
+      include Interest::Definition.instance_methods_for(:followee, :follower)
+
+      def followed_by?(follower)
+        followee_collection_for(follower).include? follower
+      end
+
+      module ClassMethods
+        include Interest::Definition.class_methods_for(:followee, :follower)
+
+        def define_followee_association_methods
+          has_many :follower_relationships,
+            -> { where(Interest.following_class.table_name.to_sym => {status: "accepted"}).uniq },
+            as:          :followee,
+            dependent:   :destroy,
+            class_name:  Interest.following_class_name do
+              include Interest::Definition.collection_methods_for(:follower)
+            end
+        end
+
+        def define_followee_association_method(source_type)
+          association_method_name = followee_association_method_name_for source_type
+
+          has_many association_method_name,
+            -> { uniq },
+            through:     :follower_relationships,
+            source:      :follower,
+            source_type: source_type
+        end
+      end
+    end
+  end
+end

data/lib/interest/followable/follower.rb

@@ -0,0 +1,68 @@
+require "active_support"
+require "active_record"
+require "interest/utils"
+require "interest/definition"
+require "interest/followable/exceptions"
+require "interest/followable/followee"
+
+module Interest
+  module Followable
+    module Follower
+      extend ActiveSupport::Concern
+
+      include Interest::Definition.instance_methods_for(:follower, :following)
+
+      def following?(followee)
+        follower_collection_for(followee).include? followee
+      end
+
+      def follow(followee, raise_record_invalid = false)
+        following_relationships.create!(followee: followee)
+      rescue ActiveRecord::RecordInvalid => exception
+        raise_record_invalid ? (raise exception) : nil
+      rescue ActiveRecord::RecordNotUnique
+        if follow_requester? and followee.follow_requestee?
+          outgoing_follow_requests.find_by(followee: followee).try(:accept!)
+        end or following_relationships.find_by(followee: followee)
+      end
+
+      def follow!(followee)
+        follow(followee, true)
+      rescue ActiveRecord::RecordInvalid => exception
+        raise Interest::Followable::Rejected.new(exception)
+      end
+
+      def unfollow(followee)
+        follower_collection_for(followee).delete followee
+      end
+
+      def valid_following_for?(followee)
+        not (followee == self or not followable?(followee))
+      end
+
+      module ClassMethods
+        include Interest::Definition.class_methods_for(:follower, :following)
+
+        def define_follower_association_methods
+          has_many :following_relationships,
+            -> { where(Interest.following_class.table_name.to_sym => {status: "accepted"}).uniq },
+            as:          :follower,
+            dependent:   :destroy,
+            class_name:  Interest.following_class_name do
+              include Interest::Definition.collection_methods_for(:followee)
+            end
+        end
+
+        def define_follower_association_method(source_type)
+          association_method_name = follower_association_method_name_for source_type
+
+          has_many association_method_name,
+            -> { uniq },
+            through:     :following_relationships,
+            source:      :followee,
+            source_type: source_type
+        end
+      end
+    end
+  end
+end

data/lib/interest/followable/following.rb

@@ -0,0 +1,62 @@
+require "active_support"
+
+module Interest
+  module Followable
+    module Following
+      extend ActiveSupport::Concern
+
+      included do
+        belongs_to :follower, polymorphic: true
+        belongs_to :followee, polymorphic: true
+
+        validates :follower, presence: true
+        validates :followee, presence: true
+        validates :status, presence: true, inclusion: {in: %w(pending accepted)}
+
+        validate :validate_following_relationships, if: :should_validate_following_relationships?
+
+        scope :accepted, -> { where(status: "accepted") }
+        scope :pending, -> { where(status: "pending") }
+
+        scope :between, ->(a, b) {
+          a_to_b = where(follower: a, followee: b).where_values.reduce(:and)
+          b_to_a = where(follower: b, followee: a).where_values.reduce(:and)
+
+          where a_to_b.or(b_to_a)
+        }
+      end
+
+      def accepted?
+        status == "accepted"
+      end
+
+      def pending?
+        status == "pending"
+      end
+
+      def mutual
+        followee.follow(follower)
+      end
+
+      def mutual!
+        followee.follow!(follower)
+      end
+
+      def should_validate_following_relationships?
+        accepted? and follower.is_a?(ActiveRecord::Base) and followee.is_a?(ActiveRecord::Base)
+      end
+
+      def validate_following_relationships
+        errors.add :follower, :invalid unless follower.follower?
+        errors.add :followee, :invalid unless followee.followee?
+        errors.add :followee, :rejected if follower.follower? and not follower.valid_following_for?(followee)
+      end
+
+      module ClassMethods
+        def destroy_relationships_between(a, b)
+          between(a, b).destroy_all
+        end
+      end
+    end
+  end
+end

data/lib/interest/utils.rb

@@ -0,0 +1,29 @@
+require "active_support"
+require "active_support/core_ext/string/inflections"
+require "active_record"
+
+module Interest
+  module Utils
+    class << self
+      def symbolic_name_of(object)
+        if object.is_a?(ActiveRecord::Base)
+          object.class.name
+        elsif object.is_a?(Class) and object < ActiveRecord::Base
+          object.name
+        else
+          object.to_s
+        end.underscore.pluralize
+      end
+
+      def source_type_of(object)
+        if object.is_a?(ActiveRecord::Base)
+          object.class.name
+        elsif object.is_a?(Class) and object < ActiveRecord::Base
+          object.name
+        else
+          object.to_s.classify
+        end
+      end
+    end
+  end
+end

data/lib/interest/version.rb

@@ -0,0 +1,3 @@
+module Interest
+  VERSION = "0.0.1"
+end

data/spec/blockable_spec.rb

@@ -0,0 +1,127 @@
+require "spec_helper"
+
+describe "Blockable" do
+  it "should block other" do
+    user       = BlockableUser.create!
+    other_user = BlockableUser.create!
+
+    user.block(other_user)
+
+    expect(user).to be_blocking(other_user)
+  end
+
+  it "should not block self" do
+    user = BlockableUser.create!
+
+    user.block(user)
+
+    expect(user).not_to be_blocking(user)
+  end
+
+  it "should not duplicate blockee" do
+    user       = BlockableUser.create!
+    other_user = BlockableUser.create!
+
+    user.block(other_user)
+    user.block(other_user)
+
+    expect(user.blocking_relationships.count).to eq(1)
+    expect(user.blocking_blockable_users.count).to eq(1)
+  end
+
+  it "should be a Blocking" do
+    user       = BlockableUser.create!
+    other_user = BlockableUser.create!
+
+    user.block(other_user)
+
+    expect(user.blocking_relationships.of(BlockableUser)).to be_present.and all be_a Blocking
+  end
+
+  it "should be a model is blocked" do
+    user       = BlockableUser.create!
+    other_user = BlockableUser.create!
+    collection = Collection.create!
+
+    user.block(other_user)
+    user.block(collection)
+
+    expect(user.blocking_blockable_users).to be_present.and all be_a BlockableUser
+  end
+
+  it "should not block self and raise exception" do
+    user = BlockableUser.create!
+
+    expect { user.block!(user) }.to raise_error(Interest::Blockable::Rejected)
+  end
+
+  it "should be followed by other user if user is not blocking one" do
+    user       = FollowableAndBlockableUser.create!
+    other_user = FollowableAndBlockableUser.create!
+
+    expect { other_user.follow!(user) }.not_to raise_error
+  end
+
+  it "should not be followed by other user if user is blocking one" do
+    user       = FollowableAndBlockableUser.create!
+    other_user = FollowableAndBlockableUser.create!
+
+    user.block(other_user)
+
+    expect { other_user.follow!(user) }.to raise_error(Interest::Followable::Rejected)
+  end
+
+  it "should destroy their followship when either follower or followee blocks other" do
+    user       = FollowableAndBlockableUser.create!
+    other_user = FollowableAndBlockableUser.create!
+
+    user.follow(other_user)
+    other_user.follow(user)
+
+    user.block(other_user)
+
+    expect(user).not_to be_following(other_user)
+    expect(other_user).not_to be_following(user)
+  end
+
+  it "should destroy their follow requests when either requester or requestee blocks other" do
+    user       = FollowRequestableAndBlockableUser.create!
+    other_user = FollowRequestableAndBlockableUser.create!
+
+    user.request_to_follow(other_user)
+    other_user.request_to_follow(user)
+
+    user.block(other_user)
+
+    expect(user).not_to have_requested_to_follow(other_user)
+    expect(other_user).not_to have_been_requested_to_follow(user)
+  end
+
+  it "should find outgoing blocking of specified type" do
+    user        = BlockableUser.create!
+    other_user1 = BlockableUser.create!
+    other_user2 = BlockableUser.create!
+    collection  = Collection.create!
+
+    user.block(other_user1)
+    user.block(other_user2)
+    user.block(collection)
+
+    expect(user.blocking_relationships.of(BlockableUser)).to have_exactly(2).items
+    expect(user.blocking_relationships.of(Collection)).to have_exactly(1).items
+  end
+
+  it "should find incoming blocking of specified type" do
+    user        = BlockableUser.create!
+    other_user1 = BlockableUser.create!
+    other_user2 = BlockableUser.create!
+    collection  = Collection.create!
+
+    other_user1.block(user)
+    other_user2.block(user)
+    collection.block(user)
+
+    expect(user.blocker_relationships.of(BlockableUser)).to have_exactly(2).items
+    expect(user.blocker_relationships.of(Collection)).to have_exactly(1).items
+  end
+end