socialization-cassandra 0.0.1.pre.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fa470f9302a13641ec885b36e01fd7fc4f99b1e3
+  data.tar.gz: e236cad8edaa6d361a2bab6fa813b86f06fc19af
+SHA512:
+  metadata.gz: 1bb3d0d4e8e2dde12d7f76f260dfed526bb8c6bfcb279f9218fcaaa2619dba0752a93a2a65f4cc4d8464e66510fc77e15ba31df213e7fd3febd046bc7240d973
+  data.tar.gz: 3aa917f4743fc690e0b8cc5e6fe452077e123ca41528ef6e7e6a1c40a568471aa262799cb05aeb4bb4eb1d9465c0c943df9e7a9d5830b1a34f2a2e82873a4004

data/.gitignore

@@ -0,0 +1,13 @@
+*.gem
+test/debug.log
+coverage
+rdoc
+memory
+*.gem
+.rvmrc
+Gemfile.lock
+log
+doc
+.yardoc
+.rbenv-version
+gemfiles

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+
+script: bundle exec rake test

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+gem 'activerecord'
+gem 'cassandra-driver'
+gem 'logger'
+gem 'mocha'
+gem 'shoulda'
+gem 'sqlite3'
+gem 'yard'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Amrit Singh
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,144 @@
+# Socialization-Cassandra
+
+Socialization is a Ruby Gem that allows any ActiveRecord model to `Follow`, `Like`, 'Comment' and/or `Share` any other model. Cassandra is used as a data store.
+
+## Installation
+
+### Rails 3/4
+
+Add the gem to the gemfile:
+`gem "socialization-cassandra"`
+
+Run the generator:
+`rails generate socialization -s`
+
+Run:
+`rake socialization:migrate`
+
+### Rails 2.3.x Support
+
+This gem requires Rails 3 or better. Sorry!
+
+## Usage
+
+### Setup
+
+Allow a model to be followed:
+
+    class Celebrity < ActiveRecord::Base
+      ...
+      acts_as_followable
+      ...
+    end
+
+Allow a model to be a follower:
+
+    class User < ActiveRecord::Base
+      ...
+      acts_as_follower
+      ...
+    end
+
+
+Allow a model to be liked:
+
+    class Movie < ActiveRecord::Base
+      ...
+      acts_as_likeable
+      ...
+    end
+
+Allow a model to like:
+
+    class User < ActiveRecord::Base
+      ...
+      acts_as_liker
+      ...
+    end
+
+***
+
+
+### acts_as_follower Methods
+
+Follow something
+
+    user.follow!(celebrity)
+
+Stop following
+
+    user.unfollow!(celebrity)
+
+Toggle
+
+    user.toggle_follow!(celebrity)
+
+Is following?
+
+    user.follows?(celebrity)
+
+What items are you following (given that an Item model is followed)?
+
+    user.followees(Item)
+
+
+***
+
+
+### acts_as_followable Methods
+
+Find out if an objects follows
+
+    celebrity.followed_by?(user)
+
+All followers
+
+    celebrity.followers(User)
+
+
+***
+
+
+### acts_as_liker Methods
+
+Like something
+
+    user.like!(movie)
+
+Stop liking
+
+    user.unlike!(movie)
+
+Toggle
+
+    user.toggle_like!(celebrity)
+
+Likes?
+
+    user.likes?(movie)
+
+***
+
+
+### acts_as_likeable Methods
+
+Find out if an objects likes
+
+    movie.liked_by?(user)
+
+All likers
+
+    movie.likers(User)
+
+***
+
+## Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2015-2016 Amrit Singh--  Released under the MIT license.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake'
+require 'rake/testtask'
+require 'bundler/gem_tasks'
+
+desc 'Test the socialization plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/init.rb

@@ -0,0 +1 @@
+require 'socialization'

data/lib/generators/socialization/socialization_generator.rb

@@ -0,0 +1,17 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class SocializationGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+  source_root File.expand_path(File.join('templates'), File.dirname(__FILE__))
+
+  def create_migration_file
+    copy_file "cassandra/model_follow.rb",  'app/models/follow.rb'
+    copy_file "cassandra/model_like.rb",    'app/models/like.rb'
+    copy_file "cassandra/model_comment.rb", 'app/models/comment.rb'
+    copy_file "cassandra/model_share.rb", 'app/models/share.rb'
+
+    migration_template 'socialization_cassandra_migrations.rake', 'lib/tasks/socialization_cassandra_migrations.rake'
+
+  end
+end

data/lib/generators/socialization/templates/cassandra/model_comment.rb

