socialization 0.4.0 → 0.5.0.beta

data/lib/generators/socialization/socialization_generator.rb

@@ -1,9 +1,12 @@
 require 'rails/generators'
 require 'rails/generators/migration'
 
+STORES = %w(active_record redis)
+
 class SocializationGenerator < Rails::Generators::Base
   include Rails::Generators::Migration
-  source_root File.expand_path(File.join('..', '..', '..', 'generators', 'socialization', 'templates'), File.dirname(__FILE__))
+  source_root File.expand_path(File.join('templates'), File.dirname(__FILE__))
+  class_option :store, :type => :string, :default => 'active_record', :description => "Type of datastore"
 
   def self.next_migration_number(dirname)
     if ActiveRecord::Base.timestamped_migrations
@@ -14,14 +17,22 @@ class SocializationGenerator < Rails::Generators::Base
   end
 
   def create_migration_file
-    copy_file 'model_follow.rb',  'app/models/follow.rb'
-    copy_file 'model_like.rb',    'app/models/like.rb'
-    copy_file 'model_mention.rb', 'app/models/mention.rb'
+    options[:store].downcase!
+    unless STORES.include?(options[:store])
+      puts "Invalid store '#{options[:store]}'. The following stores are valid: #{STORES.join(', ')}."
+      exit 1
+    end
 
-    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'
-    sleep 1 # wait a second to have a unique migration timestamp
-    migration_template 'migration_mentions.rb', 'db/migrate/create_mentions.rb'
+    copy_file "#{options[:store]}/model_follow.rb",  'app/models/follow.rb'
+    copy_file "#{options[:store]}/model_like.rb",    'app/models/like.rb'
+    copy_file "#{options[:store]}/model_mention.rb", 'app/models/mention.rb'
+
+    if options[:store] == 'active_record'
+      migration_template "#{options[:store]}/migration_follows.rb",  'db/migrate/create_follows.rb'
+      sleep 1 # wait a second to have a unique migration timestamp
+      migration_template "#{options[:store]}/migration_likes.rb",    'db/migrate/create_likes.rb'
+      sleep 1 # wait a second to have a unique migration timestamp
+      migration_template "#{options[:store]}/migration_mentions.rb", 'db/migrate/create_mentions.rb'
+    end
   end
 end

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

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

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

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

data/lib/generators/socialization/templates/active_record/model_mention.rb

@@ -0,0 +1,2 @@
+class Mention < Socialization::ActiveRecordStores::MentionStore
+end

data/lib/socialization.rb

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

data/lib/socialization/actors/follower.rb

@@ -0,0 +1,74 @@
+module ActiveRecord
+  class Base
+    def is_follower?
+      false
+    end
+  end
+end
+
+module Socialization
+  module Follower
+    extend ActiveSupport::Concern
+
+    included do
+      # Specifies if self can follow {Followable} objects.
+      #
+      # @return [Boolean]
+      def is_follower?
+        true
+      end
+
+      # Create a new {FollowStores follow} relationship.
+      #
+      # @param [Followable] followable the object to be followed.
+      # @return [Boolean]
+      def follow!(followable)
+        raise ArgumentError, "#{followable} is not followable!"  unless followable.respond_to?(:is_followable?) && followable.is_followable?
+        Socialization.follow_model.follow!(self, followable)
+      end
+
+      # Delete a {FollowStores follow} relationship.
+      #
+      # @param [Followable] followable the object to unfollow.
+      # @return [Boolean]
+      def unfollow!(followable)
+        raise ArgumentError, "#{followable} is not followable!" unless followable.respond_to?(:is_followable?) && followable.is_followable?
+        Socialization.follow_model.unfollow!(self, followable)
+      end
+
+      # Toggles a {FollowStores follow} relationship.
+      #
+      # @param [Followable] followable the object to follow/unfollow.
+      # @return [Boolean]
+      def toggle_follow!(followable)
+        raise 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 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
+
+    end
+  end
+end

data/lib/socialization/actors/liker.rb

