socialization-cassandra 0.0.1.pre.alpha

data/lib/socialization/actors/mentioner.rb

@@ -0,0 +1,79 @@
+module Socialization
+  module Mentioner
+    extend ActiveSupport::Concern
+
+    included do
+      after_destroy { Socialization.mention_model.remove_mentionables(self) }
+
+      # Specifies if self can mention {Mentionable} objects.
+      #
+      # @return [Boolean]
+      def is_mentioner?
+        true
+      end
+      alias mentioner? is_mentioner?
+
+      # Create a new {Mention mention} relationship.
+      #
+      # @param [Mentionable] mentionable the object to be mentioned.
+      # @return [Boolean]
+      def mention!(mentionable)
+        raise Socialization::ArgumentError, "#{mentionable} is not mentionable!"  unless mentionable.respond_to?(:is_mentionable?) && mentionable.is_mentionable?
+        Socialization.mention_model.mention!(self, mentionable)
+      end
+
+      # Delete a {Mention mention} relationship.
+      #
+      # @param [Mentionable] mentionable the object to unmention.
+      # @return [Boolean]
+      def unmention!(mentionable)
+        raise Socialization::ArgumentError, "#{mentionable} is not mentionable!" unless mentionable.respond_to?(:is_mentionable?) && mentionable.is_mentionable?
+        Socialization.mention_model.unmention!(self, mentionable)
+      end
+
+      # Toggles a {Mention mention} relationship.
+      #
+      # @param [Mentionable] mentionable the object to mention/unmention.
+      # @return [Boolean]
+      def toggle_mention!(mentionable)
+        raise Socialization::ArgumentError, "#{mentionable} is not mentionable!" unless mentionable.respond_to?(:is_mentionable?) && mentionable.is_mentionable?
+        if mentions?(mentionable)
+          unmention!(mentionable)
+          false
+        else
+          mention!(mentionable)
+          true
+        end
+      end
+
+      # Specifies if self mentions a {Mentionable} object.
+      #
+      # @param [Mentionable] mentionable the {Mentionable} object to test against.
+      # @return [Boolean]
+      def mentions?(mentionable)
+        raise Socialization::ArgumentError, "#{mentionable} is not mentionable!" unless mentionable.respond_to?(:is_mentionable?) && mentionable.is_mentionable?
+        Socialization.mention_model.mentions?(self, mentionable)
+      end
+
+      # Returns all the mentionables of a certain type that are mentioned by self
+      #
+      # @params [Mentionable] klass the type of {Mentionable} you want
+      # @params [Hash] opts a hash of options
+      # @return [Array<Mentionable, Numeric>] An array of Mentionable objects or IDs
+      def mentionables(klass, opts = {})
+        Socialization.mention_model.mentionables(self, klass, opts)
+      end
+      alias :mentionees :mentionables
+
+      # Returns a relation for all the mentionables of a certain type that are mentioned by self
+      #
+      # @params [Mentionable] klass the type of {Mentionable} you want
+      # @params [Hash] opts a hash of options
+      # @return ActiveRecord::Relation
+      def mentionables_relation(klass, opts = {})
+        Socialization.mention_model.mentionables_relation(self, klass, opts)
+      end
+      alias :mentionees_relation :mentionables_relation
+    end
+  end
+end

data/lib/socialization/actors/sharer.rb

