aiwilliams-mlist 0.0.0 → 0.1.0

data/lib/mlist/mail_list.rb

@@ -1,77 +1,148 @@
 module MList
   class MailList < ActiveRecord::Base
-    def self.find_or_create_by_list(list)
-      mail_list = find_or_create_by_identifier(list.list_id)
-      mail_list.manager_list = list
+    set_table_name 'mlist_mail_lists'
+    
+    # Provides the MailList for a given implementation of MList::List,
+    # connecting it to the provided email server for delivering posts.
+    #
+    def self.find_or_create_by_list(list, outgoing_server)
+      if list.is_a?(ActiveRecord::Base)
+        mail_list = find_or_create_by_manager_list_identifier_and_manager_list_type_and_manager_list_id(
+          list.list_id, list.class.base_class.name, list.id
+        )
+      else
+        mail_list = find_or_create_by_manager_list_identifier(list.list_id)
+        mail_list.manager_list = list
+      end
+      mail_list.outgoing_server = outgoing_server
       mail_list
     end
     
-    has_many :messages, :dependent => :delete_all
-    has_many :threads, :dependent => :delete_all
+    belongs_to :manager_list, :polymorphic => true
     
-    attr_accessor :manager_list
-    delegate :address, :recipients, :subscriptions,
-             :to => :manager_list
+    has_many :messages, :class_name => 'MList::Message', :dependent => :delete_all
+    has_many :threads, :class_name => 'MList::Thread', :dependent => :delete_all
     
-    def post(email_server, message)
-      return unless process?(message)
-      prepare_delivery(message)
-      deliver(message, email_server)
-    end
+    delegate :address, :label, :post_url, :to => :list
+    
+    attr_accessor :outgoing_server
     
-    def been_there?(message)
-      message.header_string('x-beenthere') == address
+    # Creates a new MList::Message and delivers it to the subscribers of this
+    # list.
+    #
+    def post(email_or_attributes)
+      email = email_or_attributes
+      email = MList::EmailPost.new(email_or_attributes) unless email.is_a?(MList::EmailPost)
+      process_message messages.build(
+        :parent => email.reply_to_message,
+        :parent_identifier => email.parent_identifier,
+        :mail_list => self,
+        :subscriber => email.subscriber,
+        :recipients => list.recipients(email.subscriber),
+        :email => MList::Email.new(:tmail => email.to_tmail)
+      ), :search_parent => false
     end
     
-    # http://mail.python.org/pipermail/mailman-developers/2006-April/018718.html
-    def bounce_headers
-      {'sender'    => "mlist-#{address}",
-       'errors-to' => "mlist-#{address}"}
+    # Processes the email received by the MList::Server.
+    #
+    def process_email(email)
+      subscriber = list.subscriber(email.from_address)
+      recipients = list.recipients(subscriber)
+      process_message messages.build(
+        :mail_list => self,
+        :subscriber => subscriber,
+        :recipients => recipients,
+        :email => email
+      )
     end
     
-    def deliver(message, email_server)
-      transaction do
-        email_server.deliver(message.tmail)
-        thread = find_thread(message)
-        thread.messages << message
-        thread.save!
-      end
+    def list
+      @list ||= manager_list
     end
     
-    def find_thread(message)
-      if message.reply?
-        threads.find(:first,
-          :joins => :messages,
-          :readonly => false,
-          :conditions => ['messages.identifier = ?', message.parent_identifier]
-        )
+    def manager_list_with_dual_type=(list)
+      if list.is_a?(ActiveRecord::Base)
+        self.manager_list_without_dual_type = list
+        @list = list
       else
-        threads.build
+        self.manager_list_without_dual_type = nil
+        @list = list
       end
     end
+    alias_method_chain :manager_list=, :dual_type
     
-    # http://www.jamesshuggins.com/h/web1/list-email-headers.htm
-    def list_headers
-      headers = manager_list.list_headers
-      headers['x-beenthere'] = address
-      headers.update(bounce_headers)
-      headers.delete_if {|k,v| v.nil?}
-    end
-    
-    def prepare_delivery(message)
-      prepare_list_headers(message)
-      message.to = address
-      message.bcc = recipients(message)
+    def process?(message)
+      !message.recipients.blank?
     end
     
