acts-as-messageable 0.5.0 → 1.0.0

data/gemfiles/rails_master.gemfile

@@ -6,18 +6,24 @@ source 'http://rubygems.org'
 
 gem 'activerecord', git: 'https://github.com/rails/rails.git'
 gem 'activesupport', git: 'https://github.com/rails/rails.git'
-gem 'ancestry'
+gem 'ancestry', require: false
 gem 'railties', git: 'https://github.com/rails/rails.git'
+gem 'sorbet-rails', require: false
+gem 'sorbet-static-and-runtime', require: false
 
 group :development do
-  gem 'appraisal'
-  gem 'coveralls', require: false
-  gem 'jeweler'
-  gem 'pg'
-  gem 'pry'
-  gem 'rspec'
+  gem 'appraisal', require: false
+  gem 'coveralls_reborn', require: false
+  gem 'jeweler', require: false
+  gem 'pg', git: 'https://github.com/ged/ruby-pg.git'
+  gem 'pry', require: false
+  gem 'rspec', require: false
   gem 'rubocop', require: false
+  gem 'rubocop-sorbet', require: false
+  gem 'sord', require: false
   gem 'sqlite3'
-  gem 'timecop'
-  gem 'yard'
+  gem 'tapioca', github: 'Shopify/tapioca', require: false
+  gem 'timecop', require: false
+  gem 'unparser', require: false
+  gem 'yard', require: false
 end

data/lib/acts-as-messageable.rb

@@ -1,3 +1,4 @@
+# typed: strong
 # frozen_string_literal: true
 
 require 'acts_as_messageable'

data/lib/acts_as_messageable/message.rb

@@ -1,34 +1,53 @@
+# typed: strict
 # frozen_string_literal: true
 
-require 'ancestry'
-
 module ActsAsMessageable
   class Message < ::ActiveRecord::Base
+    extend T::Sig
+
     include ActsAsMessageable::Scopes
+    include Ancestry::InstanceMethods
 
     has_ancestry
 
     belongs_to :received_messageable, polymorphic: true
     belongs_to :sent_messageable, polymorphic: true
 
+    sig { returns(T.nilable(T::Boolean)) }
     attr_accessor :removed, :restored
 
     cattr_accessor :required
 
+    sig { params(args: T.untyped, kwargs: T.untyped).void }
+    def initialize(*args, **kwargs)
+      @removed = T.let(false, T.nilable(T::Boolean))
+      @restored = T.let(false, T.nilable(T::Boolean))
+
+      super
+    end
+
     ActsAsMessageable.rails_api.new(self).attr_accessible(
       :topic, :body, :opened, :opened_at, :recipient_permanent_delete,
       :recipient_delete, :sender_permanent_delete, :sender_delete
     )
     ActsAsMessageable.rails_api.new(self).default_scope('created_at desc')
 
+    # @return [Boolean] whether the message has been read
+    sig { returns(T::Boolean) }
     def open?
       opened?
     end
 
+    # @return [Boolean] whether the message has been read
+    # @see open?
+    sig { returns(T::Boolean) }
     def opened?
       opened_at.present? || super
     end
 
+    # Method open message (will mark message as read)
+    # @return [Boolean] whether the message has been open
+    sig { returns(T::Boolean) }
     def open
       ActsAsMessageable.rails_api.new(self).update_attributes!(opened_at: DateTime.now)
       ActsAsMessageable.rails_api.new(self).update_attributes!(opened: true)
@@ -37,6 +56,9 @@ module ActsAsMessageable
     alias mark_as_read open
     alias read open
 
+    # Method close message (will mark message as unread)
+    # @return [Boolean] whether the message has been closed
+    sig { returns(T::Boolean) }
     def close
       ActsAsMessageable.rails_api.new(self).update_attributes!(opened_at: nil)
       ActsAsMessageable.rails_api.new(self).update_attributes!(opened: false)
@@ -45,33 +67,68 @@ module ActsAsMessageable
     alias mark_as_unread close
     alias unread close
 