@@ -0,0 +1,2 @@
+class Comment < Socialization::CassandraStores::Comment
+end

data/lib/generators/socialization/templates/cassandra/model_follow.rb

@@ -0,0 +1,2 @@
+class Follow < Socialization::CassandraStores::Follow
+end

data/lib/generators/socialization/templates/cassandra/model_like.rb

@@ -0,0 +1,2 @@
+class Like < Socialization::CassandraStores::Like
+end

data/lib/generators/socialization/templates/cassandra/model_share.rb

@@ -0,0 +1,2 @@
+class Share < Socialization::CassandraStores::Share
+end

data/lib/generators/socialization/templates/socialization_cassandra_migrations.rake

@@ -0,0 +1,141 @@
+class SocializationCassandraMigrations
+
+  MIGRATIONS = [
+
+    # likes
+
+    "CREATE TABLE likes (
+      actor_type varchar,
+      actor_id bigint,
+      victim_id bigint,
+      victim_type varchar,
+      created_at bigint,
+      PRIMARY KEY ((actor_type, actor_id), created_at)
+    );",
+
+    "CREATE INDEX ON likes (victim_type)",
+    "CREATE INDEX ON likes (victim_id)",
+
+    "CREATE TABLE likers (
+      actor_type varchar,
+      actor_id bigint,
+      victim_id bigint,
+      victim_type varchar,
+      created_at bigint,
+      PRIMARY KEY ((victim_type, victim_id), created_at)
+    );",
+
+    "CREATE INDEX ON likers (actor_type)",
+    "CREATE INDEX ON likers (actor_id)",
+
+    "CREATE TABLE liker_counter (
+      victim_id bigint,
+      victim_type varchar,
+      cnt counter,
+      PRIMARY KEY (victim_type, victim_id)
+    );",
+
+    # follow
+
+    "CREATE TABLE followings (
+      actor_type varchar,
+      actor_id bigint,
+      victim_id bigint,
+      victim_type varchar,
+      created_at bigint,
+      PRIMARY KEY ((actor_type, actor_id), created_at)
+    );",
+
+    "CREATE INDEX ON followings (victim_type)",
+    "CREATE INDEX ON followings (victim_id)",
+
+    "CREATE TABLE followers (
+      actor_type varchar,
+      actor_id bigint,
+      victim_id bigint,
+      victim_type varchar,
+      created_at bigint,
+      PRIMARY KEY ((victim_type, victim_id), created_at)
+    );",
+
+    "CREATE INDEX ON followers (actor_type)",
+    "CREATE INDEX ON followers (actor_id)",
+
+    "CREATE TABLE following_counter (
+      actor_id bigint,
+      actor_type varchar,
+      cnt counter,
+      PRIMARY KEY (actor_type, actor_id)
+    );",
+
+    "CREATE TABLE follower_counter (
+      victim_id bigint,
+      victim_type varchar,
+      cnt counter,
+      PRIMARY KEY (victim_type, victim_id)
+    );",
+
+    # Comments 
+
+    "CREATE TABLE comments (
+      actor_type varchar,
+      actor_id bigint,
+      victim_id bigint,
+      victim_type varchar,
+      created_at bigint,
+      txt text,
+      PRIMARY KEY ((victim_type, victim_id), created_at)
+    );",
+
+    "CREATE TABLE comment_counter (
+      victim_id bigint,
+      victim_type varchar,
+      cnt counter,
+      PRIMARY KEY (victim_type, victim_id)
+    );",
+
+    # Share
+
+    "CREATE TABLE shares (
+      actor_type varchar,
+      actor_id bigint,
+      victim_id bigint,
+      victim_type varchar,
+      networks set<text>,
+      created_at bigint,
+      txt text,
+      PRIMARY KEY ((victim_type, victim_id), created_at)
+    );",
+
+    "CREATE TABLE share_counter (
+      victim_id bigint,
+      victim_type varchar,
+      cnt counter,
+      PRIMARY KEY (victim_type, victim_id)
+    );"
+
+  ]
+
+end
+
+
+namespace :socialization do
+  desc "Socialization Cassandra Migrations"
+  task(:migrate => :environment) do
+    begin
+      session = Socialization.cassandra.connect('system')
+      session.execute("CREATE KEYSPACE #{Socialization.keyspace} WITH replication = {'class': 'NetworkTopologyStrategy'}")
+    rescue Cassandra::Errors::AlreadyExistsError => e
+      next
+    end
+    session = Socialization.cassandra.connect(Socialization.keyspace)
+
+    SocializationCassandraMigrations::MIGRATIONS.each do |m|
+      begin
+        Socialization.cassandra_session.execute(m)
+      rescue Cassandra::Errors::AlreadyExistsError => e
+        next
+      end
+    end
+  end
+end