@@ -0,0 +1,79 @@
+module Socialization
+  module Sharer
+    extend ActiveSupport::Concern
+
+    included do
+      after_destroy { Socialization.share_model.remove_shareables(self) }
+
+      # Specifies if self can share {Shareable} objects.
+      #
+      # @return [Boolean]
+      def is_sharer?
+        true
+      end
+      alias sharer? is_sharer?
+
+      # Create a new {Share share} relationship.
+      #
+      # @param [Shareable] shareable the object to be shared.
+      # @return [Boolean]
+      def share!(shareable)
+        raise Socialization::ArgumentError, "#{shareable} is not shareable!"  unless shareable.respond_to?(:is_shareable?) && shareable.is_shareable?
+        Socialization.share_model.share!(self, shareable)
+      end
+
+      # Delete a {Share share} relationship.
+      #
+      # @param [Shareable] shareable the object to unshare.
+      # @return [Boolean]
+      def unshare!(shareable)
+        raise Socialization::ArgumentError, "#{shareable} is not shareable!" unless shareable.respond_to?(:is_shareable?) && shareable.is_shareable?
+        Socialization.share_model.unshare!(self, shareable)
+      end
+
+      # Toggles a {Share share} relationship.
+      #
+      # @param [Shareable] shareable the object to share/unshare.
+      # @return [Boolean]
+      def toggle_share!(shareable)
+        raise Socialization::ArgumentError, "#{shareable} is not shareable!" unless shareable.respond_to?(:is_shareable?) && shareable.is_shareable?
+        if shares?(shareable)
+          unshare!(shareable)
+          false
+        else
+          share!(shareable)
+          true
+        end
+      end
+
+      # Specifies if self shares a {Shareable} object.
+      #
+      # @param [Shareable] shareable the {Shareable} object to test against.
+      # @return [Boolean]
+      def shares?(shareable)
+        raise Socialization::ArgumentError, "#{shareable} is not shareable!" unless shareable.respond_to?(:is_shareable?) && shareable.is_shareable?
+        Socialization.share_model.shares?(self, shareable)
+      end
+
+      # Returns all the shareables of a certain type that are shared by self
+      #
+      # @params [Shareable] klass the type of {Shareable} you want
+      # @params [Hash] opts a hash of options
+      # @return [Array<Shareable, Numeric>] An array of Shareable objects or IDs
+      def shareables(klass, opts = {})
+        Socialization.share_model.shareables(self, klass, opts)
+      end
+      alias :sharees :shareables
+
+      # Returns a relation for all the shareables of a certain type that are shared by self
+      #
+      # @params [Shareable] klass the type of {Shareable} you want
+      # @params [Hash] opts a hash of options
+      # @return ActiveRecord::Relation
+      def shareables_relation(klass, opts = {})
+        Socialization.share_model.shareables_relation(self, klass, opts)
+      end
+      alias :sharees_relation :shareables_relation
+    end
+  end
+end

data/lib/socialization/config/config.rb

@@ -0,0 +1,51 @@
+module Socialization
+  class << self
+    def follow_model
+      if @follow_model
+        @follow_model
+      else
+        ::Follow
+      end
+    end
+
+    def follow_model=(klass)
+      @follow_model = klass
+    end
+
+    def like_model
+      if @like_model
+        @like_model
+      else
+        ::Like
+      end
+    end
+
+    def like_model=(klass)
+      @like_model = klass
+    end
+
+    def comment_model
+      if @comment_model
+        @comment_model
+      else
+        ::Comment
+      end
+    end
+
+    def comment_model=(klass)
+      @comment_model = klass
+    end
+
+    def share_model
+      if @share_model
+        @share_model
+      else
+        ::Share
+      end
+    end
+
+    def share_model=(klass)
+      @share_model = klass
+    end
+  end
+end

data/lib/socialization/helpers/acts_as_helpers.rb

@@ -0,0 +1,49 @@
+require 'active_support/concern'
+
+module Socialization
+  module ActsAsHelpers
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Make the current class a {Socialization::Follower}
+      def acts_as_follower(opts = {})
+        include Socialization::Follower
+      end
+
+      # Make the current class a {Socialization::Followable}
+      def acts_as_followable(opts = {})
+        include Socialization::Followable
+      end
+
+      # Make the current class a {Socialization::Liker}
+      def acts_as_liker(opts = {})
+        include Socialization::Liker
+      end
+
+      # Make the current class a {Socialization::Likeable}
+      def acts_as_likeable(opts = {})
+        include Socialization::Likeable
+      end
+
+      # Make the current class a {Socialization::Commenter}
+      def acts_as_commenter(opts = {})
+        include Socialization::Commenter
+      end
+
+      # Make the current class a {Socialization::Commentable}
+      def acts_as_commentable(opts = {})
+        include Socialization::Commentable
+      end
+
+      # Make the current class a {Socialization::Sharer}
+      def acts_as_sharer(opts = {})
+        include Socialization::Sharer
+      end
+
+      # Make the current class a {Socialization::Shareable}
+      def acts_as_shareable(opts = {})
+        include Socialization::Shareable
+      end
+    end
+  end
+end

