X-Git-Url: https://git.sommitrealweird.co.uk/rss2maildir.git/blobdiff_plain/41170825eb09fcf3b3c69c9812073727ee8a2b4e..629cdfb564c31d54236ba24cd6d891cba1c2308a:/rss2maildir.py?ds=sidebyside

diff --git a/rss2maildir.py b/rss2maildir.py
index 25ddb3c..910b8a9 100755
--- a/rss2maildir.py
+++ b/rss2maildir.py
@@ -20,6 +20,7 @@
 import sys
 import os
 import stat
+import httplib
 import urllib
 
 import feedparser
@@ -45,214 +46,471 @@ import dbm
 
 from HTMLParser import HTMLParser
 
-entities = {
-    "amp": "&",
-    "lt": "<",
-    "gt": ">",
-    "pound": "£",
-    "copy": "©",
-    "apos": "'",
-    "quote": "\"",
-    "nbsp": " ",
-    }
-
 class HTML2Text(HTMLParser):
-    
-    def __init__(self):
-        self.inheadingone = False
-        self.inheadingtwo = False
-        self.inotherheading = False
-        self.inparagraph = True
-        self.inblockquote = False
-        self.inlink = False
+    entities = {
+        u'amp': "&",
+        u'lt': "<",
+        u'gt': ">",
+        u'pound': "£",
+        u'copy': "©",
+        u'apos': "'",
+        u'quot': "\"",
+        u'nbsp': " ",
+        }
+
+    blockleveltags = [
+        u'h1',
+        u'h2',
+        u'h3',
+        u'h4',
+        u'h5',
+        u'h6',
+        u'pre',
+        u'p',
+        u'ul',
+        u'ol',
+        u'dl',
+        u'div',
+        #u'blockquote',
+        ]
+
+    liststarttags = [
+        u'ul',
+        u'ol',
+        u'dl',
+        ]
+
+    cancontainflow = [
+        u'div',
+        u'li',
+        u'dd',
+        u'blockquote',
+    ]
+
+    def __init__(self,textwidth=70):
         self.text = u''
-        self.currentparagraph = u''
-        self.headingtext = u''
-        self.blockquote = u''
-        self.inpre = False
-        self.inul = False
-        self.initem = False
-        self.item = u''
+        self.curdata = u''
+        self.textwidth = textwidth
+        self.opentags = []
+        self.indentlevel = 0
+        self.ignorenodata = False
+        self.listcount = []
+        self.urls = []
         HTMLParser.__init__(self)
 
     def handle_starttag(self, tag, attrs):
-        if tag.lower() == "h1":
-            self.inheadingone = True
-            self.inparagraph = False
-        elif tag.lower() == "h2":
-            self.inheadingtwo = True
-            self.inparagraph = False
-        elif tag.lower() in ["h3", "h4", "h5", "h6"]:
-            self.inotherheading = True
-            self.inparagraph = False
-        elif tag.lower() == "a":
-            self.inlink = True
-        elif tag.lower() == "br":
-            self.handle_br()
-        elif tag.lower() == "blockquote":
-            self.inblockquote = True
-            self.text = self.text + u'\n'
-        elif tag.lower() == "p":
-            if self.text != "":
-                self.text = self.text + u'\n\n'
-            if self.inparagraph:
-                self.text = self.text \
-                    + u'\n'.join(textwrap.wrap(self.currentparagraph, 70))
-            self.currentparagraph = u''
-            self.inparagraph = True
-        elif tag.lower() == "pre":
-            self.text = self.text + "\n"
-            self.inpre = True
-            self.inparagraph = False
-            self.inblockquote = False
-        elif tag.lower() == "ul":
-            self.item = u''
-            self.inul = True
-            self.text = self.text + "\n"
-        elif tag.lower() == "li" and self.inul:
-            if not self.initem:
-                self.initem = True
-                self.item = u''
+        tag_name = tag.lower()
+        if tag_name in self.blockleveltags:
+            # handle starting a new block - unless we're in a block element
+            # that can contain other blocks, we'll assume that we want to close
+            # the container
+            if len(self.opentags) > 1 and self.opentags[-1] == u'li':
+                self.handle_curdata()
+
+            if tag_name == u'ol':
+                self.handle_curdata()
+                self.listcount.append(1)
+                self.listlevel = len(self.listcount) - 1
+
+            if tag_name in self.liststarttags:
+                smallist = self.opentags[-3:-1]
+                smallist.reverse()
+                for prev_listtag in smallist:
+                    if prev_listtag in [u'dl', u'ol']:
+                        self.indentlevel = self.indentlevel + 4
+                        break
+                    elif prev_listtag == u'ul':
+                        self.indentlevel = self.indentlevel + 3
+                        break
+
+            if len(self.opentags) > 0:
+                self.handle_curdata()
+                if tag_name not in self.cancontainflow:
+                    self.opentags.pop()
+            self.opentags.append(tag_name)
+        else:
+            if tag_name == "span":
+                return
+            listcount = 0
+            try:
+                listcount = self.listcount[-1]
+            except:
+                pass
+
+            if tag_name == u'dd' and len(self.opentags) > 1 \
+                and self.opentags[-1] == u'dt':
+                self.handle_curdata()
+                self.opentags.pop()
+            elif tag_name == u'dt' and len(self.opentags) > 1 \
+                and self.opentags[-1] == u'dd':
+                self.handle_curdata()
+                self.opentags.pop()
+            elif tag_name == u'a':
+                for attr in attrs:
+                    if attr[0].lower() == u'href':
+                        self.urls.append(attr[1])
+                self.curdata = self.curdata + u'`'
+                self.opentags.append(tag_name)
+                return
+            elif tag_name == u'img':
+                self.handle_image(attrs)
+                return
+            elif tag_name == u'br':
+                self.handle_br()
+                return
             else:
