mention_system 0.0.6

data/lib/mention_system/version.rb

@@ -0,0 +1,12 @@
+###
+# MentionSystem module
+#
+# This module defines common behavior in mention system
+###
+module MentionSystem
+  ###
+  # Version constant definition
+  ###
+  VERSION = "0.0.6"
+end
+

data/mention_system.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mention_system/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mention_system"
+  spec.version       = MentionSystem::VERSION
+  spec.authors       = ["Pablo Martin Viva"]
+  spec.email         = ["pmviva@gmail.com"]
+  spec.summary       = %q{An active record like system.}
+  spec.description   = %q{An active record mention system developed using ruby on rails 4.1 applying domain driven design and test driven development principles.}
+  spec.homepage      = "http://github.com/pmviva/mention_system"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.0.0")
+
+  spec.add_dependency "rails", [ ">= 4.1", "< 5" ]
+
+  spec.add_development_dependency "appraisal", "~> 2.0"
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.1"
+  spec.add_development_dependency "shoulda-matchers", "~> 2.7"
+  spec.add_development_dependency "sqlite3", "~> 1.3"
+end
+

data/spec/db/migrate/20140926000000_create_mentions.rb

@@ -0,0 +1,47 @@
+###
+# CreateMentions class
+#
+# This class defines the test create mentions migration in mention system
+###
+class CreateMentions < ActiveRecord::Migration
+  ###
+  # Changes the database
+  ###
+  def change
+    ###
+    # Mentions table creation
+    ###
+    create_table :mentions do |t|
+      ###
+      # Mentionee id field and mentionee type field definition
+      ###
+      t.references :mentionee, polymorphic: true
+
+      ###
+      # Mentioner id fiel and mentioner type field definition
+      ###
+      t.references :mentioner, polymorphic: true
+
+      ###
+      # Timestamps fields definition
+      ###
+      t.timestamps null: false
+    end
+
+    ###
+    # Mentions table mentionee id field and mentionee type field index addition
+    ###
+    add_index :mentions, [:mentionee_id, :mentionee_type], name: "mentions_mentionee_idx"
+
+    ###
+    # Mentions table mentioner id field and mentioner type field index addition
+    ###
+    add_index :mentions, [:mentioner_id, :mentioner_type], name: "mentions_mentioner_idx"
+
+    ###
+    # Mentions table mentionee id field and mentionee type field and mentioner id field and mentioner type field unique index addition
+    ###
+    add_index :mentions, [:mentionee_id, :mentionee_type, :mentioner_id, :mentioner_type], name: "mentions_mentionee_mentioner_idx", unique: true
+  end
+end
+

data/spec/db/migrate/20140926000005_create_dummy_mentioners.rb

@@ -0,0 +1,22 @@
+###
+# CreateDummyMentioners class
+#
+# This class defines the create dummy mentioners migration in mention system
+###
+class CreateDummyMentioners < ActiveRecord::Migration
+  ###
+  # Changes the database
+  ###
+  def change
+    ###
+    # Dummy mentioners table creation
+    ###
+    create_table :dummy_mentioners do |t|
+      ###
+      # Timestamps fields definition
+      ###
+      t.timestamps null: false
+    end
+  end
+end
+

data/spec/db/migrate/20140926000010_create_dummy_mentionees.rb

@@ -0,0 +1,22 @@
+###
+# CreateDummyMentionees class
+#
+# This class defines the create dummy mentionees migration in mention system
+###
+class CreateDummyMentionees < ActiveRecord::Migration
+  ###
+  # Changes the database
+  ###
+  def change
+    ###
+    # Dummy mentionees table creation
+    ###
+    create_table :dummy_mentionees do |t|
+      ###
+      # Timestamps fields definition
+      ###
+      t.timestamps null: false
+    end
+  end
+end
+

