astrotrain 0.5.4 → 0.6.0

data/.gitignore

@@ -1,26 +0,0 @@
-.DS_Store
-.rake_tasks
-log/*
-tmp/*
-TAGS
-*~
-.#*
-pkg
-schema/schema.rb
-schema/*_structure.sql
-schema/*.sqlite3
-schema/*.sqlite
-schema/*.db
-*.sqlite
-*.sqlite3
-*.db
-src/*
-.hgignore
-.hg/*
-.svn/*
-doc
-config/database.yml
-merb/custom.rb
-test/fixtures/queue
-messages
-test/messages

data/README

@@ -1,47 +0,0 @@
-astrotrain
-==========
-
-NOTE: Astrotrain is a full gem now.  If you're looking for the old Astrotrain on merb:
-http://github.com/entp/astrotrain/tree/merb
-git://github.com/entp/astrotrain.git (merb branch)
-
-Scans incoming emails for mapped recipients and sends an HTTP POST somewhere.
-
-  # setup a config file.
-  # Point the queue_path at a directory that your mail server dumps each raw incoming mail.
-  require 'astrotrain'
-
-  Astrotrain.load path do
-    DataMapper.setup(:default, {
-      :adapter  => "mysql",
-      :database => "astrotrain",
-      :username => "root",
-      :host     => "localhost"
-    })
-  end
-  Astrotrain::Message.queue_path = "/path/to/maildir"
-  Astrotrain::Mapping::Transport.processing = true
-
-  # start up IRB
-  irb -I /var/astrotrain/lib -r config.rb
-
-  # manage mappings
-  LIB=/var/astrotrain/lib CONFIG=config.rb rake at:mappings
-  LIB=/var/astrotrain/lib CONFIG=config.rb rake at:map EMAIL=support@foo.com DEST=http://foo.com/email
-  LIB=/var/astrotrain/lib CONFIG=config.rb rake at:unmap MAP=123
-
-  # start the server that runs over the queue directory
-  LIB=/var/astrotrain/lib CONFIG=config.rb rake at:process
-
-  # start the sinatra API
-  ruby -I /var/astrotrain/lib /var/astrotrain/lib/astrotrain/api.rb config.rb
-
-A single Astrotrain process currently handles email for two production applications, processing thousands daily.
-It's far from perfect, but definitely usable.
-
-TODO
-====
-
-Docs
-bounced emails (i've been rolling with http://github.com/whatcould/bounce-email for now)
-Mail gem, TMail is old school

data/VERSION

@@ -1 +0,0 @@
-0.5.4

data/config/sample.rb

@@ -1,12 +0,0 @@
-path = File.join(File.dirname(__FILE__), '..')
-$LOAD_PATH.unshift File.join(path, 'lib')
-require 'astrotrain'
-
-Astrotrain.load path do
-  DataMapper.setup(:default, {
-    :adapter  => "mysql",
-    :database => "astrotrain",
-    :username => "root",
-    :host     => "localhost"
-  })
-end

data/lib/astrotrain/api.rb

@@ -1,52 +0,0 @@
-require 'sinatra'
-
-before do
-  response['Content-Type'] = 'text/plain'
-end
-
-get '/queue_size' do
-  if File.exist?(Astrotrain::Message.queue_path)
-    (Dir.entries(Astrotrain::Message.queue_path).size - 2).to_s
-  else
-    '0'
-  end
-end
-
-get '/queue/*' do
-  path = params[:splat].first
-  path.gsub! /^\/+/, ''
-  file = File.join(Astrotrain::Message.queue_path, path)
-  if File.exist?(file)
-    IO.read(file)
-  else
-    halt 404, "#{path.inspect} was not found."
-  end
-end
-
-get '/queue' do
-  data = []
-  Dir.entries(Astrotrain::Message.queue_path).each do |e|
-    data << e unless e =~ /^\.{1,2}$/
-  end
-  data * "\n"
-end
-
-unless $testing
-  configure do
-    # the idea being, you pass the name of the config file
-    #
-    #   # loads File.join(Dir.pwd, 'config.rb')
-    #   CONFIG=config ruby lib/astrotrain/api.rb
-    #
-    #   # loads File.join(Dir.pwd, 'config.rb')
-    #   ruby lib/astrotrain/api.rb config
-    #
-    # That file contains the Greymalkin.load block that initializes Sequel
-    #
-    path = ENV['CONFIG'] || ARGV.shift
-    if path[0..0] != '/'
-      path = File.join(Dir.pwd, path)
-    end
-    require File.expand_path(path)
-  end
-end

data/lib/astrotrain/logged_mail.rb

@@ -1,48 +0,0 @@
-module Astrotrain
-  # Logs details of each incoming message.  
-  class LoggedMail
-    include DataMapper::Resource
-
-    class << self
-      attr_accessor :log_path, :log_processed
-    end
-
-    # Enabling this will save records for every processed email, not just the errored emails.
-    self.log_processed = false
-    self.log_path      = File.join(Astrotrain.root, 'messages')
-
-    property :id,            Serial
-    property :mapping_id,    Integer, :index => true
-    property :message_id,    String,  :index => true, :size => 255, :length => 1..255
-    property :sender,        String,  :index => true, :size => 255, :length => 1..255
-    property :recipient,     String,  :index => true, :size => 255, :length => 1..255
-    property :subject,       String,  :index => true, :size => 255, :length => 1..255
-    property :mail_file,     String,  :size => 255, :length => 1..255
-    property :created_at,    DateTime
-    property :delivered_at,  DateTime
-    property :error_message, Text
-
-    belongs_to :mapping
-
-    def self.from(message, file = nil)
-      logged = new
-      begin
-        logged.message_id = message.message_id
-        logged.sender     = Message.parse_email_addresses(message.sender).first
-        logged.subject    = message.subject
-        logged.mail_file  = file if file
-      end
-      if !block_given? || yield(logged)
-        begin
-          logged.save
-          if logged.delivered_at && File.exist?(logged.mail_file.to_s)
-            FileUtils.rm_rf logged.mail_file
-          end
-        rescue
-          puts $!.inspect
-        end
-      end
-      logged
-    end
-  end
-end

data/lib/astrotrain/mapping.rb

@@ -1,162 +0,0 @@
-module Astrotrain
-  class Mapping
-    include DataMapper::Resource
-
-    class << self
-      attr_accessor :default_domain
-      attr_accessor :transports
-    end
-
-    self.transports     = {"HTTP Post" => 'http_post', "Jabber" => 'jabber'}
-    self.default_domain = 'astrotrain.com'
-
-    property :id,           Serial
-    property :email_user,   String, :size => 255, :length => 1..255, :index => :email, :format => /^[\w\.\_\%\+\-]*\*?$/
-    property :email_domain, String, :size => 255, :lenght => 1..255, :index => :email, :format => /^[\w\-\_\.]+$/, :default => lambda { default_domain }
-    property :destination,  String, :size => 255, :length => 1..255
-    property :transport,    String, :size => 255, :set => transports.values, :default => 'http_post'
-    property :separator,    String, :size => 255
-
-    validates_is_unique :email_user, :scope => :email_domain
-    validates_format :destination, :as => /^(https?:)\/\/[^\/]+\/?/i, :if => :destination_uses_url?
-    validates_format :destination, :as => :email_address, :if => :destination_uses_email?
-
-    has n, :logged_mails, :order => [:created_at.desc]
-
-    # returns a mapping for the given array of email addresses
-    def self.match(email_addresses)
-      email_addresses.each do |email_address|
-        email_address.strip!
-        email_address.downcase!
-        name, domain = email_address.split("@")
-        if mapping = match_by_address(name, domain) || match_by_wildcard(name, domain)
-          return [mapping, email_address]
-        end
-      end
-      nil
-    end
-
-    # Processes a given message.  It finds a mapping, creates a LoggedMail record,
-    # and attempts to process the message.
-    def self.process(message, file = nil)
-      LoggedMail.from(message, file) do |logged|
-        save_logged = begin
-          mapping, recipient = match(message.recipients)
-          if mapping
-            logged.recipient = recipient
-            logged.mapping   = mapping
-            begin
-              mapping.process(message, recipient)
-            rescue Astrotrain::ProcessingCancelled
-              logged.error_message = "Cancelled."
-            end
-            logged.delivered_at = Time.now.utc
-          end
-          LoggedMail.log_processed # save successfully processed messages?
-        rescue
-          logged.error_message = "#{$!.message}\n#{$!.backtrace.join("\n")}"
-        end
-        Astrotrain.callback(:post_processing, message, mapping, logged)
-        save_logged
-      end
-    end
-
-    # Processes a given message and recipient against the mapping's transport.
-    def process(message, recipient)
-      Astrotrain.callback(:pre_processing, message, self)
-      Transport.process(message, self, recipient)
-    
-    end
-
-    # returns true if the email matches this mapping.  Wildcards in the name are allowed.
-    # A mapping with foo*@bar.com will match foo@bar.com and food@bar.com, but not foo@baz.com.
-    def match?(name, domain)
-      email_domain == domain && name =~ email_user_regex
-    end
-
-    def destination_uses_url?
-      transport == 'http_post'
-    end
-
-    def destination_uses_email?
-      transport == 'jabber'
-    end
-
-    def full_email
-      "#{email_user}@#{email_domain}"
-    end
-
-    # Looks for the mapping's separator in the message body and pulls only the content
-    # above it.  Assuming a separator of '===='...
-    #
-    #   This will be kept
-    #   
-    #   On Thu, Sep 3, 2009 at 12:34 AM... (this will be removed)
-    #   ====
-    #
-    #   > Everything here will be removed.
-    #
-    def find_reply_from(body)
-      return    if separator.blank?
-      return '' if body.blank?
-      lines = body.split("\n")
-      delim_line = found_empty = nil
-
-      (lines.size - 1).downto(0) do |i|
-        line = lines[i]
-        if !delim_line && line.include?(separator)
-          delim_line = i
-        elsif delim_line && !found_empty
-          delim_line = i
-          found_empty = line.strip.blank?
-        elsif delim_line && found_empty
-          if date_reply_line?(line) || line.strip.blank?
-            delim_line = i
-          else
-            break
-          end
-        end
-      end
-
-      if delim_line
-        body = if delim_line.zero?
-          []
-        elsif lines.size >= delim_line
-          lines[0..delim_line-1]
-        else
-          lines
-        end.join("\n")
-      elsif body.frozen?
-        body = body.dup
-      end
-      body.strip!
-      body
-    end
-
-  protected
-    def self.match_by_address(name, domain)
-      first(:email_user => name, :email_domain => domain)
-    end
-
-    def self.match_by_wildcard(name, domain)
-      wildcards = all(:email_domain => domain, :email_user.like => "%*")
-      wildcards.sort! { |x, y| y.email_user.size <=> x.email_user.size }
-      wildcards.detect { |w| w.match?(name, domain) }
-    end
-
-    DATE_LANGUATE_REGEXES = [/^on\b.*wrote\b?:$/i, /^am\b.*schrieb [\w\d\s]+:$/i, /^le\b.*a écrit\b?:$/i]
-    def date_reply_line?(line)
-      DATE_LANGUATE_REGEXES.any? { |re| line =~ re }
-    end
-
-    def email_user_regex
-      @email_user_regex ||= begin
-        if email_user['*']
-          /^#{email_user.sub /\*/, '(.*)'}$/
-        else
-          /^#{email_user}$/
-        end
-      end
-    end
-  end
-end

