mention_system 0.0.6

data/lib/mention_system/mention.rb

@@ -0,0 +1,155 @@
+###
+# MentionSystem module
+#
+# This module defines common behavior in mention system
+###
+module MentionSystem
+  ###
+  # Mention class
+  #
+  # This class defines the mention model in mention system
+  ###
+  class Mention < ActiveRecord::Base
+    ###
+    # Belongs to mentionee association configuration
+    ###
+    belongs_to :mentionee, polymorphic: :true
+
+    ###
+    # Belongs to mentioner association configuration
+    ###
+    belongs_to :mentioner, polymorphic: :true
+
+    ###
+    # Creates a {Mention} relationship between a {Mentioner} object and a {Mentionee} object
+    #
+    # @param [Mentioner] mentioner - the {Mentioner} of the relationship
+    # @param [Mentionee] mentionee - the {Mentionee} of the relationship
+    # @return [Boolean]
+    ###
+    def self.mention(mentioner, mentionee)
+      validate_mentionee(mentionee)
+      validate_mentioner(mentioner)
+
+      if mentions?(mentioner, mentionee)
+        false
+      else
+        mention = scope_by_mentioner(mentioner).scope_by_mentionee(mentionee).build
+        mention.save
+        true
+      end
+    end
+
+    ###
+    # Destroys a {Mention} relationship between a {Mentioner} object and a {Mentionee} object
+    #
+    # @param [Mentioner] mentioner - the {Mentioner} of the relationship
+    # @param [Mentionee] mentionee - the {Mentionee} of the relationship
+    # @return [Boolean]
+    ###
+    def self.unmention(mentioner, mentionee)
+      validate_mentionee(mentionee)
+      validate_mentioner(mentioner)
+
+      if mentions?(mentioner, mentionee)
+        mention = scope_by_mentioner(mentioner).scope_by_mentionee(mentionee).take
+        mention.destroy
+        true
+      else
+        false
+      end
+    end
+
+    ###
+    # Toggles a {Mention} relationship between a {Mentioner} object and a {Mentionee} object
+    #
+    # @param [Mentioner] mentioner - the {Mentioner} of the relationship
+    # @param [Mentionee] mentionee - the {Mentionee} of the relationship
+    # @return [Boolean]
+    ###
+    def self.toggle_mention(mentioner, mentionee)
+      validate_mentionee(mentionee)
+      validate_mentioner(mentioner)
+
+      if mentions?(mentioner, mentionee)
+        unmention(mentioner, mentionee)
+      else
+        mention(mentioner, mentionee)
+      end
+    end
+
+    ###
+    # Specifies if a {Mentioner} object mentions a {Mentionee} object
+    #
+    # @param [Mentioner] mentioner - the {Mentioner} object to test against
+    # @param [Mentionee] mentionee - the {Mentionee} object to test against
+    # @return [Boolean]
+    ###
+    def self.mentions?(mentioner, mentionee)
+      validate_mentionee(mentionee)
+      validate_mentioner(mentioner)
+
+      scope_by_mentioner(mentioner).scope_by_mentionee(mentionee).exists?
+    end
+
+    ###
+    # Retrieves a scope of {Mention} objects filtered by a {Mentionee} object
+    #
+    # @param [Mentionee] mentionee - the {Mentionee} to filter
+    # @return [ActiveRecord::Relation]
+    ###
+    def self.scope_by_mentionee(mentionee)
+      where(mentionee: mentionee)
+    end
+
+    ###
+    # Retrieves a scope of {Mention} objects filtered by a {Mentionee} type
+    #
+    # @param [Class] klass - the {Class} to filter
+    # @return [ActiveRecord::Relation]
+    ###
+    def self.scope_by_mentionee_type(klass)
+      where(mentionee_type: klass.to_s.classify)
+    end
+
+    ###
+    # Retrieves a scope of {Mention} objects filtered by a {Mentioner} object
+    #
+    # @param [Mentioner] mentioner - the {Mentioner} to filter
+    # @return [ActiveRecord::Relation]
+    ###
+    def self.scope_by_mentioner(mentioner)
+      where(mentioner: mentioner)
+    end
+
+    ###
+    # Retrieves a scope of {Mention} objects filtered by a {Mentioner} type
+    #
+    # @param [Class] klass - the {Class} to filter
+    # @return [ActiveRecord::Relation]
+    ###
+    def self.scope_by_mentioner_type(klass)
+      where(mentioner_type: klass.to_s.classify)
+    end
+
+    private
+      ###
+      # Validates a mentionee object
+      #
+      # @raise [ArgumentError] if the mentionee object is invalid
+      ###
+      def self.validate_mentionee(mentionee)
+        raise ArgumentError.new unless mentionee.respond_to?(:is_mentionee?) && mentionee.is_mentionee?
+      end
+
+      ###
+      # Validates a mentioner object
+      #
+      # @raise [ArgumentError] if the mentioner object is invalid
+      ###
+      def self.validate_mentioner(mentioner)
+        raise ArgumentError.new unless mentioner.respond_to?(:is_mentioner?) && mentioner.is_mentioner?
+      end
+  end
+end
+

