mailboxer 0.11.0 → 0.12.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b22e110378d5da7e6e327c807f46a5f0475b2fa1
-  data.tar.gz: bc9242e076e3a10d2e3d9ca1106a42200ca7bc12
+  metadata.gz: e699bff86b951b515780d88e719ae2b02eca59e7
+  data.tar.gz: 7024930841d1c7b675ecca3eab46767896fcc67c
 SHA512:
-  metadata.gz: f67c3839eb84ce3153e7e9b1b50b012f80a1d17bdb56589e18279ba1043e3e4fc4f443c17b2ed9cff7a0e4bcbc9ebef10139bd63de67b520ac12f3fcd40bc05e
-  data.tar.gz: 277d0c3921688613e407b095665d7d2b2afe783294f1500d9ba2a423c83460b5854711520a9cfaddcec876b864924c65136edcd78dbdad4fbbd8286eb5d5405f
+  metadata.gz: 81b0a14bd89091e70042fc95e215482bb3c64c2d352821f40c0da348b51eb0fa1d07c2d802bc73f933758f767e1b65c3f314e7741da3b8035c91607f10321848
+  data.tar.gz: d9e30049e35052c5253f3587239ce9dfb6568c9350056d82fb261ed9a9d20096aef578c1252c3f48353aa4f88688782e019ba187c37e448a73c8f5092224634e

data/.gitignore

@@ -9,6 +9,7 @@ spec/dummy/.project
 spec/dummy/solr
 **.tmp_*
 Gemfile.lock
