pluginaweek-has_messages 0.4.0

data/db/migrate/001_create_messages.rb

@@ -0,0 +1,16 @@
+class CreateMessages < ActiveRecord::Migration
+  def self.up
+    create_table :messages do |t|
+      t.references :sender, :polymorphic => true, :null => false
+      t.text :subject, :body
+      t.string :state, :null => false
+      t.datetime :hidden_at
+      t.string :type
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :messages
+  end
+end

data/db/migrate/002_create_message_recipients.rb

@@ -0,0 +1,17 @@
+class CreateMessageRecipients < ActiveRecord::Migration
+  def self.up
+    create_table :message_recipients do |t|
+      t.references :message, :null => false
+      t.references :receiver, :polymorphic => true, :null => false
+      t.string :kind, :null => false
+      t.integer :position
+      t.string :state, :null => false
+      t.datetime :hidden_at
+    end
+    add_index :message_recipients, [:message_id, :kind, :position], :unique => true
+  end
+  
+  def self.down
+    drop_table :message_recipients
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'has_messages'

data/lib/has_messages.rb

@@ -0,0 +1,72 @@
+require 'state_machine'
+
+# Adds a generic implementation for sending messages between users
+module HasMessages
+  module MacroMethods
+    # Creates the following message associations:
+    # * +messages+ - Messages that were composed and are visible to the owner.
+    #   Mesages may have been sent or unsent.
+    # * +received_messages - Messages that have been received from others and
+    #   are visible.  Messages may have been read or unread.
+    # 
+    # == Creating new messages
+    # 
+    # To create a new message, the +messages+ association should be used,
+    # for example:
+    # 
+    #   user = User.find(123)
+    #   message = user.messages.build
+    #   message.subject = 'Hello'
+    #   message.body = 'How are you?'
+    #   message.to User.find(456)
+    #   message.save
+    #   message.deliver
+    # 
+    # == Drafts
+    # 
+    # You can get the drafts for a particular user by using the +unsent_messages+
+    # helper method.  This will find all messages in the "unsent" state.  For example,
+    # 
+    #   user = User.find(123)
+    #   user.unsent_messages
+    # 
+    # You can also get at the messages that *have* been sent, using the +sent_messages+
+    # helper method.  For example,
+    # 
+    #  user = User.find(123)
+    #  user.sent_messages
+    def has_messages
+      has_many  :messages,
+                  :as => :sender,
+                  :class_name => 'Message',
+                  :conditions => {:hidden_at => nil},
+                  :order => 'messages.created_at ASC'
+      has_many  :received_messages,
+                  :as => :receiver,
+                  :class_name => 'MessageRecipient',
+                  :include => :message,
+                  :conditions => ['message_recipients.hidden_at IS NULL AND messages.state = ?', 'sent'],
+                  :order => 'messages.created_at ASC'
+      
+      include HasMessages::InstanceMethods
+    end
+  end
+  
+  module InstanceMethods
+    # Composed messages that have not yet been sent.  These consists of all
+    # messages that are currently in the "unsent" state.
+    def unsent_messages
+      messages.with_state(:unsent)
+    end
+    
+    # Composed messages that have already been sent.  These consists of all
+    # messages that are currently in the "queued" or "sent" states.
+    def sent_messages
+      messages.with_states(:queued, :sent)
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  extend HasMessages::MacroMethods
+end

data/test/app_root/app/models/user.rb

@@ -0,0 +1,3 @@
+class User < ActiveRecord::Base
+  has_messages
+end

data/test/app_root/config/environment.rb

@@ -0,0 +1,9 @@
+require 'config/boot'
+
+Rails::Initializer.run do |config|
+  config.plugin_paths << '..'
+  config.plugins = %w(state_machine has_messages)
+  config.cache_classes = false
+  config.whiny_nils = true
+  config.action_controller.session = {:key => 'rails_session', :secret => 'd229e4d22437432705ab3985d4d246'}
+end

data/test/app_root/db/migrate/001_create_users.rb

@@ -0,0 +1,11 @@
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string :login, :null => false
+    end
+  end
+
+  def self.down
+    drop_table :users
+  end
+end

