socialization-cassandra 0.0.1.pre.alpha

data/lib/socialization/stores/mixins/like.rb

@@ -0,0 +1,40 @@
+module Socialization
+  module Stores
+    module Mixins
+      module Like
+
+      public
+        def touch(what = nil)
+          if what.nil?
+            @touch || false
+          else
+            raise Socialization::ArgumentError unless [:all, :liker, :likeable, false, nil].include?(what)
+            @touch = what
+          end
+        end
+
+        def after_like(method)
+          raise Socialization::ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_create_hook = method
+        end
+
+        def after_unlike(method)
+          raise Socialization::ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_destroy_hook = method
+        end
+
+      protected
+        def call_after_create_hooks(liker, likeable)
+          self.send(@after_create_hook, liker, likeable) if @after_create_hook
+          touch_dependents(liker, likeable)
+        end
+
+        def call_after_destroy_hooks(liker, likeable)
+          self.send(@after_destroy_hook, liker, likeable) if @after_destroy_hook
+          touch_dependents(liker, likeable)
+        end
+
+      end
+    end
+  end
+end

data/lib/socialization/stores/mixins/mention.rb

@@ -0,0 +1,40 @@
+module Socialization
+  module Stores
+    module Mixins
+      module Mention
+
+      public
+        def touch(what = nil)
+          if what.nil?
+            @touch || false
+          else
+            raise Socialization::ArgumentError unless [:all, :mentioner, :mentionable, false, nil].include?(what)
+            @touch = what
+          end
+        end
+
+        def after_mention(method)
+          raise Socialization::ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_create_hook = method
+        end
+
+        def after_unmention(method)
+          raise Socialization::ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_destroy_hook = method
+        end
+
+      protected
+        def call_after_create_hooks(mentioner, mentionable)
+          self.send(@after_create_hook, mentioner, mentionable) if @after_create_hook
+          touch_dependents(mentioner, mentionable)
+        end
+
+        def call_after_destroy_hooks(mentioner, mentionable)
+          self.send(@after_destroy_hook, mentioner, mentionable) if @after_destroy_hook
+          touch_dependents(mentioner, mentionable)
+        end
+
+      end
+    end
+  end
+end

data/lib/socialization/version.rb

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

data/lib/socialization/victims/commentable.rb

@@ -0,0 +1,51 @@
+module ActiveRecord
+  class Base
+    def is_commentable?
+      false
+    end
+    alias commentable? is_commentable?
+  end
+end
+
+module Socialization
+  module Commentable
+    extend ActiveSupport::Concern
+
+    included do
+      after_destroy { Socialization.comment_model.remove_commenters(self) }
+
+      # Specifies if self can be commented.
+      #
+      # @return [Boolean]
+      def is_commentable?
+        true
+      end
+      alias commentable? is_commentable?
+
+      # Specifies if self is commented by a {commenter} object.
+      #
+      # @return [Boolean]
+      def commented_by?(commenter)
+        raise Socialization::ArgumentError, "#{commenter} is not commenter!"  unless commenter.respond_to?(:is_commenter?) && commenter.is_commenter?
+        Socialization.comment_model.comments?(commenter, self)
+      end
+
+      # Returns an array of {commenter}s commenting self.
+      #
+      # @param [Class] klass the {commenter} class to be included. e.g. `User`
+      # @return [Array<commenter, Numeric>] An array of commenter objects or IDs
+      def commenters(klass, opts = {})
+        Socialization.comment_model.commenters(self, klass, opts)
+      end
+
+      # Returns a scope of the {commenter}s commenting self.
+      #
+      # @param [Class] klass the {commenter} class to be included in the scope. e.g. `User`
+      # @return ActiveRecord::Relation
+      def commenters_relation(klass, opts = {})
+        Socialization.comment_model.commenters_relation(self, klass, opts)
+      end
+
+    end
+  end
+end

data/lib/socialization/victims/followable.rb