data/lib/mention_system/mention_processor.rb

@@ -0,0 +1,141 @@
+###
+# MentionSystem module
+#
+# This module defines common behavior in mention system
+###
+module MentionSystem
+  ###
+  # MentionProcessor class
+  #
+  # This class defines mention processor behavior in mention system
+  ###
+  class MentionProcessor
+    ###
+    # Constructor of the MentionProcessor class
+    ###
+    def initialize
+      @callbacks = { after: [], before: [] }
+    end
+
+    ###
+    # Adds an after callback
+    #
+    # @param [Proc] callback - the callback to add
+    ###
+    def add_after_callback(callback)
+      @callbacks[:after].push(callback)
+    end
+
+    ###
+    # Adds a before callback
+    #
+    # @param [Proc] callback - the callback to add
+    ###
+    def add_before_callback(callback)
+      @callbacks[:before].push(callback)
+    end
+
+    ###
+    # Extract handles from mentioner
+    #
+    # @param [Mentioner] mentioner - the {Mentioner} to extract handles from
+    # @return [Array]
+    ###
+    def extract_handles_from_mentioner(mentioner)
+      content = extract_mentioner_content(mentioner)
+      handles = content.scan(handle_regexp).map { |handle| handle.gsub("#{mention_prefix}","") }
+    end
+
+    ###
+    # Extracts the mentioner content
+    #
+    # @param [Mentioner] mentioner - the {Mentioner} to extract content from
+    # @return [String]
+    ###
+    def extract_mentioner_content(mentioner)
+      raise "Must be implemented in subclass"
+    end
+
+    ###
+    # Finds mentionees by handles
+    #
+    # @param [Array] handles - the array of {Mentionee} handles to find
+    # @return [Array]
+    ###
+    def find_mentionees_by_handles(*handles)
+      raise "Must be implemented in subclass"
+    end
+
+    ###
+    # Process mentions
+    #
+    # @param [Mentioner] mentioner - the {Mentioner} to process mentions from
+    ###
+    def process_mentions(mentioner)
+      handles = extract_handles_from_mentioner(mentioner)
+      mentionees = find_mentionees_by_handles(handles)
+
+      mentionees.each do |mentionee|
+        if process_before_callbacks(mentioner, mentionee)
+          if mentioner.mention(mentionee)
+            process_after_callbacks(mentioner, mentionee)
+          end
+        end
+      end
+    end
+
+    private
+      ###
+      # Retrieves the handle regexp
+      #
+      # @return [Regexp]
+      ###
+      def handle_regexp
+        /(?<!\w)#{mention_prefix}\w+/
+      end
+
+      ###
+      # Returns the mention prefix
+      #
+      # @return [String]
+      ###
+      def mention_prefix
+        "@"
+      end
+
+      ###
+      # Process after callbacks
+      #
+      # @param [Mentioner] mentioner - the mentioner of the callback
+      # @param [Mentionee] mentionee - the mentionee of the callback
+      ###
+      def process_after_callbacks(mentioner, mentionee)
+        result = true
+        @callbacks[:after].each do |callback|
+          unless callback.call(mentioner, mentionee)
+            result = false
+            break
+          end
+        end
+        result
+      end
+
+      ###
+      # Process before callbacks
+      #
+      # @param [Mentioner] mentioner - the mentioner of the callback
+      # @param [Mentionee] mentionee - the mentionee of the callback
+      ###
+      def process_before_callbacks(mentioner, mentionee)
+        result = true
+        @callbacks[:before].each do |callback|
+          unless callback.call(mentioner, mentionee)
+            result = false
+            break
+          end
+        end
+        result
+      end
+  end
+end
+

