twrk-socialization 0.0.1

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/mentionable.rb

@@ -0,0 +1,51 @@
+module ActiveRecord
+  class Base
+    def is_mentionable?
+      false
+    end
+    alias mentionable? is_mentionable?
+  end
+end
+
+module Socialization
+  module Mentionable
+    extend ActiveSupport::Concern
+
+    included do
+      after_destroy { Socialization.mention_model.remove_mentioners(self) }
+
+      # Specifies if self can be mentioned.
+      #
+      # @return [Boolean]
+      def is_mentionable?
+        true
+      end
+      alias mentionable? is_mentionable?
+
+      # Specifies if self is mentioned by a {Mentioner} object.
+      #
+      # @return [Boolean]
+      def mentioned_by?(mentioner)
+        raise Socialization::ArgumentError, "#{mentioner} is not mentioner!"  unless mentioner.respond_to?(:is_mentioner?) && mentioner.is_mentioner?
+        Socialization.mention_model.mentions?(mentioner, self)
+      end
+
+      # Returns an array of {Mentioner}s mentioning self.
+      #
+      # @param [Class] klass the {Mentioner} class to be included. e.g. `User`
+      # @return [Array<Mentioner, Numeric>] An array of Mentioner objects or IDs
+      def mentioners(klass, opts = {})
+        Socialization.mention_model.mentioners(self, klass, opts)
+      end
+
+      # Returns a scope of the {Mentioner}s mentioning self.
+      #
+      # @param [Class] klass the {Mentioner} class to be included in the scope. e.g. `User`
+      # @return ActiveRecord::Relation
+      def mentioners_relation(klass, opts = {})
+        Socialization.mention_model.mentioners_relation(self, klass, opts)
+      end
+
+    end
+  end
+end

data/lib/socialization.rb