data/spec/mention_system/mention_processor_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+###
+# Describes MentionSystem::MentionProcessor
+###
+describe MentionSystem::MentionProcessor do
+  ###
+  # Let mention_processor be MentionSystem::MentionProcessor.new
+  ###
+  let(:mention_processor) { MentionSystem::MentionProcessor.new }
+
+  ###
+  # Let mentionee be DummyMentionee.create
+  ###
+  let(:mentionee) { DummyMentionee.create }
+
+  ###
+  # Let mentioner be DummyMentioner.create
+  ###
+  let(:mentioner) { DummyMentioner.create }
+
+  ###
+  # Describes instance methods
+  ###
+  describe "instance methods" do
+    ###
+    # Should process mentions with default mention prefix
+    ###
+    it "should process mentions with default mention prefix" do
+      expect(mention_processor).to receive(:extract_mentioner_content).with(mentioner) { "This is the mentioner content with @handle1 and @handle2" }
+
+      expect(mention_processor).to receive(:find_mentionees_by_handles).with(["handle1", "handle2"]) { [mentionee] }
+
+      expect(mentioner).to receive(:mention).with(mentionee) { true }
+
+      mention_processor.process_mentions(mentioner)
+    end
+
+    ###
+    # Should process mentions with overriden mention prefix
+    ###
+    it "should process mentions with overriden mention prefix" do
+      expect(mention_processor).to receive(:mention_prefix).exactly(3).times { "#" }
+
+      expect(mention_processor).to receive(:extract_mentioner_content).with(mentioner) { "This is the mentioner content with #handle1 and #handle2" }
+
+      expect(mention_processor).to receive(:find_mentionees_by_handles).with(["handle1", "handle2"]) { [mentionee] }
+
+      expect(mentioner).to receive(:mention).with(mentionee) { true }
+
+      mention_processor.process_mentions(mentioner)
+    end
+
+    ###
+    # Should invooke after callbacks when processing mentions
+    ###
+    it "should invoke after callbacks when processing mentions" do
+      callback = Proc.new { }
+
+      mention_processor.add_after_callback(callback)
+      mention_processor.add_after_callback(callback)
+
+      expect(callback).to receive(:call).exactly(2).times { true }
+
+      expect(mention_processor).to receive(:extract_mentioner_content).with(mentioner) { "This is the mentioner content with @handle1 and @handle2" }
+
+      expect(mention_processor).to receive(:find_mentionees_by_handles).with(["handle1", "handle2"]) { [mentionee] }
+
+      expect(mentioner).to receive(:mention).with(mentionee) { true }
+
+      mention_processor.process_mentions(mentioner)
+    end
+
+    ###
+    # Should stop processing when invoke after callback returns false
+    ###
+    it "should sto processing when invoke after callback returns false" do
+      callback = Proc.new { }
+
+      mention_processor.add_after_callback(callback)
+      mention_processor.add_after_callback(callback)
+
+      expect(callback).to receive(:call).once { false }
+
+      expect(mention_processor).to receive(:extract_mentioner_content).with(mentioner) { "This is the mentioner content with @handle1 and @handle2" }
+
+      expect(mention_processor).to receive(:find_mentionees_by_handles).with(["handle1", "handle2"]) { [mentionee] }
+
+      expect(mentioner).to receive(:mention).with(mentionee) { true }
+
+      mention_processor.process_mentions(mentioner)
+    end
+
+    ###
+    # Should invoke before callbacks when processing mentions
+    ###
+    it "should invoke before callbacks when processing mentions" do
+      callback = Proc.new {}
+
+      mention_processor.add_before_callback(callback)
+      mention_processor.add_before_callback(callback)
+
+      expect(callback).to receive(:call).exactly(2).times { true }
+
+      expect(mention_processor).to receive(:extract_mentioner_content).with(mentioner) { "This is the mentioner content with @handle1 and @handle2" }
+
+      expect(mention_processor).to receive(:find_mentionees_by_handles).with(["handle1", "handle2"]) { [mentionee] }
+
+      expect(mentioner).to receive(:mention).with(mentionee) { true }
+
+      mention_processor.process_mentions(mentioner)
+    end
+
+    ###
+    # Should stop processing when invoke before callbacks returns false
+    ###
+    it "should stop processing when invoke before callback returns false" do
+      callback = Proc.new {}
+
+      mention_processor.add_before_callback(callback)
+      mention_processor.add_before_callback(callback)
+
+      expect(callback).to receive(:call).once { false }
+
+      expect(mention_processor).to receive(:extract_mentioner_content).with(mentioner) { "This is the mentioner content with @handle1 and @handle2" }
+
+      expect(mention_processor).to receive(:find_mentionees_by_handles).with(["handle1", "handle2"]) { [mentionee] }
+
+      expect(mentioner).to receive(:mention).with(mentionee).at_most(0).times
+
+      mention_processor.process_mentions(mentioner)
+    end
+
+    ###
+    # Should stop processing when mention returns false
+    ###
+    it "should stop processing when mention returns false" do
+      callback = Proc.new {}
+
+      mention_processor.add_after_callback(callback)
+      mention_processor.add_after_callback(callback)
+
+      expect(callback).to receive(:call).at_most(0).times
+
+      expect(mention_processor).to receive(:extract_mentioner_content).with(mentioner) { "This is the mentioner content with @handle1 and @handle2" }
+
+      expect(mention_processor).to receive(:find_mentionees_by_handles).with(["handle1", "handle2"]) { [mentionee] }
+
+      expect(mentioner).to receive(:mention).with(mentionee) { false }
+
+      mention_processor.process_mentions(mentioner)
+    end
+  end
+end
+