data/test/app_root/db/migrate/002_migrate_has_messages_to_version_2.rb

@@ -0,0 +1,13 @@
+class MigrateHasMessagesToVersion2 < ActiveRecord::Migration
+  def self.up
+    ActiveRecord::Migrator.new(:up, "#{Rails.root}/../../db/migrate", 0).migrations.each do |migration|
+      migration.migrate(:up)
+    end
+  end
+  
+  def self.down
+    ActiveRecord::Migrator.new(:up, "#{Rails.root}/../../db/migrate", 0).migrations.each do |migration|
+      migration.migrate(:down)
+    end
+  end
+end

data/test/factory.rb

@@ -0,0 +1,57 @@
+module Factory
+  # Build actions for the model
+  def self.build(model, &block)
+    name = model.to_s.underscore
+    
+    define_method("#{name}_attributes", block)
+    define_method("valid_#{name}_attributes") {|*args| valid_attributes_for(model, *args)}
+    define_method("new_#{name}")              {|*args| new_record(model, *args)}
+    define_method("create_#{name}")           {|*args| create_record(model, *args)}
+  end
+  
+  # Get valid attributes for the model
+  def valid_attributes_for(model, attributes = {})
+    name = model.to_s.underscore
+    send("#{name}_attributes", attributes)
+    attributes.stringify_keys!
+    attributes
+  end
+  
+  # Build an unsaved record
+  def new_record(model, *args)
+    attributes = valid_attributes_for(model, *args)
+    record = model.new(attributes)
+    attributes.each {|attr, value| record.send("#{attr}=", value) if model.accessible_attributes && !model.accessible_attributes.include?(attr) || model.protected_attributes && model.protected_attributes.include?(attr)}
+    record
+  end
+  
+  # Build and save/reload a record
+  def create_record(model, *args)
+    record = new_record(model, *args)
+    record.save!
+    record.reload
+    record
+  end
+  
+  build Message do |attributes|
+    attributes[:sender] = create_user unless attributes.include?(:sender)
+    attributes.reverse_merge!(
+      :subject => 'New features',
+      :body => 'Lots of new things to talk about... come to the meeting tonight to find out!'
+    )
+  end
+  
+  build MessageRecipient do |attributes|
+    attributes[:message] = create_message unless attributes.include?(:message)
+    attributes[:receiver] = create_user(:login => 'me') unless attributes.include?(:receiver)
+    attributes.reverse_merge!(
+      :kind => 'to'
+    )
+  end
+  
+  build User do |attributes|
+    attributes.reverse_merge!(
+      :login => 'admin'
+    )
+  end
+end

data/test/functional/has_messages_test.rb