data/lib/mention_system/mentionee.rb

@@ -0,0 +1,58 @@
+###
+# MentionSystem module
+#
+# This module defines common behavior in mention system
+###
+module MentionSystem
+  ###
+  # Mentionee module
+  #
+  # This module defines mentionee behavior in mention system
+  ###
+  module Mentionee
+    ###
+    # Extends ActiveSupport::Concern
+    ###
+    extend ActiveSupport::Concern
+
+    ###
+    # Included configuration
+    ###
+    included do
+      ###
+      # Has many mentioners association configuration
+      ###
+      has_many :mentioners, class_name: "MentionSystem::Mention", as: :mentionee, dependent: :destroy
+    end
+
+    ###
+    # Specifies if self can be mentioned by {Mentioner} objects
+    #
+    # @return [Boolean]
+    ###
+    def is_mentionee?
+      true
+    end
+
+    ###
+    # Specifies if self is mentioned by a {Mentioner} object
+    #
+    # @param [Mentioner] mentioner - the {Mentioner} object to test against
+    # @return [Boolean]
+    ###
+    def mentioned_by?(mentioner)
+      Mention.mentions?(mentioner, self)
+    end
+
+    ###
+    # Retrieves a scope of {Mention} objects that mentions self filtered {Mentioner} type
+    #
+    # @param [Class] klass - the {Class} to filter
+    # @return [ActiveRecord::Relation]
+    ###
+    def mentioners_by(klass)
+      Mention.scope_by_mentionee(self).scope_by_mentioner_type(klass)
+    end
+  end
+end
+

data/lib/mention_system/mentioner.rb

@@ -0,0 +1,88 @@
+###
+# MentionSystem module
+#
+# This module defines common behavior in mention system
+###
+module MentionSystem
+  ###
+  # Mentioner module
+  #
+  # This module defines mentioner behavior in mention system
+  ###
+  module Mentioner
+    ###
+    # Extends ActiveSupport::Concern
+    ###
+    extend ActiveSupport::Concern
+
+    ###
+    # Included configuration
+    ###
+    included do
+      ###
+      # Has many mentionees association configuration
+      ###
+      has_many :mentionees, class_name: "MentionSystem::Mention", as: :mentioner, dependent: :destroy
+    end
+
+    ###
+    # Specifies if self can mention {Mentionee} objects
+    #
+    # @return [Boolean]
+    ###
+    def is_mentioner?
+      true
+    end
+
+    ###
+    # Creates a {Mention} relationship between self and a {Mentionee} object
+    #
+    # @param [Mentionee] mentionee - the mentionee of the {Mention} relationship
+    # @return [Boolean]
+    ###
+    def mention(mentionee)
+      Mention.mention(self, mentionee)
+    end
+
+    ###
+    # Destroys a {Mention} relationship between self and a {Mentionee} object
+    #
+    # @param [Mentionee] mentionee - the mentionee of the {Mention} relationship
+    # @return [Boolean]
+    ###
+    def unmention(mentionee)
+      Mention.unmention(self, mentionee)
+    end
+
+    ###
+    # Toggles a {Mention} relationship between self and a {Mentionee} object
+    #
+    # @param [Mentionee] mentionee - the mentionee of the {Mention} relationship
+    # @return [Boolean]
+    ###
+    def toggle_mention(mentionee)
+      Mention.toggle_mention(self, mentionee)
+    end
+
+    ###
+    # Specifies if self mentions a {Mentioner} object
+    #
+    # @param [Mentionee] mentionee - the {Mentionee} object to test against
+    # @return [Boolean]
+    ###
+    def mentions?(mentionee)
+      Mention.mentions?(self, mentionee)
+    end
+
+    ###
+    # Retrieves a scope of {Mention} objects that are mentioned by self
+    #
+    # @param [Class] klass - the {Class} to include
+    # @return [ActiveRecord::Relation]
+    ###
+    def mentionees_by(klass)
+      Mention.scope_by_mentioner(self).scope_by_mentionee_type(klass)
+    end
+  end
+end
+