mailmanager 1.0.8

data/Changelog

@@ -0,0 +1,8 @@
+Current version is 1.0.8
+
+changes since 1.0.7
+- added documentation
+
+1.0.7 -- First working release
+
+1.0.0 - 1.0.6 -- Internal testing releases

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2011, Democratic National Committee
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Democratic National Committee nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE DEMOCRATIC NATIONAL COMMITTEE BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.rdoc

@@ -0,0 +1,38 @@
+= MailManager
+
+MailManager is a Ruby wrapper for the GNU Mailman mailing list manager. It exposes
+some administrative functions to Ruby. See the API docs for details.
+It is licensed under the New BSD License (see the LICENSE file for details).
+
+MailManager has been tested with Mailman 2.1.14. It has NOT been tested with any
+release of Mailman 3 (in alpha as of 1/19/2011). It requires Python 2.6 or higher.
+Note that while Mailman itself requires Python, it can work with older versions. So
+check your Python version before using this.
+
+== Installation
+
+  gem install mailmanager
+  
+== Basic Usage
+
+  mm = MailManager.init('/mailman/root')
+  all_lists = mm.lists
+  foo_list = mm.get_list('foo')
+  new_list = mm.create_list(:name => 'newlist', :admin_email => 'me@here.com', :admin_password => 'secret')
+  new_list.add_member('bar@baz.com')
+  new_list.members (returns ['foo@baz.com'])
+
+== Contributing
+
+- Fork on GitHub
+- Make a new branch
+- Push your changes to that branch (i.e. not master)
+- Make a pull request
+- Bask in your awesomeness
+
+== Author
+
+- Wes Morgan (cap10morgan on GitHub)
+
+Copyright 2011 Democratic National Committee,
+All Rights Reserved.

data/lib/mailmanager.rb

@@ -0,0 +1,104 @@
+require "singleton"
+require "rubygems"
+require "bundler/setup"
+require "json"
+require "open4"
+
+require 'mailmanager/lib'
+require 'mailmanager/list'
+
+module MailManager
+  @root = nil
+  @python = '/usr/bin/env python'
+  @debug = ENV['MAILMANAGER_DEBUG'] =~ /^(?:1|true|y|yes|on)$/i ? true : false
+
+  def self.root=(root) #:nodoc:
+    @root = root
+  end
+
+  def self.root #:nodoc:
+    @root
+  end
+
+  def self.python=(python) #:nodoc:
+    @python = python
+  end
+
+  def self.python #:nodoc:
+    @python
+  end
+
+  def self.debug #:nodoc:
+    @debug
+  end
+
+  # Call this method to start using MailManager. Give it the full path to your
+  # Mailman installation. It will return an instance of MailManager::Base.
+  def self.init(root)
+    self.root = root
+    Base.instance
+  end
+
+  # The MailManager::Base class is the root class for working with a Mailman
+  # installation. You get an instance of it by calling
+  # MailManager.init('/mailman/root').
+  class Base
+    include Singleton
+
+    REQUIRED_BIN_FILES = ['list_lists', 'newlist', 'inject'] #:nodoc:
+
+    def initialize #:nodoc:
+      raise "Must set MailManager.root before calling #{self.class}.instance" if MailManager.root.nil?
+      raise "#{root} does not exist" unless Dir.exist?(root)
+      raise "#{root}/bin does not exist" unless Dir.exist?("#{root}/bin")
+      REQUIRED_BIN_FILES.each do |bin_file|
+        raise "#{root}/bin/#{bin_file} not found" unless File.exist?("#{root}/bin/#{bin_file}")
+      end
+      @lib = MailManager::Lib.new
+    end
+
+    # If you want to use a non-default python executable to run the Python
+    # portions of this gem, set its full path here. Since we require Python
+    # 2.6+ and some distros don't ship with that version, you can point this at
+    # a newer Python you have installed. Defaults to /usr/bin/env python.
+    def python=(python)
+      MailManager.python = python
+    end
+
+    def python #:nodoc:
+      MailManager.python
+    end
+
+    def root #:nodoc:
+      MailManager.root
+    end
+
+    # Returns an array of MailManager::List instances of the lists in your
+    # Mailman installation.
+    def lists
+      @lib.lists
+    end
+
+    # Only retrieves the list names, doesn't wrap them in MailManager::List
+    # instances.
+    def list_names
+      lists.map { |list| list.name }
+    end
+
+    # Create a new list. Returns an instance of MailManager::List. Params are:
+    # * :name => 'new_list_name'
+    # * :admin_email => 'admin@domain.com'
+    # * :admin_password => 'supersecret'
+    def create_list(params)
+      MailManager::List.create(params)
+    end
+
+    # Get an existing list as a MailManager::List instance. Raises an exception if
+    # the list doesn't exist.
+    def get_list(list_name)
+      raise "#{list_name} list does not exist" unless list_names.include?(list_name.downcase)
+      MailManager::List.new(list_name)
+    end
+  end
+
+end