@@ -0,0 +1,74 @@
+module ActiveRecord
+  class Base
+    def is_liker?
+      false
+    end
+  end
+end
+
+module Socialization
+  module Liker
+    extend ActiveSupport::Concern
+
+    included do
+      # Specifies if self can like {Likeable} objects.
+      #
+      # @return [Boolean]
+      def is_liker?
+        true
+      end
+
+      # Create a new {LikeStores like} relationship.
+      #
+      # @param [Likeable] likeable the object to be liked.
+      # @return [Boolean]
+      def like!(likeable)
+        raise ArgumentError, "#{likeable} is not likeable!"  unless likeable.respond_to?(:is_likeable?) && likeable.is_likeable?
+        Socialization.like_model.like!(self, likeable)
+      end
+
+      # Delete a {LikeStores like} relationship.
+      #
+      # @param [Likeable] likeable the object to unlike.
+      # @return [Boolean]
+      def unlike!(likeable)
+        raise ArgumentError, "#{likeable} is not likeable!" unless likeable.respond_to?(:is_likeable?) && likeable.is_likeable?
+        Socialization.like_model.unlike!(self, likeable)
+      end
+
+      # Toggles a {LikeStores like} relationship.
+      #
+      # @param [Likeable] likeable the object to like/unlike.
+      # @return [Boolean]
+      def toggle_like!(likeable)
+        raise 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 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
+
+    end
+  end
+end

data/lib/socialization/actors/mentioner.rb

@@ -0,0 +1,74 @@
+module ActiveRecord
+  class Base
+    def is_mentioner?
+      false
+    end
+  end
+end
+
+module Socialization
+  module Mentioner
+    extend ActiveSupport::Concern
+
+    included do
+      # Specifies if self can mention {Mentionable} objects.
+      #
+      # @return [Boolean]
+      def is_mentioner?
+        true
+      end
+
+      # Create a new {MentionStores mention} relationship.
+      #
+      # @param [Mentionable] mentionable the object to be mentioned.
+      # @return [Boolean]
+      def mention!(mentionable)
+        raise ArgumentError, "#{mentionable} is not mentionable!"  unless mentionable.respond_to?(:is_mentionable?) && mentionable.is_mentionable?
+        Socialization.mention_model.mention!(self, mentionable)
+      end
+
+      # Delete a {MentionStores mention} relationship.
+      #
+      # @param [Mentionable] mentionable the object to unmention.
+      # @return [Boolean]
+      def unmention!(mentionable)
+        raise ArgumentError, "#{mentionable} is not mentionable!" unless mentionable.respond_to?(:is_mentionable?) && mentionable.is_mentionable?
+        Socialization.mention_model.unmention!(self, mentionable)
+      end
+
+      # Toggles a {MentionStores mention} relationship.
+      #
+      # @param [Mentionable] mentionable the object to mention/unmention.
+      # @return [Boolean]
+      def toggle_mention!(mentionable)
+        raise 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 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
+
+    end
+  end
+end

data/lib/socialization/acts_as_helpers.rb

@@ -0,0 +1,43 @@
+require 'active_support/concern'
+
+%w(helpers stores actors victims).each do |path|
+  Dir["#{File.dirname(__FILE__)}/#{path}/**/*.rb"].each { |f| require(f) }
+end
+
+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::Mentioner}
+      def acts_as_mentioner(opts = {})
+        include Socialization::Mentioner
+      end
+
+      # Make the current class a {Socialization::Mentionable}
+      def acts_as_mentionable(opts = {})
+        include Socialization::Mentionable
+      end
+    end
+  end
+end

data/lib/socialization/config.rb

@@ -0,0 +1,45 @@
+module Socialization
+  class << self
+    def follow_model
+      if @follow_model
+        @follow_model
+      elsif defined?(::Follow)
+        ::Follow
+      else
+        raise RuntimeError.new("No Follow model has been defined.")
+      end
+    end
+
+    def follow_model=(klass)
+      @follow_model = klass
+    end
+
+    def like_model
+      if @like_model
+        @like_model
+      elsif defined?(::Like)
+        ::Like
+      else
+        raise RuntimeError.new("No Like model has been defined.")
+      end
+    end
+
+    def like_model=(klass)
+      @like_model = klass
+    end
+
+    def mention_model
+      if @mention_model
+        @mention_model
+      elsif defined?(::Mention)
+        ::Mention
+      else
+        raise RuntimeError.new("No Mention model has been defined.")
+      end
+    end
+
+    def mention_model=(klass)
+      @mention_model = klass
+    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