mailman 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2010 Jonathan Rudenberg
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,26 @@
+# Mailman
+
+Mailman is an incoming mail processing microframework (with POP3 and Maildir
+support), that works with Rails "out of the box".
+
+    require 'mailman'
+    Mailman::Application.new do
+      to 'ticket-%id%@example.org' do

+        Ticket.find(params[:id]).add_reply(message)
+      end
+    end
+
+See the {file:USER_GUIDE.md} for more information.
+
+## Installation
+
+    gem install mailman
+
+## Thanks
+
+This project is sponsored by the [Ruby Summer of Code](http://rubysoc.org),
+and my mentor is [Steven Soroka](http://github.com/ssoroka).
+
+## Copyright
+
+Copyright (c) 2010 Jonathan Rudenberg. See LICENSE for details.

data/USER_GUIDE.md

@@ -0,0 +1,217 @@
+# Mailman User Guide
+
+Mailman is a microframework for processing incoming email.
+
+Here is an example Mailman app that takes incoming messages to a support
+email account, and adds them to a database.
+
+    # mailman_app.rb
+    require 'mailman'
+
+    Mailman.config.maildir = '~/Maildir'
+
+    Mailman::Application.new do
+      to 'support@example.org' do
+        Ticket.new_from_message(message)
+      end
+    end
+
+The Mailman app could then be started by running `ruby mailman_app.rb`.
+
+## Installation
+
+Installation is as simple as `gem install mailman`.
+
+
+## Routes & Conditions
+
+A **Condition** specifies the part of the message to match against. `to`,
+`from`, and `subject` are some valid conditions. A **Matcher** is used by a
+condition to determine whether it matches the message. Matchers can be
+strings or regular expressions. One or more Condition/Matcher pairs are
+combined with a block of code to form a **Route**.
+
+### Matchers
+
+There are string and regular expression matchers. Both can perform captures.
+
+#### String
+
+String matchers are very simple. They search through a whole field for a
+specific substring. For instance: `'ID'` would match `Ticket ID`, `User ID`,
+etc.
+
+They can also perform named captures. `'%username%@example.org'` will match any
+email address that ends with `@example.org`, and store the user part of the
+address in a capture called `username`. Captures can be accessed by using
+the `params` helper inside of blocks, or with block arguments (see below for
+details).
+
+The capture names may only contain letters and underscores. Behind the scenes
+they are compiled to regular expressions, and each capture is the equivalent to
+`.*`. There is currently no way to escape `%` characters. If a literal `%` is
+required, and Mailman thinks it is a named capture, use a regular expression
+matcher instead.
+
+#### Regular expression
+
+Regular expressions may be used as matchers. All captures will be available from
+the params helper (`params[:captures]`) as an Array, and as block arguments.
+
+
+### Routes
+
+Routes are defined within a Mailman application block:
+
+    Mailman::Application.new do
+      # routes here
+    end
+
+Messages are passed through routes in the order they are defined in the
+application from top to bottom. The first matching route's block will be
+called.
+
+#### Condition Chaining
+
+Conditions can be chained so that the route will only be executed if all
+conditions pass:
+
+    to('support@example.org').subject(/urgent/) do
+      # process urgent message here
+    end
+
+#### Special routes
+
+The `default` route is a catch-all that is run if no other routes match:
+
+    default do
+      # process non-matching messages
+    end
+
+#### Block Arguments
+
+All captures from matchers are available as block arguments:
+
+    from('%user%@example.org').subject(/Ticket (\d+)/) do |username, ticket_id|
+      puts "Got message from #{username} about Ticket #{ticket_id}"
+    end
+
+#### Route Helpers
+
+There are two helpers available inside of route blocks:
+
+The `params` hash holds all captures from matchers:
+
+    from('%user%@example.org').subject(/RE: (.*)/) do
+      params[:user] #=> 'chunkybacon'
+      # it is an indifferent hash, so you can use strings and symbols
+      # interchangeably as keys
+      params['captures'][0] #=> 'A very important message about pigs'
+    end
+
+The `message` helper is a `Mail::Message` object that contains the entire
+message. See the [mail](http://github.com/mikel/mail/) docs for information on
+the properties available.
+
+
+### Conditions
+
+Currently there are four conditions available: `to`, `from`, `subject`, `body`
+
+More can be added easily (see `lib/mailman/route/conditions.rb`).
+
+
+## Receivers
+
+There are currently three types of receivers in Mailman: Standard Input,
+Maildir, and POP3. If IMAP or any complex setups are required, use a mail
+retriever like [getmail](http://pyropus.ca/software/getmail/) with the
+Maildir receiver.
+
+
+### Standard Input
+
+If a message is piped to a Mailman app, this receiver will override any
+configured receivers. The app will process the message, and then quit. This
+receiver is useful for testing and debugging.
+
+**Example**: `cat plain_message.eml | ruby mailman_app.rb`
+
+
+### POP3
+
+The POP3 receiver is enabled when the `Mailman.config.pop3` hash is set. It
+will poll every minute by default (this can be changed with
+`Mailman.config.poll_interval`). After new messages are processed, they will
+be deleted from the server. *No copy of messages will be saved anywhere
+after processing*. If you want to keep a copy of messages, it is recommended
+that you use a mail retriever with the Maildir receiver.
+
+
+### Maildir
+
+The Maildir receiver is enabled when `Mailman.config.maildir` is set to a
+directory. If the `cur`, `new`, and `tmp` folders do not already exist in
+the folder, they will be created. All messages in `new` folder will be
+processed when the application launches, then moved to the `cur` folder, and
+marked as seen. After processing these messages, Mailman will use the
+[fssm](http://github.com/ttilley/fssm) gem to monitor the `new` folder, and
+process messages as they are created.
+
+## Configuration
+
+Configuration is stored in the `Mailman.config` object. All paths are
+relative to the process's working directory or absolute if starting with a
+`/`.
+
+
+### Logging
+
+`Mailman.config.logger` can be set to a `Logger` instance. You should
+change this if you want to log to a file in production.
+
+**Example**: `Mailman.config.logger = Logger.new('logs/mailman.log')`
+
+**Default**: `Logger.new(STDOUT)`
+
+
+### POP3 Receiver
+
+`Mailman.config.pop3` stores an optional POP3 configuration hash. If it is
+set, Mailman will use POP3 polling as the receiver.
+
+**Example**:
+
+    Mailman.config.pop3 = {
+      :username => 'chunky',
+      :password => 'bacon',
+      :server   => 'example.org',
+      :port     => 110 # defaults to 110
+    }
+
+
+### Polling
+
+`Mailman.config.poll_interval` is the duration in seconds to wait between
+checking for new messages on the server. It is currently only used by the
+POP3 reciever. If it is set to `0`, Mailman will do a one-time retrieval and
+then exit.
+
+**Default**: `60`
+
+
+### Maildir
+
+`Mailman.config.maildir` is the location of a Maildir folder to watch. If it
+is set, Mailman will use Maildir watching as the receiver.
+
+**Example**: `Mailman.config.maildir = '~/Maildir'`
+
+
+### Rails
+
+`Mailman.config.rails_root` is the location of the root of a Rails app to
+load the environment from. If this option is set to `nil`, Rails environment
+loading will be disabled.
+
+**Default**: `'.'`

data/examples/simple_route.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mailman'
+
+Mailman::Application.new do
+
+  from('%user%@%domain%') do
+    puts "Got #{message.subject} from #{params[:user]}"
+  end
+
+end.run
+
+# cat ../spec/fixtures/example01.eml | ./simple_route.rb

data/lib/mailman.rb

@@ -0,0 +1,36 @@
+require 'logger'
+require 'fcntl'
+require 'mail'
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/hash/indifferent_access'
+
+require 'maildir'
+require 'fssm'
+
+require 'mailman/version'
+
+module Mailman
+
+  [:Application, :Router, :Configuration, :Receiver, :MessageProcessor].each do |constant|
+    autoload constant, "mailman/#{constant.to_s.underscore}"
+  end
+
+  require 'mailman/route'
+
+  # @return [Configuration] the application configuration.
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  # Resets the app config (useful for testing).
+  def self.reset_config!
+    @config = Configuration.new
+  end
+
+  # Shortcut for the logger object
+  def self.logger
+    Mailman.config.logger
+  end
+
+end

data/lib/mailman/application.rb

@@ -0,0 +1,78 @@
+module Mailman
+  # The main application class. Pass a block to {#new} to create a new app.
+  class Application
+
+    # @return [Router] the app's router
+    attr_reader :router
+
+    # @return [MessageProcessor] the app's message processor
+    attr_reader :processor
+
+    # Creates a new router, and sets up any routes passed in the block.
+    # @param [Proc] block a block with routes
+    def initialize(&block)
+      @router = Mailman::Router.new
+      @processor = MessageProcessor.new(:router => @router)
+      instance_eval(&block)
+    end
+
+    # Sets the block to run if no routes match a message.
+    def default(&block)
+      @router.default_block = block
+    end
+
+    # Runs the application.
+    def run
+      Mailman.logger.info "Mailman v#{Mailman::VERSION} started"
+
+      rails_env = File.join(Mailman.config.rails_root, 'config', 'environment.rb')
+      if Mailman.config.rails_root && File.exist?(rails_env)
+        Mailman.logger.info "Rails root found in #{Mailman.config.rails_root}, requiring environment..."
+        require rails_env
+      end
+
+      if $stdin.fcntl(Fcntl::F_GETFL, 0) == 0 # we have stdin
+        Mailman.logger.debug "Processing message from STDIN."
+        @processor.process($stdin.read)
+      elsif Mailman.config.pop3
+        options = {:processor => @processor}.merge(Mailman.config.pop3)
+        Mailman.logger.info "POP3 receiver enabled (#{options[:username]}@#{options[:server]})."
+        connection = Receiver::POP3.new(options)
+        begin
+          connection.connect
+          if Mailman.config.poll_interval > 0 # we should poll
+            Mailman.logger.info "Polling enabled. Checking every #{Mailman.config.poll_interval} seconds."
+            loop do
+              Mailman.logger.debug "Polling POP3 server for messages..."
+              connection.get_messages
+              sleep Mailman.config.poll_interval
+            end
+          else # one-time retrieval
+            Mailman.logger.info "Polling disabled. Checking for messages..."
+            connection.get_messages
+          end
+        ensure
+          connection.disconnect
+        end
+      elsif Mailman.config.maildir
+        Mailman.logger.info "Maildir receiver enabled (#{Mailman.config.maildir})."
+        maildir = Maildir.new(Mailman.config.maildir)
+
+        # Process messages queued in the new directory
+        Mailman.logger.debug "Processing new message queue..."
+        maildir.list(:new).each do |message|
+          @processor.process_maildir_message(message)
+        end
+
+        Mailman.logger.debug "Monitoring the Maildir for new messages..."
+        FSSM.monitor File.join(Mailman.config.maildir, 'new') do |monitor|
+          monitor.create { |directory, filename| # a new message was delivered to new
+            message = Maildir::Message.new(maildir, "new/#{filename}")
+            @processor.process_maildir_message(message)
+          }
+        end
+      end
+    end
+
+  end
+end

data/lib/mailman/configuration.rb

@@ -0,0 +1,34 @@
+module Mailman
+  class Configuration
+
+    # @return [Logger] the application's logger
+    attr_accessor :logger
+
+    # @return [Hash] the configuration hash for POP3
+    attr_accessor :pop3
+
+    # @return [Fixnum] the poll interval for POP3 or IMAP. Setting this to 0
+    #   disables polling
+    attr_accessor :poll_interval
+
+    # @return [String] the path to the maildir
+    attr_accessor :maildir
+
+    # @return [String] the path to the rails root. Setting this to nil stops
+    #   rails environment loading
+    attr_accessor :rails_root
+
+    def logger
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    def poll_interval
+      @poll_interval ||= 60
+    end
+
+    def rails_root
+      @rails_root ||= '.'
+    end
+
+  end
+end

data/lib/mailman/message_processor.rb

@@ -0,0 +1,29 @@
+module Mailman
+  # Turns a raw email into a +Mail::Message+ and passes it to the router.
+  class MessageProcessor
+
+    # @param [Hash] options the options to create the processor with
+    # @option options [Router] :router the router to pass processed
+    #   messages to
+    def initialize(options)
+      @router = options[:router]
+    end
+
+    # Converts a raw email into a +Mail::Message+ instance, and passes it to the
+    # router.
+    # @param [String] message the message to process
+    def process(message)
+      message = Mail.new(message)
+      Mailman.logger.info "Got new message from '#{message.from.first}' with subject '#{message.subject}'."
+      @router.route(message)
+    end
+
+    # Processes a +Maildir::Message+ instance.
+    def process_maildir_message(message)
+      message.process # move message to cur
+      message.seen!
+      process(message.data)
+    end
+
+  end
+end

data/lib/mailman/receiver.rb

@@ -0,0 +1,7 @@
+module Mailman
+  class Receiver
+
+    autoload :POP3, 'mailman/receiver/pop3'
+
+  end
+end

data/lib/mailman/receiver/pop3.rb

@@ -0,0 +1,46 @@
+require 'net/pop'
+
+module Mailman
+  class Receiver
+    # Receives messages using POP3, and passes them to a {MessageProcessor}.
+    class POP3
+
+      # @return [Net::POP3] the POP3 connection
+      attr_reader :connection
+
+      # @param [Hash] options the receiver options
+      # @option options [MessageProcessor] :processor the processor to pass new
+      #   messages to
+      # @option options [String] :server the server to connect to
+      # @option options [Integer] :port the port to connect to
+      # @option options [String] :username the username to authenticate with
+      # @option options [String] :password the password to authenticate with
+      def initialize(options)
+        @processor = options[:processor]
+        @username = options[:username]
+        @password = options[:password]
+        @connection = Net::POP3.new(options[:server], options[:port])
+      end
+
+      # Connects to the POP3 server.
+      def connect
+        @connection.start(@username, @password)
+      end
+
+      # Disconnects from the POP3 server.
+      def disconnect
+        @connection.finish
+      end
+
+      # Iterates through new messages, passing them to the processor, and
+      # deleting them.
+      def get_messages
+        @connection.each_mail do |message|
+          @processor.process(message.pop)
+        end
+        @connection.delete_all
+      end
+
+    end
+  end
+end

data/lib/mailman/route.rb

@@ -0,0 +1,39 @@
+module Mailman
+  # The main route class. Has condition methods defined on it by
+  # {Route::Condition.inherited}. Stores a route with a set of conditions and
+  # matches against them.
+  class Route
+
+    # @return [Proc] the block that should be run if the conditions match
+    attr_reader :block
+
+    # @return [Array] the list of condition instances associated with the route
+    attr_reader :conditions
+
+    def initialize
+      @conditions = []
+    end
+
+    # Checks whether a message matches the route.
+    # @param [Mail::Message] message the message to match against
+    # @return [Hash] the +:block+ associated with the route, the
+    #   +:params+ hash, and the block +:args+ array.
+    def match!(message)
+      params = {}
+      args = []
+      @conditions.each do |condition|
+        if result = condition.match(message)
+          params.merge!(result[0])
+          args += result[1]
+        else
+          return nil
+        end
+      end
+      { :block => @block, :params => params, :args => args }
+    end
+
+  end
+end
+
+require 'mailman/route/matcher'
+require 'mailman/route/condition'

data/lib/mailman/route/condition.rb

@@ -0,0 +1,53 @@
+module Mailman
+  class Route
+    # The base condition class. All conditions should subclass and override
+    # {#match}.
+    class Condition
+
+      # @return the matcher to match against.
+      attr_reader :matcher
+
+      # @param [String, Regexp] the raw matcher to use in the condition,
+      #   converted to a matcher instance by {Matcher.create}
+      def initialize(condition)
+        @matcher = Matcher.create(condition)
+      end
+
+      # @abstract Extracts the attribute from the message, and runs the matcher
+      #   on it.
+      # @param message [Mail::Message] The message to match against
+      # @return [(Hash, Array)] a hash to merge into params, and an array of
+      #   block arguments.
+      def match(message)
+        raise NotImplementedError
+      end
+
+      # Registers a condition subclass, which creates instance methods on
+      # {Route} and {Application}.
+      # @param [Class] condition the condition subclass to register. The method
+      #   name is extracted by taking the class name, such as +ToCondition+,
+      #   and removing the +Condition+ ending
+      def self.inherited(condition)
+        condition_name = condition.to_s.split('::')[-1][0...-9].downcase
+        Route.class_eval <<-EOM
+          def #{condition_name}(pattern, &block)
+            @conditions << #{condition}.new(pattern)
+            if block_given?
+              @block = block
+            end
+            self
+          end
+        EOM
+
+        Application.class_eval <<-EOM
+          def #{condition_name}(pattern, &block)
+            @router.add_route Route.new.#{condition_name}(pattern, &block)
+          end
+        EOM
+      end
+
+    end
+  end
+end
+
+require 'mailman/route/conditions'

data/lib/mailman/route/conditions.rb

@@ -0,0 +1,43 @@
+module Mailman
+  class Route
+
+    # Matches against the To addresses of a message.
+    class ToCondition < Condition
+      def match(message)
+        message.to.each do |address|
+          if result = @matcher.match(address)
+            return result
+          end
+        end
+        nil
+      end
+    end
+
+    # Matches against the From addresses of a message.
+    class FromCondition < Condition
+      def match(message)
+        message.from.each do |address|
+          if result = @matcher.match(address)
+            return result
+          end
+        end
+        nil
+      end
+    end
+
+    # Matches against the Subject of a message.
+    class SubjectCondition < Condition
+      def match(message)
+        @matcher.match(message.subject)
+      end
+    end
+
+    # Matches against the Body of a message.
+    class BodyCondition < Condition
+      def match(message)
+        @matcher.match(message.body.decoded)
+      end
+    end
+
+  end
+end

data/lib/mailman/route/matcher.rb

@@ -0,0 +1,65 @@
+module Mailman
+  class Route
+    # The base matcher class. All matchers should subclass and override {#match}
+    # and {Matcher.valid_pattern?}. Override {#compile!} if a pattern compiler is
+    # needed.
+    class Matcher
+
+      # @return the matcher pattern, normally stored as a +Regexp+.
+      attr_reader :pattern
+
+      # Creates a new matcher and calls {#compile!}.
+      # @param pattern the matcher pattern
+      def initialize(pattern)
+        @pattern = pattern
+        compile!
+      end
+
+      # @abstract Matches a string against the stored pattern.
+      # @param [String] string the string to match against
+      # @return [(Hash, Array)] a hash to merge into params, and an array of
+      #  arguments for the block.
+      def match(string)
+        raise NotImplementedError
+      end
+
+      # @abstract Compiles the pattern into something easier to work with, usually a
+      #   +Regexp+.
+      def compile!
+      end
+
+      class << self
+
+        # @return [<Class>] The array of registered matchers.
+        attr_reader :matchers
+
+        # Registers a matcher so that it can be used in {Matcher.create}.
+        # @param matcher [Class] a matcher subclass
+        def inherited(matcher)
+          @matchers ||= []
+          @matchers << matcher
+        end
+
+        # Finds and creates a valid matcher instance for a given pattern.
+        # @param pattern the pattern to create the matcher with
+        def create(pattern)
+          @matchers.each do |matcher|
+            return matcher.new(pattern) if matcher.valid_pattern?(pattern)
+          end
+        end
+
+        # @abstract Checks whether a pattern is valid.
+        # @param pattern the pattern to check
+        # @return [true, false]
+        def valid_pattern?(pattern)
+          raise NotImplementedError
+        end
+
+      end
+
+    end
+  end
+end
+
+require 'mailman/route/regexp_matcher'
+require 'mailman/route/string_matcher'

data/lib/mailman/route/regexp_matcher.rb

@@ -0,0 +1,23 @@
+module Mailman
+  class Route
+    # Matches using a +Regexp+.
+    class RegexpMatcher < Matcher
+
+      # Matches against a string using the stored +Regexp+.
+      # @param [String] string the string to match against
+      # @return [({:captures => <String>}, <String>)] the params hash with
+      #   +:captures+ set to an array of captures, and an array of captures.
+      def match(string)
+        if match = @pattern.match(string)
+          captures = match.captures
+          [{:captures => captures}, captures]
+        end
+      end
+
+      def self.valid_pattern?(pattern)
+        pattern.class == Regexp
+      end
+
+    end
+  end
+end

data/lib/mailman/route/string_matcher.rb

@@ -0,0 +1,44 @@
+module Mailman
+  class Route
+    # Matches using a +String+ with named param captures formatted like
+    # +%user%@example.com+.
+    class StringMatcher < Matcher
+
+      # @return [Array<Symbol>] the names of the param captures
+      attr_reader :keys
+
+      # Matches against a string using the stored pattern.
+      # @param [String] string the string to match against
+      # @return [({Symbol => String}, <String>)] the params hash, and array of
+      #   captures.
+      def match(string)
+        params = {}
+        if match = @pattern.match(string)
+          captures = match.captures
+          params.merge!(Hash[*@keys.zip(captures).flatten])
+          [params, captures]
+        end
+      end
+
+      def compile!
+        @keys = []
+        special_chars = %w/* . + ? \\ | ^ $ ( ) [ ] { } /
+        compiled_pattern = @pattern.to_s.gsub(/((%[A-Za-z_]+%)|[\*\\.+?|^$()\[\]{}])/) do |match|
+          case match
+          when *special_chars
+            Regexp.escape(match)
+          else
+            @keys << $2[1..-2].to_sym
+            '(.*)'
+          end
+        end
+        @pattern = /#{compiled_pattern}/i
+      end
+
+      def self.valid_pattern?(pattern)
+        pattern.respond_to?(:to_s)
+      end
+
+    end
+  end
+end

data/lib/mailman/router.rb

@@ -0,0 +1,63 @@
+module Mailman
+  # The router. Stores routes and uses them to process messages.
+  class Router
+
+    # @return [Array] the list of routes
+    attr_accessor :routes
+
+    # @return [Proc] the block to run if a message has bounced
+    attr_accessor :bounce_block
+
+    # @return [Proc] the block to run if no routes match
+    attr_accessor :default_block
+
+    # @return [Hash] the params of the most recently processed message. Used by
+    #   route blocks
+    attr_reader :params
+
+    # @return [Mail::Message] the most recently processed message
+    attr_reader :message
+
+    def initialize
+      @routes = []
+      @params = HashWithIndifferentAccess.new
+    end
+
+    # Adds a route to the router.
+    # @param [Mailman::Route] the route to add.
+    # @return [Mailman::Route] the route object that was added (allows
+    #   chaining).
+    def add_route(route)
+      @routes.push(route)[-1]
+    end
+
+    # Route a message. If the route block accepts arguments, it passes any
+    # captured params. Named params are available from the +params+ helper. The
+    # message is available from the +message+ helper.
+    # @param [Mail::Message] the message to route.
+    def route(message)
+      @message = message
+      result = nil
+
+      if @bounce_block and message.respond_to?(:bounced?) and message.bounced?
+        return instance_exec(&@bounce_block)
+      end
+
+      routes.each do |route|
+        break if result = route.match!(message)
+      end
+
+      if result
+        @params.merge!(result[:params])
+        if result[:block].arity > 0
+          instance_exec(*result[:args], &result[:block])
+        else
+          instance_exec(&result[:block])
+        end
+      elsif @default_block
+        instance_exec(&@default_block)
+      end
+    end
+
+  end
+end

data/lib/mailman/version.rb

@@ -0,0 +1,3 @@
+module Mailman
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification 
+name: mailman
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jonathan Rudenberg
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-27 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mail
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 0
+        - 3
+        version: 2.0.3
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 3
+        - 4
+        version: 2.3.4
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: fssm
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 0
+        - 1
+        - 4
+        version: 0.1.4
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: maildir
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 0
+        - 5
+        - 0
+        version: 0.5.0
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Mailman makes it easy to process incoming emails with a simple routing DSL
+email: 
+- jonathan@titanous.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/mailman/application.rb
+- lib/mailman/configuration.rb
+- lib/mailman/message_processor.rb
+- lib/mailman/receiver/pop3.rb
+- lib/mailman/receiver.rb
+- lib/mailman/route/condition.rb
+- lib/mailman/route/conditions.rb
+- lib/mailman/route/matcher.rb
+- lib/mailman/route/regexp_matcher.rb
+- lib/mailman/route/string_matcher.rb
+- lib/mailman/route.rb
+- lib/mailman/router.rb
+- lib/mailman/version.rb
+- lib/mailman.rb
+- examples/simple_route.rb
+- LICENSE
+- README.md
+- USER_GUIDE.md
+has_rdoc: true
+homepage: http://mailmanrb.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: mailman
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A incoming email processing microframework
+test_files: []
+