data/lib/mailmanager/lib.rb

@@ -0,0 +1,194 @@
+module MailManager
+
+  class MailmanExecuteError < StandardError #:nodoc:
+  end
+
+  class Lib #:nodoc:all
+
+    def mailmanager
+      MailManager::Base.instance
+    end
+
+    def lists
+      cmd = :list_lists
+      out = command(cmd)
+      parse_output(cmd, out)
+    end
+
+    def create_list(params)
+      cmd = :newlist
+      out = command(cmd, params)
+      parse_output(cmd, out)
+    end
+
+    def list_address(list)
+      cmd = :withlist
+      out = command(cmd, :name => list.name, :wlcmd => :getListAddress)
+      parse_json_output(out)
+    end
+
+    def regular_members(list)
+      cmd = :withlist
+      out = command(cmd, :name => list.name, :wlcmd => :getRegularMemberKeys)
+      parse_json_output(out)
+    end
+
+    def digest_members(list)
+      cmd = :withlist
+      out = command(cmd, :name => list.name, :wlcmd => :getDigestMemberKeys)
+      parse_json_output(out)
+    end
+
+    def add_member(list, member)
+      cmd = :withlist
+      out = command(cmd, :name => list.name, :wlcmd => :AddMember, :arg => member)
+      parse_json_output(out)
+    end
+
+    def approved_add_member(list, member)
+      cmd = :withlist
+      out = command(cmd, :name => list.name, :wlcmd => :ApprovedAddMember,
+                    :arg => member)
+      parse_json_output(out)
+    end
+
+    def delete_member(list, email)
+      cmd = :withlist
+      out = command(cmd, :name => list.name, :wlcmd => :DeleteMember,
+                    :arg => email)
+      parse_json_output(out)
+    end
+
+    def approved_delete_member(list, email)
+      cmd = :withlist
+      out = command(cmd, :name => list.name, :wlcmd => :ApprovedDeleteMember,
+                    :arg => email)
+      parse_json_output(out)
+    end
+
+    def moderators(list)
+      cmd = :withlist
+      out = command(cmd, :name => list.name, :wlcmd => :moderator)
+      parse_json_output(out)
+    end
+
+    def add_moderator(list, email)
+      if moderators(list)['return'].include?(email)
+        return {'result' => 'already_a_moderator'}
+      end
+      cmd = :withlist
+      out = command(cmd, :name => list.name, :wlcmd => 'moderator.append',
+                    :arg => email)
+      parse_json_output(out)
+    end
+
+    def delete_moderator(list, email)
+      raise "#{email} is not a moderator" unless moderators(list)['return'].include?(email)
+      cmd = :withlist
+      out = command(cmd, :name => list.name, :wlcmd => 'moderator.remove',
+                    :arg => email)
+      parse_json_output(out)
+    end
+
+    def inject(list, message, queue=nil)
+      cmd = :inject
+      params = {:listname => list.name, :stdin => message}
+      params[:queue] = queue unless queue.nil?
+      command(cmd, params)
+    end
+
+    def command(cmd, opts = {})
+      mailman_cmd = "#{mailmanager.root}/bin/#{cmd.to_s} "
+      # delete opts as we handle them explicitly
+      stdin = nil
+      stdin = opts.delete(:stdin) if opts.has_key?(:stdin)
+      case cmd
+      when :newlist
+        mailman_cmd += "-q "
+        raise ArgumentError, "Missing :name param" if opts[:name].nil?
+        raise ArgumentError, "Missing :admin_email param" if opts[:admin_email].nil?
+        raise ArgumentError, "Missing :admin_password param" if opts[:admin_password].nil?
+        mailman_cmd_suffix = [:name, :admin_email, :admin_password].map { |key|
+          escape(opts.delete(key))
+        }.join(' ')
+        mailman_cmd += "#{mailman_cmd_suffix} "
+      when :withlist
+        raise ArgumentError, "Missing :name param" if opts[:name].nil?
+        proxy_path = File.dirname(__FILE__)
+        mailman_cmd = "PYTHONPATH=#{proxy_path} #{MailManager.python} #{mailman_cmd}"
+        mailman_cmd += "-q -r listproxy.command #{escape(opts.delete(:name))} " +
+                       "#{opts.delete(:wlcmd)} "
+        if !opts[:arg].nil? && opts[:arg].length > 0
+          mailman_cmd += "#{escape(opts.delete(:arg))} "
+        end
+      end
+
+      # assume any leftover opts are POSIX-style args
+      mailman_cmd += opts.keys.map { |k| "--#{k}=#{escape(opts[k])}" }.join(' ')
+      mailman_cmd += ' ' if mailman_cmd[-1,1] != ' '
+      mailman_cmd += "2>&1"
+      if MailManager.debug
+        puts "Running mailman command: #{mailman_cmd}"
+        puts " with stdin: #{stdin}" unless stdin.nil?
+      end
+      out, process = run_command(mailman_cmd, stdin)
+
+      if process.exitstatus > 0
+        raise MailManager::MailmanExecuteError.new(mailman_cmd + ':' + out.to_s)
+      end
+      out
+    end
+
+    def run_command(mailman_cmd, stdindata=nil)
+      output = nil
+      process = Open4::popen4(mailman_cmd) do |pid, stdin, stdout, stderr|
+        if !stdindata.nil?
+          stdin.puts(stdindata)
+          stdin.close
+        end
+        output = stdout.read
+      end
+      [output, process]
+    end
+
+    def escape(s)
+      # no idea what this does, stole it from the ruby-git gem
+      escaped = s.to_s.gsub('\'', '\'\\\'\'')
+      %Q{"#{escaped}"}
+    end
+
+    def parse_output(mailman_cmd, output)
+      case mailman_cmd
+      when :newlist
+        list_name = nil
+        output.split("\n").each do |line|
+          if match = /^##\s+(.+?)mailing\s+list\s*$/.match(line)
+            list_name = match[1]
+          end
+        end
+        raise "Error getting name of newly created list" if list_name.nil?
+        return_obj = MailManager::List.new(list_name)
+      when :list_lists
+        lists = []
+        puts "Output from Mailman:\n#{output}" if MailManager.debug
+        output.split("\n").each do |line|
+          next if line =~ /^\d+ matching mailing lists found:$/
+          /^\s*(.+?)\s+-\s+(.+)$/.match(line) do |m|
+            puts "Found list #{m[1]}" if MailManager.debug
+            lists << MailManager::List.new(m[1].downcase)
+          end
+        end
+        return_obj = lists
+      end
+      return_obj
+    end
+
+    def parse_json_output(json)
+      result = JSON.parse(json)
+      if result.is_a?(Hash) && !result['error'].nil?
+        raise MailmanExecuteError, result['error']
+      end
+      result
+    end
+  end
+end

