gurgitate-mail 1.10.9 → 1.10.10

data/lib/gurgitate/mail_headers.rb

@@ -0,0 +1,167 @@
+#!/opt/bin/ruby -w
+# -*- encoding : utf-8 -*-
+
+require "gurgitate/headers"
+
+module Gurgitate
+    class IllegalHeader < RuntimeError ; end
+
+# ========================================================================
+
+    # A slightly bigger class for all of a message's headers
+    class MailHeaders < Headers
+
+        private
+
+        # Figures out whether the first line of a mail message is an
+        # mbox-style "From " line (say, if you get this from sendmail),
+        # or whether it's just a normal header.
+        # -- 
+        # If you run "fetchmail" with the -m option to feed the
+        # mail message straight to gurgitate, skipping the "local
+        # MTA" step, then it doesn't have a "From " line.  So I
+        # have to deal with that by hand.  First, check to see if
+        # there's a "From " line present in the first place.
+        def figure_out_from_line(headertext)
+            (unix_from,normal_headers)  = headertext.split(/\n/,2)
+
+            if unix_from =~ /^From /  then
+                headertext=normal_headers
+                unix_from=unix_from
+            else
+                # If there isn't, then deal with it after we've
+                # worried about the rest of the headers, 'cos we'll
+                # have to make our own.
+                unix_from=nil
+            end
+            return unix_from, headertext
+        end
+
+        # Get the envelope From information.  This comes with a
+        # whole category of rants: this information is absurdly hard
+        # to get your hands on.  The best you can manage is a sort
+        # of educated guess.  Thus, this horrible glob of hackiness.
+        # I don't recommend looking too closely at this code if you
+        # can avoid it, and further I recommend making sure to
+        # configure your MTA so that it sends proper sender and
+        # recipient information to gurgitate so that this code never
+        # has to be run at all.
+        def guess_sender
+            # Start by worrying about the "From foo@bar" line.  If it's
+            # not there, then make one up from the Return-Path: header.
+            # If there isn't a "Return-Path:" header (then I suspect we
+            # have bigger problems, but still) then use From: as a wild
+            # guess.  If I hope that this entire lot of code doesn't get
+            # used, then I _particularly_ hope that things never get so
+            # bad that poor gurgitate has to use the From: header as a
+            # source of authoritative information on anything.
+            #
+            # And then after all that fuss, if we're delivering to a
+            # Maildir, I have to get rid of it.  And sometimes the MTA
+            # gives me a mbox-style From line and sometimes it doesn't.
+            # It's annoying, but I have no choice but to Just Deal With
+            # It.
+            if @unix_from then
+                # If it is there, then grab the email address in it and
+                # use that as our official "from".
+                fromregex=/^From ([^ ]+@[^ ]+) /
+                fromregex.match(@unix_from)
+                @from=$+
+
+                # or maybe it's local
+                if @from == nil then
+                    @unix_from =~ /^From (\S+) /
+                    @from=$+
+                end
+            else
+                fromregex=/([^ ]+@[^ ]+) \(.*\)|[^<]*[<](.*@.*)[>]|([^ ]+@[^ ]+)/
+                if self["Return-Path"] != nil then
+                    fromregex.match(self["Return-Path"][0].contents)
+                else
+                    if self["From"] != nil then
+                        fromregex.match(self["From"][0].contents)
+                    end
+                end
+                address_candidate=$+
+
+                # If there STILL isn't a match, then it's probably safe to
+                # assume that it's local mail, and doesn't have an @ in its
+                # address.
+                unless address_candidate
+                    if self["Return-Path"] != nil then
+                        self["Return-Path"][0].contents =~ /(\S+)/
+                        address_candidate=$+
+                    else
+                        self["From"][0].contents =~ /(\S+)/
+                        address_candidate=$+
+                    end
+                end
+
+                @from=address_candidate
+
+                @unix_from="From "+self.from+" "+Time.new.to_s
+            end
+        end
+
+        public
+
+        # Creates a MailHeaders object.
+        # headertext::
+        #   The text of the message headers.
+        def initialize(headertext=nil, sender=nil, recipient=nil)
+            @from    = sender
+            @to      = recipient
+            @headers = Hash.new(nil)
+
+            if Hash === headertext
+                @headers_changed = true
+                headertext.each_key do |key|
+
+                    headername = key.to_s.gsub("_","-")
+
+                    header=Header.new(headername, headertext[key])
+                    @headers[header.name] ||= HeaderBag.new
+                    @headers[header.name].push(header)
+                end
+            else
+                if headertext
+                    @unix_from, @headertext = figure_out_from_line headertext
+                    parse_headers if @headertext
+
+                    if sender # then don't believe the mbox separator
+                        @from = sender
+                        @unix_from="From "+self.from+" "+Time.new.to_s
+                    else
+                        guess_sender
+                    end
+                end
+            end
+        end
+
+        # Who the message is to (the envelope to)
+        #
+        # Yet another bucket of rants.  Unix mail sucks.
+        def to
+            return @to || @headers["X-Original-To"] || nil
+        end
+
+        # Who the message is from (the envelope from)
+        def from
+            return @from || ""
+        end
+
+        # Change the envelope from line to whatever you want.  This might
+        # not be particularly neighborly, but oh well.
+        # newfrom:: An email address
+        def from=(newfrom) 
+            @from=newfrom
+            @unix_from="From "+self.from+" "+Time.new.to_s
+        end
+
+        # Returns the headers properly formatted for an mbox-format
+        # email message.
+        def to_mbox
+            return @unix_from+"\n"+to_s
+        end
+    end
+end