data/lib/socialization/helpers/string.rb

@@ -0,0 +1,17 @@
+class String
+
+  def deep_const_get
+    result = nil
+    path = self.clone.split("::")
+
+    path.each do |p|
+      result = (result || Kernel).const_get(p)
+    end
+    result
+  end
+
+  def is_integer?
+    self.to_i.to_s == self
+  end
+
+end

data/lib/socialization/lib/exceptions.rb

@@ -0,0 +1,3 @@
+module Socialization
+  class ArgumentError < ::ArgumentError; end
+end

data/lib/socialization/stores/cassandra/base.rb

@@ -0,0 +1,149 @@
+module Socialization
+  module CassandraStores
+    class Base
+
+      class << self
+      protected
+        def actors(victim, klass, options = {})
+          if options[:pluck]
+            query_result = Socialization.cassandra_session.execute("SELECT actor_type, actor_id from #{backward_table_name} WHERE victim_type = '#{victim.class}' AND victim_id = #{victim.id}")
+            return [] if query_result.blank? || query_result.rows.blank?
+            query_result.rows.collect {|i| i['actor_id'] if i['actor_type'] == klass.to_s}
+          else
+            actors_relation(victim, klass, options).to_a
+          end
+        end
+
+        def actors_cnt(victim, klass, options = {})
+          return 0 if counter_backward_table_name.nil?
+          query_result = Socialization.cassandra_session.execute("SELECT cnt from #{counter_backward_table_name} WHERE victim_type = '#{victim.class}' AND victim_id = #{victim.id}")
+          return 0 if query_result.blank? || query_result.rows.blank?
+          query_result.rows.first['cnt']
+        end
+
+        def actors_relation(victim, klass, options = {})
+          ids = actors(victim, klass, :pluck => :id)
+          klass.where("#{klass.table_name}.id IN (?)", ids)
+        end
+
+        def victims_relation(actor, klass, options = {})
+          ids = victims(actor, klass, :pluck => :id)
+          klass.where("#{klass.table_name}.id IN (?)", ids)
+        end
+
+        def victims(actor, klass, options = {})
+          if options[:pluck]
+            query_result = Socialization.cassandra_session.execute("SELECT victim_type, victim_id from #{forward_table_name} WHERE actor_type='#{actor.class}' AND actor_id=#{actor.id}")
+            return [] if query_result.blank? || query_result.rows.blank?
+            query_result.rows.collect {|i| i['victim_id'] if i['victim_type'] == klass.to_s}
+          else
+            victims_relation(actor, klass, options).to_a
+          end
+        end
+
+        def victims_cnt(actor, klass, options = {})
+          return 0 if counter_forward_table_name.nil?
+          query_result = Socialization.cassandra_session.execute("SELECT cnt from #{counter_forward_table_name} WHERE actor_type = '#{actor.class}' AND actor_id = #{actor.id}")
+          return 0 if query_result.blank? || query_result.rows.blank?
+          query_result.rows.first['cnt']
+        end
+
+        def relation!(actor, victim, options = {})
+          unless options[:skip_check] || relation?(actor, victim)
+            add_new_entry(actor, victim, {})
+            call_after_create_hooks(actor, victim)
+            true
+          else
+            false
+          end
+        end
+
+        def unrelation!(actor, victim, options = {})
+          if options[:skip_check] || relation?(actor, victim)
+            delete_entry(actor, victim, {})
+            call_after_destroy_hooks(actor, victim)
+            true
+          else
+            false
+          end
+        end
+
+        def relation?(actor, victim)
+          if backward_table_name
+            query_result = Socialization.cassandra_session.execute("SELECT * FROM #{backward_table_name} WHERE victim_type = '#{victim.class}' AND victim_id = #{victim.id} AND actor_type = '#{actor.class}' AND actor_id = #{actor.id} ALLOW FILTERING")
+            !query_result.rows.to_a.empty?
+          else
+            false
+          end
+        end
+
+        def remove_actor_relations(victim)
+          query_result = Socialization.cassandra_session.execute("SELECT * FROM #{backward_table_name} WHERE victim_type='#{victim.class}' AND victim_id=#{victim.id}")
+          if query_result.present? && query_result.rows.present?
+            query_result.rows.to_a.each do |i|
+              delete_entry_from_forward_table_name(i['actor_type'], i['actor_id'], victim.class, victim.id)
+              Socialization.cassandra_session.execute("DELETE FROM #{backward_table_name} WHERE victim_type='#{victim.class}' AND victim_id=#{victim.id} AND created_at=#{i["created_at"]}")
+            end
+          end
+          # puts "DELETE FROM #{backward_table_name} WHERE victim_type=#{victim.class} AND victim_id=#{victim.id}"
+          # Socialization.cassandra_session.execute("DELETE FROM #{backward_table_name} WHERE victim_type=#{victim.class} AND victim_id=#{victim.id}")
+          true
+        end
+
+        def remove_victim_relations(actor)
+          query_result = Socialization.cassandra_session.execute("SELECT * FROM #{forward_table_name} WHERE actor_type='#{actor.class}' AND actor_id=#{actor.id}")
+          if query_result.present? && query_result.rows.present?
+            query_result.rows.to_a.each do |i|
+              delete_entry_from_backward_table_name(actor.class, actor.id, i['victim_type'], i['victim_id'])
+              Socialization.cassandra_session.execute("DELETE FROM #{forward_table_name} WHERE actor_type='#{actor.class}' AND actor_id=#{actor.id} AND created_at=#{i["created_at"]}")
+            end
+          end
+          # Socialization.cassandra_session.execute("DELETE FROM #{forward_table_name} WHERE actor_type='#{actor.class}' AND actor_id=#{actor.id}")
+          true
+        end
+
+
+      private
+
+        def add_new_entry(actor, victim, options={})
+          [forward_table_name, backward_table_name].uniq.each do |table_name|
+            query_columns = "actor_type, actor_id, victim_type, victim_id, created_at"
+            query_values = "'#{actor.class}', #{actor.id}, '#{victim.class}', #{victim.id}, #{(Time.now.to_f * 100000).to_i}"
+            if options[:text]
+              query_columns += ", text"
+              query_values += ", '#{options[:text]}'"
+            end
+            if options[:networks] && options[:networks].is_a?(Array)
+              query_columns += ", networks"
+              query_values += ", #{options[:networks].to_s.gsub('[', '{').gsub(']', '}')}"
+            end
+            Socialization.cassandra_session.execute("INSERT INTO #{table_name} (#{query_columns}) VALUES (#{query_values})")
+          end
+          Socialization.cassandra_session.execute("UPDATE #{counter_forward_table_name} SET cnt = cnt + 1 WHERE actor_type = '#{actor.class}' AND actor_id = #{actor.id}") if counter_forward_table_name
+          Socialization.cassandra_session.execute("UPDATE #{counter_backward_table_name} SET cnt = cnt + 1 WHERE victim_type = '#{victim.class}' AND victim_id = #{victim.id}") if counter_backward_table_name
+        end
+
+        def delete_entry_from_forward_table_name(actor_type, actor_id, victim_type, victim_id)
+          row = Socialization.cassandra_session.execute("SELECT * FROM #{forward_table_name} WHERE actor_type='#{actor_type}' AND actor_id=#{actor_id} AND victim_type='#{victim_type}' AND victim_id=#{victim_id} ALLOW FILTERING").rows.first
+          Socialization.cassandra_session.execute("DELETE FROM #{forward_table_name} WHERE actor_type='#{actor_type}' AND actor_id=#{actor_id} AND created_at=#{row["created_at"]}") # if row
+          Socialization.cassandra_session.execute("UPDATE #{counter_forward_table_name} SET cnt = cnt - 1 WHERE actor_type = '#{actor_type}' AND actor_id = #{actor_id}") if counter_forward_table_name
+        end
+
+        def delete_entry_from_backward_table_name(actor_type, actor_id, victim_type, victim_id)
+          row = Socialization.cassandra_session.execute("SELECT * FROM #{backward_table_name} WHERE actor_type='#{actor_type}' AND actor_id=#{actor_id} AND victim_type='#{victim_type}' AND victim_id=#{victim_id} ALLOW FILTERING").rows.to_a.first
+          Socialization.cassandra_session.execute("DELETE FROM #{backward_table_name} WHERE victim_type='#{victim_type}' AND victim_id=#{victim_id} AND created_at=#{row["created_at"]}") if row
+          Socialization.cassandra_session.execute("UPDATE #{counter_forward_table_name} SET cnt = cnt - 1 WHERE actor_type = '#{actor_type}' AND actor_id = #{actor_id}") if counter_forward_table_name
+        end
+
+        def delete_entry(actor, victim, options={})
+          delete_entry_from_forward_table_name(actor.class, actor.id, victim.class, victim.id) if forward_table_name
+          delete_entry_from_backward_table_name(actor.class, actor.id, victim.class, victim.id) if backward_table_name
+          Socialization.cassandra_session.execute("UPDATE #{counter_forward_table_name} SET cnt = cnt - 1 WHERE actor_type = '#{actor.class}' AND actor_id = #{actor.id}") if counter_forward_table_name
+          Socialization.cassandra_session.execute("UPDATE #{counter_backward_table_name} SET cnt = cnt - 1 WHERE victim_type = '#{victim.class}' AND victim_id = #{victim.id}") if counter_backward_table_name
+        end
+
+      end # class << self
+
+    end # Base
+  end # CassandraStores
+end # Socialization

