# A simple and limited RSS feed parser used in the RSS reader example.

# Copyright (c) 2005 Nokia Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


import re
import urllib

def parse(url):
    return parse_feed(urllib.urlopen(url).read())

def parse_feed(text):
    feed={}
    items=[]
    currentitem=[{}]

    def clean_entities(text): return re.sub('&[#0-9a-z]+;','?',text)
    def clean_lf(text): return re.sub('[\n\t\r]',' ',text)

    def end_a(tag,content): write('LINK(%s)'%gettext())
    def start_item(tag,content):
        gettext()
        write(content)
        currentitem[0]={}
    def end_item(tag,content):
        items.append(currentitem[0])
        currentitem[0]={}
    def end_link(tag,content):
        if within('item'):
            currentitem[0]['link']=gettext()
    def end_description(tag,content):
        if within('item'):
            currentitem[0]['summary']=clean_entities(gettext())
    def end_title(tag,content):
        text=clean_lf(gettext()).strip()
        if within('item'):
            currentitem[0]['title']=text
        elif parentis('channel'):
            feed['title']=text
            
    tagre=re.compile('([^ \n\t]+)(.*)>(.*)',re.S)
    tagpath=[]
    textbuffer=[[]]
    assumed_encoding='latin-1'
    lines=text.split('<')
    def start_default(tag,content): write(content)
    def end_default(tag,content): pass
    def tag_default(tag,content): pass
    def write(text): textbuffer[0].append(text)
    def gettext():
        text=''.join(textbuffer[0])
        textbuffer[0]=[]
        return unicode(text,assumed_encoding)
    def current_tag(): return tagpath[-1]
    def current_path(): return '/'.join(tagpath)
    def within(tag): return tag in tagpath
    def parentis(tag): return current_tag()==tag
    for k in lines:
        m=tagre.match(k)
        if m:
            (tag,attributes,content)=m.groups()
            if tag.startswith('?'):
                continue
            if tag.startswith('/'):
                tagname=tag[1:]
                handler='end_%s'%tagname
                generic_handler=end_default
                if current_tag() != tagname:
                    pass # Unbalanced tags, just ignore for now.
                del tagpath[-1]
            elif tag.endswith('/'):
                tagname=tag[0:-1]
                handler='tag_%s'%tagname
                generic_handler=tag_default
            else:
                tagname=tag
                handler='start_%s'%tagname
                generic_handler=start_default
                tagpath.append(tagname)
            locals().get(handler,generic_handler)(tagname,content)
        else:
            pass # Malformed line, just ignore.
        
    feed['entries']=items
    return feed