data/lib/gurgitate/mailmessage.rb

@@ -0,0 +1,142 @@
+# -*- encoding : utf-8 -*-
+# Contains the class Gurgitate::Mailmessage, used to handle the parsing
+# of existing messages and the creation of new messages.
+
+require 'gurgitate/headers'
+require 'gurgitate/message'
+
+module Gurgitate
+
+    # A complete mail message.  This is the base class for
+    # gurgitate-mail itself: if you want to use gurgitate-mail to create
+    # new messages, this is what you want to use.
+    class Mailmessage < Message
+
+        Fromregex=/([^ ]+@[^ ]+) \(.*\)|[^<][<](.*@.*)[>]|([^ ]+@[^ ]+)/;
+
+        # The envelope sender and recipient, if anyone thought to
+        # mention them to us.
+        attr_accessor :sender
+        attr_accessor :recipient
+
+        # Creates a new mail message from the options hash, and the body of the
+        # message in a string.
+        #
+        # This can actually be invoked in several ways:
+        #
+        #    Gurgitate::Mailmessage.create "This is the message body",
+        #       :from    => "from_address@example.com",
+        #       :to      => "to_address@example.com",
+        #       :subject => "This is the message subject"
+        #
+        # This results in an email message that, when rendered via to_s, will
+        # look like this:
+        #
+        #   From: from_address@example.com
+        #   To: to_address@example.com
+        #   Subject: This is the message subject
+        #
+        #   This is the message body
+        #
+        # If you prefer to do things entirely by options hashes, as some do,
+        # you can substitute a :body key for the first argument:
+        #
+        #    Gurgitate::Mailmessage.create(
+        #        :body    => "This is the message body",
+        #        :from    => "from_address@example.com",
+        #        :to      => "to_address@example.com",
+        #        :subject => "This is the message subject"
+        #    )
+        #
+        # There are two other special options you can use: :sender and
+        # :recipient.  These are used to specify the sender and recipient of
+        # email messages, when the message is sent via SMTP.
+        #
+        def self.create(*args)
+            options = body = nil
+
+            if String === args[0]
+                options = args[1]
+                body = args[0]
+            elsif Hash === args[0]
+                options = args[0]
+            else
+                options = {}
+            end
+
+            message = self.new
+
+            message.instance_eval do
+                if body
+                    @body=body
+                end
+
+                %w/sender recipient body/.each do |key|
+                    if options.has_key? key.to_sym
+                        instance_variable_set("@#{key}", options[key.to_sym])
+                        options.delete key.to_sym
+                    end
+                end
+
+                @headers = MailHeaders.new(options)
+            end
+
+            message
+        end
+
+        def initialize(text=nil, recipient=nil, sender=nil)
+
+            @recipient = recipient
+            @sender = sender
+
+            begin
+                # ASCII_8BIT is what Ruby 1.9 and up calls
+                # "binary stream of unknown encoding".
+                #
+                # At least it treats the ASCII characters
+                # as strings, so I can do regex things
+                # with them
+                text.force_encoding(Encoding::ASCII_8BIT)
+            rescue NameError  # Ruby 1.9 and up
+                true
+            end
+
+            if text
+                (@headertext,@body)=text.split(/\n\n/m,2)
+                @headers=MailHeaders.new(@headertext);
+                Fromregex.match(
+                    if @headers["From"] then
+                        @headers["From"][0].contents
+                    else
+                        ""
+                    end);
+                @from=$+
+            else
+                super(text)
+            end
+        end
+
+        # custom accessors
+    
+        # Returns the message's sender
+        def from; @sender || @headers.from; end
+
+        # Returns all the candidates for a recipient
+        def to
+            if @recipient
+                then @recipient
+            elsif @headers["To"]
+                then @headers["To"][0].contents
+            elsif @headers["Cc"]
+                then @headers["Cc"][0].contents
+            elsif @headers["X-Original-To"]
+                then @headers["X-Original-To"][0].contents
+            else
+                ""
+            end
+        end
+
+        # Returns the mail message formatted for mbox
+        def to_mbox; @headers.to_mbox + "\n\n" + @body; end
+    end
+end

