# XML "function" nodes that evaluate their contents to text

import datetime

import exc

import xml_dom

class SyntaxException(Exception):

    def __init__(self, cause=None):

        Exception.__init__(self, 'Invalid syntax in XML function: '+str(cause))

def map_items(func, items):

    return [(name, func(value)) for name, value in items]

def conv_items(type_, items):

    try: return map_items(type_, items)

    except ValueError, e: raise SyntaxException(e)

def alt(items):

    items = list(items)

    items.sort()

    return items[0][1] # value of lowest-numbered item

def range_(items):

    items = dict(conv_items(float, items))

    try:

        to = items['to']

        from_ = items['from']

    except KeyError, e: raise SyntaxException(e)

    return str(to - from_)

def avg(items):

    count = 0

    sum_ = 0.

    for name, value in conv_items(float, items):

        count += 1

        sum_ += value

    return str(sum_/count)

def date(items):

    items = dict(items)

    if 'date' in items:

        str_ = items['date']

        try: year = float(str_)

        except ValueError:

            try: import dateutil.parser

            except ImportError: return str_

            try: date = dateutil.parser.parse(str_)

            except ValueError, e: raise SyntaxException(e)

        else: date = (datetime.date(int(year), 1, 1) +

            datetime.timedelta(round((year % 1.)*365)))

    else:

        def get_part(part, default=1):

            val = items.get(part, default)

            if val == 0: val = default

            return val

        year = get_part('year', 1900)

        month = get_part('month')

        day = get_part('day')

        try:

            year = int(year)

            month = int(month)

            day = int(day)

            date = datetime.date(year, month, day)

        except ValueError, e: raise SyntaxException(e)

    try: return date.strftime('%Y-%m-%d')

    except ValueError, e: raise SyntaxException(e)

_name_parts_slices_items = [

    ('first', slice(None, 1)),

    ('middle', slice(1, -1)),

    ('last', slice(-1, None)),

]

name_parts_slices = dict(_name_parts_slices_items)

name_parts = [name for name, slice_ in _name_parts_slices_items]

def name(items):

    items = dict(items)

    parts = []

    for part in name_parts:

        if part in items: parts.append(items[part])

    return ' '.join(parts)

def name_part(items):

    out_items = []

    for part, value in items:

        try: slice_ = name_parts_slices[part]

        except KeyError, e: raise SyntaxException(e)

        else: out_items.append((part, ' '.join(value.split(' ')[slice_])))

    return name(out_items)

# Function names must start with _ to avoid collisions with real tags

# Functions take arguments (items)

funcs = {'_alt': alt, '_range': range_, '_avg': avg, '_date': date,

    '_name': name, '_namePart': name_part}

def process(node, on_error=exc.raise_):

    for child in xml_dom.NodeElemIter(node): process(child, on_error)

    name = node.tagName

    if name.startswith('_') and name in funcs:

        try: value = funcs[name](xml_dom.NodeTextEntryIter(node))

        except SyntaxException, e:

            str_ = str(node)

            exc.add_msg(e, 'function:\n'+str_)

            xml_dom.replace(node, node.ownerDocument.createComment('\n'+str_))

            on_error(e)

        else: xml_dom.replace_with_text(node, value)