has_messages 0.1.0

data/db/migrate/001_create_messages.rb

@@ -0,0 +1,17 @@
+class CreateMessages < ActiveRecord::Migration
+  def self.up
+    create_table :messages do |t|
+      t.references :sender, :polymorphic => true, :null => false
+      t.text :subject
+      t.text :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,75 @@
+require 'state_machine'
+
+module PluginAWeek #:nodoc:
+  # Adds a generic implementation for sending messages between users
+  module HasMessages
+    def self.included(base) #:nodoc:
+      base.class_eval do
+        extend PluginAWeek::HasMessages::MacroMethods
+      end
+    end
+    
+    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 PluginAWeek::HasMessages::InstanceMethods
+      end
+    end
+    
+    module InstanceMethods
+      # Composed messages that have not yet been sent
+      def unsent_messages
+        messages.with_state('unsent')
+      end
+      
+      # Composed messages that have already been sent
+      def sent_messages
+        messages.with_states(%w(queued sent))
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include PluginAWeek::HasMessages
+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'
+require "#{File.dirname(__FILE__)}/../../../../plugins_plus/boot"
+
+Rails::Initializer.run do |config|
+  config.plugin_paths << '..'
+  config.plugins = %w(plugins_plus state_machine has_messages)
+  config.cache_classes = false
+  config.whiny_nils = true
+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,9 @@
+class MigrateHasMessagesToVersion2 < ActiveRecord::Migration
+  def self.up
+    Rails::Plugin.find(:has_messages).migrate(2)
+  end
+  
+  def self.down
+    Rails::Plugin.find(:has_messages).migrate(0)
+  end
+end

data/test/factory.rb

@@ -0,0 +1,47 @@
+module Factory
+  # Build actions for the class
+  def self.build(klass, &block)
+    name = klass.to_s.underscore
+    define_method("#{name}_attributes", block)
+    
+    module_eval <<-end_eval
+      def valid_#{name}_attributes(attributes = {})
+        #{name}_attributes(attributes)
+        attributes
+      end
+      
+      def new_#{name}(attributes = {})
+        #{klass}.new(valid_#{name}_attributes(attributes))
+      end
+      
+      def create_#{name}(*args)
+        record = new_#{name}(*args)
+        record.save!
+        record.reload
+        record
+      end
+    end_eval
+  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 < Test::Unit::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 < Test::Unit::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 < Test::Unit::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 < Test::Unit::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 < Test::Unit::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 < Test::Unit::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")
+class Test::Unit::TestCase #:nodoc:
+  include Factory
+end

data/test/unit/message_recipient_test.rb

@@ -0,0 +1,419 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class MessageRecipientByDefaultTest < Test::Unit::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 < Test::Unit::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_equal 1, Array(recipient.errors.on(:message_id)).size
+  end
+  
+  def test_should_require_a_kind
+    recipient = new_message_recipient(:kind => nil)
+    assert !recipient.valid?
+    assert_equal 1, Array(recipient.errors.on(:kind)).size
+  end
+  
+  def test_should_require_a_state
+    recipient = new_message_recipient(:state => nil)
+    assert !recipient.valid?
+    assert_equal 1, Array(recipient.errors.on(:state)).size
+  end
+  
+  def test_should_require_a_receiver_id
+    recipient = new_message_recipient(:receiver => nil)
+    assert !recipient.valid?
+    assert_equal 1, Array(recipient.errors.on(:receiver_id)).size
+  end
+  
+  def test_should_require_a_receiver_type
+    recipient = new_message_recipient(:receiver => nil)
+    assert !recipient.valid?
+    assert_equal 1, Array(recipient.errors.on(:receiver_type)).size
+  end
+  
+  def test_should_not_require_a_position
+    recipient = new_message_recipient(:position => nil)
+    assert recipient.valid?
+  end
+end
+
+class MessageRecipientAfterBeingCreatedTest < Test::Unit::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 < Test::Unit::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 < Test::Unit::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 < Test::Unit::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 < Test::Unit::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 < Test::Unit::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
+end
+
+class MessageRecipientUnhiddenTest < Test::Unit::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
+end
+
+class MessageRecipientForwardedTest < Test::Unit::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 < Test::Unit::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 < Test::Unit::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 < Test::Unit::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 < Test::Unit::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