data/lib/gurgitate/message.rb

@@ -0,0 +1,114 @@
+#!/opt/bin/ruby -w
+# -*- encoding : utf-8 -*-
+
+#------------------------------------------------------------------------
+# Handles a complete mail message
+#------------------------------------------------------------------------
+
+require 'gurgitate/mail_headers'
+
+module Gurgitate
+
+    # A complete mail message.
+    class Message
+
+        # The headers of the message
+        attr_reader :headers
+        # The body of the message
+        attr_accessor :body
+
+        # Creates a new message from the options hash, and the body of the
+        # message in a string.
+        #
+        # This can actually be invoked in several ways:
+        #
+        #    Gurgitate::Mailmessage.create "This is the message body",
+        #       :from    => "from_address@example.com",
+        #       :to      => "to_address@example.com",
+        #       :subject => "This is the message subject"
+        #
+        # This results in an email message that, when rendered via to_s, will
+        # look like this:
+        #
+        #   From: from_address@example.com
+        #   To: to_address@example.com
+        #   Subject: This is the message subject
+        #
+        #   This is the message body
+        #
+        # If you prefer to do things entirely by options hashes, as some do,
+        # you can substitute a :body key for the first argument:
+        #
+        #    Gurgitate::Mailmessage.create(
+        #        :body    => "This is the message body",
+        #        :from    => "from_address@example.com",
+        #        :to      => "to_address@example.com",
+        #        :subject => "This is the message subject"
+        #    )
+        #
+        # There are two other special options you can use: :sender and
+        # :recipient.  These are used to specify the sender and recipient of
+        # email messages, when the message is sent via SMTP.
+        #
+        def self.create(*args)
+            options = body = nil
+
+            if String === args[0]
+                options = args[1]
+                body = args[0]
+            elsif Hash === args[0]
+                options = args[0]
+            else
+                options = {}
+            end
+
+            message = self.new
+
+            message.instance_eval do
+                if body
+                    @body=body
+                end
+
+                @headers = Headers.new(options)
+            end
+
+            message
+        end
+
+        # Creates a new Gurgitate message from a pre-existing message.
+        # This is what is used when gurgitate-mail is used as a mail filter.
+        #
+        # ARGUMENTS::
+        # +text+      :: An RFC822-formatted message.
+        # +recipient+ :: The recipient of the email message, from the MTA
+        # +sender+    :: The sender of the email message, also from the MTA
+        #
+        # All of its arguments can be nil: if called with no arguments,
+        # it simply returns an empty email message, which can be populated
+        # after the fact.
+        def initialize(text=nil)
+            if text
+                (@headertext,@body)=text.split(/\n\n/,2)
+                @headers=Headers.new(@headertext);
+            else
+                @headers = Headers.new
+                @body = ""
+            end
+        end
+
+        # Returns the header +name+, which is, note, a HeaderBag of all
+        # headers by that name, not just a single header.
+        #
+        # If you want the text of the header, then you have to coerce it to a
+        # string:
+        #
+        #    header("name").to_s
+        #
+        def header(name)
+            @headers[name].each { |h| h.contents }.join(", ")
+        end
+
+        # Returns the formatted mail message
+        def to_s; @headers.to_s + "\n\n" + ( @body || ""); end
+    end
+end

