socialization 0.1.0

data/demo/demo_app/test/fixtures/celebrities.yml

@@ -0,0 +1,7 @@
+# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/Fixtures.html
+
+one:
+  name: MyString
+
+two:
+  name: MyString

data/demo/demo_app/test/fixtures/movies.yml

@@ -0,0 +1,7 @@
+# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/Fixtures.html
+
+one:
+  name: MyString
+
+two:
+  name: MyString

data/demo/demo_app/test/fixtures/users.yml

@@ -0,0 +1,7 @@
+# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/Fixtures.html
+
+one:
+  name: MyString
+
+two:
+  name: MyString

data/demo/demo_app/test/performance/browsing_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+require 'rails/performance_test_help'
+
+class BrowsingTest < ActionDispatch::PerformanceTest
+  # Refer to the documentation for all available options
+  # self.profile_options = { :runs => 5, :metrics => [:wall_time, :memory]
+  #                          :output => 'tmp/performance', :formats => [:flat] }
+
+  def test_homepage
+    get '/'
+  end
+end

data/demo/demo_app/test/test_helper.rb

@@ -0,0 +1,13 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/demo/demo_app/test/unit/celebrity_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class CelebrityTest < ActiveSupport::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end

data/demo/demo_app/test/unit/movie_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class MovieTest < ActiveSupport::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end

data/demo/demo_app/test/unit/user_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class UserTest < ActiveSupport::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end

data/generators/socialization/USAGE

@@ -0,0 +1 @@
+Generates both the Follow model class and the migration to create its table.

data/generators/socialization/socialization_generator.rb

@@ -0,0 +1,11 @@
+class SocializationGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.template 'model_follow.rb', 'app/models/follow.rb'
+      m.template 'model_like.rb', 'app/models/like.rb'
+      m.migration_template 'migration_follows.rb', 'db/migrate', :migration_file_name => 'create_follows'
+      sleep 1  # force unique migration timestamp
+      m.migration_template 'migration_likes.rb', 'db/migrate',   :migration_file_name => 'create_likes'
+    end
+  end
+end

data/generators/socialization/templates/migration_follows.rb

@@ -0,0 +1,14 @@
+class CreateFollows < ActiveRecord::Migration
+  def change
+    create_table :follows do |t|
+      t.string  :follower_type
+      t.integer :follower_id
+      t.string  :followable_type
+      t.integer :followable_id
+      t.datetime :created_at
+    end
+
+    add_index :follows, ["follower_id", "follower_type"],     :name => "fk_follows"
+    add_index :follows, ["followable_id", "followable_type"], :name => "fk_followables"
+  end
+end

data/generators/socialization/templates/migration_likes.rb

@@ -0,0 +1,14 @@
+class CreateLikes < ActiveRecord::Migration
+  def change
+    create_table :likes do |t|
+      t.string  :liker_type
+      t.integer :liker_id
+      t.string  :likeable_type
+      t.integer :likeable_id
+      t.datetime :created_at
+    end
+
+    add_index :likes, ["liker_id", "liker_type"],       :name => "fk_likes"
+    add_index :likes, ["likeable_id", "likeable_type"], :name => "fk_likeables"
+  end
+end

data/generators/socialization/templates/model_follow.rb

@@ -0,0 +1,3 @@
+class Follow < ActiveRecord::Base
+  acts_as_follow_store
+end

data/generators/socialization/templates/model_like.rb

@@ -0,0 +1,3 @@
+class Like < ActiveRecord::Base
+  acts_as_like_store
+end

data/init.rb

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

data/lib/generators/socialization/socialization_generator.rb

@@ -0,0 +1,23 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class SocializationGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+  source_root File.expand_path(File.join('..', '..', '..', 'generators', 'socialization', 'templates'), File.dirname(__FILE__))
+
+  def self.next_migration_number(dirname)
+    if ActiveRecord::Base.timestamped_migrations
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    else
+      "%.3d" % (current_migration_number(dirname) + 1)
+    end
+  end
+
+  def create_migration_file
+    copy_file 'model_follow.rb', 'app/models/follow.rb'
+    copy_file 'model_like.rb', 'app/models/like.rb'
+    migration_template 'migration_follows.rb', 'db/migrate/create_follows.rb'
+    sleep 1 # wait a second to have a unique migration timestamp
+    migration_template 'migration_likes.rb', 'db/migrate/create_likes.rb'
+  end
+end