data/lib/mailmanager/list.rb

@@ -0,0 +1,129 @@
+module MailManager
+
+  # The List class represents mailing lists in Mailman.
+  # Typically you get them by doing one of these things:
+  # mm = MailManager.init('/mailman/root')
+  # mylist = mm.get_list('list_name')
+  # OR
+  # mylist = mm.create_list(:name => 'list_name', :admin_email =>
+  # 'foo@bar.com', :admin_password => 'supersecret')
+  #
+
+  class List
+    # The name of the list
+    attr_reader :name
+
+    # This doesn't do any checking to see whether or not the requested list
+    # exists or not. Better to use MailManager::Base#get_list instead.
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s #:nodoc:
+      @name
+    end
+
+    def lib #:nodoc:
+      self.class.lib
+    end
+
+    def self.lib #:nodoc:
+      MailManager::Lib.new
+    end
+
+    def self.create(params) #:nodoc:
+      lib.create_list(params)
+    end
+
+    # Returns the list's email address
+    def address
+      result = lib.list_address(self)
+      result['return']
+    end
+
+    # Returns all list members (regular & digest) as an array
+    def members
+      regular_members + digest_members
+    end
+
+    # Returns just the regular list members (no digest members) as an array
+    def regular_members
+      result = lib.regular_members(self)
+      result['return']
+    end
+
+    # Returns just the digest list members (no regular members) as an array
+    def digest_members
+      result = lib.digest_members(self)
+      result['return']
+    end
+
+    # Adds a new list member, subject to the list's subscription rules
+    def add_member(email, name='')
+      add_member_using(:add_member, email, name)
+    end
+
+    # Adds a new list member, bypassing the list's subscription rules
+    def approved_add_member(email, name='')
+      add_member_using(:approved_add_member, email, name)
+    end
+
+    # Deletes a list member, subject to the list's unsubscription rules
+    def delete_member(email)
+      delete_member_using(:delete_member, email)
+    end
+
+    # Deletes a list member, bypassing the list's unsubscription rules
+    def approved_delete_member(email, name='')
+      delete_member_using(:approved_delete_member, email)
+    end
+
+    # Returns the list of moderators as an array of email addresses
+    def moderators
+      result = lib.moderators(self)
+      result['return']
+    end
+
+    # Adds a new moderator to the list
+    def add_moderator(email)
+      result = lib.add_moderator(self, email)
+      result['result'].to_sym
+    end
+
+    # Deletes a moderator from the list. Will raise an exception if the
+    # moderator doesn't exist yet.
+    def delete_moderator(email)
+      result = lib.delete_moderator(self, email)
+      result['result'].to_sym
+    end
+
+    # Injects a message into the list.
+    def inject(from, subject, message)
+      inject_message =<<EOF
+From: #{from}
+To: #{address}
+Subject: #{subject}
+
+#{message}
+EOF
+      lib.inject(self, inject_message)
+    end
+
+    private
+
+    def add_member_using(method, email, name)
+      if name.length > 0
+        member = "#{name} <#{email}>"
+      else
+        member = email
+      end
+      result = lib.send(method, self, member)
+      result['result'].to_sym
+    end
+
+    def delete_member_using(method, email)
+      result = lib.send(method, self, email)
+      result['result'].to_sym
+    end
+  end
+end