data/lib/socialization/actors/commenter.rb

@@ -0,0 +1,79 @@
+module Socialization
+  module Commenter
+    extend ActiveSupport::Concern
+
+    included do
+      after_destroy { Socialization.comment_model.remove_commentables(self) }
+
+      # Specifies if self can comment {Commentable} objects.
+      #
+      # @return [Boolean]
+      def is_commenter?
+        true
+      end
+      alias commenter? is_commenter?
+
+      # Create a new {Comment comment} relationship.
+      #
+      # @param [Commentable] commentable the object to be commented.
+      # @return [Boolean]
+      def comment!(commentable)
+        raise Socialization::ArgumentError, "#{commentable} is not commentable!"  unless commentable.respond_to?(:is_commentable?) && commentable.is_commentable?
+        Socialization.comment_model.comment!(self, commentable)
+      end
+
+      # Delete a {Comment comment} relationship.
+      #
+      # @param [Commentable] commentable the object to uncomment.
+      # @return [Boolean]
+      def uncomment!(commentable)
+        raise Socialization::ArgumentError, "#{commentable} is not commentable!" unless commentable.respond_to?(:is_commentable?) && commentable.is_commentable?
+        Socialization.comment_model.uncomment!(self, commentable)
+      end
+
+      # Toggles a {Comment comment} relationship.
+      #
+      # @param [Commentable] commentable the object to comment/uncomment.
+      # @return [Boolean]
+      def toggle_comment!(commentable)
+        raise Socialization::ArgumentError, "#{commentable} is not commentable!" unless commentable.respond_to?(:is_commentable?) && commentable.is_commentable?
+        if comments?(commentable)
+          uncomment!(commentable)
+          false
+        else
+          comment!(commentable)
+          true
+        end
+      end
+
+      # Specifies if self comments a {Commentable} object.
+      #
+      # @param [Commentable] commentable the {Commentable} object to test against.
+      # @return [Boolean]
+      def comments?(commentable)
+        raise Socialization::ArgumentError, "#{commentable} is not commentable!" unless commentable.respond_to?(:is_commentable?) && commentable.is_commentable?
+        Socialization.comment_model.comments?(self, commentable)
+      end
+
+      # Returns all the commentables of a certain type that are commented by self
+      #
+      # @params [Commentable] klass the type of {Commentable} you want
+      # @params [Hash] opts a hash of options
+      # @return [Array<Commentable, Numeric>] An array of Commentable objects or IDs
+      def commentables(klass, opts = {})
+        Socialization.comment_model.commentables(self, klass, opts)
+      end
+      alias :commentees :commentables
+
+      # Returns a relation for all the commentables of a certain type that are commented by self
+      #
+      # @params [Commentable] klass the type of {Commentable} you want
+      # @params [Hash] opts a hash of options
+      # @return ActiveRecord::Relation
+      def commentables_relation(klass, opts = {})
+        Socialization.comment_model.commentables_relation(self, klass, opts)
+      end
+      alias :commentees_relation :commentables_relation
+    end
+  end
+end

data/lib/socialization/actors/follower.rb