data/spec/mention_system/mention_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+###
+# Describes MentionSystem::Mention
+###
+describe MentionSystem::Mention do
+  ###
+  # Let mentionee be DummyMentionee.create
+  ###
+  let(:mentionee) { DummyMentionee.create }
+
+  ###
+  # Let mentioner be DummyMentioner.create
+  ###
+  let(:mentioner) { DummyMentioner.create }
+
+  ###
+  # Describes associations
+  ###
+  describe "associations" do
+    ###
+    # Should belong to mentionee
+    ###
+    it "should belong to mentionee" do
+      should belong_to(:mentionee)
+    end
+
+    ###
+    # Should belong to mentioner
+    ###
+    it "should belong to mentioner" do
+      should belong_to(:mentioner)
+    end
+  end
+
+  ###
+  # Describes class methods
+  ###
+  describe "class methods" do
+    ###
+    # Should raise argument error on invalid mentionee when mentions
+    ###
+    it "should raise argument error on invalid mentionee when mentions" do
+      expect { MentionSystem::Mention.mention(mentioner, mentioner) }.to raise_error ArgumentError
+    end
+
+    ###
+    # Should raise argument error on invalid mentioner when mentions
+    ###
+    it "should raise argument error on invalid mentioner when mentions " do
+      expect { MentionSystem::Mention.mention(mentionee, mentionee) }.to raise_error ArgumentError
+    end
+
+    ###
+    # Should mention
+    ###
+    it "should mention" do
+      expect(MentionSystem::Mention.mention(mentioner, mentionee)).to equal(true)
+    end
+
+    ###
+    # Should not mention
+    ###
+    it "should not mention" do
+      MentionSystem::Mention.mention(mentioner, mentionee)
+
+      expect(MentionSystem::Mention.mention(mentioner, mentionee)).to equal(false)
+    end
+
+    ###
+    # Should raise argument error on invalid mentionee when unmentions
+    ###
+    it "should raise argument error on invalid mentionee when unmentions" do
+      expect { MentionSystem::Mention.unmention(mentioner, mentioner) }.to raise_error ArgumentError
+    end
+
+    ###
+    # Should raise argument error on invalid mentioner when unmentions
+    ###
+    it "should raise argument error on invalid mentioner when unmentions" do
+      expect { MentionSystem::Mention.unmention(mentionee, mentionee) }.to raise_error ArgumentError
+    end
+
+    ###
+    # Should unmention
+    ###
+    it "should unmention" do
+      MentionSystem::Mention.mention(mentioner, mentionee)
+
+      expect(MentionSystem::Mention.unmention(mentioner, mentionee)).to equal(true)
+    end
+
+    ###
+    # Should not unmention
+    ###
+    it "should not unmention" do
+      expect(MentionSystem::Mention.unmention(mentioner, mentionee)).to equal(false)
+    end
+
+    ###
+    # Should raise argument error on invalid mentionee when toggle mention
+    ###
+    it "should raise argument error on invalid mentionee when toggle mention" do
+      expect { MentionSystem::Mention.toggle_mention(mentioner, mentioner) }.to raise_error ArgumentError
+    end
+
+    ###
+    # Should raise argument error on invalid mentioner when toggle mention
+    ###
+    it "should raise argument error on invalid mentioner when toggle mention" do
+      expect { MentionSystem::Mention.toggle_mention(mentionee, mentionee) }.to raise_error ArgumentError
+    end
+
+    ###
+    # Should toggle mention
+    ###
+    it "should toggle mention" do
+      expect(MentionSystem::Mention.mentions?(mentioner, mentionee)).to equal(false)
+
+      MentionSystem::Mention.toggle_mention(mentioner, mentionee)
+
+      expect(MentionSystem::Mention.mentions?(mentioner, mentionee)).to equal(true)
+
+      MentionSystem::Mention.toggle_mention(mentioner, mentionee)
+
+      expect(MentionSystem::Mention.mentions?(mentioner, mentionee)).to equal(false)
+    end
+
+    ###
+    # Should specify if mentions
+    ###
+    it "should specify if mentions" do
+      expect(MentionSystem::Mention.mentions?(mentioner, mentionee)).to equal(false)
+
+      MentionSystem::Mention.mention(mentioner, mentionee)
+
+      expect(MentionSystem::Mention.mentions?(mentioner, mentionee)).to equal(true)
+    end
+
+    ###
+    # Should scope mentions by mentionee
+    ###
+    it "should scope mentions by mentionee" do
+      scope = MentionSystem::Mention.where(mentionee: mentionee)
+
+      expect(MentionSystem::Mention.scope_by_mentionee(mentionee)).to eq(scope)
+    end
+
+    ###
+    # Should scope mentions by mentionee type
+    ####
+    it "should scope mentions by mentionee type" do
+      scope = MentionSystem::Mention.where(mentionee_type: DummyMentionee)
+
+      expect(MentionSystem::Mention.scope_by_mentionee_type(DummyMentionee)).to eq(scope)
+    end
+
+    ###
+    # Should scope mentions by mentioner
+    ###
+    it "should scope mentions by mentioner" do
+      scope = MentionSystem::Mention.where(mentioner: mentioner)
+
+      expect(MentionSystem::Mention.scope_by_mentioner(mentioner)).to eq(scope)
+    end
+
+    ###
+    # Should scope mentions by mentioner type
+    ####
+    it "should scope mentions by mentioner type" do
+      scope = MentionSystem::Mention.where(mentioner_type: DummyMentioner)
+
+      expect(MentionSystem::Mention.scope_by_mentioner_type(DummyMentioner)).to eq(scope)
+    end
+  end
+end
+