acts_as_mentionable 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a9e8c57fc330401901ba129fabddc2b3383f0c93b018a7bedf86f7a1c98a4835
+  data.tar.gz: da143817eb31788245c13d3ae16e978320db6f8d78de4bdfd1c66405e61df5e8
+SHA512:
+  metadata.gz: ab5f7ababfd7e3dc833d1a63fde4c1fb1516d636843d80853cb448b274f134bd4a088ec6be6b183278b08746799ff508a38ef76de021e611c783ba8e37c9f76e
+  data.tar.gz: 215a73fc8de11cb20c7c3caf465cdf31cbc1a50dc8a9c7a36158010c1d88fc51378b46796b0a02d58f8768c82c4b7cf4f7348a6979f2d363f38b1aef4bbf535d

data/.circleci/config.yml

@@ -0,0 +1,66 @@
+# Ruby CircleCI 2.0 configuration file
+#
+# Check https://circleci.com/docs/2.0/language-ruby/ for more details
+#
+version: 2
+jobs:
+  build:
+    docker:
+       - image: circleci/ruby:2.3.8-jessie
+
+      # Specify service dependencies here if necessary
+      # CircleCI maintains a library of pre-built images
+      # documented at https://circleci.com/docs/2.0/circleci-images/
+      # - image: circleci/postgres:9.4
+
+    working_directory: ~/acts_as_mentionable
+
+    steps:
+      - checkout
+
+      # Download and cache dependencies
+      - restore_cache:
+          keys:
+          - v1-dependencies-
+
+      - run:
+          name: install dependencies
+          command: |
+            bundle install --jobs=4 --retry=3 --path vendor/bundle
+
+      - save_cache:
+          paths:
+            - ./vendor/bundle
+          key: v1-dependencies-{{ checksum "Gemfile.lock" }}
+
+      # run tests
+      - run:
+          name: Run Commit Message Checker
+          command: |
+            bundle exec fuse-dev-tools git validate_commit_message
+      - run:
+          name: Run Pull Request Validator
+          command: |
+            bundle exec fuse-dev-tools git validate_pull_request
+      - run:
+          name: Run Rubocop
+          command: |
+            bundle exec rubocop
+      - run:
+          name: Run Rspec
+          command: |
+            mkdir /tmp/test-results
+            TEST_FILES="$(circleci tests glob "spec/**/*_spec.rb" | circleci tests split --split-by=timings)"
+
+            bundle exec rspec --format progress \
+                            --format RspecJunitFormatter \
+                            --out /tmp/test-results/rspec.xml \
+                            --format progress \
+                            $TEST_FILES
+
+      # collect reports
+      - store_test_results:
+          path: /tmp/test-results
+      - store_artifacts:
+          path: /tmp/test-results
+          destination: test-results

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/spec/debug.log
+/Gemfile.lock
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,5 @@
+inherit_gem:
+  fuse-dev-tools: lib/fuse_dev_tools/templates/rubocop.yml
+
+AllCops:
+  TargetRubyVersion: 2.3

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.4
+before_install: gem install bundler -v 1.17.1

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in acts_as_mentionable.gemspec
+gemspec
+
+group :development do
+  gem 'fuse-dev-tools', github: 'Fuseit/fuse-dev-tools'
+  gem 'pry'
+  gem 'pry-byebug'
+  gem 'rubocop'
+  gem 'rubocop-rspec'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Baron Bloomer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,212 @@
+# ActsAsMentionable
+
+ActsAsMentionable is an ActiveRecord gem, which is called to help you build your own mentioning system on top of your Ruby On Rails project. With its help you can mention ActiveRecord objects from ActiveRecord objects, such as users from within the comment's text. For instance, when John Doe mentioned Richard Roe in a comment, then Richard Roe usually will receive the notification about being mentioned and mention will be stored in database.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'acts_as_mentionable'
+```
+
+And then execute:
+```shell
+$ bundle
+```
+
+Or install it yourself as:
+```shell
+$ gem install acts_as_mentionable
+```
+
+#### Post Installation
+
+Install migrations
+```shell
+rake acts_as_mentionable_engine:install:migrations
+```
+
+Review the generated migrations then migrate:
+```shell
+rake db:migrate
+```
+
+## Usage
+
+Let's continue with mentioning users from the comment. In a such case comment is a mentioner, because it can mention users, and user is a mentionable, as user can be mentioned.
+
+### Mentioner model
+
+```ruby
+# == Schema Information
+#
+#  id          :integer          not null, primary key
+#  body        :text(65535)
+#  parsed_body :text(65535)
+#
+
+class Comment < ActiveRecord::Base
+  # ...
+  acts_as_mentioner :body
+  # ...
+  def retrieve_mentions_callback
+    mentionables = ActsAsMentionable::MentionerParser.new(self).parse!
+    replace_mentionables(mentionables, save: true)
+  end
+end
+```
+
+Mentioner (`Comment`) model is expected to have two fields:
+1. The field, which contains, let's say, plain version of the comment - in the example above it's `body`. This field, by default, is rewritten by the parser and contains all the mentions as the plain text, e.g. `Hello, @john!`.
+2. The field, which contains comment with the mentions. It's named as the `parsed_*`, where `*` is meant to be the field, which contains plain version of the comment. In the example above it's named `parsed_body`. Mentions are recognized by the following template - `{#|RECORD_ID|RECORD_MODEL_NAME}`, where `RECORD_ID` is the ID of record being mentioned, for instance, user ID, and, `RECORD_MODEL_NAME` is the name of the model being mentioned, for instance, for `User` model it is `user`. According to this, `parsed_body` field may have the following value - `Hello, {#|42|user}!`.
+
+So, as you may have already noticed, the argument provided to the `#acts_as_mentioner` method is the name of the field, which is a plain version of the comment - `body`, and the name of the field, which contains mentions is generated automatically - `parsed_body`.
+
+### Mentionable model
+
+```ruby
+# == Schema Information
+#
+#  id       :integer          not null, primary key
+#  username :string(255)
+#
+
+class User < ActiveRecord::Base
+  # ...
+  acts_as_mentionable :username
+  # ...
+end
+```
+The argument `username` provided to `#acts_as_mentionable` method, is a field on user's model, which is used as a replacement for mention template in order to build a plain version of the comment. For example, we have the following code:
+```ruby
+user = User.create! id: 42, username: 'john'
+comment = Comment.create! parsed_body: 'Hello, {#|42|user}!'
+puts comment.body
+# => Hello, @john!
+```
+As you can see, it this case `{#|42|user}` in `parsed_body` is replaced by `@` + `username` field of the user in comment's `body`.
+
+### Retrieving mentions
+
+Mentioner's `parsed_*` field is not parsed by default. You have to invoke `ActsAsMentionable::MentionerParser#parse!` method in order to parse it and retrieve mentionables (users in our case).
+
+```ruby
+mentionables = ActsAsMentionable::MentionerParser.new(comment).parse!
+```
+
+The line above parses comment's `parsed_body` field and does the following:
+1. Generates and saves the plain version of the comment - `body` field.
+2. Returns mentionables - in our case only users are expected, but it's possible to mix different types of mentionables.
+
+We can mix together several types of mentionables. Let's check the following code:
+
+```ruby
+comment = Comment.create! \
+  parsed_body: 'Hello, {#|42|user}! Can you please join the {#|123|community}?'
+
+mentionables = ActsAsMentionable::MentionerParser.new(comment).parse!
+
+comment.body
+# => Hello, @john! Can you please join the @developers?
+
+mentionables
+# => [#<User:...>, #<Community:...>]
+```
+
+In this case `User` with ID `42` and `Community` with ID `123` are mentioned, but only if `Community` model has `acts_as_mentionable` defined on it. Otherwise, `{#|123|community}` will be left as is:
+```ruby
+comment.body
+# => Hello, @john! Can you please join the {#|123|community}?
+
+mentionables
+# => [#<User:...>]
+```
+
+Just in case, `ActsAsMentionable::MentionerParser` class does not fit your needs, you can either extend or define your own class, which parses `parsed_body` field, writes `body` and returns mentioned records. Here you can see implementation details of the existing one [mentioner_parser.rb](https://github.com/Fuseit/acts_as_mentionable/blob/master/lib/acts_as_mentionable/mentioner_parser.rb).
+
+### Saving mentions
+
+In order to save mentioned records you can use of the following methods defined on mentioner:
+
+Mention records, `save` option is set to `false` by default:
+```ruby
+comment.mention mentionables, save: false
+```
+
+Unmention records, `save` option is set to `false` by default:
+```ruby
+comment.unmention mentionables, save: false
+```
+
+Replace mentioned records, `save` option is set to `false` by default:
+```ruby
+comment.replace_mentionables mentionables, save: false
+```
+
+Save changes to mentions:
+```ruby
+comment.save_mentions
+```
+
+### Callbacks
+
+When there are changes to mentions and mentions being saved a callback with mentioner record and mention changes can be invoked. In order to define a callback, add the Rails initializer like the following:
+
+```ruby
+# config/initializers/acts_as_mentionable.rb
+
+ActsAsMentionable.setup do |configuration|
+  configuration.mentions_updated_callback = lambda do |mentioner, changes|
+    p mentioner
+    # => #<Comment:...>
+
+    p changes
+    # =>
+    # {
+    #   changed: true,
+    #   added: [#<User:...>, #<Community:...>],
+    #   removed: [#<User:...>],
+    #   previous: [#<User:...>],
+    #   current: [#<User:...>, #<Community:...>]
+    # }
+  end
+end
+```
+
+Where, `mentioner` in our case is a comment record, which mentioned users, and changes is a hash of changes, which has the following keys:
+* `:changed` - detects if changed is being made to mentions
+* `:added` - defines, which mentions were added
+* `:removed` - defines, which mentions were removed
+* `:previous` - defines, which mentions were before
+* `:current` - defines, which mentions are currently saved
+
+### Mentioner methods
+
+* `#mentioner?` - is always set to `true` for mentioner records (e.g. comment), otherwise is set to `false`
+* `#mentionables` - returns mentioned records
+* `#mention *mentionables, save: false` - mention records
+* `#unmention *mentionables, save: false` - unmention records
+* `#replace_mentionables *mentionables, save: false` - replace mentioned records
+* `#save_mentions` - save changes to mentions
+* `#retrieve_mentions_callback` - is a callback method, which should retrieve and save mentions. It does nothing by default, so you have to redefine it.
+* `#need_retrieve_mentions?` - returns `true` if `#retrieve_mentions_callback` should be invoked. By default it's an alias to mentioner's `parsed_*_changed?` attribute, e.g. `parsed_body_changed?`. You can redefine this method if you want to have custom logic for invoking `#retrieve_mentions_callback`.
+
+### Mentionable methods
+
+* `#mentionable?` - is always set to `true` for mentionable records (e.g. user), otherwise is set to `false`
+* `#mentionables` - returns mentioner records, e. g. an array of comments, where user is mentioned
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Fuseit/acts_as_mentionable.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/acts_as_mentionable.gemspec

@@ -0,0 +1,37 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'acts_as_mentionable/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'acts_as_mentionable'
+  spec.version = ActsAsMentionable::VERSION
+  spec.authors = ['Baron Bloomer', 'Dmitry Radionov', 'Nazar Vinnychuk']
+  spec.email = ['baronbloomer@gmail.com']
+
+  spec.summary = 'Add the ability to mention ActiveRecord objects such as users within text!'
+  spec.description = 'With ActsAsMentionable you can mention a different models in different contents.'
+  spec.homepage = 'https://github.com/Fuseit/acts_as_mentionable'
+  spec.license = 'MIT'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+
+  spec.require_paths = %w[lib]
+  spec.required_ruby_version = '>= 2.3.4'
+
+  # Need to support different ActiveRecord versions i.e. 4.2, 5+
+  # Differentiate through versioned code?
+  spec.add_runtime_dependency 'activerecord', '~> 4.2'
+
+  spec.add_development_dependency 'bundler', '~> 1.17'
+  spec.add_development_dependency 'database_cleaner', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.5'
+  spec.add_development_dependency 'rspec', '~> 3.8'
+  spec.add_development_dependency 'rspec-its', '~> 1.2'
+  spec.add_development_dependency 'rspec_junit_formatter'
+  spec.add_development_dependency 'sqlite3', '~> 1.3'
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'acts_as_mentionable'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/db/migrate/1_acts_as_mentionable_migration.rb

@@ -0,0 +1,20 @@
+if ActiveRecord.gem_version >= Gem::Version.new('5.0')
+  class ActsAsMentionableMigration < ActiveRecord::Migration[4.2]; end
+else
+  class ActsAsMentionableMigration < ActiveRecord::Migration; end
+end
+
+ActsAsMentionableMigration.class_eval do
+  def change
+    create_table ActsAsMentionable.mentions_table do |t|
+      t.references :mentionable, polymorphic: true, index: { name: 'mentions_mentionable_idx' }
+      t.references :mentioner, polymorphic: true, index: { name: 'mentions_mentioner_idx' }
+      t.timestamps
+    end
+
+    add_index ActsAsMentionable.mentions_table,
+      %i[mentionable_id mentionable_type mentioner_id mentioner_type],
+      name: 'mentions_mentionable_mentioner_idx',
+      unique: true
+  end
+end

data/lib/acts_as_mentionable/active_record_methods.rb

@@ -0,0 +1,40 @@
+module ActsAsMentionable
+  module ActiveRecordMethods
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def acts_as_mentionable mentionable_field
+        class_eval do
+          cattr_reader :mentionable_field
+
+          class_variable_set('@@mentionable_field', mentionable_field)
+        end
+        include ActsAsMentionable::Mentionable
+      end
+
+      def acts_as_mentioner mention_field
+        class_eval do
+          cattr_reader :mention_field, :mention_parsed_field
+
+          after_save :retrieve_mentions_callback, if: :need_retrieve_mentions? if self <= ActiveRecord::Base
+
+          define_method(:need_retrieve_mentions?) { send "parsed_#{self.class.mention_field}_changed?" }
+
+          define_method(:retrieve_mentions_callback) { nil }
+
+          class_variable_set('@@mention_field', mention_field)
+          class_variable_set('@@mention_parsed_field', "parsed_#{mention_field}".to_sym)
+        end
+        include ActsAsMentionable::Mentioner
+      end
+    end
+
+    def mentionable?
+      false
+    end
+
+    def mentioner?
+      false
+    end
+  end
+end

data/lib/acts_as_mentionable/engine.rb

@@ -0,0 +1,4 @@
+module ActsAsMentionable
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/acts_as_mentionable/mention.rb

@@ -0,0 +1,46 @@
+# == Schema Information
+#
+# Table name: mentions
+#
+#  id               :integer          not null, primary key
+#  mentionable_id   :integer          not null
+#  mentionable_type :string(255)      not null
+#  mentioner_id     :integer          not null
+#  mentioner_type   :string(255)      not null
+#  created_at       :datetime         not null
+#  updated_at       :datetime         not null
+#
+
+module ActsAsMentionable
+  class Mention < ::ActiveRecord::Base
+    self.table_name = ActsAsMentionable.mentions_table
+
+    belongs_to :mentioner, polymorphic: true
+    belongs_to :mentionable, polymorphic: true
+
+    scope :by_mentioners, ->(mentioners) { where mentioner: mentioners }
+    scope :by_mentionables, ->(mentionables) { where mentionable: mentionables }
+
+    validate :validate_mentioner
+    validate :validate_mentionable
+
+    def self.remove_mentionables_for_mentioner mentioner, mentionables
+      by_mentioners(mentioner).by_mentionables(mentionables).delete_all
+    end
+
+    def self.add_mentionables_for_mentioner mentioner, mentionables
+      attributes_list = Array(mentionables).map { |mentionable| { mentionable: mentionable } }
+      by_mentioners(mentioner).create! attributes_list
+    end
+
+    private
+
+      def validate_mentioner
+        errors.add :mentioner, :invalid unless mentioner.respond_to?(:mentioner?) && mentioner.mentioner?
+      end
+
+      def validate_mentionable
+        errors.add :mentionable, :invalid unless mentionable.respond_to?(:mentionable?) && mentionable.mentionable?
+      end
+  end
+end

data/lib/acts_as_mentionable/mentionable.rb

@@ -0,0 +1,20 @@
+module ActsAsMentionable
+  module Mentionable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :mentions,
+        as: :mentionable,
+        dependent: :delete_all,
+        class_name: '::ActsAsMentionable::Mention'
+    end
+
+    def mentionable?
+      true
+    end
+
+    def mentioners
+      RetrievePolymorphic.new(mentions, :mentioner).call
+    end
+  end
+end

data/lib/acts_as_mentionable/mentionables_manipulator.rb

@@ -0,0 +1,66 @@
+module ActsAsMentionable
+  class MentionablesManipulator
+    attr_reader :previous_set, :current_set
+
+    def initialize mentionables
+      @previous_set = mentionables.to_set
+      @current_set = mentionables.to_set
+    end
+
+    def add *mentionables
+      current_set.merge prepare_mentionables(mentionables)
+      self
+    end
+
+    def remove *mentionables
+      current_set.subtract prepare_mentionables(mentionables)
+      self
+    end
+
+    def replace *mentionables
+      current_set.replace prepare_mentionables(mentionables)
+      self
+    end
+
+    def fix_changes!
+      previous_set.replace current_set
+      self
+    end
+
+    def changes
+      {
+        changed: changed?,
+        added: added,
+        removed: removed,
+        previous: previous,
+        current: current
+      }
+    end
+
+    def changed?
+      current_set != previous_set
+    end
+
+    def added
+      (current_set - previous_set).to_a
+    end
+
+    def removed
+      (previous_set - current_set).to_a
+    end
+
+    def previous
+      previous_set.to_a
+    end
+
+    def current
+      current_set.to_a
+    end
+
+    private
+
+      def prepare_mentionables mentionables
+        mentionables.flatten
+      end
+  end
+end

data/lib/acts_as_mentionable/mentioner.rb

@@ -0,0 +1,69 @@
+module ActsAsMentionable
+  module Mentioner
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :mentions,
+        as: :mentioner,
+        dependent: :delete_all,
+        class_name: '::ActsAsMentionable::Mention'
+    end
+
+    def mentioner?
+      true
+    end
+
+    def mentionables
+      RetrievePolymorphic.new(mentions, :mentionable).call
+    end
+
+    def mention *mentionables, save: false
+      mentionables_manipulator.add(*mentionables)
+      return_changes { save_mentions if save }
+    end
+
+    def unmention *mentionables, save: false
+      mentionables_manipulator.remove(*mentionables)
+      return_changes { save_mentions if save }
+    end
+
+    def replace_mentionables *mentionables, save: false
+      mentionables_manipulator.replace(*mentionables)
+      return_changes { save_mentions if save }
+    end
+
+    def save_mentions
+      return unless mentionables_manipulator.changed?
+
+      return_changes do
+        MentionsUpdater.new(self, mentionables_manipulator.changes).call do
+          fix_mentionables_changes!
+        end
+      end
+    end
+
+    private
+
+      def return_changes
+        mentionables_manipulator.changes.tap { yield }
+      end
+
+      def mentionables_manipulator
+        @mentionables_manipulator ||= MentionablesManipulator.new mentionables
+      end
+
+      def refresh_mentionables_manipulator!
+        remove_instance_variable :@mentionables_manipulator
+      end
+
+      def fix_mentionables_changes!
+        mentionables_manipulator.fix_changes!
+
+        TransactionCallbacks.on_rolled_back do
+          current = mentionables_manipulator.current
+          refresh_mentionables_manipulator!
+          mentionables_manipulator.replace current
+        end
+      end
+  end
+end

data/lib/acts_as_mentionable/mentioner_parser.rb

@@ -0,0 +1,41 @@
+module ActsAsMentionable
+  class MentionerParser
+    attr_reader :mentioner
+
+    def initialize mentioner
+      @mentioner = mentioner
+    end
+
+    def parse!
+      mentionables = []
+      new_mention_field = mentioner.send(mentioner.class.mention_parsed_field).gsub(template_for_parsing) do |template|
+        _delimiter, mentionable_id, mentionable_klass = template.gsub(/[\{,\}]/, '').split('|')
+        mentionable = retrieve_mentionable mentionable_klass, mentionable_id
+        mentionables << mentionable if mentionable.respond_to?(:mentionable?) && mentionable.mentionable?
+        metionable_template mentionable, template
+      end
+      mentioner.update_column(mentioner.class.mention_field, new_mention_field)
+      mentionables
+    end
+
+    def retrieve_mentionable mentionable_klass, mentionable_id
+      mentionable_klass.classify.constantize.find mentionable_id
+    rescue NameError
+      nil
+    end
+
+    private
+
+      def template_for_parsing
+        /\{@\|\d+\|\w+\}/
+      end
+
+      def metionable_template mentionable, template
+        if mentionable.respond_to?(:mentionable?) && mentionable.mentionable?
+          "<U+2063>@#{mentionable.send(mentionable.class.mentionable_field)}<U+2063>"
+        else
+          template
+        end
+      end
+  end
+end

data/lib/acts_as_mentionable/mentions_updater.rb

@@ -0,0 +1,35 @@
+module ActsAsMentionable
+  class MentionsUpdater
+    attr_reader :mentioner, :changes
+
+    def initialize mentioner, changes
+      @mentioner = mentioner
+      @changes = changes
+    end
+
+    def call
+      Mention.transaction do
+        remove_old_mentionables
+        add_new_mentionables
+        invoke_mentions_updated_callback
+        yield if block_given?
+      end
+    end
+
+    private
+
+      def remove_old_mentionables
+        Mention.remove_mentionables_for_mentioner mentioner, changes[:removed] unless changes[:removed].empty?
+      end
+
+      def add_new_mentionables
+        Mention.add_mentionables_for_mentioner mentioner, changes[:added] unless changes[:added].empty?
+      end
+
+      def invoke_mentions_updated_callback
+        TransactionCallbacks.on_committed do
+          ActsAsMentionable.mentions_updated_callback.call mentioner, changes
+        end
+      end
+  end
+end

data/lib/acts_as_mentionable/retrieve_polymorphic.rb

@@ -0,0 +1,26 @@
+module ActsAsMentionable
+  class RetrievePolymorphic
+    attr_reader :relation, :polymorphic_association_name
+
+    def initialize relation, polymorphic_association_name
+      @relation = relation
+      @polymorphic_association_name = polymorphic_association_name
+    end
+
+    def call
+      type_to_ids.map { |type, ids| type.constantize.unscoped.find ids }.flatten
+    end
+
+    private
+
+      def type_and_id_list
+        relation.pluck "#{polymorphic_association_name}_type", "#{polymorphic_association_name}_id"
+      end
+
+      def type_to_ids
+        type_and_id_list.group_by(&:first).each_with_object({}) do |(type, type_and_id), hash|
+          hash[type] = type_and_id.map(&:last)
+        end
+      end
+  end
+end

data/lib/acts_as_mentionable/transaction_callbacks.rb

@@ -0,0 +1,42 @@
+module ActsAsMentionable
+  class TransactionCallbacks
+    class << self
+      def on_committed &block
+        if current_transaction.open?
+          add_transaction_record new(block, nil)
+        else
+          yield
+        end
+      end
+
+      def on_rolled_back &block
+        add_transaction_record new(nil, block)
+      end
+
+      private
+
+        def add_transaction_record record
+          current_transaction.add_record record
+        end
+
+        def current_transaction
+          Mention.connection.current_transaction
+        end
+    end
+
+    attr_reader :on_committed_block, :on_rolled_back_block
+
+    def initialize on_committed_block, on_rolled_back_block
+      @on_committed_block = on_committed_block
+      @on_rolled_back_block = on_rolled_back_block
+    end
+
+    def committed! _should_run_callbacks = true
+      on_committed_block&.call
+    end
+
+    def rolledback! _force_restore_state = false, _should_run_callbacks = true
+      on_rolled_back_block&.call
+    end
+  end
+end

data/lib/acts_as_mentionable/version.rb

@@ -0,0 +1,3 @@
+module ActsAsMentionable
+  VERSION = '0.2.0'.freeze
+end

data/lib/acts_as_mentionable.rb

@@ -0,0 +1,57 @@
+require 'active_record'
+require 'acts_as_mentionable/version'
+
+begin
+  require 'rails/engine'
+  require 'acts_as_mentionable/engine'
+rescue LoadError
+  puts 'Rails enviroment is not detected - database migrations are not appended.'
+end
+
+module ActsAsMentionable
+  extend ActiveSupport::Autoload
+
+  autoload :Mention
+  autoload :MentionablesManipulator
+  autoload :MentionsUpdater
+  autoload :Mentionable
+  autoload :Mentioner
+  autoload :ActiveRecordMethods
+  autoload :RetrievePolymorphic
+  autoload :TransactionCallbacks
+  autoload :MentionerParser
+
+  def self.setup
+    @configuration ||= Configuration.new
+    yield @configuration if block_given?
+  end
+
+  def self.respond_to_missing? method_name, include_private = false
+    @configuration.respond_to?(method_name) || super
+  end
+
+  def self.method_missing method_name, *args, &block
+    if @configuration.respond_to?(method_name)
+      @configuration.send(method_name, *args, &block)
+    else
+      super
+    end
+  end
+
+  class Configuration
+    attr_accessor \
+      :mentions_table,
+      :mentions_updated_callback
+
+    def initialize
+      @mentions_table = :acts_as_mentionable_mentions
+      @mentions_updated_callback = ->(_mentioner, _changes) { nil }
+    end
+  end
+
+  setup
+end
+
+ActiveSupport.on_load :active_record do
+  include ActsAsMentionable::ActiveRecordMethods
+end

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification
+name: acts_as_mentionable
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Baron Bloomer
+- Dmitry Radionov
+- Nazar Vinnychuk
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-06-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.5'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: With ActsAsMentionable you can mention a different models in different
+  contents.
+email:
+- baronbloomer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".circleci/config.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- acts_as_mentionable.gemspec
+- bin/console
+- bin/setup
+- db/migrate/1_acts_as_mentionable_migration.rb
+- lib/acts_as_mentionable.rb
+- lib/acts_as_mentionable/active_record_methods.rb
+- lib/acts_as_mentionable/engine.rb
+- lib/acts_as_mentionable/mention.rb
+- lib/acts_as_mentionable/mentionable.rb
+- lib/acts_as_mentionable/mentionables_manipulator.rb
+- lib/acts_as_mentionable/mentioner.rb
+- lib/acts_as_mentionable/mentioner_parser.rb
+- lib/acts_as_mentionable/mentions_updater.rb
+- lib/acts_as_mentionable/retrieve_polymorphic.rb
+- lib/acts_as_mentionable/transaction_callbacks.rb
+- lib/acts_as_mentionable/version.rb
+homepage: https://github.com/Fuseit/acts_as_mentionable
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.4
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: Add the ability to mention ActiveRecord objects such as users within text!
+test_files: []