mlist 0.1.9

data/lib/mlist/message.rb

@@ -0,0 +1,150 @@
+module MList
+  
+  class Message < ActiveRecord::Base
+    set_table_name 'mlist_messages'
+    
+    include MList::Util::EmailHelpers
+    
+    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
+    
+    after_destroy :delete_unreferenced_email
+    
+    # A temporary storage of recipient subscribers, obtained from
+    # MList::Lists. This list is not available when a message is reloaded.
+    #
+    attr_accessor :recipients
+    
+    # Answers an MList::TMailBuilder for assembling the TMail::Mail object
+    # that will be fit for delivery. If this is not a new message, the
+    # delivery will be updated to reflect the message-id, x-mailer, etc. of
+    # this message.
+    #
+    def delivery
+      @delivery ||= begin
+        d = MList::Util::TMailBuilder.new(TMail::Mail.parse(email.source))
+        unless new_record?
+          d.message_id = self.identifier
+          d.mailer = self.mailer
+          d.date = self.created_at
+        end
+        d
+      end
+    end
+    
+    def email_with_capture=(email)
+      self.subject = email.subject
+      self.mailer = email.mailer
+      self.email_without_capture = email
+    end
+    alias_method_chain :email=, :capture
+    
+    # Answers the html content of the message.
+    #
+    def html
+      email.html
+    end
+    
+    # Answers the text content of the message.
+    #
+    def text
+      email.text
+    end
+    
+    # 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
+    
+    # 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
+    
+    # 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 parent_with_identifier_capture=(parent)
+      if parent
+        self.parent_without_identifier_capture = parent
+        self.parent_identifier = parent.identifier
+      else
+        self.parent_without_identifier_capture = nil
+        self.parent_identifier = nil
+      end
+    end
+    alias_method_chain :parent=, :identifier_capture
+    
+    # Answers the recipient email addresses from the MList::List recipient
+    # subscribers, except those that are in the email TO or CC fields as
+    # placed there by the sending MUA. It is assumed that those addresses have
+    # received a copy of the email already, and that by including them here,
+    # we would cause them to receive two copies of the message.
+    #
+    def recipient_addresses
+      @recipients.collect(&:email_address).collect(&:downcase) - email.recipient_addresses
+    end
+    
+    # Answers the subject with 'Re:' prefixed. Note that it is the
+    # responsibility of the MList::MailList to perform any processing of the
+    # persisted subject (ie, cleaning up labels, etc).
+    #
+    #   message.subject = '[List Label] Re: The new Chrome Browser from Google'
+    #   message.subject_for_reply   => 'Re: [List Label] The new Chrome Browser from Google'
+    #
+    #   message.subject = 'Re: [List Label] Re: The new Chrome Browser from Google'
+    #   message.subject_for_reply   => 'Re: [List Label] The new Chrome Browser from Google'
+    #
+    def subject_for_reply
+      subject =~ REGARD_RE ? subject : "Re: #{subject}"
+    end
+    
+    # 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
+    
+    # Assigns the subscriber from which this message comes.
+    #
+    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
+        @subscriber = self.subscriber_address = self.subscriber_type = self.subscriber_id = nil
+      end
+    end
+    
+    private
+      def delete_unreferenced_email
+        email.destroy unless MList::Message.count(:conditions => "email_id = #{email_id} and id != #{id}") > 0
+      end
+  end
+end

data/lib/mlist/server.rb

@@ -0,0 +1,62 @@
+module MList
+  class Server
+    attr_reader :list_manager, :email_server, :notifier
+    
+    def initialize(config)
+      @list_manager = config[:list_manager]
+      @email_server = config[:email_server]
+      @notifier = MList::Manager::Notifier.new
+      @email_server.receiver(self)
+    end
+    
+    def receive_email(email)
+      lists = list_manager.lists(email)
+      if lists.empty?
+        list_manager.no_lists_found(email)
+      elsif email.bounce?
+        process_bounce(lists.first, email)
+      else
+        process_post(lists, email)
+      end
+    end
+    
+    def mail_list(list)
+      MailList.find_or_create_by_list(list, @email_server)
+    end
+    
+    protected
+      def process_post(lists, email)
+        lists.each do |list|
+          next if email.been_here?(list)
+          if list.subscriber?(email.from_address)
+            publish_if_list_active(list, email)
+          else
+            list.non_subscriber_post(email)
+          end
+        end
+      end
+      
+      def publish_if_list_active(list, email)
+        if list.active?
+          subscriber = list.subscriber(email.from_address)
+          publish_unless_blocked(list, email, subscriber)
+        else
+          list.inactive_post(email)
+        end
+      end
+      
+      def publish_unless_blocked(list, email, subscriber)
+        if list.blocked?(subscriber)
+          notice_delivery = notifier.subscriber_blocked(list, email, subscriber)
+          email_server.deliver(notice_delivery.tmail)
+        else
+          mail_list(list).process_email(email, subscriber)
+        end
+      end
+      
+      def process_bounce(list, email)
+        list.bounce(email)
+      end
+      
+  end
+end