data/lib/astrotrain/mapping/http_post.rb

@@ -1,18 +0,0 @@
-module Astrotrain
-  class Mapping
-    class HttpPost < Transport
-      def process
-        return unless Transport.processing
-        RestClient.post @mapping.destination, fields.merge(:emails => fields[:emails].join(","))
-      end
-
-      def fields
-        super
-        @message.attachments.each_with_index do |att, index|
-          @fields[:"attachments_#{index}"] = att
-        end
-        @fields
-      end
-    end
-  end
-end

data/lib/astrotrain/mapping/jabber.rb

@@ -1,28 +0,0 @@
-begin
-  require 'xmpp4r-simple'
-  module Astrotrain
-    class Mapping
-      # This is experimental.  No attachments are supported.
-      class Jabber < Transport
-        class << self
-          attr_accessor :login, :password
-        end
-
-        def process
-          return unless Transport.processing
-          connection.deliver(@mapping.destination, content)
-        end
-
-        def connection
-          @connection ||= ::Jabber::Simple.new(self.class.login, self.class.password)
-        end
-
-        def content
-          @content ||= "From: %s\nTo: %s\nSubject: %s\nEmails: %s\n%s" % [fields[:from], fields[:to], fields[:subject], fields[:emails] * ", ", fields[:body]]
-        end
-      end
-    end
-  end
-rescue LoadError
-  puts "Install xmpp4r-simple for Jabber support."
-end

