aiwilliams-mlist 0.0.0 → 0.1.0

data/README

@@ -17,6 +17,29 @@ backscatter - only the Mailman developers know what else. I have enough
 experience to know that rewrites are NEVER as easy as they seem. I begin
 this with fear and trepidation. Alas, I go boldly forward.
 
+==== Extracting 'from' IP address from emails is not implemented
+
+http://compnetworking.about.com/od/workingwithipaddresses/qt/ipaddressemail.htm
+  
+==== Observing MList ActiveRecord subsclasses (ie, MList::Message, MList::Thread)
+
+ActiveRecord observers are reloaded at each request in development mode. They
+will be registered with the MList models each time. Since the MList models are
+required once at initialization, there will always only be one instance of the
+model class, and therefore, many instances of the observer class (all but the
+most recent invalid, since they were undefined) registered with it.
+
+There are a number of ways to solve this, the best being the one that makes things
+'just work' such that I can delete this part of the document. For now, do the
+following in environment.rb:
+
+* remove the observer from the Rails' config.active_record.observers list
+* after the Rails::Initializer.run block, "require 'myobserver'"
+* after that require line, "Myobserver.instance"
+
+This will load the observer once, thereby only registering it once with the MList
+class you are observing.
+
 == SYNOPSIS:
 
 Let's say you want your web application to have a mailing list feature.

data/Rakefile

@@ -17,7 +17,7 @@ begin
     s.name = 'mlist'
     s.summary = 'A Ruby mailing list library designed to be integrated into other applications.'
     s.email = 'adam@thewilliams.ws'
-    s.files = FileList["[A-Z]*", "{lib,rails}/**/*"].exclude("tmp,**/tmp")
+    s.files = FileList["[A-Z]*", "{lib}/**/*"].exclude("tmp,**/tmp")
     s.homepage = "http://github.com/aiwilliams/mlist"
     s.description = s.summary
     s.authors = ['Adam Williams']

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:minor: 0
+:minor: 1
 :patch: 0
 :major: 0

data/lib/mlist.rb

@@ -1,13 +1,32 @@
 require 'tmail'
+require 'activesupport'
 require 'activerecord'
 
 require 'mlist/util'
+require 'mlist/email'
 require 'mlist/message'
 require 'mlist/list'
 require 'mlist/mail_list'
+require 'mlist/email_post'
 require 'mlist/email_server'
+require 'mlist/email_subscriber'
 require 'mlist/server'
 require 'mlist/thread'
 
 module MList
-end
+  class DoubleDeliveryError < StandardError
+    def initialize(message)
+      super("A message should never be delivered more than once. An attempt was made to deliver this message:\n#{message.inspect}")
+    end
+  end
+end
+
+Time::DATE_FORMATS[:mlist_reply_timestamp] = Date::DATE_FORMATS[:mlist_reply_timestamp] = lambda do |time|
+  time.strftime('%a, %b %d, %Y at %I:%M %p').sub(/0(\d,)/, '\1').sub(/0(\d:)/, '\1')
+end
+
+# In order to keep the inline images in email intact. Certainly a scary bit of
+# hacking, but this is the solution out there on the internet.
+TMail::HeaderField::FNAME_TO_CLASS.delete 'content-id'
+
+TMail::Mail::ALLOW_MULTIPLE['x-beenthere'] = true

data/lib/mlist/email.rb