data/lib/mlist/thread.rb

@@ -0,0 +1,98 @@
+module MList
+  class Thread < ActiveRecord::Base
+    set_table_name 'mlist_threads'
+    
+    belongs_to :mail_list, :class_name => 'MList::MailList', :counter_cache => :threads_count
+    has_many :messages, :class_name => 'MList::Message', :dependent => :delete_all
+    
+    def first?(message)
+      tree_order.first == message
+    end
+    
+    def last?(message)
+      tree_order.last == message
+    end
+    
+    def next(message)
+      i = tree_order.index(message)
+      tree_order[i + 1] unless messages.size < i
+    end
+    
+    def previous(message)
+      i = tree_order.index(message)
+      tree_order[i - 1] if i > 0
+    end
+    
+    def subject
+      messages.first.subject
+    end
+    
+    # Answers a tree of messages.
+    #
+    # The nodes of the tree are decorated to act like a linked list, providing
+    # pointers to _next_ and _previous_ in the tree.
+    #
+    def tree
+      return nil if messages.size == 0
+      build_tree unless @tree
+      @tree
+    end
+    
+    def tree_order
+      build_tree unless @tree
+      @tree_order
+    end
+    
+    private
+      def build_tree
+        nodes = messages.collect do |m|
+          m.parent = messages.detect {|pm| pm.id == m.parent_id}
+          Node.new(m)
+        end
+        
+        nodes.each do |node|
+          if parent_node = nodes.detect {|n| n == node.parent}
+            node.parent_node = parent_node
+            parent_node.children << node
+          end
+        end
+        
+        @tree_order = []
+        previous_node = nil
+        nodes.first.visit do |node|
+          @tree_order << node
+          if previous_node
+            node.previous = previous_node
+            previous_node.next = node
+          end
+          previous_node = node
+        end
+        
+        @tree = @tree_order.first
+      end
+      
+      class Node < DelegateClass(Message)
+        attr_accessor :parent_node, :previous, :next
+        attr_reader :children
+        
+        def initialize(message)
+          super
+          @children = []
+        end
+        
+        def leaf?
+          children.empty?
+        end
+        
+        def root?
+          parent_node.nil?
+        end
+        
+        def visit(&visitor)
+          visitor.call self
+          children.each {|c| c.visit(&visitor)}
+        end
+      end
+      
+  end
+end

data/lib/mlist/util/email_helpers.rb