@@ -0,0 +1,50 @@
+module ActiveRecord
+  class Base
+    def is_followable?
+      false
+    end
+    alias followable? is_followable?
+  end
+end
+
+module Socialization
+  module Followable
+    extend ActiveSupport::Concern
+
+    included do
+      after_destroy { Socialization.follow_model.remove_followers(self) }
+
+      # Specifies if self can be followed.
+      #
+      # @return [Boolean]
+      def is_followable?
+        true
+      end
+      alias followable? is_followable?
+
+      # Specifies if self is followed by a {Follower} object.
+      #
+      # @return [Boolean]
+      def followed_by?(follower)
+        raise Socialization::ArgumentError, "#{follower} is not follower!"  unless follower.respond_to?(:is_follower?) && follower.is_follower?
+        Socialization.follow_model.follows?(follower, self)
+      end
+
+      # Returns an array of {Follower}s following self.
+      #
+      # @param [Class] klass the {Follower} class to be included. e.g. `User`
+      # @return [Array<Follower, Numeric>] An array of Follower objects or IDs
+      def followers(klass, opts = {})
+        Socialization.follow_model.followers(self, klass, opts)
+      end
+
+      # Returns a scope of the {Follower}s following self.
+      #
+      # @param [Class] klass the {Follower} class to be included in the scope. e.g. `User`
+      # @return ActiveRecord::Relation
+      def followers_relation(klass, opts = {})
+        Socialization.follow_model.followers_relation(self, klass, opts)
+      end
+    end
+  end
+end

data/lib/socialization/victims/likeable.rb

@@ -0,0 +1,51 @@
+module ActiveRecord
+  class Base
+    def is_likeable?
+      false
+    end
+    alias likeable? is_likeable?
+  end
+end
+
+module Socialization
+  module Likeable
+    extend ActiveSupport::Concern
+
+    included do
+      after_destroy { Socialization.like_model.remove_likers(self) }
+
+      # Specifies if self can be liked.
+      #
+      # @return [Boolean]
+      def is_likeable?
+        true
+      end
+      alias likeable? is_likeable?
+
+      # Specifies if self is liked by a {Liker} object.
+      #
+      # @return [Boolean]
+      def liked_by?(liker)
+        raise Socialization::ArgumentError, "#{liker} is not liker!"  unless liker.respond_to?(:is_liker?) && liker.is_liker?
+        Socialization.like_model.likes?(liker, self)
+      end
+
+      # Returns an array of {Liker}s liking self.
+      #
+      # @param [Class] klass the {Liker} class to be included. e.g. `User`
+      # @return [Array<Liker, Numeric>] An array of Liker objects or IDs
+      def likers(klass, opts = {})
+        Socialization.like_model.likers(self, klass, opts)
+      end
+
+      # Returns a scope of the {Liker}s liking self.
+      #
+      # @param [Class] klass the {Liker} class to be included in the scope. e.g. `User`
+      # @return ActiveRecord::Relation
+      def likers_relation(klass, opts = {})
+        Socialization.like_model.likers_relation(self, klass, opts)
+      end
+
+    end
+  end
+end

data/lib/socialization/victims/shareable.rb

@@ -0,0 +1,51 @@
+module ActiveRecord
+  class Base
+    def is_shareable?
+      false
+    end
+    alias shareable? is_shareable?
+  end
+end
+
+module Socialization
+  module Shareable
+    extend ActiveSupport::Concern
+
+    included do
+      after_destroy { Socialization.share_model.remove_sharers(self) }
+
+      # Specifies if self can be shared.
+      #
+      # @return [Boolean]
+      def is_shareable?
+        true
+      end
+      alias shareable? is_shareable?
+
+      # Specifies if self is shared by a {sharer} object.
+      #
+      # @return [Boolean]
+      def shared_by?(sharer)
+        raise Socialization::ArgumentError, "#{sharer} is not sharer!"  unless sharer.respond_to?(:is_sharer?) && sharer.is_sharer?
+        Socialization.share_model.shares?(sharer, self)
+      end
+
+      # Returns an array of {sharer}s shareing self.
+      #
+      # @param [Class] klass the {sharer} class to be included. e.g. `User`
+      # @return [Array<sharer, Numeric>] An array of sharer objects or IDs
+      def sharers(klass, opts = {})
+        Socialization.share_model.sharers(self, klass, opts)
+      end
+
+      # Returns a scope of the {sharer}s sharing self.
+      #
+      # @param [Class] klass the {sharer} class to be included in the scope. e.g. `User`
+      # @return ActiveRecord::Relation
+      def sharers_relation(klass, opts = {})
+        Socialization.share_model.sharers_relation(self, klass, opts)
+      end
+
+    end
+  end
+end

data/lib/socialization.rb

@@ -0,0 +1,17 @@
+%w(
+  lib/*.rb
+  stores/mixins/base.rb
+  stores/mixins/**/*.rb
+  stores/cassandra/mixins/base.rb
+  stores/cassandra/mixins/**/*.rb
+  stores/cassandra/base.rb
+  stores/cassandra/**/*.rb
+  actors/**/*.rb
+  victims/**/*.rb
+  helpers/**/*.rb
+  config/**/*.rb
+).each do |path|
+  Dir["#{File.dirname(__FILE__)}/socialization/#{path}"].each { |f| require(f) }
+end
+
+ActiveRecord::Base.send :include, Socialization::ActsAsHelpers