@@ -0,0 +1,139 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class UserByDefaultTest < ActiveSupport::TestCase
+  def setup
+    @user = create_user
+  end
+  
+  def test_should_not_have_any_messages
+    assert @user.messages.empty?
+  end
+  
+  def test_should_not_have_any_unsent_messages
+    assert @user.unsent_messages.empty?
+  end
+  
+  def test_should_not_have_any_sent_messages
+    assert @user.sent_messages.empty?
+  end
+  
+  def test_should_not_have_any_received_messages
+    assert @user.received_messages.empty?
+  end
+end
+
+class UserTest < ActiveSupport::TestCase
+  def setup
+    @user = create_user
+  end
+  
+  def test_should_be_able_to_create_new_messages
+    message = @user.messages.build
+    assert_instance_of Message, message
+    assert_equal @user, message.sender
+  end
+  
+  def test_should_be_able_to_send_new_messages
+    message = @user.messages.build
+    message.to create_user(:login => 'John')
+    assert message.deliver
+  end
+end
+
+class UserWithUnsentMessages < ActiveSupport::TestCase
+  def setup
+    @user = create_user
+    @sent_message = create_message(:sender => @user, :to => create_user(:login => 'you'))
+    @sent_message.deliver
+    @first_draft = create_message(:sender => @user)
+    @second_draft = create_message(:sender => @user)
+  end
+  
+  def test_should_have_unsent_messages
+    assert_equal [@first_draft, @second_draft], @user.unsent_messages
+  end
+  
+  def test_should_include_unsent_messages_in_messages
+    assert_equal [@sent_message, @first_draft, @second_draft], @user.messages
+  end
+end
+
+class UserWithSentMessages < ActiveSupport::TestCase
+  def setup
+    @user = create_user
+    @to = create_user(:login => 'you')
+    @draft = create_message(:sender => @user)
+    
+    @first_sent_message = create_message(:sender => @user, :to => @to)
+    @first_sent_message.deliver
+    
+    @second_sent_message = create_message(:sender => @user, :to => @to)
+    @second_sent_message.deliver
+  end
+  
+  def test_should_have_sent_messages
+    assert_equal [@first_sent_message, @second_sent_message], @user.sent_messages
+  end
+  
+  def test_should_include_sent_messages_in_messages
+    assert_equal [@draft, @first_sent_message, @second_sent_message], @user.messages
+  end
+end
+
+class UserWithReceivedMessages < ActiveSupport::TestCase
+  def setup
+    @sender = create_user
+    @user = create_user(:login => 'me')
+    
+    @unsent_message = create_message(:sender => @sender, :to => @user)
+    
+    @first_sent_message = create_message(:sender => @sender, :to => @user)
+    @first_sent_message.deliver
+    
+    @second_sent_message = create_message(:sender => @sender, :to => @user)
+    @second_sent_message.deliver
+  end
+  
+  def test_should_have_received_messages
+    assert_equal [@first_sent_message, @second_sent_message], @user.received_messages.map(&:message)
+  end
+end
+
+class UserWithHiddenMessagesTest < ActiveSupport::TestCase
+  def setup
+    @user = create_user
+    @friend = create_user(:login => 'you')
+    
+    hidden_unsent_message = create_message(:sender => @user)
+    hidden_unsent_message.hide
+    @unsent_message = create_message(:sender => @user)
+    
+    hidden_sent_message = create_message(:sender => @user, :to => @friend)
+    hidden_sent_message.deliver
+    hidden_sent_message.hide
+    @sent_message = create_message(:sender => @user, :to => @friend)
+    @sent_message.deliver
+    
+    hidden_received_message = create_message(:sender => @friend, :to => @user)
+    hidden_received_message.deliver
+    hidden_received_message.recipients.first.hide
+    @received_message = create_message(:sender => @friend, :to => @user)
+    @received_message.deliver
+  end
+  
+  def test_should_not_include_hidden_messages_in_messages
+    assert_equal [@unsent_message, @sent_message], @user.messages
+  end
+  
+  def test_should_not_include_hidden_messages_in_unsent_messages
+    assert_equal [@unsent_message], @user.unsent_messages
+  end
+  
+  def test_should_not_include_hidden_messages_in_sent_messages
+    assert_equal [@sent_message], @user.sent_messages
+  end
+  
+  def test_should_not_include_hidden_messages_in_received_messages
+    assert_equal [@received_message], @user.received_messages.map(&:message)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+# Load the plugin testing framework
+$:.unshift("#{File.dirname(__FILE__)}/../../plugin_test_helper/lib")
+require 'rubygems'
+require 'plugin_test_helper'
+
+# Run the migrations
+ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate")
+
+# Mixin the factory helper
+require File.expand_path("#{File.dirname(__FILE__)}/factory")
+Test::Unit::TestCase.class_eval do
+  include Factory
+end

data/test/unit/message_recipient_test.rb