data/lib/socialization/stores/cassandra/comment.rb

@@ -0,0 +1,28 @@
+module Socialization
+  module CassandraStores
+    class Comment< Socialization::CassandraStores::Base
+      extend Socialization::Stores::Mixins::Base
+      extend Socialization::Stores::Mixins::Like
+      extend Socialization::CassandraStores::Mixins::Base
+
+      class << self
+        def forward_table_name
+          nil
+        end
+        def backward_table_name
+          "comments"
+        end
+        def counter_forward_table_name
+          nil
+        end
+        def counter_backward_table_name
+          "comment_counter"
+        end
+        alias_method :comment!, :relation!;                           public :comment!
+        alias_method :remove_comments, :remove_actor_relations;       public :remove_comments
+        alias_method :comments_cnt, :actors_cnt;                      public :comments_cnt
+      end
+
+    end
+  end
+end

data/lib/socialization/stores/cassandra/config.rb

@@ -0,0 +1,29 @@
+module Socialization
+  class << self
+    def cassandra
+      @cassandra
+    end
+
+    def cassandra=(cassandra)
+      @cassandra = cassandra
+    end
+
+    def keyspace
+      @cas_keyspace
+    end
+
+    def keyspace=(keyspace)
+      @cas_keyspace = keyspace
+      @cassandra_session = cassandra.connect(keyspace)
+    end
+
+    def cassandra_session
+      @cassandra_session ||= @cassandra.connect(@cas_keyspace)
+    rescue
+      @cassandra = Cassandra.cluster
+      @cas_keyspace = 'test'
+      @cassandra_session ||= @cassandra.connect(@cas_keyspace)
+    end
+
+  end
+end