@@ -0,0 +1,79 @@
+module Socialization
+  module Follower
+    extend ActiveSupport::Concern
+
+    included do
+      after_destroy { Socialization.follow_model.remove_followables(self) }
+
+      # Specifies if self can follow {Followable} objects.
+      #
+      # @return [Boolean]
+      def is_follower?
+        true
+      end
+      alias follower? is_follower?
+
+      # Create a new {Follow follow} relationship.
+      #
+      # @param [Followable] followable the object to be followed.
+      # @return [Boolean]
+      def follow!(followable)
+        raise Socialization::ArgumentError, "#{followable} is not followable!"  unless followable.respond_to?(:is_followable?) && followable.is_followable?
+        Socialization.follow_model.follow!(self, followable)
+      end
+
+      # Delete a {Follow follow} relationship.
+      #
+      # @param [Followable] followable the object to unfollow.
+      # @return [Boolean]
+      def unfollow!(followable)
+        raise Socialization::ArgumentError, "#{followable} is not followable!" unless followable.respond_to?(:is_followable?) && followable.is_followable?
+        Socialization.follow_model.unfollow!(self, followable)
+      end
+
+      # Toggles a {Follow follow} relationship.
+      #
+      # @param [Followable] followable the object to follow/unfollow.
+      # @return [Boolean]
+      def toggle_follow!(followable)
+        raise Socialization::ArgumentError, "#{followable} is not followable!" unless followable.respond_to?(:is_followable?) && followable.is_followable?
+        if follows?(followable)
+          unfollow!(followable)
+          false
+        else
+          follow!(followable)
+          true
+        end
+      end
+
+      # Specifies if self follows a {Followable} object.
+      #
+      # @param [Followable] followable the {Followable} object to test against.
+      # @return [Boolean]
+      def follows?(followable)
+        raise Socialization::ArgumentError, "#{followable} is not followable!" unless followable.respond_to?(:is_followable?) && followable.is_followable?
+        Socialization.follow_model.follows?(self, followable)
+      end
+
+      # Returns all the followables of a certain type that are followed by self
+      #
+      # @params [Followable] klass the type of {Followable} you want
+      # @params [Hash] opts a hash of options
+      # @return [Array<Followable, Numeric>] An array of Followable objects or IDs
+      def followables(klass, opts = {})
+        Socialization.follow_model.followables(self, klass, opts)
+      end
+      alias :followees :followables
+
+      # Returns a relation for all the followables of a certain type that are followed by self
+      #
+      # @params [Followable] klass the type of {Followable} you want
+      # @params [Hash] opts a hash of options
+      # @return ActiveRecord::Relation
+      def followables_relation(klass, opts = {})
+        Socialization.follow_model.followables_relation(self, klass, opts)
+      end
+      alias :followees_relation :followables_relation
+    end
+  end
+end

data/lib/socialization/actors/liker.rb

@@ -0,0 +1,79 @@
+module Socialization
+  module Liker
+    extend ActiveSupport::Concern
+
+    included do
+      after_destroy { Socialization.like_model.remove_likeables(self) }
+
+      # Specifies if self can like {Likeable} objects.
+      #
+      # @return [Boolean]
+      def is_liker?
+        true
+      end
+      alias liker? is_liker?
+
+      # Create a new {Like like} relationship.
+      #
+      # @param [Likeable] likeable the object to be liked.
+      # @return [Boolean]
+      def like!(likeable)
+        raise Socialization::ArgumentError, "#{likeable} is not likeable!"  unless likeable.respond_to?(:is_likeable?) && likeable.is_likeable?
+        Socialization.like_model.like!(self, likeable)
+      end
+
+      # Delete a {Like like} relationship.
+      #
+      # @param [Likeable] likeable the object to unlike.
+      # @return [Boolean]
+      def unlike!(likeable)
+        raise Socialization::ArgumentError, "#{likeable} is not likeable!" unless likeable.respond_to?(:is_likeable?) && likeable.is_likeable?
+        Socialization.like_model.unlike!(self, likeable)
+      end
+
+      # Toggles a {Like like} relationship.
+      #
+      # @param [Likeable] likeable the object to like/unlike.
+      # @return [Boolean]
+      def toggle_like!(likeable)
+        raise Socialization::ArgumentError, "#{likeable} is not likeable!" unless likeable.respond_to?(:is_likeable?) && likeable.is_likeable?
+        if likes?(likeable)
+          unlike!(likeable)
+          false
+        else
+          like!(likeable)
+          true
+        end
+      end
+
+      # Specifies if self likes a {Likeable} object.
+      #
+      # @param [Likeable] likeable the {Likeable} object to test against.
+      # @return [Boolean]
+      def likes?(likeable)
+        raise Socialization::ArgumentError, "#{likeable} is not likeable!" unless likeable.respond_to?(:is_likeable?) && likeable.is_likeable?
+        Socialization.like_model.likes?(self, likeable)
+      end
+
+      # Returns all the likeables of a certain type that are liked by self
+      #
+      # @params [Likeable] klass the type of {Likeable} you want
+      # @params [Hash] opts a hash of options
+      # @return [Array<Likeable, Numeric>] An array of Likeable objects or IDs
+      def likeables(klass, opts = {})
+        Socialization.like_model.likeables(self, klass, opts)
+      end
+      alias :likees :likeables
+
+      # Returns a relation for all the likeables of a certain type that are liked by self
+      #
+      # @params [Likeable] klass the type of {Likeable} you want
+      # @params [Hash] opts a hash of options
+      # @return ActiveRecord::Relation
+      def likeables_relation(klass, opts = {})
+        Socialization.like_model.likeables_relation(self, klass, opts)
+      end
+      alias :likees_relation :likeables_relation
+    end
+  end
+end