@@ -0,0 +1,155 @@
+module MList
+  module Util
+    
+    class HtmlTextExtraction
+      
+      # We need a way to maintain non-breaking spaces. Hpricot will replace
+      # them with ??.chr. We can easily teach it to convert it to a space, but
+      # then we lose the information in the Text node that we need to keep the
+      # space around, since that is what they would see in a view of the HTML.
+      NBSP = '!!!NBSP!!!'
+      
+      def initialize(html)
+        @doc = Hpricot(html.gsub(' ', NBSP))
+      end
+      
+      def execute
+        @text, @anchors = '', []
+        @doc.each_child do |node|
+          extract_text_from_node(node) if Hpricot::Elem::Trav === node
+        end
+        @text.strip!
+        unless @anchors.empty?
+          refs = []
+          @anchors.each_with_index do |href, i|
+            refs << "[#{i+1}] #{href}"
+          end
+          @text << "\n\n--\n#{refs.join("\n")}"
+        end
+        @text.gsub(NBSP, ' ')
+      end
+      
+      def extract_text_from_node(node)
+        case node.name
+        when 'head'
+        when 'h1', 'h2', 'h3', 'h4', 'h5', 'h6'
+          @text << node.inner_text
+          @text << "\n\n"
+        when 'br'
+          @text << "\n"
+        when 'ol'
+          node.children_of_type('li').each_with_index do |li, i|
+            @text << " #{i+1}. #{li.inner_text}"
+            @text << "\n\n"
+          end
+        when 'ul'
+          node.children_of_type('li').each do |li|
+            @text << " * #{li.inner_text.strip}"
+            @text << "\n\n"
+          end
+        when 'strong'
+          @text << "*#{node.inner_text}*"
+        when 'em'
+          @text << "_#{node.inner_text}_"
+        when 'dl'
+          node.traverse_element('dt', 'dd') do |dt_dd|
+            extract_text_from_node(dt_dd)
+          end
+        when 'a'
+          @anchors << node['href']
+          extract_text_from_text_node(node)
+          @text << "[#{@anchors.size}]"
+        when 'p', 'dt', 'dd'
+          extract_text_from_children(node)
+          @text.rstrip!
+          @text << "\n\n"
+        else
+          extract_text_from_children(node)
+        end
+      end
+      
+      def extract_text_from_children(elem)
+        elem.each_child do |node|
+          case node
+          when Hpricot::Text::Trav
+            extract_text_from_text_node(node)
+          when Hpricot::Elem::Trav
+            extract_text_from_node(node)
+          end
+        end
+      end
+      
+      def extract_text_from_text_node(node)
+        text = @text.end_with?("\n") ? node.inner_text.lstrip : node.inner_text
+        @text << text.gsub(/\s{2,}/, ' ').sub(/\n/, '')
+      end
+    end
+    
+    module EmailHelpers
+      def sanitize_header(charset, name, *values)
+        header_sanitizer(name).call(charset, *values)
+      end
+      
+      def header_sanitizer(name)
+        Util.default_header_sanitizers[name]
+      end
+      
+      def html_to_text(html)
+        HtmlTextExtraction.new(html).execute
+      end
+      
+      def normalize_new_lines(text)
+        text.to_s.gsub(/\r\n?/, "\n")
+      end
+      
+      def subscriber_name_and_address(subscriber)
+        a = subscriber.email_address
+        a = "#{subscriber.display_name} #{bracket(a)}" if subscriber.respond_to?(:display_name)
+        a
+      end
+      
+      BRACKETS_RE = /\A<(.*?)>\Z/
+      def bracket(string)
+        string.blank? || string =~ BRACKETS_RE ? string : "<#{string}>"
+      end
+      
+      def remove_brackets(string)
+        string =~ BRACKETS_RE ? $1 : string
+      end
+      
+      REGARD_RE = /(^|[^\w])re: /i
+      def remove_regard(string)
+        while string =~ REGARD_RE
+          string = string.sub(REGARD_RE, ' ')
+        end
+        string.strip
+      end
+      
+      def text_to_html(text)
+        lines = normalize_new_lines(text).split("\n")
+        lines.collect! do |line|
+          line = escape_once(line)
+          line = ("&nbsp;" * $1.length) + $2 if line =~ /^(\s+)(.*?)$/
+          line = %{<span class="quote">#{line}</span>} if line =~ /^(&gt;|[|]|[A-Za-z]+&gt;)/
+          line = line.gsub(/\s\s/, ' &nbsp;')
+          line
+        end
+        lines.join("<br />\n")
+      end
+      
+      def text_to_quoted(text)
+        lines = normalize_new_lines(text).split("\n")
+        lines.collect! do |line|
+          '> ' + line
+        end
+        lines.join("\n")
+      end
+      
+      HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;' }
+      def escape_once(text)
+        text.gsub(/[\"><]|&(?!([a-zA-Z]+|(#\d+));)/) { |special| HTML_ESCAPE[special] }
+      end
+    end
+    
+  end
+end

data/lib/mlist/util/header_sanitizer.rb

@@ -0,0 +1,71 @@
+module MList
+  module Util
+    
+    class QuotingSanitizer
+      include Quoting
+      
+      def initialize(method, bracket_urls)
+        @method, @bracket_urls = method, bracket_urls
+      end
+      
+      def bracket_urls(values)
+        values.map do |value|
+          if value.include?('<') && value.include?('>')
+            value
+          else
+            "<#{value}>"
+          end
+        end
+      end
+      
+      def call(charset, *values)
+        values = bracket_urls(values.flatten) if @bracket_urls
+        send(@method, charset, *values)
+      end
+    end
+    
+    class HeaderSanitizerHash
+      def initialize
+        @hash = Hash.new
+        initialize_default_sanitizers
+      end
+      
+      def initialize_default_sanitizers
+        self['message-id'] = quoter(:quote_address_if_necessary)
+        
+        self['to']       = quoter(:quote_any_address_if_necessary)
+        self['cc']       = quoter(:quote_any_address_if_necessary)
+        self['bcc']      = quoter(:quote_any_address_if_necessary)
+        self['from']     = quoter(:quote_any_address_if_necessary)
+        self['reply-to'] = quoter(:quote_any_address_if_necessary)
+        self['subject']  = quoter(:quote_any_if_necessary)
+        
+        self['sender']      = quoter(:quote_address_if_necessary)
+        self['errors-to']   = quoter(:quote_address_if_necessary)
+        self['in-reply-to'] = quoter(:quote_any_address_if_necessary)
+        self['x-mailer']    = quoter(:quote_if_necessary, false)
+        
+        self['list-id']          = quoter(:quote_address_if_necessary)
+        self['list-help']        = quoter(:quote_address_if_necessary)
+        self['list-subscribe']   = quoter(:quote_address_if_necessary)
+        self['list-unsubscribe'] = quoter(:quote_address_if_necessary)
+        self['list-post']        = quoter(:quote_address_if_necessary)
+        self['list-owner']       = quoter(:quote_address_if_necessary)
+        self['list-archive']     = quoter(:quote_address_if_necessary)
+      end
+      
+      def [](key)
+        @hash[key.downcase] ||= lambda { |charset, value| value }
+      end
+      
+      def []=(key, value)
+        @hash[key.downcase] = value
+      end
+      
+      def quoter(method, bracket_urls = true)
+        QuotingSanitizer.new(method, bracket_urls)
+      end
+    end
+    
+  end
+end

data/lib/mlist/util/quoting.rb

@@ -0,0 +1,70 @@
+module MList
+  module Util
+    
+    # Copyright (c) 2004-2008 David Heinemeier Hansson
+    #
+    # Taken from ActionMailer. Modified to make charset first argument in all
+    # signatures, allowing for a consistent pattern of invocation.
+    #
+    module Quoting #:nodoc:
+      # Convert the given text into quoted printable format, with an instruction
+      # that the text be eventually interpreted in the given charset.
+      def quoted_printable(charset, text)
+        text = text.gsub( /[^a-z ]/i ) { quoted_printable_encode($&) }.
+                    gsub( / /, "_" )
+        "=?#{charset}?Q?#{text}?="
+      end
+
+      # Convert the given character to quoted printable format, taking into
+      # account multi-byte characters (if executing with $KCODE="u", for instance)
+      def quoted_printable_encode(character)
+        result = ""
+        character.each_byte { |b| result << "=%02x" % b }
+        result
+      end
+
+      # A quick-and-dirty regexp for determining whether a string contains any
+      # characters that need escaping.
+      if !defined?(CHARS_NEEDING_QUOTING)
+        CHARS_NEEDING_QUOTING = /[\000-\011\013\014\016-\037\177-\377]/
+      end
+
+      # Quote the given text if it contains any "illegal" characters
+      def quote_if_necessary(charset, text)
+        text = text.dup.force_encoding(Encoding::ASCII_8BIT) if text.respond_to?(:force_encoding)
+
+        (text =~ CHARS_NEEDING_QUOTING) ?
+          quoted_printable(charset, text) :
+          text
+      end
+
+      # Quote any of the given strings if they contain any "illegal" characters
+      def quote_any_if_necessary(charset, *args)
+        args.map { |v| quote_if_necessary(charset, v) }
+      end
+
+      # Quote the given address if it needs to be. The address may be a
+      # regular email address, or it can be a phrase followed by an address in
+      # brackets. The phrase is the only part that will be quoted, and only if
+      # it needs to be. This allows extended characters to be used in the
+      # "to", "from", "cc", "bcc" and "reply-to" headers.
+      def quote_address_if_necessary(charset, address)
+        if Array === address
+          address.map { |a| quote_address_if_necessary(charset, a) }
+        elsif address =~ /^(\S.*)\s+(<.*>)$/
+          address = $2
+          phrase = quote_if_necessary(charset, $1.gsub(/^['"](.*)['"]$/, '\1'))
+          "\"#{phrase.gsub(/\\/, '\&\&').gsub('"', '\\"')}\" #{address}"
+        else
+          address
+        end
+      end
+
+      # Quote any of the given addresses, if they need to be.
+      def quote_any_address_if_necessary(charset, *args)
+        args.map { |v| quote_address_if_necessary(charset, v) }
+      end
+    end
+
+  end
+end

data/lib/mlist/util/tmail_builder.rb

@@ -0,0 +1,42 @@
+module MList
+  module Util
+    
+    class TMailBuilder
+      include EmailHelpers
+      include TMailReaders
+      include TMailWriters
+      
+      attr_reader :tmail
+      
+      def initialize(tmail)
+        @tmail = tmail
+      end
+      
+      def add_html_part(body)
+        part = TMail::Mail.new
+        part.body = normalize_new_lines(body)
+        part.set_content_type('text/html')
+        self.parts << part
+      end
+      
+      def add_text_part(body)
+        part = TMail::Mail.new
+        part.body = normalize_new_lines(body)
+        part.set_content_type('text/plain')
+        self.parts << part
+      end
+      
+      # Provide delegation to *most* of the underlying TMail::Mail methods,
+      # excluding those overridden by this Module.
+      #
+      def method_missing(symbol, *args, &block) # :nodoc:
+        if tmail.respond_to?(symbol)
+          tmail.__send__(symbol, *args, &block)
+        else
+          super
+        end
+      end
+    end
+    
+  end
+end