@@ -0,0 +1,20 @@
+%w(
+  lib/*.rb
+  stores/mixins/base.rb
+  stores/mixins/**/*.rb
+  stores/active_record/mixins/base.rb
+  stores/active_record/mixins/**/*.rb
+  stores/redis/mixins/base.rb
+  stores/redis/mixins/**/*.rb
+  stores/active_record/**/*.rb
+  stores/redis/base.rb
+  stores/redis/**/*.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.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "socialization/version"
+
+Gem::Specification.new do |s|
+  s.name = "twrk-socialization"
+  s.version = "0.0.1"
+  s.authors = ["twrk"]
+  s.email = "twrkitrealgood@gmail.com"
+  s.homepage = "https://github.com/twrk/socialization"
+  s.summary = "Easily socialize your app with Likes and Follows"
+  s.description = "A modification of the smer/socialization plugin; currently not being maintained by original authorr. 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_development_dependency "appraisal"
+  s.add_development_dependency "logger"
+  s.add_development_dependency "rspec", "~> 3.3.0"
+  s.add_development_dependency "rspec-mocks"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "mock_redis"
+  s.add_development_dependency "guard"
+  s.add_development_dependency "guard-rspec"
+end

data/spec/actors/follower_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Socialization::Follower do
+  before(:all) do
+    use_ar_store
+    @follower = ImAFollower.new
+    @followable = ImAFollowable.create
+  end
+
+  describe "#is_follower?" do
+    it "returns true" do
+      expect(@follower.is_follower?).to be true
+    end
+  end
+
+  describe "#follower?" do
+    it "returns true" do
+      expect(@follower.follower?).to be true
+    end
+  end
+
+  describe "#follow!" do
+    it "does not accept non-followables" do
+      expect { @follower.follow!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "calls $Follow.follow!" do
+      expect($Follow).to receive(:follow!).with(@follower, @followable).once
+      @follower.follow!(@followable)
+    end
+  end
+
+  describe "#unfollow!" do
+    it "does not accept non-followables" do
+      expect { @follower.unfollow!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "calls $Follow.follow!" do
+      expect($Follow).to receive(:unfollow!).with(@follower, @followable).once
+      @follower.unfollow!(@followable)
+    end
+  end
+
+  describe "#toggle_follow!" do
+    it "does not accept non-followables" do
+      expect { @follower.unfollow!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "unfollows when following" do
+      expect(@follower).to receive(:follows?).with(@followable).once.and_return(true)
+      expect(@follower).to receive(:unfollow!).with(@followable).once
+      @follower.toggle_follow!(@followable)
+    end
+
+    it "follows when not following" do
+      expect(@follower).to receive(:follows?).with(@followable).once.and_return(false)
+      expect(@follower).to receive(:follow!).with(@followable).once
+      @follower.toggle_follow!(@followable)
+    end
+  end
+
+  describe "#follows?" do
+    it "does not accept non-followables" do
+      expect { @follower.unfollow!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "calls $Follow.follows?" do
+      expect($Follow).to receive(:follows?).with(@follower, @followable).once
+      @follower.follows?(@followable)
+    end
+  end
+
+  describe "#followables" do
+    it "calls $Follow.followables" do
+      expect($Follow).to receive(:followables).with(@follower, @followable.class, { :foo => :bar })
+      @follower.followables(@followable.class, { :foo => :bar })
+    end
+  end
+
+  describe "#followees" do
+    it "calls $Follow.followables" do
+      expect($Follow).to receive(:followables).with(@follower, @followable.class, { :foo => :bar })
+      @follower.followees(@followable.class, { :foo => :bar })
+    end
+  end
+
+  describe "#followables_relation" do
+    it "calls $Follow.followables_relation" do
+      expect($Follow).to receive(:followables_relation).with(@follower, @followable.class, { :foo => :bar })
+      @follower.followables_relation(@followable.class, { :foo => :bar })
+    end
+  end
+
+  describe "#followees_relation" do
+    it "calls $Follow.followables_relation" do
+      expect($Follow).to receive(:followables_relation).with(@follower, @followable.class, { :foo => :bar })
+      @follower.followees_relation(@followable.class, { :foo => :bar })
+    end
+  end
+
+  describe "deleting a follower" do
+    before(:all) do
+      @follower = ImAFollower.create
+      @follower.follow!(@followable)
+    end
+
+    it "removes follow relationships" do
+      expect(Socialization.follow_model).to receive(:remove_followables).with(@follower)
+      @follower.destroy
+    end
+  end
+
+end

data/spec/actors/liker_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Socialization::Liker do
+  before(:all) do
+    use_ar_store
+    @liker = ImALiker.new
+    @likeable = ImALikeable.create
+  end
+
+  describe "#is_liker?" do
+    it "returns true" do
+      expect(@liker.is_liker?).to be true
+    end
+  end
+
+  describe "#liker?" do
+    it "returns true" do
+      expect(@liker.liker?).to be true
+    end
+  end
+
+  describe "#like!" do
+    it "does not accept non-likeables" do
+      expect { @liker.like!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "calls $Like.like!" do
+      expect($Like).to receive(:like!).with(@liker, @likeable).once
+      @liker.like!(@likeable)
+    end
+  end
+
+  describe "#unlike!" do
+    it "does not accept non-likeables" do
+      expect { @liker.unlike!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "calls $Like.like!" do
+      expect($Like).to receive(:unlike!).with(@liker, @likeable).once
+      @liker.unlike!(@likeable)
+    end
+  end
+
+  describe "#toggle_like!" do
+    it "does not accept non-likeables" do
+      expect { @liker.unlike!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "unlikes when likeing" do
+      expect(@liker).to receive(:likes?).with(@likeable).once.and_return(true)
+      expect(@liker).to receive(:unlike!).with(@likeable).once
+      @liker.toggle_like!(@likeable)
+    end
+
+    it "likes when not likeing" do
+      expect(@liker).to receive(:likes?).with(@likeable).once.and_return(false)
+      expect(@liker).to receive(:like!).with(@likeable).once
+      @liker.toggle_like!(@likeable)
+    end
+  end
+
+  describe "#likes?" do
+    it "does not accept non-likeables" do
+      expect { @liker.unlike!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "calls $Like.likes?" do
+      expect($Like).to receive(:likes?).with(@liker, @likeable).once
+      @liker.likes?(@likeable)
+    end
+  end
+
+  describe "#likeables" do
+    it "calls $Like.likeables" do
+      expect($Like).to receive(:likeables).with(@liker, @likeable.class, { :foo => :bar })
+      @liker.likeables(@likeable.class, { :foo => :bar })
+    end
+  end
+
+  describe "#likees" do
+    it "calls $Like.likeables" do
+      expect($Like).to receive(:likeables).with(@liker, @likeable.class, { :foo => :bar })
+      @liker.likees(@likeable.class, { :foo => :bar })
+    end
+  end
+
+  describe "#likeables_relation" do
+    it "calls $Follow.likeables_relation" do
+      expect($Like).to receive(:likeables_relation).with(@liker, @likeable.class, { :foo => :bar })
+      @liker.likeables_relation(@likeable.class, { :foo => :bar })
+    end
+  end
+
+  describe "#likees_relation" do
+    it "calls $Follow.likeables_relation" do
+      expect($Like).to receive(:likeables_relation).with(@liker, @likeable.class, { :foo => :bar })
+      @liker.likees_relation(@likeable.class, { :foo => :bar })
+    end
+  end
+
+  it "removes like relationships" do
+    expect(Socialization.like_model).to receive(:remove_likeables).with(@liker)
+    @liker.destroy
+  end
+end

data/spec/actors/mentioner_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Socialization::Mentioner do
+  before(:all) do
+    use_ar_store
+    @mentioner = ImAMentioner.new
+    @mentionable = ImAMentionable.create
+  end
+
+  describe "#is_mentioner?" do
+    it "returns true" do
+      expect(@mentioner.is_mentioner?).to be true
+    end
+  end
+
+  describe "#mentioner?" do
+    it "returns true" do
+      expect(@mentioner.mentioner?).to be true
+    end
+  end
+
+  describe "#mention!" do
+    it "does not accept non-mentionables" do
+      expect { @mentioner.mention!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "calls $Mention.mention!" do
+      expect($Mention).to receive(:mention!).with(@mentioner, @mentionable).once
+      @mentioner.mention!(@mentionable)
+    end
+  end
+
+  describe "#unmention!" do
+    it "does not accept non-mentionables" do
+      expect { @mentioner.unmention!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "calls $Mention.mention!" do
+      expect($Mention).to receive(:unmention!).with(@mentioner, @mentionable).once
+      @mentioner.unmention!(@mentionable)
+    end
+  end
+
+  describe "#toggle_mention!" do
+    it "does not accept non-mentionables" do
+      expect { @mentioner.unmention!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "unmentions when mentioning" do
+      expect(@mentioner).to receive(:mentions?).with(@mentionable).once.and_return(true)
+      expect(@mentioner).to receive(:unmention!).with(@mentionable).once
+      @mentioner.toggle_mention!(@mentionable)
+    end
+
+    it "mentions when not mentioning" do
+      expect(@mentioner).to receive(:mentions?).with(@mentionable).once.and_return(false)
+      expect(@mentioner).to receive(:mention!).with(@mentionable).once
+      @mentioner.toggle_mention!(@mentionable)
+    end
+  end
+
+  describe "#mentions?" do
+    it "does not accept non-mentionables" do
+      expect { @mentioner.unmention!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "calls $Mention.mentions?" do
+      expect($Mention).to receive(:mentions?).with(@mentioner, @mentionable).once
+      @mentioner.mentions?(@mentionable)
+    end
+  end
+
+  describe "#mentionables" do
+    it "calls $Mention.mentionables" do
+      expect($Mention).to receive(:mentionables).with(@mentioner, @mentionable.class, { :foo => :bar })
+      @mentioner.mentionables(@mentionable.class, { :foo => :bar })
+    end
+  end
+
+  describe "#mentionees" do
+    it "calls $Mention.mentionables" do
+      expect($Mention).to receive(:mentionables).with(@mentioner, @mentionable.class, { :foo => :bar })
+      @mentioner.mentionees(@mentionable.class, { :foo => :bar })
+    end
+  end
+
+  describe "#mentionables_relation" do
+    it "calls $Mention.mentionables_relation" do
+      expect($Mention).to receive(:mentionables_relation).with(@mentioner, @mentionable.class, { :foo => :bar })
+      @mentioner.mentionables_relation(@mentionable.class, { :foo => :bar })
+    end
+  end
+
+  describe "#mentionees_relation" do
+    it "calls $Mention.mentionables_relation" do
+      expect($Mention).to receive(:mentionables_relation).with(@mentioner, @mentionable.class, { :foo => :bar })
+      @mentioner.mentionees_relation(@mentionable.class, { :foo => :bar })
+    end
+  end
+
+  it "removes mention relationships" do
+    expect(Socialization.mention_model).to receive(:remove_mentionables).with(@mentioner)
+    @mentioner.destroy
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+$MOCK_REDIS = true
+
+require 'bundler/setup'
+Bundler.setup
+
+RSpec.configure do |config|
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+end
+
+$:.push File.expand_path("../lib", __FILE__)
+require 'active_record'
+require "socialization"
+require 'spec_support/data_stores'
+require 'spec_support/matchers'
+require 'logger'
+
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.irregular 'cache', 'caches'
+end