data/lib/socialization.rb

@@ -0,0 +1,6 @@
+require 'socialization/hello'
+
+module Socialization
+end
+
+ActiveRecord::Base.send :include, Socialization::Hello

data/lib/socialization/follow_store.rb

@@ -0,0 +1,14 @@
+module Socialization
+  module FollowStore
+    def self.included(base)
+      base.class_eval do
+        belongs_to :follower,   :polymorphic => true
+        belongs_to :followable, :polymorphic => true
+
+        validates_uniqueness_of :followable_type, :scope => [:followable_id, :follower_type, :follower_id], :message => 'You cannot follow the same thing twice.'
+
+        def self.human_attribute_name(*args); ''; end
+      end
+    end
+  end
+end

data/lib/socialization/followable.rb

@@ -0,0 +1,23 @@
+module Socialization
+  module Followable
+    def self.included(base)
+      base.class_eval do
+        # A following is the Follow record of the follower following self.
+        has_many :followings, :as => :followable, :dependent => :destroy, :class_name => 'Follow'
+
+        def is_followable?
+          true
+        end
+
+        def followed_by?(follower)
+          raise ArgumentError, "#{follower} is not a follower!" unless follower.respond_to?(:is_follower?) && follower.is_follower?
+          !self.followings.where(:follower_type => follower.class.to_s, :follower_id => follower.id).pluck("1").empty?
+        end
+
+        def followers
+          self.followings.map { |f| f.follower }
+        end
+      end
+    end
+  end
+end

data/lib/socialization/follower.rb

@@ -0,0 +1,31 @@
+module Socialization
+  module Follower
+    def self.included(base)
+      base.class_eval do
+        # A follow is the Follow record of self following a followable record.
+        has_many :follows, :as => :follower, :dependent => :destroy, :class_name => 'Follow'
+
+        def is_follower?
+          true
+        end
+
+        def follow!(followable)
+          raise ArgumentError, "#{followable} is not followable!" unless followable.respond_to?(:is_followable?)
+          Follow.create! follower: self, followable: followable
+        end
+
+        def unfollow!(followable)
+          followable.followers.where(:follower => self).each do |f|
+            f.destroy
+          end
+        end
+
+        def follows?(followable)
+          raise ArgumentError, "#{followable} is not followable!" unless followable.respond_to?(:is_followable?) && followable.is_followable?
+          !self.follows.where(:followable_type => followable.class.to_s, :followable_id => followable.id).pluck("1").empty?
+        end
+
+      end
+    end
+  end
+end

data/lib/socialization/hello.rb

@@ -0,0 +1,37 @@
+%w{followable follower follow_store likeable liker like_store}.each do |f|
+  require "#{File.dirname(__FILE__)}/#{f}"
+end
+
+module Socialization
+  module Hello
+    def self.included(klass)
+      klass.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def acts_as_follower(opts = nil)
+        include Socialization::Follower
+      end
+
+      def acts_as_followable(opts = nil)
+        include Socialization::Followable
+      end
+
+      def acts_as_follow_store(opts = nil)
+        include Socialization::FollowStore
+      end
+
+      def acts_as_liker(opts = nil)
+        include Socialization::Liker
+      end
+
+      def acts_as_likeable(opts = nil)
+        include Socialization::Likeable
+      end
+
+      def acts_as_like_store(opts = nil)
+        include Socialization::LikeStore
+      end
+    end
+  end
+end

data/lib/socialization/like_store.rb

@@ -0,0 +1,14 @@
+module Socialization
+  module LikeStore
+    def self.included(base)
+      base.class_eval do
+        belongs_to :liker,    :polymorphic => true
+        belongs_to :likeable, :polymorphic => true
+
+        validates_uniqueness_of :likeable_type, :scope => [:likeable_id, :liker_type, :liker_id], :message => 'You cannot like the same thing twice.'
+
+        def self.human_attribute_name(*args); ''; end
+      end
+    end
+  end
+end