data/lib/astrotrain/mapping/transport.rb

@@ -1,55 +0,0 @@
-module Astrotrain
-  class Mapping
-    class Transport
-      class << self
-        attr_accessor :processing
-      end
-
-      # Enable this turn on processing.
-      self.processing = false
-
-      attr_reader :message, :mapping
-
-      # process a given message against the mapping.  The mapping transport is checked,
-      # and the appropirate transport class handles the request.
-      def self.process(message, mapping, recipient)
-        case mapping.transport
-          when 'http_post' then HttpPost.process(message, mapping, recipient)
-          when 'jabber'    then Jabber.process(message, mapping, recipient)
-        end
-      end
-
-      def initialize(message, mapping, recipient)
-        message.body = mapping.find_reply_from(message.body)
-        @message     = message
-        @mapping     = mapping
-        @recipient   = recipient
-      end
-
-      def process
-        raise UnimplementedError
-      end
-
-      def fields
-        @fields ||= begin
-          all_emails = @message.recipients - [@recipient]
-          f = {:subject => @message.subject, :to => @recipient, :from => @message.sender, :body => @message.body, :emails => all_emails, :html => @message.html}
-          @message.headers.each do |key, value|
-            f["headers[#{key}]"] = value
-          end
-          f
-        end
-      end
-
-      # defines custom #process class methods that instantiate the class and calls a #process instance method
-      def self.inherited(child)
-        super
-        class << child
-          def process(message, mapping, recipient)
-            new(message, mapping, recipient).process
-          end
-        end
-      end
-    end
-  end
-end