@@ -0,0 +1,449 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class MessageRecipientByDefaultTest < ActiveSupport::TestCase
+  def setup
+    @recipient = MessageRecipient.new
+  end
+  
+  def test_should_not_have_a_message
+    assert_nil @recipient.message_id
+  end
+  
+  def test_should_not_have_a_receiver_id
+    assert_nil @recipient.receiver_id
+  end 
+  
+  def test_should_not_have_a_receiver_type
+    assert @recipient.receiver_type.blank?
+  end
+  
+  def test_should_not_have_a_kind
+    assert @recipient.kind.blank?
+  end
+  
+  def test_should_not_have_a_position
+    assert_nil @recipient.position
+  end
+  
+  def test_should_be_in_the_unread_state
+    assert_equal 'unread', @recipient.state
+  end
+  
+  def test_should_not_be_hidden
+    assert_nil @recipient.hidden_at
+    assert !@recipient.hidden?
+  end
+end
+
+class MesageRecipientTest < ActiveSupport::TestCase
+  def test_should_be_valid_with_a_set_of_valid_attributes
+    recipient = new_message_recipient
+    assert recipient.valid?
+  end
+  
+  def test_should_require_a_message
+    recipient = new_message_recipient(:message => nil)
+    assert !recipient.valid?
+    assert recipient.errors.invalid?(:message_id)
+  end
+  
+  def test_should_require_a_kind
+    recipient = new_message_recipient(:kind => nil)
+    assert !recipient.valid?
+    assert recipient.errors.invalid?(:kind)
+  end
+  
+  def test_should_require_a_state
+    recipient = new_message_recipient(:state => nil)
+    assert !recipient.valid?
+    assert recipient.errors.invalid?(:state)
+  end
+  
+  def test_should_require_a_receiver_id
+    recipient = new_message_recipient(:receiver => nil)
+    assert !recipient.valid?
+    assert recipient.errors.invalid?(:receiver_id)
+  end
+  
+  def test_should_require_a_receiver_type
+    recipient = new_message_recipient(:receiver => nil)
+    assert !recipient.valid?
+    assert recipient.errors.invalid?(:receiver_type)
+  end
+  
+  def test_should_not_require_a_position
+    recipient = new_message_recipient(:position => nil)
+    assert recipient.valid?
+  end
+  
+  def test_should_protect_attributes_from_mass_assignment
+    recipient = MessageRecipient.new(
+      :id => 1,
+      :message_id => 1,
+      :receiver_id => 1,
+      :receiver_type => 'User',
+      :kind => 'bcc',
+      :position => 10,
+      :state => 'read',
+      :hidden_at => Time.now
+    )
+    
+    assert_nil recipient.id
+    assert_equal 1, recipient.message_id
+    assert_equal 1, recipient.receiver_id
+    assert_equal 'User', recipient.receiver_type
+    assert_equal 'bcc', recipient.kind
+    assert_nil recipient.position
+    assert_equal 'unread', recipient.state
+    assert_nil recipient.hidden_at
+  end
+end
+
+class MessageRecipientAfterBeingCreatedTest < ActiveSupport::TestCase
+  def setup
+    @admin = create_user(:login => 'admin')
+    @erich = create_user(:login => 'Erich')
+    @richard = create_user(:login => 'Richard')
+    @ralph = create_user(:login => 'Ralph')
+    
+    message = create_message(
+      :subject => 'Hello',
+      :body => 'How are you?',
+      :sender => @admin,
+      :cc => @richard,
+      :bcc => @ralph
+    )
+    @recipient = create_message_recipient(
+      :message => message,
+      :receiver => @erich,
+      :kind => 'to'
+    )
+  end
+  
+  def test_should_not_be_hidden
+    assert !@recipient.hidden?
+  end
+  
+  def test_should_delegate_sender_to_message
+    assert_equal @admin, @recipient.sender
+  end
+  
+  def test_should_delegate_subject_to_message
+    assert_equal 'Hello', @recipient.subject
+  end
+  
+  def test_should_delegate_body_to_message
+    assert_equal 'How are you?', @recipient.body
+  end
+  
+  def test_should_delegate_recipients_to_message
+    assert_equal [@erich, @richard, @ralph], @recipient.recipients.map(&:receiver)
+  end
+  
+  def test_should_delegate_to_receivers_to_message
+    assert_equal [@erich], @recipient.to
+  end
+  
+  def test_should_delegate_cc_receivers_to_message
+    assert_equal [@richard], @recipient.cc
+  end
+  
+  def test_should_delegate_bcc_receivers_to_message
+    assert_equal [@ralph], @recipient.bcc
+  end
+  
+  def test_should_delegate_created_at_to_message
+    assert_not_nil @recipient.created_at
+  end
+end
+
+class MessageRecipientOfMultipleTest < ActiveSupport::TestCase
+  def setup
+    @erich = create_user(:login => 'Erich')
+    @richard = create_user(:login => 'Richard')
+    @ralph = create_user(:login => 'Ralph')
+    
+    message = create_message(:to => [@erich, @richard])
+    @recipient = create_message_recipient(
+      :message => message,
+      :receiver => @ralph,
+      :kind => 'to'
+    )
+  end
+  
+  def test_should_use_position_based_on_position_of_last_recipient
+    assert_equal 3, @recipient.position
+  end
+end
+
+class MessageRecipientUnreadWithUnsentMessageTest < ActiveSupport::TestCase
+  def setup
+    @recipient = create_message_recipient
+  end
+  
+  def test_should_be_in_the_unread_state
+    assert_equal 'unread', @recipient.state
+  end
+  
+  def test_should_not_be_able_to_view
+    assert !@recipient.view
+  end
+end
+
+class MessageRecipientUnreadWithSentMessageTest < ActiveSupport::TestCase
+  def setup
+    @recipient = create_message_recipient
+    @recipient.message.deliver
+  end
+  
+  def test_should_be_in_the_unread_state
+    assert_equal 'unread', @recipient.state
+  end
+  
+  def test_should_be_able_to_view
+    assert @recipient.view
+  end
+end
+
+class MessageRecipientReadTest < ActiveSupport::TestCase
+  def setup
+    @recipient = create_message_recipient
+    @recipient.message.deliver
+    @recipient.view
+  end
+  
+  def test_should_be_in_the_read_state
+    assert_equal 'read', @recipient.state
+  end
+  
+  def test_should_not_be_able_to_view
+    assert !@recipient.view
+  end
+end
+
+class MessageRecipientHiddenTest < ActiveSupport::TestCase
+  def setup
+    @recipient = create_message_recipient
+    @recipient.hide
+  end
+  
+  def test_should_record_when_it_was_hidden
+    assert_not_nil @recipient.hidden_at
+  end
+  
+  def test_should_be_hidden
+    assert @recipient.hidden?
+  end
+  
+  def test_should_not_be_visible
+    assert !@recipient.visible?
+  end
+end
+
+class MessageRecipientUnhiddenTest < ActiveSupport::TestCase
+  def setup
+    @recipient = create_message_recipient
+    @recipient.hide
+    @recipient.unhide
+  end
+  
+  def test_should_not_have_the_recorded_value_when_it_was_hidden
+    assert_nil @recipient.hidden_at
+  end
+  
+  def test_should_not_be_hidden
+    assert !@recipient.hidden?
+  end
+  
+  def test_should_be_visible
+    assert @recipient.visible?
+  end
+end
+
+class MessageRecipientForwardedTest < ActiveSupport::TestCase
+  def setup
+    @erich = create_user(:login => 'Erich')
+    original_message = create_message(
+      :subject => 'Hello',
+      :body => 'How are you?',
+      :cc => create_user(:login => 'Richard'),
+      :bcc => create_user(:login => 'Ralph')
+    )
+    @recipient = create_message_recipient(
+      :message => original_message,
+      :receiver => @erich
+    )
+    @message = @recipient.forward
+  end
+  
+  def test_should_be_in_unsent_state
+    assert_equal 'unsent', @message.state
+  end
+  
+  def test_should_not_be_hidden
+    assert !@message.hidden?
+  end
+  
+  def test_should_have_original_subject
+    assert_equal 'Hello', @message.subject
+  end
+  
+  def test_should_have_original_body
+    assert_equal 'How are you?', @message.body
+  end
+  
+  def test_should_use_receiver_as_the_sender
+    assert_equal @erich, @message.sender
+  end
+  
+  def test_should_not_include_to_recipients
+    assert @message.to.empty?
+  end
+  
+  def test_should_not_include_cc_recipients
+    assert @message.cc.empty?
+  end
+  
+  def test_should_not_include_bcc_recipients
+    assert @message.bcc.empty?
+  end
+end
+
+class MessageRecipientRepliedTest < ActiveSupport::TestCase
+  def setup
+    @erich = create_user(:login => 'Erich')
+    @john = create_user(:login => 'John')
+    original_message = create_message(
+      :subject => 'Hello',
+      :body => 'How are you?',
+      :to => @john,
+      :cc => create_user(:login => 'Richard'),
+      :bcc => create_user(:login => 'Ralph')
+    )
+    @recipient = create_message_recipient(
+      :message => original_message,
+      :receiver => @erich
+    )
+    @message = @recipient.reply
+  end
+  
+  def test_should_be_in_unsent_state
+    assert_equal 'unsent', @message.state
+  end
+  
+  def test_should_not_be_hidden
+    assert !@message.hidden?
+  end
+  
+  def test_should_have_original_subject
+    assert_equal 'Hello', @message.subject
+  end
+  
+  def test_should_have_original_body
+    assert_equal 'How are you?', @message.body
+  end
+  
+  def test_should_use_receiver_as_the_sender
+    assert_equal @erich, @message.sender
+  end
+  
+  def test_should_include_to_recipients
+    assert [@erich, @john], @message.to
+  end
+  
+  def test_should_not_include_cc_recipients
+    assert @message.cc.empty?
+  end
+  
+  def test_should_not_include_bcc_recipients
+    assert @message.bcc.empty?
+  end
+end
+
+class MessageRecipientRepliedToAllTest < ActiveSupport::TestCase
+  def setup
+    @erich = create_user(:login => 'Erich')
+    @john = create_user(:login => 'John')
+    @richard = create_user(:login => 'Richard')
+    @ralph = create_user(:login => 'Ralph')
+    original_message = create_message(
+      :subject => 'Hello',
+      :body => 'How are you?',
+      :to => @john,
+      :cc => @richard,
+      :bcc => @ralph
+    )
+    @recipient = create_message_recipient(
+      :message => original_message,
+      :receiver => @erich
+    )
+    @message = @recipient.reply_to_all
+  end
+  
+  def test_should_be_in_unsent_state
+    assert_equal 'unsent', @message.state
+  end
+  
+  def test_should_not_be_hidden
+    assert !@message.hidden?
+  end
+  
+  def test_should_have_original_subject
+    assert_equal 'Hello', @message.subject
+  end
+  
+  def test_should_have_original_body
+    assert_equal 'How are you?', @message.body
+  end
+  
+  def test_should_use_receiver_as_the_sender
+    assert_equal @erich, @message.sender
+  end
+  
+  def test_should_include_to_recipients
+    assert [@erich, @john], @message.to
+  end
+  
+  def test_should_include_cc_recipients
+    assert_equal [@richard], @message.cc
+  end
+  
+  def test_should_include_bcc_recipients
+    assert_equal [@ralph], @message.bcc
+  end
+end
+
+class MessageRecipientAfterBeingDestroyedTest < ActiveSupport::TestCase
+  def setup
+    message = create_message
+    @first_recipient = create_message_recipient(
+      :message => message,
+      :receiver => create_user(:login => 'Erich'),
+      :kind => 'to'
+    )
+    @last_recipient = create_message_recipient(
+      :message => message,
+      :receiver => create_user(:login => 'Richard'),
+      :kind => 'to'
+    )
+    
+    assert @first_recipient.destroy
+    @last_recipient.reload
+  end
+  
+  def test_should_reorder_positions_of_all_other_recipients
+    assert_equal 1, @last_recipient.position
+  end
+end
+
+class MessageRecipientAsAClassTest < ActiveSupport::TestCase
+  def setup
+    message = create_message
+    @hidden_recipient = create_message_recipient(:message => message, :receiver => create_user(:login => 'erich'), :hidden_at => Time.now)
+    @visible_recipient = create_message_recipient(:message => message, :receiver => create_user(:login => 'richard'))
+  end
+  
+  def test_should_include_only_visible_messages_in_visible_scope
+    assert_equal [@visible_recipient], MessageRecipient.visible
+  end
+end