data/lib/socialization/likeable.rb

@@ -0,0 +1,23 @@
+module Socialization
+  module Likeable
+    def self.included(base)
+      base.class_eval do
+        # A liking is the Like record of the liker liking self.
+        has_many :likings, :as => :likeable, :dependent => :destroy, :class_name => 'Like'
+
+        def is_likeable?
+          true
+        end
+
+        def liked_by?(liker)
+          raise ArgumentError, "#{liker} is not a liker!" unless liker.respond_to?(:is_liker?) && liker.is_liker?
+          !self.likings.where(:liker_type => liker.class.to_s, :liker_id => liker.id).pluck("1").empty?
+        end
+
+        def likers
+          self.likings.map { |l| l.liker }
+        end
+      end
+    end
+  end
+end

data/lib/socialization/liker.rb

@@ -0,0 +1,31 @@
+module Socialization
+  module Liker
+    def self.included(base)
+      base.class_eval do
+        # A like is the Like record of self liking a likeable record.
+        has_many :likes, :as => :liker, :dependent => :destroy, :class_name => 'Like'
+
+        def is_liker?
+          true
+        end
+
+        def like!(likeable)
+          raise ArgumentError, "#{likeable} is not likeable!" unless likeable.respond_to?(:is_likeable?)
+          Like.create! liker: self, likeable: likeable
+        end
+
+        def unlike!(likeable)
+          likeable.likers.where(:liker => self).each do |l|
+            l.destroy
+          end
+        end
+
+        def likes?(likeable)
+          raise ArgumentError, "#{likeable} is not likeable!" unless likeable.respond_to?(:is_likeable?) && likeable.is_likeable?
+          !self.likes.where(:likeable_type => likeable.class.to_s, :likeable_id => likeable.id).pluck("1").empty?
+        end
+
+      end
+    end
+  end
+end

data/lib/socialization/version.rb

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

data/socialization.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "socialization/version"
+
+Gem::Specification.new do |s|
+  s.name = "socialization"
+  s.version = Socialization::VERSION
+  s.authors = ["Carl Mercier"]
+  s.email = "carl@carlmercier.com"
+  s.homepage = "https://github.com/cmer/socialization"
+  s.summary = "Easily socialize your app with Likes and Follows"
+  s.description = "Socialization allow 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 = true
+  s.extra_rdoc_files = ["README.rdoc"]
+  s.rdoc_options = ["--charset=UTF-8"]
+
+  s.add_runtime_dependency "activerecord"
+
+  s.add_development_dependency "appraisal"
+  s.add_development_dependency "logger"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "sqlite3"
+end

data/test/follow_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__)+'/test_helper'
+
+class FollowTest < Test::Unit::TestCase
+  def setup
+    @u_john  = User.create name: 'John Doe'
+    @u_jane  = User.create name: 'Jane Doe'
+    @c_chuck = Celebrity.create name: 'Chuck Norris'
+    @c_uma   = Celebrity.create name: 'Uma Thurman'
+    @c_rick  = Celebrity.create name: 'Rick Astley'
+  end
+
+  def test_the_world
+    assert @u_john.is_follower?
+    assert @c_chuck.is_followable?
+
+    assert @u_john.follow!(@c_rick)
+    assert @u_john.follow!(@c_chuck)
+    assert @u_jane.follow!(@c_rick)
+
+    assert_equal true, @u_john.follows?(@c_chuck)
+    assert_equal true, @u_john.follows?(@c_rick)
+    assert_equal true, @c_chuck.followed_by?(@u_john)
+
+    assert @c_uma.followers.empty?
+
+    # can't have duplicate follows
+    assert_raise ActiveRecord::RecordInvalid do
+      @u_john.follow!(@c_rick)
+    end
+  end
+
+  def test_user_following_user
+    @u_john.follow!(@u_jane)
+    assert_equal true,  @u_john.follows?(@u_jane)
+    assert_equal false, @u_jane.follows?(@u_john)
+  end
+end