data/lib/socialization/stores/cassandra/follow.rb

@@ -0,0 +1,36 @@
+module Socialization
+  module CassandraStores
+    class Follow < Socialization::CassandraStores::Base
+      extend Socialization::Stores::Mixins::Base
+      extend Socialization::Stores::Mixins::Follow
+      extend Socialization::CassandraStores::Mixins::Base
+
+      class << self
+        def forward_table_name
+          "followings"
+        end
+        def backward_table_name
+          "followers"
+        end
+        def counter_forward_table_name
+          "following_counter"
+        end
+        def counter_backward_table_name
+          "follower_counter"
+        end
+        alias_method :follow!, :relation!;                            public :follow!
+        alias_method :unfollow!, :unrelation!;                        public :unfollow!
+        alias_method :follows?, :relation?;                           public :follows?
+        alias_method :followers_relation, :actors_relation;           public :followers_relation
+        alias_method :followers, :actors;                             public :followers
+        alias_method :followables_relation, :victims_relation;        public :followables_relation
+        alias_method :followables, :victims;                          public :followables
+        alias_method :remove_followers, :remove_actor_relations;      public :remove_followers
+        alias_method :remove_followables, :remove_victim_relations;   public :remove_followables
+        alias_method :followers_cnt, :actors_cnt;                     public :followers_cnt
+        alias_method :following_cnt, :victims_cnt;                    public :following_cnt
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Socialization
+  module CassandraStores
+    class Like < Socialization::CassandraStores::Base
+      extend Socialization::Stores::Mixins::Base
+      extend Socialization::Stores::Mixins::Like
+      extend Socialization::CassandraStores::Mixins::Base
+
+      class << self
+        def forward_table_name
+          "likes"
+        end
+        def backward_table_name
+          "likers"
+        end
+        def counter_forward_table_name
+          nil
+        end
+        def counter_backward_table_name
+          "liker_counter"
+        end
+        alias_method :like!, :relation!;                          public :like!
+        alias_method :unlike!, :unrelation!;                      public :unlike!
+        alias_method :likes?, :relation?;                         public :likes?
+        alias_method :likers_relation, :actors_relation;          public :likers_relation
+        alias_method :likers, :actors;                            public :likers
+        alias_method :likeables_relation, :victims_relation;      public :likeables_relation
+        alias_method :likeables, :victims;                        public :likeables
+        alias_method :remove_likers, :remove_actor_relations;     public :remove_likers
+        alias_method :remove_likeables, :remove_victim_relations; public :remove_likeables
+        alias_method :likers_cnt, :actors_cnt;                    public :likers_cnt
+      end
+
+    end
+  end
+end