@@ -0,0 +1,75 @@
+module MList
+  
+  class Email < ActiveRecord::Base
+    set_table_name 'mlist_emails'
+    
+    include MList::Util::EmailHelpers
+    include MList::Util::TMailReaders
+    
+    def been_here?(list)
+      tmail.header_string('x-beenthere') == list.address
+    end
+    
+    def from
+      tmail.header_string('from')
+    end
+    
+    # Answers the usable destination addresses of the email.
+    #
+    def list_addresses
+      bounce? ? tmail.header_string('to').match(/\Amlist-(.*)\Z/)[1] : tmail.to.collect(&:downcase)
+    end
+    
+    # Answers true if this email is a bounce.
+    #
+    # TODO Delegate to the email_server's bounce detector.
+    #
+    def bounce?
+      tmail.header_string('to') =~ /mlist-/
+    end
+    
+    # Extracts the parent message identifier from the source, using
+    # in-reply-to first, then references. Brackets around the identifier are
+    # removed.
+    #
+    # If you provide an MList::MailList, it will be searched for a message
+    # having the same subject as a last resort.
+    #
+    def parent_identifier(mail_list = nil)
+      identifier = tmail.header_string('in-reply-to') || begin
+        references = tmail['references']
+        references.ids.first if references
+      end
+      
+      if identifier
+        remove_brackets(identifier)
+      elsif mail_list && subject =~ /(^|[^\w])re:/i
+        parent_message = mail_list.messages.find(:first,
+          :select => 'identifier',
+          :conditions => ['mlist_messages.subject = ?', remove_regard(subject)],
+          :order => 'created_at asc')
+        parent_message.identifier if parent_message
+      end
+    end
+    
+    def tmail=(tmail)
+      @tmail = tmail
+      write_attribute(:source, tmail.to_s)
+    end
+    
+    def tmail
+      @tmail ||= TMail::Mail.parse(source)
+    end
+    
+    # Provide reader delegation to *most* of the underlying TMail::Mail
+    # methods, excluding those overridden by this Class and the [] method (an
+    # ActiveRecord method).
+    def method_missing(symbol, *args, &block) # :nodoc:
+      if symbol.to_s !~ /=\Z/ && symbol != :[] && symbol != :source &&  tmail.respond_to?(symbol)
+        tmail.__send__(symbol, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/mlist/email_post.rb

@@ -0,0 +1,105 @@
+module MList
+  
+  # The simplest post that can be made to an MList::MailList. Every instance
+  # must have at least the text content and a subject. Html may also be added.
+  #
+  # It is important to understand that this class is intended to be used by
+  # applications that have some kind of UI for creating a post. It assumes
+  # Rails form builder support is desired, and that there is no need for
+  # manipulating the final TMail::Mail object that will be delivered to the
+  # list outside of the methods provided herein.
+  #
+  class EmailPost
+    ATTRIBUTE_NAMES = %w(html text mailer subject subscriber)
+    ATTRIBUTE_NAMES.each do |attribute_name|
+      define_method(attribute_name) do
+        @attributes[attribute_name]
+      end
+      define_method("#{attribute_name}=") do |value|
+        @attributes[attribute_name] = value
+      end
+    end
+    
+    attr_reader :parent_identifier, :reply_to_message
+    
+    def initialize(attributes)
+      @attributes = {}
+      self.attributes = {
+        :mailer => 'MList Client Application'
+      }.merge(attributes)
+    end
+    
+    def attributes
+      @attributes.dup
+    end
+    
+    def attributes=(new_attributes)
+      return if new_attributes.nil?
+      attributes = new_attributes.dup
+      attributes.stringify_keys!
+      attributes.each do |attribute_name, value|
+        send("#{attribute_name}=", value)
+      end
+    end
+    
+    def reply_to_message=(message)
+      if message
+        @parent_identifier = message.identifier
+      else
+        @parent_identifier = nil
+      end
+      @reply_to_message = message
+    end
+    
+    def subject
+      @attributes['subject'] || (reply_to_message ? "Re: #{reply_to_message.subject}" : nil)
+    end
+    
+    def to_tmail
+      raise ActiveRecord::RecordInvalid.new(self) unless valid?
+      
+      builder = MList::Util::TMailBuilder.new(TMail::Mail.new)
+      
+      builder.mime_version = "1.0"
+      builder.mailer = mailer
+      
+      builder.in_reply_to = parent_identifier if parent_identifier
+      
+      builder.from = subscriber.email_address
+      builder.subject = subject
+      
+      if html
+        builder.add_text_part(text)
+        builder.add_html_part(html)
+        builder.set_content_type('multipart/alternative')
+      else
+        builder.body = text
+        builder.set_content_type('text/plain')
+      end
+      
+      builder.tmail
+    end
+    
+    # vvv  ActiveRecord validations interface implementation  vvv
+    
+    def self.human_attribute_name(attribute_key_name, options = {})
+      attribute_key_name.humanize
+    end
+    
+    def errors
+      @errors ||= ActiveRecord::Errors.new(self)
+    end
+    
+    def validate
+      errors.clear
+      errors.add(:subject, 'required') if subject.blank?
+      errors.add(:text, 'required') if text.blank?
+      errors.add(:text, 'needs to be a bit longer') if !text.blank? && text.strip.size < 25
+      errors.empty?
+    end
+    
+    def valid?
+      validate
+    end
+  end
+end

data/lib/mlist/email_server.rb

@@ -1,3 +1,2 @@
-require 'mlist/email_server/email'
 require 'mlist/email_server/base'
-require 'mlist/email_server/fake'
+require 'mlist/email_server/default'

data/lib/mlist/email_server/base.rb

@@ -1,17 +1,20 @@
 module MList
   module EmailServer
     class Base
-      def initialize
+      attr_reader :settings
+      
+      def initialize(settings)
+        @settings = settings
         @receivers = []
       end
       
-      def deliver(email)
+      def deliver(tmail, destinations)
         raise 'Implement actual delivery mechanism in subclasses'
       end
       
       def receive(tmail)
-        email = EmailServer::Email.new(tmail)
-        @receivers.each { |r| r.receive(email) }
+        email = MList::Email.new(:tmail => tmail)
+        @receivers.each { |r| r.receive_email(email) }
       end
       
       def receiver(rx)

data/lib/mlist/email_server/default.rb

@@ -0,0 +1,31 @@
+module MList
+  module EmailServer
+    
+    class Default < Base
+      def initialize(incoming_server, outgoing_server)
+        super({})
+        @incoming_server, @outgoing_server = incoming_server, outgoing_server
+        @incoming_server.receiver(self)
+      end
+      
+      # Delegates delivery of email to outgoing server.
+      #
+      def deliver(tmail, destinations)
+        @outgoing_server.deliver(tmail, destinations)
+      end
+      
+      # Delegates fetching emails to incoming server.
+      def execute
+        @incoming_server.execute
+      end
+      
+      # Delegates processing of email from incoming server to receivers on
+      # self.
+      #
+      def receive_email(email)
+        @receivers.each { |r| r.receive_email(email) }
+      end
+    end
+    
+  end
+end

data/lib/mlist/email_server/fake.rb

@@ -4,11 +4,11 @@ module MList
       attr_reader :deliveries
       
       def initialize
-        super
+        super({})
         @deliveries = []
       end
       
-      def deliver(tmail)
+      def deliver(tmail, destinations)
         @deliveries << tmail
       end
     end

data/lib/mlist/email_server/pop.rb

@@ -0,0 +1,28 @@
+require 'pop_ssl'
+
+module MList
+  module EmailServer
+    
+    class Pop < Base
+      def deliver(tmail, destinations)
+        raise "Mail cannot be delivered through a POP server. Please use the '#{MList::EmailServer::Default.name}' type."
+      end
+      
+      def execute
+        connect_to_email_account do |pop|
+          pop.mails.each { |message| receive(TMail::Mail.parse(message.pop)); message.delete }
+        end
+      end
+      
+      private
+        def connect_to_email_account
+          pop3 = Net::POP3.new(settings[:server], settings[:port], false)
+          pop3.enable_ssl if settings[:ssl]
+          pop3.start(settings[:username], settings[:password]) do |pop|
+            yield pop
+          end
+        end
+    end
+    
+  end
+end

data/lib/mlist/email_server/smtp.rb

@@ -0,0 +1,21 @@
+require 'net/smtp'
+
+module MList
+  module EmailServer
+    
+    class Smtp < Base
+      def deliver(tmail, destinations)
+        sender = tmail['return-path'] || tmail.from
+        Net::SMTP.start(settings[:address], settings[:port], settings[:domain],
+            settings[:user_name], settings[:password], settings[:authentication]) do |smtp|
+          smtp.sendmail(tmail.encoded, sender, destinations)
+        end
+      end
+      
+      def execute
+        raise "Mail cannot be received through an SMTP server. Please use the '#{MList::EmailServer::Default.name}' type."
+      end
+    end
+    
+  end
+end

data/lib/mlist/email_subscriber.rb

@@ -0,0 +1,6 @@
+module MList
+  
+  # Represents a simple subscriber instance, wrapping an email address.
+  #
+  EmailSubscriber = Struct.new('EmailSubscriber', :email_address)
+end

data/lib/mlist/list.rb

@@ -6,8 +6,11 @@ module MList
   # into may re-define behavior appropriately.
   #
   module List
-    def bounce(email)
-      
+    
+    # Answers whether this list is active or not.
+    #
+    def active?
+      true
     end
     
     def host
@@ -27,7 +30,7 @@ module MList
     end
     
     def list_id
-      "#{label} <#{address}>"
+      raise 'answer a unique, never changing value'
     end
     
     def name
@@ -38,12 +41,40 @@ module MList
       address
     end
     
-    def recipients(message)
-      subscriptions.collect(&:address) - [message.from_address]
+    def recipients(subscriber)
+      subscribers.collect(&:email_address) - [subscriber.email_address]
     end
     
-    def subscriber?(address)
-      !subscriptions.detect {|s| s.address == address}.nil?
+    def subscriber(email_address)
+      subscribers.detect {|s| s.email_address == email_address}
     end
+    
+    def subscriber?(email_address)
+      !subscriber(email_address).nil?
+    end
+    
+    # Methods that will be invoked on your implementation of Mlist::List when
+    # certain events occur during the processing of email sent to a list.
+    #
+    module Callbacks
+      def bounce(email)
+      end
+      
+      # Called when an email is a post to the list while the list is inactive
+      # (answers false to _active?_). This will not be called if the email is
+      # from a non-subscribed sender. Instead, _non_subscriber_post_ will be
+      # called.
+      #
+      def inactive_post(email)
+      end
+      
+      # Called when an email is a post to the list from a non-subscribed
+      # sender. This will be called even if the list is inactive.
+      #
+      def non_subscriber_post(email)
+      end
+    end
+    include Callbacks
+    
   end
 end