-    alias from sent_messageable
-    alias to received_messageable
+    sig { returns(ActiveRecord::Base) }
+    def from
+      sent_messageable
+    end
+
+    sig { returns(ActiveRecord::Base) }
+    def to
+      received_messageable
+    end
 
+    # @param [ActiveRecord::Base] user
+    # @return [ActiveRecord::Base] real receiver of the mssage
+    sig { params(user: ActiveRecord::Base).returns(ActiveRecord::Base) }
     def real_receiver(user)
       user == from ? to : from
     end
 
+    # @return [Boolean] whether user is participant of group message
+    # @param [ActiveRecord::Base] user
+    sig { params(user: T.untyped).returns(T::Boolean) }
     def participant?(user)
       user.class.group_messages || (to == user) || (from == user)
     end
 
+    # @return [Object] conversation tree
+    sig { returns(T.untyped) }
     def conversation
       root.subtree
     end
 
+    # Method will mark message as removed
+    # @return [TrueClass]
+    sig { returns(TrueClass) }
     def delete
       self.removed = true
     end
 
+    # Method will mark message as removed
+    # @return [TrueClass]
+    sig { returns(TrueClass) }
     def restore
       self.restored = true
     end
 
+    # Reply to given message
+    # @param [Hash] args
+    # @option args [String] topic Topic of the message
+    # @option args [String] body Body of the message
+    # @return [ActsAsMessageable::Message] a message that is a response to a given message
+    # @return [Boolean] when user is not participant of the message
+    # @see ActsAsMessageable::Model::InstanceMethods#reply_to
+    sig do
+      params(args: T.any(T::Hash[String, String],
+                         String)).returns(T.any(ActsAsMessageable::Message, T::Boolean, ActiveRecord::Base))
+    end
     def reply(*args)
-      to.reply_to(self, *args)
+      T.unsafe(to).reply_to(self, *args)
     end
 
+    # Method will return list of users in the conversation
+    # @return [Array<ActiveRecord::Base>] users
+    sig { returns(T::Array[ActiveRecord::Base]) }
     def people
       conversation.map(&:from).uniq!
     end

data/lib/acts_as_messageable/model.rb

@@ -1,18 +1,36 @@
+# typed: strict
 # frozen_string_literal: true
 
 module ActsAsMessageable
   module Model
+    extend T::Sig
+
+    # @return [Object]
+    # @param [Object] base
+    sig { params(base: Module).returns(T.untyped) }
     def self.included(base)
       base.extend ClassMethods
     end
 
     module ClassMethods
+      extend T::Helpers
+      extend T::Sig
+
+      requires_ancestor { T.class_of(ActiveRecord::Base) }
+
       # Method make ActiveRecord::Base object messageable