data/lib/socialization/stores/cassandra/mixins/base.rb

@@ -0,0 +1,8 @@
+module Socialization
+  module CassandraStores
+    module Mixins
+      module Base
+      end
+    end
+  end
+end

data/lib/socialization/stores/cassandra/share.rb

@@ -0,0 +1,28 @@
+module Socialization
+  module CassandraStores
+    class Share < Socialization::CassandraStores::Base
+      extend Socialization::Stores::Mixins::Base
+      extend Socialization::Stores::Mixins::Like
+      extend Socialization::CassandraStores::Mixins::Base
+
+      class << self
+        def forward_table_name
+          nil
+        end
+        def backward_table_name
+          "shares"
+        end
+        def counter_forward_table_name
+          nil
+        end
+        def counter_backward_table_name
+          "share_counter"
+        end
+        alias_method :share!, :relation!;                           public :share!
+        alias_method :remove_shares, :remove_actor_relations;       public :remove_shares
+        alias_method :shares_cnt, :actors_cnt;                      public :shares_cnt
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Socialization
+  module Stores
+    module Mixins
+      module Base
+        def touch_dependents(actor, victim)
+          actor.touch if touch_actor?(actor)
+          victim.touch if touch_victim?(victim)
+        end
+
+        def touch_actor?(actor)
+          return false unless actor.respond_to?(:touch)
+          touch == :all || touch.to_s =~ /er$/i
+        end
+
+        def touch_victim?(victim)
+          return false unless victim.respond_to?(:touch)
+          touch == :all || touch.to_s =~ /able$/i
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Socialization
+  module Stores
+    module Mixins
+      module Follow
+
+      public
+        def touch(what = nil)
+          if what.nil?
+            @touch || false
+          else
+            raise Socialization::ArgumentError unless [:all, :follower, :followable, false, nil].include?(what)
+            @touch = what
+          end
+        end
+
+        def after_follow(method)
+          raise Socialization::ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_create_hook = method
+        end
+
+        def after_unfollow(method)
+          raise Socialization::ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_destroy_hook = method
+        end
+
+      protected
+        def call_after_create_hooks(follower, followable)
+          self.send(@after_create_hook, follower, followable) if @after_create_hook
+          touch_dependents(follower, followable)
+        end
+
+        def call_after_destroy_hooks(follower, followable)
+          self.send(@after_destroy_hook, follower, followable) if @after_destroy_hook
+          touch_dependents(follower, followable)
+        end
+      end
+    end
+  end
+end