-    def prepare_list_headers(message)
-      list_headers.each do |k,v|
-        message.write_header(k,v)
+    private
+      # http://mail.python.org/pipermail/mailman-developers/2006-April/018718.html
+      def bounce_headers
+        {'sender'    => "mlist-#{address}",
+         'errors-to' => "mlist-#{address}"}
+      end
+      
+      # http://www.jamesshuggins.com/h/web1/list-email-headers.htm
+      def list_headers
+        headers = list.list_headers
+        headers['x-beenthere'] = address
+        headers.update(bounce_headers)
+        headers.delete_if {|k,v| v.nil?}
+      end
+      
+      def process_message(message, options = {})
+        raise MList::DoubleDeliveryError.new(message) unless message.new_record?
+        return message unless process?(message)
+        
+        options = {
+          :search_parent => true,
+          :delivery_time => Time.now
+        }.merge(options)
+        transaction do
+          thread = find_thread(message, options)
+          thread.messages << message
+          prepare_delivery(message)
+          destinations = message.delivery.destinations
+          tmail = message.to_tmail
+          self.updated_at = thread.updated_at = options[:delivery_time]
+          thread.save! && save!
+          outgoing_server.deliver(tmail, destinations)
+        end
+        message
+      end
+      
+      def prepare_delivery(message)
+        delivery = message.delivery
+        prepare_list_headers(delivery)
+        delivery.subject = list_subject(message)
+        delivery.to = address
+        delivery.bcc = message.recipients
+        delivery.reply_to = "#{label} <#{post_url}>"
+      end
+      
+      def prepare_list_headers(delivery)
+        list_headers.each do |k,v|
+          if TMail::Mail::ALLOW_MULTIPLE.include?(k.downcase)
+            delivery.prepend_header(k,v)
+          else
+            delivery.write_header(k,v)
+          end
+        end
+      end
+      
+      def list_subject(message)
+        prefix = "[#{label}]"
+        subject = message.subject.gsub(%r(#{Regexp.escape(prefix)}\s*), '')
+        subject.gsub!(%r{(re:\s*){2,}}i, 'Re: ')
+        "#{prefix} #{subject}"
+      end
+      
+      def find_thread(message, options)
+        if options[:search_parent]
+          message.parent_identifier = message.email.parent_identifier(self)
+          message.parent = messages.find_by_identifier(message.parent_identifier)
+        end
+        message.parent ? message.parent.thread : threads.build
       end
-    end
-    
-    def process?(message)
-      !been_there?(message) && !recipients(message).blank?
-    end
   end
 end

data/lib/mlist/manager/database.rb

@@ -12,20 +12,24 @@ module MList
       
       def lists(email)
         lists = List.find_all_by_address(email.list_addresses)
-        email.list_addresses.map { |a| lists.detect {|l| l.address == a} }
+        email.list_addresses.map { |a| lists.detect {|l| l.address == a} }.compact
       end
       
       class List < ActiveRecord::Base
         include ::MList::List
         
-        has_many :subscriptions, :dependent => :delete_all
+        has_many :subscribers, :dependent => :delete_all
+        
+        def list_id
+          "#{self.class.name}#{id}"
+        end
         
         def subscribe(address)
-          subscriptions.find_or_create_by_address(address)
+          subscribers.find_or_create_by_email_address(address)
         end
       end
       
-      class Subscription < ActiveRecord::Base
+      class Subscriber < ActiveRecord::Base
         belongs_to :list
       end
     end

data/lib/mlist/message.rb

@@ -1,107 +1,111 @@
 module MList
   
-  # The persisted version of an email that is processed by MList::MailLists.
-  #
-  # The tmail object referenced by these are unique, though they may reference
-  # the 'same' originating email.
-  #
   class Message < ActiveRecord::Base
-    belongs_to :mail_list
+    set_table_name 'mlist_messages'
     
-    attr_writer :header_sanitizers
-    before_save :serialize_tmail
+    include MList::Util::EmailHelpers
     
-    def charset
-      'utf-8'
-    end
+    belongs_to :email, :class_name => 'MList::Email'
+    belongs_to :parent, :class_name => 'MList::Message'
+    belongs_to :mail_list, :class_name => 'MList::MailList', :counter_cache => :messages_count
+    belongs_to :thread, :class_name => 'MList::Thread', :counter_cache => :messages_count
     
-    def delete_header(name)
-      tmail[name] = nil
-    end
+    # A temporary storage of recipient subscribers, obtained from
+    # MList::Lists. This list is not available when a message is reloaded.
+    #
+    attr_accessor :recipients
     
-    def from_address
-      tmail.from.first
+    def delivery
+      @delivery ||= MList::Util::TMailBuilder.new(TMail::Mail.parse(email.source))
     end
     
-    def parent_identifier
-      if in_reply_to = header_string('in-reply-to')
-        identifier = in_reply_to
-      elsif references = read_header('references')
-        identifier = references.ids.first
-      else
-        parent_message = mail_list.messages.find(:first,
-          :conditions => ['messages.subject = ?', remove_regard(subject)],
-          :order => 'created_at asc'
-        )
-        identifier = parent_message.identifier if parent_message
-      end
-      remove_brackets(identifier) if identifier
+    def email_with_capture=(email)
+      self.subject = email.subject
+      self.mailer = email.mailer
+      self.email_without_capture = email
     end
+    alias_method_chain :email=, :capture
     
-    def read_header(name)
-      tmail[name]
+    # Answers the html content of the message.
+    #
+    def html
+      email.html
     end
     
-    def reply?
-      !parent_identifier.nil?
+    # Answers the text content of the message.
+    #
+    def text
+      email.text
     end
     
-    def write_header(name, value)
-      tmail[name] = sanitize_header(name, value)
+    # Answers the text content of the message as HTML. The structure of this
+    # output is very simple. For examples of what it can handle, please check
+    # out the spec documents for MList::Util::EmailHelpers.
+    #
+    def text_html
+      text_to_html(text)
     end
     
-    def tmail=(tmail)
-      write_attribute(:identifier, remove_brackets(tmail.header_string('message-id')))
-      write_attribute(:subject, tmail.subject)
-      @tmail = tmail
+    # Answers text suitable for creating a reply message.
+    #
+    def text_for_reply
+      timestamp = email.date.to_s(:mlist_reply_timestamp)
+      "On #{timestamp}, #{email.from} wrote:\n#{text_to_quoted(text)}"
     end
     
-    def tmail
-      @tmail ||= TMail::Mail.parse(email_text)
+    # Answers text suitable for creating a reply message, converted to the
+    # same simple html of _text_html_.
+    #
+    def html_for_reply
+      text_to_html(text_for_reply)
     end
     
-    def to=(recipients)
-      tmail.to = sanitize_header('to', recipients)
+    # Answers the subject with all prefixes removed.
+    #
+    #   message.subject = 'Re: [List Label] Re: The new Chrome Browser from Google'
+    #   message.subject_for_reply   => 'Re: The new Chrome Browser from Google'
+    #
+    def subject_for_reply
+      "Re: #{remove_regard(subject)}"
     end
     
-    def bcc=(recipients)
-      tmail.bcc = sanitize_header('bcc', recipients)
+    # Answers the subscriber from which this message comes.
+    #
+    def subscriber
+      @subscriber ||= begin
+        if subscriber_type? && subscriber_id?
+          subscriber_type.constantize.find(subscriber_id)
+        elsif subscriber_address?
+          MList::EmailSubscriber.new(subscriber_address)
+        end
+      end
     end
     
-    # Provide delegation to *most* of the underlying TMail::Mail methods,
-    # excluding those overridden by this class and the [] and []= methods. We
-    # must maintain the ActiveRecord interface over that of the TMail::Mail
-    # interface.
+    # Assigns the subscriber from which this message comes.
     #
-    def method_missing(symbol, *args, &block) # :nodoc:
-      if @tmail && @tmail.respond_to?(symbol) && !(symbol == :[] || symbol == :[]=)
-        @tmail.__send__(symbol, *args, &block)
+    def subscriber=(subscriber)
+      case subscriber
+      when ActiveRecord::Base
+        @subscriber = subscriber
+        self.subscriber_address = subscriber.email_address
+        self.subscriber_type = subscriber.class.base_class.name
+        self.subscriber_id = subscriber.id
+      when MList::EmailSubscriber
+        @subscriber = subscriber
+        self.subscriber_address = subscriber.email_address
+        self.subscriber_type = self.subscriber_id = nil
+      when String
+        self.subscriber = MList::EmailSubscriber.new(subscriber)
       else
-        super
+        @subscriber = self.subscriber_address = self.subscriber_type = self.subscriber_id = nil
       end
     end
     
-    def sanitize_header(name, *values)
-      header_sanitizer(name).call(charset, *values)
+    def to_tmail
+      delivery.mailer = mailer
+      delivery.ready_to_send
+      self.identifier = delivery.identifier
+      delivery.tmail
     end
-    
-    private
-      def header_sanitizer(name)
-        @header_sanitizers ||= Util.default_header_sanitizers
-        @header_sanitizers[name]
-      end
-      
-      def remove_brackets(string)
-        string =~ /\A<(.*?)>\Z/ ? $1 : string
-      end
-      
-      def remove_regard(string)
-        stripped = string.strip
-        stripped =~ /\Are:\s+(.*?)\Z/i ? $1 : stripped
-      end
-      
-      def serialize_tmail
-        write_attribute(:email_text, @tmail.to_s)
-      end
   end
 end

data/lib/mlist/server.rb

@@ -8,7 +8,7 @@ module MList
       @email_server.receiver(self)
     end
     
-    def receive(email)
+    def receive_email(email)
       lists = list_manager.lists(email)
       if email.bounce?
         process_bounce(lists.first, email)
@@ -17,6 +17,10 @@ module MList
       end
     end
     
+    def mail_list(list)
+      MailList.find_or_create_by_list(list, @email_server)
+    end
+    
     protected
       def process_bounce(list, email)
         list.bounce(email)
@@ -24,11 +28,15 @@ module MList
       
       def process_post(lists, email)
         lists.each do |list|
+          next if email.been_here?(list)
           if list.subscriber?(email.from_address)
-            mail_list = MailList.find_or_create_by_list(list)
-            mail_list.post(email_server, MList::Message.new(:mail_list => mail_list, :tmail => email.tmail))
+            if list.active?
+              mail_list(list).process_email(email)
+            else
+              list.inactive_post(email)
+            end
           else
-            list.non_subscriber_posted(email)
+            list.non_subscriber_post(email)
           end
         end
       end