data/socialization-cassandra.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "socialization/version"
+
+Gem::Specification.new do |s|
+  s.name = "socialization-cassandra"
+  s.version = Socialization::VERSION
+  s.authors = ["Amrit Singh"]
+  s.email = "amrit0403@gmail.com"
+  s.homepage = "https://github.com/amritsingh/socialization-cassandra"
+  s.summary = "Easily socialize your app with Likes and Follows"
+  s.description = "Socialization allows any model to Follow and/or Like any other model. This is accomplished through a double polymorphic relationship on the Follow and Like models. But you don't need to know that since all the complexity is hidden from you."
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.has_rdoc = false
+
+  s.add_runtime_dependency "activerecord"
+  s.add_runtime_dependency "cassandra-driver"
+
+  s.add_development_dependency "logger"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "shoulda"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "minitest", "~> 4.0"
+end

data/test/actors/follower_test.rb

@@ -0,0 +1,129 @@
+require File.expand_path(File.dirname(__FILE__))+'/../test_helper'
+
+class FollowerTest < TestCase
+  include Assertions
+  context "Follower" do
+    setup do
+      # @follower = ImAFollower.new
+      @follower = ImAFollower.create
+      @followable = ImAFollowable.create
+    end
+
+    context "#is_follower?" do
+      should "return true" do
+        assert_true @follower.is_follower?
+      end
+    end
+
+    context "#follower?" do
+      should "return true" do
+        assert_true @follower.follower?
+      end
+    end
+
+    context "#follow!" do
+      should "not accept non-followables" do
+        assert_raises(Socialization::ArgumentError) { @follower.follow!(:foo) }
+      end
+
+      should "call $Follow.follow!" do
+        assert_send([$Follow, :follow!, *[@follower, @followable]])
+        @follower.follow!(@followable)
+      end
+    end
+
+    context "#unfollow!" do
+      should "not accept non-followables" do
+        assert_raises(Socialization::ArgumentError) { @follower.unfollow!(:foo) }
+      end
+
+      should "call $Follow.follow!" do
+        Minitest::Mock.new.expect(:check, true) do
+          $Follow.unfollows!(@follower, @followable)
+        end
+        @follower.unfollow!(@followable)
+      end
+    end
+
+    context "#toggle_follow!" do
+      should "not accept non-followables" do
+        assert_raises(Socialization::ArgumentError) { @follower.unfollow!(:foo) }
+      end
+
+      should "unfollow when following" do
+        @follower.follow!(@followable)
+        Minitest::Mock.new.expect(:check, true) do
+          @follower.follows?(@followable)
+        end
+        # @follower.expect :follows?, true, *[@followable]
+        # assert_send([@follower, :follows?, *[@followable]])
+        assert_send([@follower, :unfollow!, *[@followable]])
+        @follower.toggle_follow!(@followable)
+      end
+
+      should "follow when not following" do
+        Minitest::Mock.new.expect(:check, false) do
+          @follower.follows?(@followable)
+        end
+        # !assert_send([@follower, :follows?, *[@followable]])
+        # assert_send([@follower, :follows?, *[@followable]])
+        @follower.toggle_follow!(@followable)
+      end
+    end
+
+    context "#follows?" do
+      should "not accept non-followables" do
+        assert_raises(Socialization::ArgumentError) { @follower.unfollow!(:foo) }
+      end
+
+      should "call $Follow.follows?" do
+        Minitest::Mock.new.expect(:check, false) do
+          $Follow.follows?(@follower, @followable)
+        end
+        # assert_send([$Follow, :follows?, *[@follower, @followable]])
+        @follower.follows?(@followable)
+      end
+    end
+
+    context "#followables" do
+      should "call $Follow.followables" do
+        assert_send([$Follow, :followables, *[@follower, @followable.class, { :foo => :bar  }]])
+        @follower.followables(@followable.class, { :foo => :bar })
+      end
+    end
+
+    context "#followees" do
+      should "call $Follow.followables" do
+        assert_send([$Follow, :followables, *[@follower, @followable.class, { :foo => :bar  }]])
+        @follower.followees(@followable.class, { :foo => :bar })
+      end
+    end
+
+    context "#followables_relation" do
+      should "call $Follow.followables_relation" do
+        assert_send([$Follow, :followables_relation, *[@follower, @followable.class, { :foo => :bar  }]])
+        @follower.followables_relation(@followable.class, { :foo => :bar })
+      end
+    end
+
+    context "#followees_relation" do
+      should "call $Follow.followables_relation" do
+        assert_send([$Follow, :followables_relation, *[@follower, @followable.class, { :foo => :bar  }]])
+        @follower.followees_relation(@followable.class, { :foo => :bar })
+      end
+    end
+
+    context "deleting a follower" do
+      setup do
+        @follower = ImAFollower.create
+        @follower.follow!(@followable)
+      end
+
+      should "remove follow relationships" do
+        assert_send([Socialization.follow_model, :remove_followables, *[@follower]])
+        @follower.destroy
+      end
+    end
+
+  end
+end