-      # @param [Symbol] :table_name - table name for messages
-      # @param [String] :class_name - message class name
-      # @param [Array, Symbol] :required - required fields in message
-      # @param [Symbol] :dependent - dependent option from ActiveRecord has_many method
-      # @param [Symbol] :search_scope - name of a scope for a full text search
+      # @option options [Symbol] :table_name table name for messages
+      # @option options [String] :class_name message class name
+      # @option options [Array, Symbol] :required required fields in message
+      # @option options [Symbol] :dependent dependent option from ActiveRecord has_many method
+      # @option options [Symbol] :search_scope name of a scope for a full text search
+      # @param [Hash] options
+      # @return [Object]
+      sig do
+        params(options: T::Hash[Symbol,
+                                T.any(String, Symbol, T::Array[Symbol],
+                                      T::Array[String])]).returns(ActsAsMessageable::Model::ClassMethods)
+      end
       def acts_as_messageable(options = {})
         default_options = {
           table_name: 'messages',
@@ -50,13 +68,22 @@ module ActsAsMessageable
 
       # Method recognize real object class
       # @return [ActiveRecord::Base] class or relation object
+      sig { returns(T.class_of(ActiveRecord::Base)) }
       def resolve_active_record_ancestor
         reflect_on_association(:received_messages_relation).active_record
       end
     end
 
     module InstanceMethods
+      extend T::Helpers
+      extend T::Sig
+
+      requires_ancestor { Kernel }
+      requires_ancestor { CustomSearchUser }
+
       # @return [ActiveRecord::Relation] all messages connected with user
+      # @param [Boolean] trash Show deleted messages
+      sig { params(trash: T::Boolean).returns(ActiveRecord::Relation) }
       def messages(trash = false)
         result = self.class.messages_class_name.connected_with(self, trash)
         result.relation_context = self
@@ -65,34 +92,41 @@ module ActsAsMessageable
       end
 
       # @return [ActiveRecord::Relation] returns all messages from inbox
+      sig { returns(ActiveRecord::Relation) }
       def received_messages
         result = ActsAsMessageable.rails_api.new(received_messages_relation)
-        result = result.scoped.where(recipient_delete: false)
+        result = T.unsafe(result).scoped.where(recipient_delete: false)
         result.relation_context = self
 
         result
       end
 
       # @return [ActiveRecord::Relation] returns all messages from outbox
+      sig { returns(ActiveRecord::Relation) }
       def sent_messages
         result = ActsAsMessageable.rails_api.new(sent_messages_relation)
-        result = result.scoped.where(sender_delete: false)
+        result = T.unsafe(result).scoped.where(sender_delete: false)
         result.relation_context = self
 
         result
       end
 
       # @return [ActiveRecord::Relation] returns all messages from trash
+      sig { returns(ActiveRecord::Relation) }
       def deleted_messages
-        messages true
+        messages(true)
       end
 
-      # Method sens message to another user
+      # Method sends message to another user
       # @param [ActiveRecord::Base] to
-      # @param [String] topic
-      # @param [String] body
-      #
+      # @param [Hash] args
+      # @option args [String] topic Topic of the message
+      # @option args [String] body Body of the message
       # @return [ActsAsMessageable::Message] the message object
+      sig do
+        params(to: ActiveRecord::Base,
+               args: T.any(String, T::Hash[T.any(String, Symbol), String])).returns(ActsAsMessageable::Message)
+      end
       def send_message(to, *args)
         message_attributes = {}
 
@@ -108,7 +142,7 @@ module ActsAsMessageable
         message = self.class.messages_class_name.new message_attributes
         message.received_messageable = to
         message.sent_messageable = self
-        message.save
+        message.save!
 
         message
       end
@@ -116,26 +150,37 @@ module ActsAsMessageable
       # Method send message to another user
       # and raise exception in case of validation errors
       # @param [ActiveRecord::Base] to
-      # @param [String] topic
-      # @param [String] body
+      # @param [Hash] args
+      # @option [String] topic Topic of the message
+      # @option [String] body Body of the message
       #
       # @return [ActsAsMessageable::Message] the message object
+      sig do
+        params(to: ActiveRecord::Base,
+               args: T.any(String, T::Hash[T.any(String, Symbol), String])).returns(ActsAsMessageable::Message)
+      end
       def send_message!(to, *args)
-        send_message(to, *args).tap(&:save!)
+        T.unsafe(self).send_message(to, *T.unsafe(args)).tap(&:save!)
       end
 
       # Reply to given message
       # @param [ActsAsMessageable::Message] message
-      # @param [String] topic
-      # @param [String] body
+      # @param [Hash] args
+      # @option args [String] topic Topic of the message
+      # @option args [String] body Body of the message
       #
       # @return [ActsAsMessageable::Message] a message that is a response to a given message
+      sig do
+        params(message: ActsAsMessageable::Message,
+               args: T.any(String,
+                           T::Hash[T.any(String, Symbol), String])).returns(T.nilable(ActsAsMessageable::Message))
+      end
       def reply_to(message, *args)
-        current_user = self
+        current_user = T.cast(self, ActiveRecord::Base)
 
         return unless message.participant?(current_user)
 
-        reply_message = send_message(message.real_receiver(current_user), *args)
+        reply_message = T.unsafe(self).send_message(message.real_receiver(current_user), *args)
         reply_message.parent = message
         reply_message.save
 
@@ -143,6 +188,9 @@ module ActsAsMessageable
       end
 
       # Mark message as deleted
+      # @param [ActsAsMessageable::Message] message to delete
+      # @return [ActsAsMessageable::Message] deleted message
+      sig { params(message: ActsAsMessageable::Message).returns(T::Boolean) }
       def delete_message(message)
         current_user = self
 
@@ -159,6 +207,9 @@ module ActsAsMessageable
       end
 
       # Mark message as restored
+      # @param [ActsAsMessageable::Message] message to restore
+      # @return [ActsAsMessageable::Message] restored message
+      sig { params(message: ActsAsMessageable::Message).returns(T::Boolean) }
       def restore_message(message)
         current_user = self
 

data/lib/acts_as_messageable/rails3.rb

@@ -1,19 +1,44 @@
+# typed: strict
 # frozen_string_literal: true
 
 module ActsAsMessageable
   class Rails3
+    extend T::Sig
+
+    delegate :attr_accessible, :update_attributes!, to: :@subject
+
+    # @return [ActsAsMessageable::Rails3] api wrapper object
+    # @param [ActiveRecord::Base] subject
+    sig { params(subject: T.untyped).void }
     def initialize(subject)
       @subject = subject
     end
 
+    # @return [Object]
+    # @param [String, Symbol] order_by
+    # @see ActiveRecord::Base#default_scope
+    sig { params(order_by: T.any(String, Symbol)).void }
     def default_scope(order_by)
-      @subject.send(:default_scope, order(order_by))
+      # T.unsafe is needed here because the default_scope method is defined in
+      # different ways in different versions of Rails. In Rails 3, it is a
+      # class method, but in Rails 4, it is an instance method. We can't
+      # statically determine which version of Rails is being used, so we have
+      # to use T.unsafe here.
+      @subject.send(:default_scope, T.unsafe(@subject).order(order_by))
     end
 
+    # @return [Object]
+    # @param [Symbol] name
+    # @param [Array] args
+    sig { params(name: Symbol, args: T.untyped).returns(T.untyped) }
     def method_missing(name, *args)
-      @subject.send(name, *args) || super
+      T.unsafe(@subject).send(name, *args) || super
     end
 
+    # @return [Boolean]
+    # @param [Object] method_name
+    # @param [FalseClass] include_private
+    sig { params(method_name: Symbol, include_private: T::Boolean).returns(T::Boolean) }
     def respond_to_missing?(method_name, include_private = false)
       method_name.to_s == 'default_scope' || super
     end

data/lib/acts_as_messageable/rails4.rb

@@ -1,25 +1,52 @@
+# typed: strict
 # frozen_string_literal: true
 
 module ActsAsMessageable
   class Rails4
+    extend T::Sig
+
+    delegate :update_attributes!, to: :@subject
+
+    # @return [ActsAsMessageable::Rails4] api wrapper object
+    # @param [ActiveRecord::Base] subject
+    sig { params(subject: T.untyped).void }
     def initialize(subject)
       @subject = subject
     end
 
-    def attr_accessible(*); end
+    # Empty method for Rails 4.x
+    # @return [NilClass]
+    # @param [Array] _args
+    sig { params(_args: T.any(String, Symbol)).void }
+    def attr_accessible(*_args); end
 
+    # Default scope for Rails 4.x with block support
+    # @return [Object]
+    # @param [String, Symbol] order_by
+    sig { params(order_by: T.any(String, Symbol)).returns(Object) }
     def default_scope(order_by)
-      @subject.send(:default_scope) { order(order_by) }
+      @subject.send(:default_scope) { T.unsafe(self).order(order_by) }
     end
 
+    # Rename of the method
+    # @return [Object]
+    sig { returns(Object) }
     def scoped
-      @subject.scope
+      T.unsafe(@subject).scope
     end
 
+    # @return [Object]
+    # @param [Symbol] name
+    # @param [Array] args
+    sig { params(name: Symbol, args: T.untyped).returns(T.untyped) }
     def method_missing(name, *args)
-      @subject.send(name, *args) || super
+      T.unsafe(@subject).send(name, *args) || super
     end
 
+    # @return [Boolean]
+    # @param [String] method_name
+    # @param [Boolean] include_private
+    sig { params(method_name: Symbol, include_private: T::Boolean).returns(T::Boolean) }
     def respond_to_missing?(method_name, include_private = false)
       %w[default_scope scoped attr_accessible].include?(method_name) || super
     end

data/lib/acts_as_messageable/rails6.rb

@@ -1,29 +1,61 @@
+# typed: strict
 # frozen_string_literal: true
 
 module ActsAsMessageable
   class Rails6
+    extend T::Sig
+
+    # @return [ActsAsMessageable::Rails4] api wrapper object
+    # @param [ActiveRecord::Base] subject
+    sig { params(subject: T.untyped).void }
     def initialize(subject)
       @subject = subject
     end
 
-    def attr_accessible(*); end
+    # Empty method from Rails 3.x
+    # @return [NilClass]
+    # @param [Array] _args
+    sig { params(_args: T.any(String, Symbol)).void }
+    def attr_accessible(*_args); end
 
+    # Default scope for Rails 6.x with block support
+    # @return [Object]
+    # @param [String, Symbol] order_by
+    sig { params(order_by: T.any(String, Symbol)).returns(Object) }
     def default_scope(order_by)
-      @subject.send(:default_scope) { order(order_by) }
+      @subject.send(:default_scope) do
+        T.bind(self, ActiveRecord::Relation)
+        order(order_by)
+      end
     end
 
+    # Rename of the method
+    # @return [Object]
+    sig { returns(Object) }
     def scoped
       @subject.scope
     end
 
+    # Use new method #update! in Rails 6.x
+    # @return [Object]
+    # @param [Array] args
+    sig { params(args: T::Hash[String, String]).returns(T::Boolean) }
     def update_attributes!(*args)
       @subject.update!(*args)
     end
 
+    # @return [Object]
+    # @param [Symbol] name
+    # @param [Array] args
+    sig { params(name: Symbol, args: T.untyped).returns(T.untyped) }
     def method_missing(name, *args)
       @subject.send(name, *args) || super
     end
 
+    # @return [Boolean]
+    # @param [String] method_name
+    # @param [Boolean] include_private
+    sig { params(method_name: Symbol, include_private: T::Boolean).returns(T::Boolean) }
     def respond_to_missing?(method_name, include_private = false)
       %w[attr_accessible default_scope scoped update_attributes!].include?(method_name) || super
     end

data/lib/acts_as_messageable/railtie.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require 'active_record/railtie'

data/lib/acts_as_messageable/relation.rb

@@ -1,19 +1,35 @@
+# typed: true
 # frozen_string_literal: true
 
 module ActsAsMessageable
   module Relation
+    extend T::Sig
+    extend T::Helpers
+
+    sig { returns(ActsAsMessageable::Model::InstanceMethods) }
     attr_accessor :relation_context
 
+    requires_ancestor { ActiveRecord::Relation }
+
+    # @yield [ActsAsMessageable::Message] message
+    # @param [ActiveRecord::Base] context of relation (most of the time current_user object)
+    # @return [ActiveRecord::Relation]
+    sig { params(context: ActsAsMessageable::Model::InstanceMethods).returns(T.untyped) }
     def process(context = relation_context)
-      each do |message|
+      relation = T.cast(self, ActiveRecord::Relation)
+
+      relation.each do |message|
         yield(message) if block_given?
         context.delete_message(message) if message.removed
         context.restore_message(message) if message.restored
       end
     end
 
+    # @return [Array<ActsAsMessageable::Message>]
+    # @return [ActiveRecord::Relation]
     def conversations
-      map { |r| r.root.subtree.order('id desc').first }.uniq
+      relation = T.cast(self, ActiveRecord::Relation)
+      relation.map { |message| message.root.subtree.order('id desc').first }.uniq
     end
   end
 end

data/lib/acts_as_messageable/scopes.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require 'active_support/concern'
@@ -7,6 +8,16 @@ module ActsAsMessageable
     extend ActiveSupport::Concern
 
     module ClassMethods
+      # @return [Object]
+      # @param [String, Symbol] search_scope
+      extend T::Helpers
+      extend T::Sig
+
+      requires_ancestor { T.class_of(ActiveRecord::Base) }
+
+      include Kernel
+
+      sig { params(search_scope: T.any(String, Symbol)).void }
       def initialize_scopes(search_scope)
         scope :are_from, lambda { |*args|
           where(sent_messageable_id: args.first, sent_messageable_type: args.first.class.name)

data/lib/acts_as_messageable.rb

@@ -1,5 +1,10 @@
+# typed: strong
 # frozen_string_literal: true
 
+require 'sorbet-runtime'
+require 'sorbet-rails'
+require 'ancestry'
+
 module ActsAsMessageable
   autoload :Model, 'acts_as_messageable/model'
   autoload :Scopes, 'acts_as_messageable/scopes'
@@ -9,6 +14,19 @@ module ActsAsMessageable
   autoload :Rails4, 'acts_as_messageable/rails4'
   autoload :Rails6, 'acts_as_messageable/rails6'
 
+  extend T::Sig
+
+  # @return [Class<ActsAsMessageable::Rails4>, Class<ActsAsMessageable::Rails6>, Class<ActsAsMessageable::Rails3>]
+  #  API wrapper
+  sig do
+    returns(
+      T.any(
+        T.class_of(ActsAsMessageable::Rails4),
+        T.class_of(ActsAsMessageable::Rails6),
+        T.class_of(ActsAsMessageable::Rails3)
+      )
+    )
+  end
   def self.rails_api
     if Rails::VERSION::MAJOR >= 6
       Rails6

data/lib/generators/acts_as_messageable/migration/migration_generator.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require 'rails/generators/migration'
@@ -5,6 +6,7 @@ require 'rails/generators/active_record'
 
 module ActsAsMessageable
   class MigrationGenerator < Rails::Generators::Base
+    extend T::Sig
     include Rails::Generators::Migration
 
     namespace 'acts_as_messageable:migration'
@@ -13,10 +15,12 @@ module ActsAsMessageable
     argument :table_name, type: :string, default: 'messages'
     class_option :uuid, type: :boolean, default: false
 
+    sig { params(dirname: String).returns(String) }
     def self.next_migration_number(dirname)
       ActiveRecord::Generators::Base.next_migration_number(dirname)
     end
 
+    sig { returns(String) }
     def create_migration_file
       begin
         migration_template 'migration.rb', 'db/migrate/create_messages_table.rb'

data/lib/generators/acts_as_messageable/migration/templates/migration.rb

@@ -1,3 +1,4 @@
+# typed: ignore
 class CreateMessagesTable < ActiveRecord::Migration[4.2]
   def self.up
     create_table :<%= table_name %> do |t|

data/lib/generators/acts_as_messageable/migration/templates/migration_indexes.rb

@@ -1,3 +1,4 @@
+# typed: ignore
 class AddIndexesToMessages < ActiveRecord::Migration[4.2]
   def self.up
     add_index :<%= table_name %>, [:sent_messageable_id, :sent_messageable_type], :name => "acts_as_messageable_sent"

data/lib/generators/acts_as_messageable/migration/templates/migration_opened_as_datetime.rb

@@ -1,3 +1,4 @@
+# typed: ignore
 class AddOpenedAtToMessages < ActiveRecord::Migration[4.2]
   class MigrationMessage < ActiveRecord::Base
     self.table_name = :<%= table_name %>

data/lib/generators/acts_as_messageable/migration/templates/migration_permanent.rb

@@ -1,3 +1,4 @@
+# typed: ignore
 class AddRecipientPermanentDeleteAndSenderPermanentDeleteToMessages < ActiveRecord::Migration[4.2]
   def self.up
     add_column :<%= table_name %>, :recipient_permanent_delete, :boolean, :default => false