data/lib/mailmanager/listproxy.py

@@ -0,0 +1,73 @@
+import json
+from email.Utils import parseaddr
+from collections import Callable
+from Mailman import MailList
+from Mailman import Errors
+
+class MailingListEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, MailList.MailList):
+            return {'name': obj.internal_name()}
+        return json.JSONEncoder.default(self, obj)
+
+def dumplist(mlist):
+    print json.dumps(mlist, True, cls=MailingListEncoder)
+
+class UserDesc: pass
+def userdesc_for(member):
+    userdesc = UserDesc()
+    userdesc.fullname, userdesc.address = parseaddr(member)
+    return userdesc
+
+def unwindattrs(obj, attrs, *args):
+    if not attrs.count('.'):
+        attr = getattr(obj, attrs)
+        if isinstance(attr, Callable):
+            return attr(*args)
+        else:
+            return attr
+    else:
+        attr, nextattrs = attrs.split('.', 1)
+        nextobj = getattr(obj, attr)
+        return unwindattrs(nextobj, nextattrs, *args)
+
+needs_userdesc = dict(AddMember=True, ApprovedAddMember=True)
+needs_save = dict(AddMember=True, ApprovedAddMember=True,
+                  DeleteMember=True, ApprovedDeleteMember=True,
+                  moderator_append=True, moderator_remove=True)
+
+def command(mlist, cmd, *args):
+    result = {}
+    try:
+        if needs_save.get(cmd.replace('.','_'), False):
+            mlist.Lock()
+        if needs_userdesc.get(cmd, False):
+            result['return'] = unwindattrs(mlist, cmd, userdesc_for(args[0]))
+        else:
+            result['return'] = unwindattrs(mlist, cmd, *args)
+        if needs_save.get(cmd.replace('.','_'), False):
+            mlist.Save()
+    except TypeError as err:
+        error_msg = '%s' % err
+        print json.dumps({'error': error_msg})
+    except AttributeError as err:
+        error_msg = 'AttributeError: %s' % err
+        print json.dumps({'error': error_msg})
+    except Errors.MMSubscribeNeedsConfirmation as err:
+        print json.dumps({'result': 'pending_confirmation'})
+    except Errors.MMAlreadyAMember as err:
+        print json.dumps({'result': 'already_a_member'})
+    except Errors.MMNeedApproval as err:
+        print json.dumps({'result': 'needs_approval'})
+    except Exception as err:
+        error_msg = '%s: %s' % (type(err), err)
+        print json.dumps({'error': error_msg})
+    else:
+        result['result'] = 'success'
+        print json.dumps(result)
+
+#def loadlist(mlist, jsonlist):
+    #newlist = json.loads(jsonlist)
+    #for attr in newlist:
+        #print "Setting %s to %s" % (attr, newlist[attr])
+