data/test/actors/liker_test.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__))+'/../test_helper'
+
+class LikerTest < TestCase
+  include Assertions
+  context "Liker" do
+    setup do
+      # @liker = ImALiker.new
+      @liker = ImALiker.create
+      @likeable = ImALikeable.create
+    end
+
+    context "#is_liker?" do
+      should "return true" do
+        assert_true @liker.is_liker?
+      end
+    end
+
+    context "#liker?" do
+      should "return true" do
+        assert_true @liker.liker?
+      end
+    end
+
+    context "#like!" do
+      should "not accept non-likeables" do
+        assert_raises(Socialization::ArgumentError) { @liker.like!(:foo) }
+      end
+
+      should "call $Like.like!" do
+        assert_send([$Like, :like!, *[@liker, @likeable]])
+        @liker.like!(@likeable)
+      end
+    end
+
+    context "#unlike!" do
+      should "not accept non-likeables" do
+        assert_raises(Socialization::ArgumentError) { @liker.unlike!(:foo) }
+      end
+
+      should "call $Like.like!" do
+        Minitest::Mock.new.expect(:check, false) do
+          $Like.unlike!(@liker, @likeables)
+        end
+        @liker.unlike!(@likeable)
+      end
+    end
+
+    context "#toggle_like!" do
+      should "not accept non-likeables" do
+        assert_raises(Socialization::ArgumentError) { @liker.unlike!(:foo) }
+      end
+
+      should "unlike when likeing" do
+        @liker.like!(@likeable)
+        Minitest::Mock.new.expect(:check, true) do
+          @liker.likes?(@likeables)
+        end
+        Minitest::Mock.new.expect(:check, true) do
+          @liker.unlike!(@likeables)
+        end
+        # assert_send([@liker, :unlike!, *[@likeable]])
+        @liker.toggle_like!(@likeable)
+      end
+
+      should "like when not likeing" do
+        Minitest::Mock.new.expect(:check, false) do
+          @liker.likes?(@likeables)
+        end
+        assert_send([@liker, :like!, *[@likeable]])
+        @liker.toggle_like!(@likeable)
+      end
+    end
+
+    context "#likes?" do
+      should "not accept non-likeables" do
+        assert_raises(Socialization::ArgumentError) { @liker.unlike!(:foo) }
+      end
+
+      should "call $Like.likes?" do
+        Minitest::Mock.new.expect(:check, false) do
+          $Like.likes?(@liker, @likeables)
+        end
+        # assert_send([$Like, :likes?, *[@liker, @likeable]])
+        @liker.likes?(@likeable)
+      end
+    end
+
+    context "#likeables" do
+      should "call $Like.likeables" do
+        assert_send([$Like, :likeables, *[@liker, @likeable.class, { :foo => :bar }]])
+        @liker.likeables(@likeable.class, { :foo => :bar })
+      end
+    end
+
+    context "#likees" do
+      should "call $Like.likeables" do
+        assert_send([$Like, :likeables, *[@liker, @likeable.class, { :foo => :bar }]])
+        @liker.likees(@likeable.class, { :foo => :bar })
+      end
+    end
+
+    context "#likeables_relation" do
+      should "call $Follow.likeables_relation" do
+        assert_send([$Like, :likeables_relation, *[@liker, @likeable.class, { :foo => :bar }]])
+        @liker.likeables_relation(@likeable.class, { :foo => :bar })
+      end
+    end
+
+    context "#likees_relation" do
+      should "call $Follow.likeables_relation" do
+        assert_send([$Like, :likeables_relation, *[@liker, @likeable.class, { :foo => :bar }]])
+        @liker.likees_relation(@likeable.class, { :foo => :bar })
+      end
+    end
+
+    should "remove like relationships" do
+      assert_send([Socialization.like_model, :remove_likeables, *[@liker]])
+      @liker.destroy
+    end
+  end
+end