-                self.text = self.text \
-                    + u' * ' \
-                    + u'\n   '.join([a.strip() for a in \
-                        textwrap.wrap(self.item, 67)]) \
-                    + u'\n'
-                self.item = u''
+                # we don't know the tag, so lets avoid handling it!
+                return 
 
     def handle_startendtag(self, tag, attrs):
-        if tag.lower() == "br":
+        if tag.lower() == u'br':
             self.handle_br()
+        elif tag.lower() == u'img':
+            self.handle_image(attrs)
+            return
 
     def handle_br(self):
-            if self.inparagraph:
-                self.text = self.text \
-                + u'\n'.join( \
-                    [a \
-                        for a in textwrap.wrap( \
-                            self.currentparagraph, 70) \
-                    ] \
-                ) \
-                + u'\n'
-                self.currentparagraph = u''
-            elif self.inblockquote:
-                self.text = self.text \
-                    + u'\n> ' \
-                    + u'\n> '.join( \
-                        [a \
-                            for a in textwrap.wrap( \
-                                self.blockquote.encode("utf-8") \
-                                , 68) \
-                        ] \
+            self.handle_curdata()
+            self.opentags.append(u'br')
+            self.handle_curdata()
+            self.opentags.pop()
+
+    def handle_image(self, attrs):
+        alt = u''
+        url = u''
+        for attr in attrs:
+            if attr[0] == 'alt':
+                alt = attr[1]
+            elif attr[0] == 'src':
+                url = attr[1]
+        if url:
+            self.curdata = self.curdata \
+                + u' [img:' \
+                + unicode( \
+                    url.encode('utf-8'), \
+                    'utf-8')
+            if alt:
+                self.curdata = self.curdata \
+                    + u'(' \
+                    + unicode( \
+                        alt.encode('utf-8'), \
+                        'utf-8') \
+                    + u')'
+            self.curdata = self.curdata \
+                + u']'
+
+    def handle_curdata(self):
+
+        if len(self.opentags) == 0:
+            return
+
+        tag_thats_done = self.opentags[-1]
+
+        if len(self.curdata) == 0:
+            return
+
+        if tag_thats_done == u'br':
+            if len(self.text) == 0 or self.text[-1] != '\n':
+                self.text = self.text + '\n'
+                self.ignorenodata = True
+            return
+
+        if len(self.curdata.strip()) == 0:
+            return
+
+        if tag_thats_done in self.blockleveltags:
+            newlinerequired = self.text != u''
+            if self.ignorenodata:
+                newlinerequired = False
+            self.ignorenodata = False
+            if newlinerequired \
+                and len(self.text) > 2 \
+                and self.text[-1] != u'\n' \
+                and self.text[-2] != u'\n':
+                    self.text = self.text + u'\n\n'
+
+        if tag_thats_done in ["h1", "h2", "h3", "h4", "h5", "h6"]:
+            underline = u''
+            underlinechar = u'='
+            headingtext = unicode( \
+                self.curdata.encode("utf-8").strip(), "utf-8")
+            seperator = u'\n' + u' '*self.indentlevel
+            headingtext = seperator.join( \
+                textwrap.wrap( \
+                    headingtext, \
+                    self.textwidth - self.indentlevel \
                     ) \
-                    + u'\n'
-                self.blockquote = u''
-            else:
-                self.text = self.text + "\n"
+                )
 
-    def handle_endtag(self, tag):
-        if tag.lower() == "h1":
-            self.inheadingone = False
-            self.text = self.text \
-                + u'\n\n' \
-                + self.headingtext.encode("utf-8") \
-                + u'\n' \
-                + u'=' * len(self.headingtext.encode("utf-8").strip())
-            self.headingtext = u''
-        elif tag.lower() == "h2":
-            self.inheadingtwo = False
+            if tag_thats_done == u'h2':
+                underlinechar = u'-'
+            elif tag_thats_done != u'h1':
+                underlinechar = u'~'
+
+            if u'\n' in headingtext:
+                underline = u' ' * self.indentlevel \
+                    + underlinechar * (self.textwidth - self.indentlevel)
+            else:
+                underline = u' ' * self.indentlevel \
+                    + underlinechar * len(headingtext)
             self.text = self.text \
-                + u'\n\n' \
-                + self.headingtext.encode("utf-8") \
-                + u'\n' \
-                + u'-' * len(self.headingtext.encode("utf-8").strip())
-            self.headingtext = u''
-        elif tag.lower() in ["h3", "h4", "h5", "h6"]:
-            self.inotherheading = False
+                + headingtext.encode("utf-8") + u'\n' \
+                + underline
+        elif tag_thats_done in [u'p', u'div']:
+            paragraph = unicode( \
+                self.curdata.strip().encode("utf-8"), "utf-8")
+            seperator = u'\n' + u' ' * self.indentlevel
             self.text = self.text \
-                + u'\n\n' \
-                + self.headingtext.encode("utf-8") \
-                + u'\n' \
-                + u'~' * len(self.headingtext.encode("utf-8").strip())
-            self.headingtext = u''
-        elif tag.lower() == "p":
+                + u' ' * self.indentlevel \
+                + seperator.join( \
+                    textwrap.wrap( \
+                        paragraph, self.textwidth - self.indentlevel))
+        elif tag_thats_done == "pre":
+            self.text = self.text + unicode( \
+                self.curdata.encode("utf-8"), "utf-8")
+        elif tag_thats_done == u'blockquote':
+            quote = unicode( \
+                self.curdata.encode("utf-8").strip(), "utf-8")
+            seperator = u'\n' + u' ' * self.indentlevel + u'> '
+            if len(self.text) > 0 and self.text[-1] != u'\n':
+                self.text = self.text + u'\n'
             self.text = self.text \
-                + u'\n'.join(textwrap.wrap( \
-                    self.currentparagraph, 70) \
+                + u'> ' \
+                + seperator.join( \
+                    textwrap.wrap( \
+                        quote, \
+                        self.textwidth - self.indentlevel - 2 \
+                    )
                 )
-            self.inparagraph = False
-            self.currentparagraph = u''
-        elif tag.lower() == "blockquote":
+            self.curdata = u''
+        elif tag_thats_done == "li":
+            item = unicode(self.curdata.encode("utf-8").strip(), "utf-8")
+            if len(self.text) > 0 and self.text[-1] != u'\n':
+                self.text = self.text + u'\n'
+            # work out if we're in an ol rather than a ul
+            latesttags = self.opentags[-4:]
+            latesttags.reverse()
+            isul = None
+            for thing in latesttags:
+                if thing == 'ul':
+                    isul = True
+                    break
+                elif thing == 'ol':
+                    isul = False
+                    break
+
+            listindent = 3
+            if not isul:
+                listindent = 4
+
+            listmarker = u' * '
+            if isul == False:
+                listmarker = u' %2d. ' %(self.listcount[-1])
+                self.listcount[-1] = self.listcount[-1] + 1
+
+            seperator = u'\n' \
+                + u' ' * self.indentlevel \
+                + u' ' * listindent
             self.text = self.text \
-                + u'\n> ' \
-                + u'\n> '.join( \
-                    [a.strip() \
-                        for a in textwrap.wrap( \
-                            self.blockquote, 68)] \
+                + u' ' * self.indentlevel \
+                + listmarker \
+                + seperator.join( \
+                    textwrap.wrap( \
+                        item, \
+                        self.textwidth - self.indentlevel - listindent \
                     ) \
-                + u'\n'
-            self.inblockquote = False
-            self.blockquote = u''
-        elif tag.lower() == "pre":
-            self.inpre = False
-        elif tag.lower() == "li":
-            self.initem = False
-            if self.item != "":
+                )
+            self.curdata = u''
+        elif tag_thats_done == u'dt':
+            definition = unicode(self.curdata.encode("utf-8").strip(), "utf-8")
+            if len(self.text) > 0 and self.text[-1] != u'\n':
+                self.text = self.text + u'\n\n'
+            elif len(self.text) > 1 and self.text[-2] != u'\n':
+                self.text = self.text + u'\n'
+            definition = u' ' * self.indentlevel + definition + "::"
+            indentstring = u'\n' + u' ' * (self.indentlevel + 1)
+            self.text = self.text \
+                + indentstring.join(
+                    textwrap.wrap(definition, \
+                        self.textwidth - self.indentlevel - 1))
+            self.curdata = u''
+        elif tag_thats_done == u'dd':
+            definition = unicode(self.curdata.encode("utf-8").strip(), "utf-8")
+            if len(definition) > 0:
+                if len(self.text) > 0 and self.text[-1] != u'\n':
+                    self.text = self.text + u'\n'
+                indentstring = u'\n' + u' ' * (self.indentlevel + 4)
                 self.text = self.text \
-                    + u' * ' \
-                    + u'\n   '.join( \
-                        [a.strip() for a in textwrap.wrap(self.item, 67)]) \
-                    + u'\n'
-            self.item = u''
-        elif tag.lower() == "ul":
-            self.inul = False
+                    + u' ' * (self.indentlevel + 4) \
+                    + indentstring.join( \
+                        textwrap.wrap( \
+                            definition, \
+                            self.textwidth - self.indentlevel - 4 \
+                            ) \
+                        )
+                self.curdata = u''
+        elif tag_thats_done == u'a':
+            self.curdata = self.curdata + u'`__'
+            pass
+        elif tag_thats_done in self.liststarttags:
+            pass
+
+        if tag_thats_done in self.blockleveltags:
+            self.curdata = u''
+
+        self.ignorenodata = False
 
-    def handle_data(self, data):
-        if self.inheadingone or self.inheadingtwo or self.inotherheading:
-            self.headingtext = self.headingtext \
-                + unicode(data, "utf-8").strip() \
-                + u' '
-        elif self.inblockquote:
-            self.blockquote = self.blockquote \
-                + unicode(data, "utf-8").strip() \
-                + u' '
-        elif self.inparagraph:
-            self.currentparagraph = self.currentparagraph \
-                + unicode(data, "utf-8").strip() \
-                + u' '
-        elif self.inul and self.initem:
-            self.item = self.item + unicode(data, "utf-8")
-        elif self.inpre:
-            self.text = self.text + unicode(data, "utf-8")
+    def handle_endtag(self, tag):
+        self.ignorenodata = False
+        if tag == "span":
+            return
+
+        try:
+            tagindex = self.opentags.index(tag)
+        except:
+            return
+        tag = tag.lower()
+
+        if tag in [u'br', u'img']:
+            return
+
+        if tag in self.liststarttags:
+            if tag in [u'ol', u'dl', u'ul']:
+                self.handle_curdata()
+                # find if there was a previous list level
+                smalllist = self.opentags[:-1]
+                smalllist.reverse()
+                for prev_listtag in smalllist:
+                    if prev_listtag in [u'ol', u'dl']:
+                        self.indentlevel = self.indentlevel - 4
+                        break
+                    elif prev_listtag == u'ul':
+                        self.indentlevel = self.indentlevel - 3
+                        break
+
+        if tag == u'ol':
+            self.listcount = self.listcount[:-1]
+
+        while tagindex < len(self.opentags) \
+            and tag in self.opentags[tagindex+1:]:
+            try:
+                tagindex = self.opentags.index(tag, tagindex+1)
+            except:
+                # well, we don't want to do that then
+                pass
+        if tagindex != len(self.opentags) - 1:
+            # Assuming the data was for the last opened tag first
+            self.handle_curdata()
+            # Now kill the list to be a slice before this tag was opened
+            self.opentags = self.opentags[:tagindex + 1]
         else:
-            self.text = self.text + unicode(data, "utf-8").strip() + u' '
+            self.handle_curdata()
+            if self.opentags[-1] == tag:
+                self.opentags.pop()
+
+    def handle_data(self, data):
+        if len(self.opentags) == 0:
+            self.opentags.append(u'p')
+        self.curdata = self.curdata + unicode(data, "utf-8")
 
     def handle_entityref(self, name):
         entity = name
-        if entities.has_key(name.lower()):
-            entity = entities[name.lower()]
+        if HTML2Text.entities.has_key(name.lower()):
+            entity = HTML2Text.entities[name.lower()]
         elif name[0] == "#":
             entity = unichr(int(name[1:]))
         else:
             entity = "&" + name + ";"
 
-        if self.inparagraph:
-            self.currentparagraph = self.currentparagraph \
-                + unicode(entity, "utf-8")
-        elif self.inblockquote:
-            self.blockquote = self.blockquote + unicode(entity, "utf-8")
-        else:
-            self.text = self.text + unicode(entity, "utf-8")
+        self.curdata = self.curdata + unicode(entity, "utf-8")
 
     def gettext(self):
-        data = self.text
-        if self.inparagraph:
-            data = data + "\n".join(textwrap.wrap(self.currentparagraph, 70))
-        return data
+        self.handle_curdata()
+        if len(self.text) == 0 or self.text[-1] != u'\n':
+            self.text = self.text + u'\n'
+        self.opentags = []
+        if len(self.text) > 0:
+            while len(self.text) > 1 and self.text[-1] == u'\n':
+                self.text = self.text[:-1]
+            self.text = self.text + u'\n'
+        if len(self.urls) > 0:
+            self.text = self.text + u'\n__ ' + u'\n__ '.join(self.urls) + u'\n'
+            self.urls = []
+        return self.text
+
+def open_url(method, url):
+    redirectcount = 0
+    while redirectcount < 3:
+        (type, rest) = urllib.splittype(url)
+        (host, path) = urllib.splithost(rest)
+        (host, port) = urllib.splitport(host)
+        if port == None:
+            port = 80
+        try:
+            conn = httplib.HTTPConnection("%s:%s" %(host, port))
+            conn.request(method, path)
+            response = conn.getresponse()
+            if response.status in [301, 302, 303, 307]:
+                headers = response.getheaders()
+                for header in headers:
+                    if header[0] == "location":
+                        url = header[1]
+            elif response.status == 200:
+                return response
+        except:
+            pass
+        redirectcount = redirectcount + 1
+    return None
 
 def parse_and_deliver(maildir, url, statedir):
-    fp = feedparser.parse(url)
+    feedhandle = None
+    headers = None
+    # first check if we know about this feed already
+    feeddb = dbm.open(os.path.join(statedir, "feeds"), "c")
+    if feeddb.has_key(url):
+        data = feeddb[url]
+        data = cgi.parse_qs(data)
+        response = open_url("HEAD", url)
+        headers = None
+        if response:
+            headers = response.getheaders()
+        ischanged = False
+        try:
+            for header in headers:
+                if header[0] == "content-length":
+                    if header[1] != data["content-length"][0]:
+                        ischanged = True
+                elif header[0] == "etag":
+                    if header[1] != data["etag"][0]:
+                        ischanged = True
+                elif header[0] == "last-modified":
+                    if header[1] != data["last-modified"][0]:
+                        ischanged = True
+                elif header[0] == "content-md5":
+                    if header[1] != data["content-md5"][0]:
+                        ischanged = True
+        except:
+            ischanged = True
+        if ischanged:
+            response = open_url("GET", url)
+            if response != None:
+                headers = response.getheaders()
+                feedhandle = response
+            else:
+                sys.stderr.write("Failed to fetch feed: %s\n" %(url))
+                return
+        else:
+            return # don't need to do anything, nothings changed.
+    else:
+        response = open_url("GET", url)
+        if response != None:
+            headers = response.getheaders()
+            feedhandle = response
+        else:
+            sys.stderr.write("Failed to fetch feed: %s\n" %(url))
+            return
+
+    fp = feedparser.parse(feedhandle)
     db = dbm.open(os.path.join(statedir, "seen"), "c")
     for item in fp["items"]:
         # have we seen it before?
@@ -267,6 +525,15 @@ def parse_and_deliver(maildir, url, statedir):
 
         prevmessageid = None
 
+        # check if there's a guid too - if that exists and we match the md5,
+        # return
+        if item.has_key("guid"):
+            if db.has_key(url + "|" + item["guid"]):
+                data = db[url + "|" + item["guid"]]
+                data = cgi.parse_qs(data)
+                if data["contentmd5"][0] == md5sum:
+                    continue
+
         if db.has_key(url + "|" + item["link"]):
             data = db[url + "|" + item["link"]]
             data = cgi.parse_qs(data)
@@ -296,16 +563,29 @@ def parse_and_deliver(maildir, url, statedir):
         msg.add_header("To", "\"%s\" <rss2maildir@localhost>" %(url))
         if prevmessageid:
             msg.add_header("References", prevmessageid)
-        createddate = datetime.datetime(*item["updated_parsed"][0:6]) \
+        createddate = datetime.datetime.now() \
             .strftime("%a, %e %b %Y %T -0000")
+        try:
+            createddate = datetime.datetime(*item["updated_parsed"][0:6]) \
+                .strftime("%a, %e %b %Y %T -0000")
+        except:
+            pass
         msg.add_header("Date", createddate)
         msg.add_header("Subject", item["title"])
         msg.set_default_type("text/plain")
 
-        htmlpart = MIMEText(content.encode("utf-8"), "html", "utf-8")
+        htmlcontent = content.encode("utf-8")
+        htmlcontent = "%s\n\n<p>Item URL: <a href='%s'>%s</a></p>" %( \
+            content, \
+            item["link"], \
+            item["link"] )
+        htmlpart = MIMEText(htmlcontent.encode("utf-8"), "html", "utf-8")
         textparser = HTML2Text()
         textparser.feed(content.encode("utf-8"))
         textcontent = textparser.gettext()
+        textcontent = "%s\n\nItem URL: %s" %( \
+            textcontent, \
+            item["link"] )
         textpart = MIMEText(textcontent.encode("utf-8"), "plain", "utf-8")
         msg.attach(textpart)
         msg.attach(htmlpart)
@@ -332,187 +612,221 @@ def parse_and_deliver(maildir, url, statedir):
         # now add to the database about the item
         if prevmessageid:
             messageid = prevmessageid + " " + messageid
-        data = urllib.urlencode((
-            ("message-id", messageid), \
-            ("created", createddate), \
-            ("contentmd5", md5sum) \
-            ))
-        db[url + "|" + item["link"]] = data
+        if item.has_key("guid") and item["guid"] != item["link"]:
+            data = urllib.urlencode(( \
+                ("message-id", messageid), \
+                ("created", createddate), \
+                ("contentmd5", md5sum) \
+                ))
+            db[url + "|" + item["guid"]] = data
+            try:
+                data = db[url + "|" + item["link"]]
+                data = cgi.parse_qs(data)
+                newdata = urllib.urlencode(( \
+                    ("message-id", messageid), \
+                    ("created", data["created"][0]), \
+                    ("contentmd5", data["contentmd5"][0]) \
+                    ))
+                db[url + "|" + item["link"]] = newdata
+            except:
+                db[url + "|" + item["link"]] = data
+        else:
+            data = urllib.urlencode(( \
+                ("message-id", messageid), \
+                ("created", createddate), \
+                ("contentmd5", md5sum) \
+                ))
+            db[url + "|" + item["link"]] = data
+
+    if headers:
+        data = []
+        for header in headers:
+            if header[0] in \
+                ["content-md5", "etag", "last-modified", "content-length"]:
+                data.append((header[0], header[1]))
+        if len(data) > 0:
+            data = urllib.urlencode(data)
+            feeddb[url] = data
 
     db.close()
+    feeddb.close()
 
-# first off, parse the command line arguments
+if __name__ == "__main__":
+    # This only gets executed if we really called the program
+    # first off, parse the command line arguments
 
-oparser = OptionParser()
-oparser.add_option(
-    "-c", "--conf", dest="conf",
-    help="location of config file"
-    )
-oparser.add_option(
-    "-s", "--statedir", dest="statedir",
-    help="location of directory to store state in"
-    )
+    oparser = OptionParser()
+    oparser.add_option(
+        "-c", "--conf", dest="conf",
+        help="location of config file"
+        )
+    oparser.add_option(
+        "-s", "--statedir", dest="statedir",
+        help="location of directory to store state in"
+        )
 
-(options, args) = oparser.parse_args()
+    (options, args) = oparser.parse_args()
 
-# check for the configfile
+    # check for the configfile
 
-configfile = None
+    configfile = None
 
-if options.conf != None:
-    # does the file exist?
-    try:
-        os.stat(options.conf)
-        configfile = options.conf
-    except:
-        # should exit here as the specified file doesn't exist
-        sys.stderr.write( \
-            "Config file %s does not exist. Exiting.\n" %(options.conf,))
-        sys.exit(2)
-else:
-    # check through the default locations
-    try:
-        os.stat("%s/.rss2maildir.conf" %(os.environ["HOME"],))
-        configfile = "%s/.rss2maildir.conf" %(os.environ["HOME"],)
-    except:
+    if options.conf != None:
+        # does the file exist?
         try:
-            os.stat("/etc/rss2maildir.conf")
-            configfile = "/etc/rss2maildir.conf"
+            os.stat(options.conf)
+            configfile = options.conf
         except:
-            sys.stderr.write("No config file found. Exiting.\n")
+            # should exit here as the specified file doesn't exist
+            sys.stderr.write( \
+                "Config file %s does not exist. Exiting.\n" %(options.conf,))
             sys.exit(2)
+    else:
+        # check through the default locations
+        try:
+            os.stat("%s/.rss2maildir.conf" %(os.environ["HOME"],))
+            configfile = "%s/.rss2maildir.conf" %(os.environ["HOME"],)
+        except:
+            try:
+                os.stat("/etc/rss2maildir.conf")
+                configfile = "/etc/rss2maildir.conf"
+            except:
+                sys.stderr.write("No config file found. Exiting.\n")
+                sys.exit(2)
 
-# Right - if we've got this far, we've got a config file, now for the hard
-# bits...
+    # Right - if we've got this far, we've got a config file, now for the hard
+    # bits...
 
-scp = SafeConfigParser()
-scp.read(configfile)
+    scp = SafeConfigParser()
+    scp.read(configfile)
 
-maildir_root = "RSSMaildir"
-state_dir = "state"
+    maildir_root = "RSSMaildir"
+    state_dir = "state"
 
-if options.statedir != None:
-    state_dir = options.statedir
-    try:
-        mode = os.stat(state_dir)[stat.ST_MODE]
-        if not stat.S_ISDIR(mode):
-            sys.stderr.write( \
-                "State directory (%s) is not a directory\n" %(state_dir))
-            sys.exit(1)
-    except:
-        # try to make the directory
+    if options.statedir != None:
+        state_dir = options.statedir
         try:
-            os.mkdir(state_dir)
+            mode = os.stat(state_dir)[stat.ST_MODE]
+            if not stat.S_ISDIR(mode):
+                sys.stderr.write( \
+                    "State directory (%s) is not a directory\n" %(state_dir))
+                sys.exit(1)
         except:
-            sys.stderr.write("Couldn't create statedir %s" %(state_dir))
-            sys.exit(1)
-elif scp.has_option("general", "state_dir"):
-    new_state_dir = scp.get("general", "state_dir")
-    try:
-        mode = os.stat(state_dir)[stat.ST_MODE]
-        if not stat.S_ISDIR(mode):
-            sys.stderr.write( \
-                "State directory (%s) is not a directory\n" %(state_dir))
-            sys.exit(1)
-    except:
-        # try to create it
+            # try to make the directory
+            try:
+                os.mkdir(state_dir)
+            except:
+                sys.stderr.write("Couldn't create statedir %s" %(state_dir))
+                sys.exit(1)
+    elif scp.has_option("general", "state_dir"):
+        new_state_dir = scp.get("general", "state_dir")
         try:
-            os.mkdir(new_state_dir)
-            state_dir = new_state_dir
+            mode = os.stat(state_dir)[stat.ST_MODE]
+            if not stat.S_ISDIR(mode):
+                sys.stderr.write( \
+                    "State directory (%s) is not a directory\n" %(state_dir))
+                sys.exit(1)
         except:
-            sys.stderr.write( \
-                "Couldn't create state directory %s\n" %(new_state_dir))
-            sys.exit(1)
-else:
+            # try to create it
+            try:
+                os.mkdir(new_state_dir)
+                state_dir = new_state_dir
+            except:
+                sys.stderr.write( \
+                    "Couldn't create state directory %s\n" %(new_state_dir))
+                sys.exit(1)
+    else:
+        try:
+            mode = os.stat(state_dir)[stat.ST_MODE]
+            if not stat.S_ISDIR(mode):
+                sys.stderr.write( \
+                    "State directory %s is not a directory\n" %(state_dir))
+                sys.exit(1)
+        except:
+            try:
+                os.mkdir(state_dir)
+            except:
+                sys.stderr.write( \
+                    "State directory %s could not be created\n" %(state_dir))
+                sys.exit(1)
+
+    if scp.has_option("general", "maildir_root"):
+        maildir_root = scp.get("general", "maildir_root")
+
     try:
-        mode = os.stat(state_dir)[stat.ST_MODE]
+        mode = os.stat(maildir_root)[stat.ST_MODE]
         if not stat.S_ISDIR(mode):
             sys.stderr.write( \
-                "State directory %s is not a directory\n" %(state_dir))
+                "Maildir Root %s is not a directory\n" \
+                %(maildir_root))
             sys.exit(1)
     except:
         try:
-            os.mkdir(state_dir)
+            os.mkdir(maildir_root)
         except:
-            sys.stderr.write( \
-                "State directory %s could not be created\n" %(state_dir))
+            sys.stderr.write("Couldn't create Maildir Root %s\n" \
+                %(maildir_root))
             sys.exit(1)
 
-if scp.has_option("general", "maildir_root"):
-    maildir_root = scp.get("general", "maildir_root")
-
-try:
-    mode = os.stat(maildir_root)[stat.ST_MODE]
-    if not stat.S_ISDIR(mode):
-        sys.stderr.write( \
-            "Maildir Root %s is not a directory\n" \
-            %(maildir_root))
-        sys.exit(1)
-except:
-    try:
-        os.mkdir(maildir_root)
-    except:
-        sys.stderr.write("Couldn't create Maildir Root %s\n" %(maildir_root))
-        sys.exit(1)
-
-feeds = scp.sections()
-try:
-    feeds.remove("general")
-except:
-    pass
-
-for section in feeds:
-    # check if the directory exists
-    maildir = None
+    feeds = scp.sections()
     try:
-        maildir = scp.get(section, "maildir")
+        feeds.remove("general")
     except:
-        maildir = section
+        pass
 
-    maildir = urllib.urlencode(((section, maildir),)).split("=")[1]
-    maildir = os.path.join(maildir_root, maildir)
+    for section in feeds:
+        # check if the directory exists
+        maildir = None
+        try:
+            maildir = scp.get(section, "maildir")
+        except:
+            maildir = section
 
-    try:
-        exists = os.stat(maildir)
-        if stat.S_ISDIR(exists[stat.ST_MODE]):
-            # check if there's a new, cur and tmp directory
+        maildir = urllib.urlencode(((section, maildir),)).split("=")[1]
+        maildir = os.path.join(maildir_root, maildir)
+
+        try:
+            exists = os.stat(maildir)
+            if stat.S_ISDIR(exists[stat.ST_MODE]):
+                # check if there's a new, cur and tmp directory
+                try:
+                    mode = os.stat(os.path.join(maildir, "cur"))[stat.ST_MODE]
+                except:
+                    os.mkdir(os.path.join(maildir, "cur"))
+                    if not stat.S_ISDIR(mode):
+                        sys.stderr.write("Broken maildir: %s\n" %(maildir))
+                try:
+                    mode = os.stat(os.path.join(maildir, "tmp"))[stat.ST_MODE]
+                except:
+                    os.mkdir(os.path.join(maildir, "tmp"))
+                    if not stat.S_ISDIR(mode):
+                        sys.stderr.write("Broken maildir: %s\n" %(maildir))
+                try:
+                    mode = os.stat(os.path.join(maildir, "new"))[stat.ST_MODE]
+                    if not stat.S_ISDIR(mode):
+                        sys.stderr.write("Broken maildir: %s\n" %(maildir))
+                except:
+                    os.mkdir(os.path.join(maildir, "new"))
+            else:
+                sys.stderr.write("Broken maildir: %s\n" %(maildir))
+        except:
             try:
-                mode = os.stat(os.path.join(maildir, "cur"))[stat.ST_MODE]
+                os.mkdir(maildir)
             except:
-                os.mkdir(os.path.join(maildir, "cur"))
-                if not stat.S_ISDIR(mode):
-                    sys.stderr.write("Broken maildir: %s\n" %(maildir))
+                sys.stderr.write("Couldn't create root maildir %s\n" \
+                    %(maildir))
+                sys.exit(1)
             try:
-                mode = os.stat(os.path.join(maildir, "tmp"))[stat.ST_MODE]
-            except:
+                os.mkdir(os.path.join(maildir, "new"))
+                os.mkdir(os.path.join(maildir, "cur"))
                 os.mkdir(os.path.join(maildir, "tmp"))
-                if not stat.S_ISDIR(mode):
-                    sys.stderr.write("Broken maildir: %s\n" %(maildir))
-            try:
-                mode = os.stat(os.path.join(maildir, "new"))[stat.ST_MODE]
-                if not stat.S_ISDIR(mode):
-                    sys.stderr.write("Broken maildir: %s\n" %(maildir))
             except:
-                os.mkdir(os.path.join(maildir, "new"))
-        else:
-            sys.stderr.write("Broken maildir: %s\n" %(maildir))
-    except:
-        try:
-            os.mkdir(maildir)
-        except:
-            sys.stderr.write("Couldn't create root maildir %s\n" %(maildir))
-            sys.exit(1)
-        try:
-            os.mkdir(os.path.join(maildir, "new"))
-            os.mkdir(os.path.join(maildir, "cur"))
-            os.mkdir(os.path.join(maildir, "tmp"))
-        except:
-            sys.stderr.write( \
-                "Couldn't create required maildir directories for %s\n" \
-                %(section,))
-            sys.exit(1)
+                sys.stderr.write( \
+                    "Couldn't create required maildir directories for %s\n" \
+                    %(section,))
+                sys.exit(1)
 
-    # right - we've got the directories, we've got the section, we know the
-    # url... lets play!
+        # right - we've got the directories, we've got the section, we know the
+        # url... lets play!
 
-    parse_and_deliver(maildir, section, state_dir)
+        parse_and_deliver(maildir, section, state_dir)