+gemfiles/*.lock
 .idea
 .project
 .document
@@ -16,3 +17,4 @@ Gemfile.lock
 rdoc/
 doc/
 .yardoc/*
+.rvmrc

data/.travis.yml

@@ -2,10 +2,11 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
-  - rbx-19mode
   - jruby-19mode
 gemfile:
-  #- gemfiles/rails3.0.gemfile
-  - gemfiles/rails3.1.gemfile
   - gemfiles/rails3.2.gemfile
   - gemfiles/rails4.0.gemfile
+  - gemfiles/rails4.1.gemfile
+env:
+  global:
+    - NOKOGIRI_USE_SYSTEM_LIBRARIES=true

data/Appraisals

@@ -1,19 +1,11 @@
-# appraise "rails3.0" do
-#   gem "rails", "~> 3.0.15"
-#   gem "mailboxer", :path => "../"
-# end
-
-appraise "rails3.1" do
-  gem "rails", "~> 3.1.6"
-  gem "mailboxer", :path => "../"
-end
-
 appraise "rails3.2" do
-  gem "rails", "~> 3.2.6"
-  gem "mailboxer", :path => "../"
+  gem "rails", "~> 3.2.17"
 end
 
 appraise "rails4.0" do
-  gem "rails", ">=4.0.0"
-  gem "mailboxer", :path => "../"
+  gem "rails", "~> 4.0.4"
+end
+
+appraise "rails4.1" do
+  gem "rails", "~> 4.1.0"
 end

data/Gemfile

@@ -1,3 +1,3 @@
 source "http://rubygems.org"
 
-gemspec
+gemspec

data/README.md

@@ -1,4 +1,4 @@
-# Mailboxer 0.10.x [![](https://secure.travis-ci.org/ging/mailboxer.png)](http://travis-ci.org/ging/mailboxer) [![Gem Version](https://badge.fury.io/rb/mailboxer.png)](http://badge.fury.io/rb/mailboxer) [![](https://gemnasium.com/ging/mailboxer.png)](https://gemnasium.com/ging/mailboxer)
+# Mailboxer [![Build Status](https://travis-ci.org/mailboxer/mailboxer.svg?branch=master)](https://travis-ci.org/mailboxer/mailboxer) [![Gem Version](https://badge.fury.io/rb/mailboxer.png)](http://badge.fury.io/rb/mailboxer) [![](https://gemnasium.com/ging/mailboxer.png)](https://gemnasium.com/ging/mailboxer)
 
 This project is based on the need for a private message system for [ging
 / social\_stream](https://github.com/ging/social_stream). Instead of creating our core message system heavily
@@ -41,7 +41,7 @@ gem 'mailboxer'
 Then run:
 
 ```sh
-$ bundle update
+$ bundle install
 ```
 
 Run install script:

data/app/mailers/mailboxer/base_mailer.rb

@@ -0,0 +1,14 @@
+class Mailboxer::BaseMailer < ActionMailer::Base
+  default :from => Mailboxer.default_from
+
+  private
+
+  def set_subject(container)
+    @subject  = container.subject.html_safe? ? container.subject : strip_tags(container.subject)
+  end
+
+  def strip_tags(text)
+    ::Mailboxer::Cleaner.instance.strip_tags(text)
+  end
+
+end

data/app/mailers/{message_mailer.rb → mailboxer/message_mailer.rb}

@@ -1,5 +1,4 @@
-class MessageMailer < ActionMailer::Base
-  default :from => Mailboxer.default_from
+class Mailboxer::MessageMailer < Mailboxer::BaseMailer
   #Sends and email for indicating a new message or a reply to a receiver.
   #It calls new_message_email if notifing a new message and reply_message_email
   #when indicating a reply to an already created conversation.
@@ -11,27 +10,23 @@ class MessageMailer < ActionMailer::Base
     end
   end
 
-  include ActionView::Helpers::SanitizeHelper
-
   #Sends an email for indicating a new message for the receiver
   def new_message_email(message,receiver)
-    @message = message
+    @message  = message
     @receiver = receiver
-    subject = message.subject.to_s
-    subject = strip_tags(subject) unless subject.html_safe?
-    mail :to => receiver.send(Mailboxer.email_method,message),
-         :subject => t('mailboxer.message_mailer.subject_new', :subject => subject),
+    set_subject(message)
+    mail :to => receiver.send(Mailboxer.email_method, message),
+         :subject => t('mailboxer.message_mailer.subject_new', :subject => @subject),
          :template_name => 'new_message_email'
   end
 
   #Sends and email for indicating a reply in an already created conversation
   def reply_message_email(message,receiver)
-    @message = message
+    @message  = message
     @receiver = receiver
-    subject = message.subject.to_s
-    subject = strip_tags(subject) unless subject.html_safe?
-    mail :to => receiver.send(Mailboxer.email_method,message),
-         :subject => t('mailboxer.message_mailer.subject_reply', :subject => subject),
+    set_subject(message)
+    mail :to => receiver.send(Mailboxer.email_method, message),
+         :subject => t('mailboxer.message_mailer.subject_reply', :subject => @subject),
          :template_name => 'reply_message_email'
   end
 end

data/app/mailers/mailboxer/notification_mailer.rb

@@ -0,0 +1,17 @@
+class Mailboxer::NotificationMailer < Mailboxer::BaseMailer
+  #Sends and email for indicating a new notification to a receiver.
+  #It calls new_notification_email.
+  def send_email(notification, receiver)
+    new_notification_email(notification, receiver)
+  end
+
+  #Sends an email for indicating a new message for the receiver
+  def new_notification_email(notification, receiver)
+    @notification = notification
+    @receiver     = receiver
+    set_subject(notification)
+    mail :to => receiver.send(Mailboxer.email_method, notification),
+         :subject => t('mailboxer.notification_mailer.subject', :subject => @subject),
+         :template_name => 'new_notification_email'
+  end
+end

data/app/models/mailboxer/conversation.rb

@@ -0,0 +1,196 @@
+class Mailboxer::Conversation < ActiveRecord::Base
+  self.table_name = :mailboxer_conversations
+
+  attr_accessible :subject if Mailboxer.protected_attributes?
+
+  has_many :opt_outs, :dependent => :destroy, :class_name => "Mailboxer::Conversation::OptOut"
+  has_many :messages, :dependent => :destroy, :class_name => "Mailboxer::Message"
+  has_many :receipts, :through => :messages,  :class_name => "Mailboxer::Receipt"
+
+  validates :subject, :presence => true,
+                      :length => { :maximum => Mailboxer.subject_max_length }
+
+  before_validation :clean
+
+  scope :participant, lambda {|participant|
+    where('mailboxer_notifications.type'=> Mailboxer::Message.name).
+    order("mailboxer_conversations.updated_at DESC").
+    joins(:receipts).merge(Mailboxer::Receipt.recipient(participant)).uniq
+  }
+  scope :inbox, lambda {|participant|
+    participant(participant).merge(Mailboxer::Receipt.inbox.not_trash.not_deleted)
+  }
+  scope :sentbox, lambda {|participant|
+    participant(participant).merge(Mailboxer::Receipt.sentbox.not_trash.not_deleted)
+  }
+  scope :trash, lambda {|participant|
+    participant(participant).merge(Mailboxer::Receipt.trash)
+  }
+  scope :unread,  lambda {|participant|
+    participant(participant).merge(Mailboxer::Receipt.is_unread)
+  }
+  scope :not_trash,  lambda {|participant|
+    participant(participant).merge(Mailboxer::Receipt.not_trash)
+  }
+
+  #Mark the conversation as read for one of the participants
+  def mark_as_read(participant)
+    return unless participant
+    receipts_for(participant).mark_as_read
+  end
+
+  #Mark the conversation as unread for one of the participants
+  def mark_as_unread(participant)
+    return unless participant
+    receipts_for(participant).mark_as_unread
+  end
+
+  #Move the conversation to the trash for one of the participants
+  def move_to_trash(participant)
+    return unless participant
+    receipts_for(participant).move_to_trash
+  end
+
+  #Takes the conversation out of the trash for one of the participants
+  def untrash(participant)
+    return unless participant
+    receipts_for(participant).untrash
+  end
+
+  #Mark the conversation as deleted for one of the participants
+  def mark_as_deleted(participant)
+    return unless participant
+    deleted_receipts = receipts_for(participant).mark_as_deleted
+    if is_orphaned?
+      destroy
+    else
+      deleted_receipts
+    end
+  end
+
+  #Returns an array of participants
+  def recipients
+    return [] unless original_message
+    Array original_message.recipients
+  end
+
+  #Returns an array of participants
+  def participants
+    recipients
+  end
+
+  #Originator of the conversation.
+  def originator
+    @originator ||= self.original_message.sender
+  end
+
+  #First message of the conversation.
+  def original_message
+    @original_message ||= self.messages.order('created_at').first
+  end
+
+  #Sender of the last message.
+  def last_sender
+    @last_sender ||= self.last_message.sender
+  end
+
+  #Last message in the conversation.
+  def last_message
+    @last_message ||= self.messages.order('created_at DESC').first
+  end
+
+  #Returns the receipts of the conversation for one participants
+  def receipts_for(participant)
+    Mailboxer::Receipt.conversation(self).recipient(participant)
+  end
+
+  #Returns the number of messages of the conversation
+  def count_messages
+    Mailboxer::Message.conversation(self).count
+  end
+
+  #Returns true if the messageable is a participant of the conversation
+  def is_participant?(participant)
+    return false unless participant
+    receipts_for(participant).any?
+  end
+
+	#Adds a new participant to the conversation
+	def add_participant(participant)
+		messages = self.messages
+		messages.each do |message|
+		  receipt = Mailboxer::Receipt.new
+		  receipt.notification = message
+		  receipt.is_read = false
+		  receipt.receiver = participant
+		  receipt.mailbox_type = 'inbox'
+		  receipt.updated_at = message.updated_at
+		  receipt.created_at = message.created_at
+		  receipt.save
+		end
+	end
+
+  #Returns true if the participant has at least one trashed message of the conversation
+  def is_trashed?(participant)
+    return false unless participant
+    self.receipts_for(participant).trash.count != 0
+  end
+
+  #Returns true if the participant has deleted the conversation
+  def is_deleted?(participant)
+    return false unless participant
+    return self.receipts_for(participant).deleted.count == self.receipts_for(participant).count
+  end
+
+  #Returns true if both participants have deleted the conversation
+  def is_orphaned?
+    participants.reduce(true) do |is_orphaned, participant|
+      is_orphaned && is_deleted?(participant)
+    end
+  end
+
+  #Returns true if the participant has trashed all the messages of the conversation
+  def is_completely_trashed?(participant)
+    return false unless participant
+    receipts_for(participant).trash.count == receipts_for(participant).count
+  end
+
+  def is_read?(participant)
+    !is_unread?(participant)
+  end
+
+  #Returns true if the participant has at least one unread message of the conversation
+  def is_unread?(participant)
+    return false unless participant
+    receipts_for(participant).not_trash.is_unread.count != 0
+  end
+
+  # Creates a opt out object
+  # because by default all particpants are opt in
+  def opt_out(participant)
+    return unless has_subscriber?(participant)
+    opt_outs.create(:unsubscriber => participant)
+  end
+
+  # Destroys opt out object if any
+  # a participant outside of the discussion is, yet, not meant to optin
+  def opt_in(participant)
+    opt_outs.unsubscriber(participant).destroy_all
+  end
+
+  # tells if participant is opt in
+  def has_subscriber?(participant)
+    !opt_outs.unsubscriber(participant).any?
+  end
+
+  protected
+
+  #Use the default sanitize to clean the conversation subject
+  def clean
+    self.subject = sanitize subject
+  end
+
+  def sanitize(text)
+    ::Mailboxer::Cleaner.instance.sanitize(text)
+  end
+end

data/app/models/mailboxer/conversation/opt_out.rb

@@ -0,0 +1,15 @@
+module Mailboxer
+  class Conversation
+    class OptOut < ActiveRecord::Base
+      self.table_name = :mailboxer_conversation_opt_outs
+
+      belongs_to :conversation, :class_name  => "Mailboxer::Conversation"
+      belongs_to :unsubscriber, :polymorphic => true
+
+      validates :unsubscriber, :presence => true
+
+      scope :unsubscriber, lambda { |entity| where(:unsubscriber_type => entity.class.base_class.name, :unsubscriber_id => entity.id) }
+
+    end
+  end
+end

data/app/models/{mailbox.rb → mailboxer/mailbox.rb}

@@ -1,4 +1,4 @@
-class Mailbox
+class Mailboxer::Mailbox
   attr_accessor :type
   attr_reader :messageable
 
@@ -10,7 +10,7 @@ class Mailbox
   #Returns the notifications for the messageable
   def notifications(options = {})
     #:type => nil is a hack not to give Messages as Notifications
-    notifs = Notification.recipient(@messageable).where(:type => nil).order("notifications.created_at DESC")
+    notifs = Mailboxer::Notification.recipient(@messageable).where(:type => nil).order("mailboxer_notifications.created_at DESC")
     if (options[:read].present? and options[:read]==false) or (options[:unread].present? and options[:unread]==true)
       notifs = notifs.unread
     end
@@ -31,18 +31,18 @@ class Mailbox
   #* :unread=true
   #
   def conversations(options = {})
-    conv = Conversation.participant(@messageable)
+    conv = Mailboxer::Conversation.participant(@messageable)
 
     if options[:mailbox_type].present?
       case options[:mailbox_type]
       when 'inbox'
-        conv = Conversation.inbox(@messageable)
+        conv = Mailboxer::Conversation.inbox(@messageable)
       when 'sentbox'
-        conv = Conversation.sentbox(@messageable)
+        conv = Mailboxer::Conversation.sentbox(@messageable)
       when 'trash'
-        conv = Conversation.trash(@messageable)
+        conv = Mailboxer::Conversation.trash(@messageable)
       when  'not_trash'
-        conv = Conversation.not_trash(@messageable)
+        conv = Mailboxer::Conversation.not_trash(@messageable)
       end
     end
 
@@ -79,7 +79,7 @@ class Mailbox
 
   #Returns all the receipts of messageable, from Messages and Notifications
   def receipts(options = {})
-    Receipt.where(options).recipient(@messageable)
+    Mailboxer::Receipt.where(options).recipient(@messageable)
   end
 
   #Deletes all the messages in the trash of messageable. NOT IMPLEMENTED.
@@ -113,9 +113,9 @@ class Mailbox
   #If object isn't one of the above, a nil will be returned
   def receipts_for(object)
     case object
-    when Message, Notification
+    when Mailboxer::Message, Mailboxer::Notification
       object.receipt_for(@messageable)
-    when Conversation
+    when Mailboxer::Conversation
       object.receipts_for(@messageable)
     end
   end

data/app/models/mailboxer/message.rb

@@ -0,0 +1,49 @@
+class Mailboxer::Message < Mailboxer::Notification
+  attr_accessible :attachment if Mailboxer.protected_attributes?
+  self.table_name = :mailboxer_notifications
+
+  belongs_to :conversation, :class_name => "Mailboxer::Conversation", :validate => true, :autosave => true
+  validates_presence_of :sender
+
+  class_attribute :on_deliver_callback
+  protected :on_deliver_callback
+  scope :conversation, lambda { |conversation|
+    where(:conversation_id => conversation.id)
+  }
+
+  mount_uploader :attachment, AttachmentUploader
+
+  class << self
+    #Sets the on deliver callback method.
+    def on_deliver(callback_method)
+      self.on_deliver_callback = callback_method
+    end
+  end
+
+  #Delivers a Message. USE NOT RECOMENDED.
+  #Use Mailboxer::Models::Message.send_message instead.
+  def deliver(reply = false, should_clean = true)
+    self.clean if should_clean
+
+    #Receiver receipts
+    temp_receipts = recipients.map { |r| build_receipt(r, 'inbox') }
+
+    #Sender receipt
+    sender_receipt = build_receipt(sender, 'sentbox', true)
+
+    temp_receipts << sender_receipt
+
+    if temp_receipts.all?(&:valid?)
+      temp_receipts.each(&:save!) 	#Save receipts
+
+      Mailboxer::MailDispatcher.new(self, recipients).call
+
+      conversation.touch if reply
+
+      self.recipients = nil
+
+      on_deliver_callback.call(self) if on_deliver_callback
+    end
+    sender_receipt
+  end
+end