data/lib/mailmanager/version.rb

@@ -0,0 +1,3 @@
+module MailManager
+  VERSION = '1.0.8'
+end

data/spec/lib/mailmanager/lib_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe MailManager::Lib do
+  let(:mailmanager) { mock(MailManager) }
+  let(:subject)     { MailManager::Lib.new }
+  let(:fake_root)   { '/foo/bar' }
+  let(:process)     { mock(Process::Status) }
+
+  before :each do
+    subject.stub(:mailmanager).and_return(mailmanager)
+    mailmanager.stub(:root).and_return(fake_root)
+    process.stub(:exitstatus).and_return(0)
+  end
+
+  describe "#lists" do
+    it "should return all existing lists" do
+      list_result = <<EOF 
+3 matching mailing lists found:
+        Foo - [no description available]
+     BarBar - Dummy list
+    Mailman - Mailman site list
+EOF
+      subject.stub(:run_command).with("#{fake_root}/bin/list_lists 2>&1", nil).
+        and_return([list_result,process])
+      subject.lists.should have(3).lists
+    end
+  end
+
+  describe "#create_list" do
+    it "should raise an argument error if list name is missing" do
+      lambda {
+        subject.create_list(:admin_email => 'foo@bar.baz', :admin_password => 'qux')
+      }.should raise_error(ArgumentError)
+    end
+    it "should raise an argument error if list admin email is missing" do
+      lambda {
+        subject.create_list(:name => 'foo', :admin_password => 'qux')
+      }.should raise_error(ArgumentError)
+    end
+    it "should raise an argument error if admin password is missing" do
+      lambda {
+        subject.create_list(:name => 'foo', :admin_email => 'foo@bar.baz')
+      }.should raise_error(ArgumentError)
+    end
+
+    context "with valid list params" do
+      let(:new_aliases) {
+        ['foo:              "|/foo/bar/mail/mailman post foo"',
+         'foo-admin:        "|/foo/bar/mail/mailman admin foo"',
+         'foo-bounces:      "|/foo/bar/mail/mailman bounces foo"',
+         'foo-confirm:      "|/foo/bar/mail/mailman confirm foo"',
+         'foo-join:         "|/foo/bar/mail/mailman join foo"',
+         'foo-leave:        "|/foo/bar/mail/mailman leave foo"',
+         'foo-owner:        "|/foo/bar/mail/mailman owner foo"',
+         'foo-request:      "|/foo/bar/mail/mailman request foo"',
+         'foo-subscribe:    "|/foo/bar/mail/mailman subscribe foo"',
+         'foo-unsubscribe:  "|/foo/bar/mail/mailman unsubscribe foo"']
+      }
+      let(:new_list_return) {
+        prefix =<<EOF
+To finish creating your mailing list, you must edit your /etc/aliases (or                           
+equivalent) file by adding the following lines, and possibly running the                            
+`newaliases' program:                                                                               
+                                                                                                    
+## foo mailing list                                                                                 
+EOF
+        prefix+new_aliases.join("\n")
+      }
+      let(:fake_aliases_file) { mock(File) }
+
+      before :each do
+        File.stub(:open).with('/etc/aliases', 'a').and_return(fake_aliases_file)
+        subject.stub(:run_newaliases_command)
+      end
+
+      it "should create the list" do
+        subject.should_receive(:run_command).
+          with("#{fake_root}/bin/newlist -q \"foo\" \"foo@bar.baz\" \"qux\" 2>&1", nil).
+          and_return([new_list_return,process])
+        subject.create_list(:name => 'foo', :admin_email => 'foo@bar.baz',
+                            :admin_password => 'qux')
+      end
+    end
+  end
+
+  context "with populated list" do
+    let(:list) { list = mock(MailManager::List)
+                 list.stub(:name).and_return('foo')
+                 list }
+
+    let(:regular_members) { ['me@here.com', 'you@there.org'] }
+    let(:digest_members)  { ['them@that.net'] }
+
+    let(:cmd) { "PYTHONPATH=#{File.expand_path('lib/mailmanager')} " +
+                "#{fake_root}/bin/withlist -q -r listproxy.command \"foo\" " }
+
+    describe "#regular_members" do
+      it "should ask Mailman for the regular list members" do
+        subject.should_receive(:run_command).
+          with(cmd+"getRegularMemberKeys 2>&1", nil).
+          and_return([JSON.generate(regular_members),process])
+        subject.regular_members(list).should == regular_members
+      end
+    end
+
+    describe "#digest_members" do
+      it "should ask Mailman for the digest list members" do
+        subject.should_receive(:run_command).
+          with(cmd+"getDigestMemberKeys 2>&1", nil).
+          and_return([JSON.generate(digest_members),process])
+        subject.digest_members(list).should == digest_members
+      end
+    end
+
+    describe "#add_member" do
+      it "should ask Mailman to add the member to the list" do
+        new_member = 'newb@dnc.org'
+        result = {"result" => "pending_confirmation"}
+        subject.should_receive(:run_command).
+          with(cmd+"AddMember \"#{new_member}\" 2>&1", nil).
+          and_return([JSON.generate(result),process])
+        subject.add_member(list, new_member).should == result
+      end
+    end
+
+    describe "#approved_add_member" do
+      it "should ask Mailman to add the member to the list" do
+        new_member = 'newb@dnc.org'
+        result = {"result" => "success"}
+        subject.should_receive(:run_command).
+          with(cmd+"ApprovedAddMember \"#{new_member}\" 2>&1", nil).
+          and_return([JSON.generate(result),process])
+        subject.approved_add_member(list, new_member).should == result
+      end
+    end
+
+    describe "#delete_member" do
+      it "should ask Mailman to delete the member from the list" do
+        former_member = 'oldie@ofa.org'
+        result = {"result" => "success"}
+        subject.should_receive(:run_command).
+          with(cmd+"DeleteMember \"#{former_member}\" 2>&1", nil).
+          and_return([JSON.generate(result),process])
+        subject.delete_member(list, former_member).should == result
+      end
+    end
+
+    describe "#approved_delete_member" do
+      it "should ask Mailman to delete the member from the list" do
+        former_member = 'oldie@ofa.org'
+        result = {"result" => "success"}
+        subject.should_receive(:run_command).
+          with(cmd+"ApprovedDeleteMember \"#{former_member}\" 2>&1", nil).
+          and_return([JSON.generate(result),process])
+        subject.approved_delete_member(list, former_member).should == result
+      end
+    end
+  end
+
+end

data/spec/lib/mailmanager/list_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe MailManager::List do
+  let(:lib)       { mock(MailManager::Lib) }
+  let(:subject)   { MailManager::List.new('foo') }
+
+  before :each do
+    MailManager::List.stub(:lib).and_return(lib)
+  end
+
+  describe ".create" do
+    it "should require the params arg" do
+      lambda {
+        MailManager::List.create
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should return the new list" do
+      params = {:name => 'foo', :admin_email => 'foo@bar.baz', :admin_password => 'qux'}
+      lib.stub(:create_list).with(params).and_return(subject)
+      new_list = MailManager::List.create(params)
+      new_list.should_not be_nil
+      new_list.name.should == 'foo'
+    end
+  end
+
+  describe "#initialize" do
+    it "should take a name parameter" do
+      MailManager::List.new('foo').name.should == 'foo'
+    end
+
+    it "should raise an error if the name arg is missing" do
+      lambda {
+        MailManager::List.new
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "#to_s" do
+    it "should return its name" do
+      subject.to_s.should == "foo"
+    end
+  end
+
+  context "with list members" do
+    let(:regular_members) { ['me@here.com', 'you@there.org'] }
+    let(:digest_members)  { ['them@that.net'] }
+    let(:all_members)     { regular_members + digest_members }
+
+    describe "#regular_members" do
+      it "should return only regular members" do
+        lib.stub(:regular_members).with(subject).and_return({'return' => regular_members})
+        subject.regular_members.should == regular_members
+      end
+    end
+
+    describe "#digest_members" do
+      it "should return only digest members" do
+        lib.stub(:digest_members).with(subject).and_return({'return' => digest_members})
+        subject.digest_members.should == digest_members
+      end
+    end
+
+    describe "#members" do
+      it "should return the list of all members" do
+        lib.stub(:regular_members).with(subject).and_return({'return' => regular_members})
+        lib.stub(:digest_members).with(subject).and_return({'return' => digest_members})
+        subject.members.should == all_members
+      end
+    end
+  end
+
+  describe "#add_member" do
+    it "should tell lib to add the member" do
+      lib.should_receive(:add_member).with(subject, 'foo@bar.baz').
+        and_return({'result' => 'pending_confirmation'})
+      subject.add_member('foo@bar.baz').should == :pending_confirmation
+    end
+
+    it "should accept an optional name argument" do
+      lib.should_receive(:add_member).with(subject, 'Foo Bar <foo@bar.baz>').
+        and_return({'result' => 'pending_confirmation'})
+      subject.add_member('foo@bar.baz', 'Foo Bar').should == :pending_confirmation
+    end
+  end
+
+  describe "#approved_add_member" do
+    it "should tell lib to add the member" do
+      lib.should_receive(:approved_add_member).with(subject, 'foo@bar.baz').
+        and_return({'result' => 'success'})
+      subject.approved_add_member('foo@bar.baz').should == :success
+    end
+
+    it "should accept an optional name argument" do
+      lib.should_receive(:approved_add_member).with(subject, 'Foo Bar <foo@bar.baz>').
+        and_return({'result' => 'success'})
+      subject.approved_add_member('foo@bar.baz', 'Foo Bar').should == :success
+    end
+  end
+
+  describe "#delete_member" do
+    it "should tell lib to delete the member" do
+      lib.should_receive(:delete_member).with(subject, 'foo@bar.baz').
+        and_return({'result' => 'success'})
+      subject.delete_member('foo@bar.baz').should == :success
+    end
+  end
+
+  describe "#approved_delete_member" do
+    it "should tell lib to delete the member" do
+      lib.should_receive(:approved_delete_member).with(subject, 'foo@bar.baz').
+        and_return({'result' => 'success'})
+      subject.approved_delete_member('foo@bar.baz').should == :success
+    end
+  end
+end

data/spec/lib/mailmanager_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe "MailManager" do
+
+  describe "Base" do
+    describe ".instance" do
+      it "should require setting the Mailman root directory first" do
+        lambda {
+          MailManager::Base.instance
+        }.should raise_error
+      end
+
+      it "should require that the Mailman directory exist" do
+        lambda {
+          MailManager.root = '/foo/bar'
+          MailManager::Base.instance
+        }.should raise_error
+      end
+
+      it "should require that the Mailman dir have a bin subdir" do
+        Dir.stub(:exist?).with('/foo/bar').and_return(true)
+        Dir.stub(:exist?).with('/foo/bar/bin').and_return(false)
+        lambda {
+          MailManager.root = '/foo/bar'
+          MailManager::Base.instance
+        }.should raise_error
+      end
+
+      context "with a valid Mailman dir" do
+        let(:mailman_path) { '/usr/local/mailman' }
+        let(:bin_files) { ['list_lists', 'newlist', 'inject'] }
+
+        before :each do
+          Dir.stub(:exist?).with(mailman_path).and_return(true)
+          Dir.stub(:exist?).with("#{mailman_path}/bin").and_return(true)
+          bin_files.each do |bf|
+            File.stub(:exist?).with("#{mailman_path}/bin/#{bf}").and_return(true)
+          end
+        end
+
+        it "should raise an error if one of the bin files is missing" do
+          File.stub(:exist?).with("#{mailman_path}/bin/inject").and_return(false)
+          lambda {
+            MailManager.root = mailman_path
+            MailManager::Base.instance
+          }.should raise_error
+        end
+
+        it "should succeed if the all the bin files are present" do
+          MailManager.root = mailman_path
+          MailManager::Base.instance.should_not be_nil
+        end
+
+        describe "#lists" do
+          it "should return an array of existing mailing lists" do
+
+          end
+        end
+      end
+    end
+  end
+
+  describe "List" do
+    describe ".initialize" do
+
+    end
+
+    describe ".create" do
+      
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$:.unshift('../lib')
+require 'mailmanager'
+

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: mailmanager
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 8
+  version: 1.0.8
+platform: ruby
+authors: 
+- Wes Morgan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-19 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 4
+        - 6
+        version: 1.4.6
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: open4
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 1
+        version: 1.0.1
+  type: :runtime
+  version_requirements: *id002
+description: Ruby wrapper library for GNU Mailman's admin functions
+email: MorganW@dnc.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/mailmanager/lib.rb
+- lib/mailmanager/list.rb
+- lib/mailmanager/version.rb
+- lib/mailmanager.rb
+- lib/mailmanager/listproxy.py
+- spec/lib/mailmanager/lib_spec.rb
+- spec/lib/mailmanager/list_spec.rb
+- spec/lib/mailmanager_spec.rb
+- spec/spec_helper.rb
+- Changelog
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/dnclabs/mailmanager
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: GNU Mailman wrapper for Ruby
+test_files: []
+