data/test/test_delivery.rb

@@ -163,7 +163,7 @@ class TC_Delivery < GurgitateTest
             end
             system("ls -ld #{@spoolfile}")
         end
-        
+
     end
 
     def test_mailbox_heuristics_mbox

metadata

@@ -1,98 +1,91 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: gurgitate-mail
-version: !ruby/object:Gem::Version 
-  hash: 45
-  prerelease: 
-  segments: 
-  - 1
-  - 10
-  - 9
-  version: 1.10.9
+version: !ruby/object:Gem::Version
+  version: 1.10.10
 platform: ruby
-authors: 
+authors:
 - Dave Brown
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-06-04 00:00:00 Z
+date: 2015-02-05 00:00:00.000000000 Z
 dependencies: []
-
-description: "    gurgitate-mail is a mail filter.  It can be used as a module or\n    as a standalone application.\n"
+description: |2
+      gurgitate-mail is a mail filter.  It can be used as a module or
+      as a standalone application.
 email: gurgitate-mail@dagbrown.com
-executables: 
+executables:
 - gurgitate-mail
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
+- ".gemtest"
+- Rakefile
+- bin/gurgitate-mail
+- lib/gurgitate-mail.rb
+- lib/gurgitate/deliver.rb
+- lib/gurgitate/deliver/maildir.rb
+- lib/gurgitate/deliver/mbox.rb
+- lib/gurgitate/deliver/mh.rb
+- lib/gurgitate/header.rb
+- lib/gurgitate/headers.rb
+- lib/gurgitate/mail_headers.rb
+- lib/gurgitate/mailmessage.rb
+- lib/gurgitate/message.rb
+- test/gurgitate-test.rb
 - test/runtests.rb
-- test/test_writing.rb
-- test/test_rules.rb
-- test/test_header.rb
-- test/test_gurgitate_delivery.rb
-- test/test_process.rb
-- test/test_deliver.rb
 - test/test_configuration.rb
-- test/gurgitate-test.rb
-- test/test_mail_headers.rb
+- test/test_deliver.rb
 - test/test_delivery.rb
-- test/test_headers_creating_from_hash.rb
-- test/test_headers_meddling_with_headers.rb
 - test/test_execute_rules.rb
+- test/test_gurgitate_delivery.rb
+- test/test_header.rb
 - test/test_headers.rb
+- test/test_headers_creating_from_hash.rb
+- test/test_headers_meddling_with_headers.rb
+- test/test_mail_headers.rb
 - test/test_mail_headers_meddling_with_headers.rb
-- .gemtest
-- Rakefile
-- bin/gurgitate-mail
-homepage: http://www.rubyforge.org/projects/gurgitate-mail/
-licenses: []
-
+- test/test_process.rb
+- test/test_rules.rb
+- test/test_writing.rb
+homepage: http://www.github.com/dagbrown/gurgitate-mail/
+licenses:
+- GPL-2.0
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  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
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: gurgitate-mail
-rubygems_version: 1.8.24
+rubyforge_project: 
+rubygems_version: 2.4.5
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: gurgitate-mail is a mail filter (and a mail-delivery agent)
-test_files: 
-- test/runtests.rb
+test_files:
 - test/test_writing.rb
+- test/test_headers_meddling_with_headers.rb
 - test/test_rules.rb
-- test/test_header.rb
+- test/test_execute_rules.rb
+- test/test_mail_headers.rb
 - test/test_gurgitate_delivery.rb
-- test/test_process.rb
+- test/runtests.rb
 - test/test_deliver.rb
+- test/test_process.rb
+- test/test_mail_headers_meddling_with_headers.rb
 - test/test_configuration.rb
-- test/gurgitate-test.rb
-- test/test_mail_headers.rb
+- test/test_header.rb
 - test/test_delivery.rb
 - test/test_headers_creating_from_hash.rb
-- test/test_headers_meddling_with_headers.rb
-- test/test_execute_rules.rb
+- test/gurgitate-test.rb
 - test/test_headers.rb
-- test/test_mail_headers_meddling_with_headers.rb