# -*- coding: iso-8859-1 -*- """     MoinMoin - EventAggregator library      @copyright: 2008, 2009 by Paul Boddie <paul@boddie.org.uk>     @copyright: 2000-2004 Juergen Hermann <jh@web.de>,                 2005-2008 MoinMoin:ThomasWaldmann.     @license: GNU GPL (v2 or later), see COPYING.txt for details. """  from MoinMoin.Page import Page from MoinMoin import search, version from MoinMoin import wikiutil import calendar import datetime import time import re  __version__ = "0.3"  # Date labels.  month_labels = ["January", "February", "March", "April", "May", "June",     "July", "August", "September", "October", "November", "December"] weekday_labels = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]  # Regular expressions where MoinMoin does not provide the required support.  category_regexp = None definition_list_regexp = re.compile(ur'^\s+(?P<term>.*?)::\s(?P<desc>.*?)$', re.UNICODE | re.MULTILINE) date_regexp = re.compile(ur'(?P<year>[0-9]{4})-(?P<month>[0-9]{2})-(?P<day>[0-9]{2})', re.UNICODE) month_regexp = re.compile(ur'(?P<year>[0-9]{4})-(?P<month>[0-9]{2})', re.UNICODE) verbatim_regexp = re.compile(ur'(?:'     ur'<<Verbatim\((?P<verbatim>.*?)\)>>'     ur'|'     ur'\[\[Verbatim\((?P<verbatim2>.*?)\)\]\]'     ur'|'     ur'`(?P<monospace>.*?)`'     ur'|'     ur'{{{(?P<preformatted>.*?)}}}'     ur')', re.UNICODE)  # Utility functions.  def isMoin15():     return version.release.startswith("1.5.")  def getCategoryPattern(request):     global category_regexp      try:         return request.cfg.cache.page_category_regexact     except AttributeError:          # Use regular expression from MoinMoin 1.7.1 otherwise.          if category_regexp is None:             category_regexp = re.compile(u'^%s$' % ur'(?P<all>Category(?P<key>(?!Template)\S+))', re.UNICODE)         return category_regexp  # Action support functions.  def getCategories(request):      """     From the AdvancedSearch macro, return a list of category page names using     the given 'request'.     """      # This will return all pages with "Category" in the title.      cat_filter = getCategoryPattern(request).search     return request.rootpage.getPageList(filter=cat_filter)  def getCategoryMapping(category_pagenames, request):      """     For the given 'category_pagenames' return a list of tuples of the form     (category name, category page name) using the given 'request'.     """      cat_pattern = getCategoryPattern(request)     mapping = []     for pagename in category_pagenames:         name = cat_pattern.match(pagename).group("key")         if name != "Category":             mapping.append((name, pagename))     mapping.sort()     return mapping  def getPageRevision(page):      # From Page.edit_info...      if hasattr(page, "editlog_entry"):         line = page.editlog_entry()     else:         line = page._last_edited(page.request) # MoinMoin 1.5.x and 1.6.x      timestamp = line.ed_time_usecs     mtime = wikiutil.version2timestamp(long(timestamp)) # must be long for py 2.2.x     return {"timestamp" : time.gmtime(mtime), "comment" : line.comment}  def getHTTPTimeString(tmtuple):     return "%s, %02d %s %04d %02d:%02d:%02d GMT" % (         weekday_labels[tmtuple.tm_wday],         tmtuple.tm_mday,         month_labels[tmtuple.tm_mon -1], # zero-based labels         tmtuple.tm_year,         tmtuple.tm_hour,         tmtuple.tm_min,         tmtuple.tm_sec         )  # The main activity functions.  def getPages(pagename, request):      "Return the links minus category links for 'pagename' using the 'request'."      query = search.QueryParser().parse_query('category:%s' % pagename)     if isMoin15():         results = search.searchPages(request, query)         results.sortByPagename()     else:         results = search.searchPages(request, query, "page_name")      cat_pattern = getCategoryPattern(request)     pages = []     for page in results.hits:         if not cat_pattern.match(page.page_name):             pages.append(page)     return pages  def getSimpleWikiText(text):      """     Return the plain text representation of the given 'text' which may employ     certain Wiki syntax features, such as those providing verbatim or monospaced     text.     """      # NOTE: Re-implementing support for verbatim text and linking avoidance.      return "".join([s for s in verbatim_regexp.split(text) if s is not None])  def getFormat(page):      "Get the format used on 'page'."      if isMoin15():         return "wiki" # page.pi_format     else:         return page.pi["format"]  def getEventDetails(page):      "Return a dictionary of event details from the given 'page'."      event_details = {}      if getFormat(page) == "wiki":         for match in definition_list_regexp.finditer(page.get_raw_body()):              # Permit case-insensitive list terms.              term = match.group("term").lower()             desc = match.group("desc")              # Special value type handling.              # Dates.              if term in ("start", "end"):                 desc = getDate(desc)              # Lists (whose elements may be quoted).              elif term in ("topics", "categories"):                 desc = [getSimpleWikiText(value.strip()) for value in desc.split(",")]              # Labels which may well be quoted.              elif term in ("title", "summary", "description"):                 desc = getSimpleWikiText(desc)              if desc is not None:                 event_details[term] = desc      return event_details  def getEventSummary(event_page, event_details):      """     Return either the given title or summary of the event described by the given     'event_page', according to the given 'event_details', or return the pretty     version of the page name.     """      if event_details.has_key("title"):         return event_details["title"]     elif event_details.has_key("summary"):         return event_details["summary"]     else:         return getPrettyPageName(event_page)  def getDate(s):      "Parse the string 's', extracting and returning a date string."      m = date_regexp.search(s)     if m:         return tuple(map(int, m.groups()))     else:         return None  def getMonth(s):      "Parse the string 's', extracting and returning a month string."      m = month_regexp.search(s)     if m:         return tuple(map(int, m.groups()))     else:         return None  def getCurrentMonth():      "Return the current month as a (year, month) tuple."      today = datetime.date.today()     return (today.year, today.month)  def getCurrentYear():      "Return the current year."      today = datetime.date.today()     return today.year  def monthupdate(date, n):      "Return 'date' updated by 'n' months."      if n < 0:         fn = prevmonth     else:         fn = nextmonth      i = 0     while i < abs(n):         date = fn(date)         i += 1              return date  def daterange(first, last, step=1):      """     Get the range of dates starting at 'first' and ending on 'last', using the     specified 'step'.     """      results = []      months_only = len(first) == 2     start_year = first[0]     end_year = last[0]      for year in range(start_year, end_year + step, step):         if step == 1 and year < end_year:             end_month = 12         elif step == -1 and year > end_year:             end_month = 1         else:             end_month = last[1]          if step == 1 and year > start_year:             start_month = 1         elif step == -1 and year < start_year:             start_month = 12         else:             start_month = first[1]          for month in range(start_month, end_month + step, step):             if months_only:                 results.append((year, month))             else:                 if step == 1 and month < end_month:                     _wd, end_day = calendar.monthrange(year, month)                 elif step == -1 and month > end_month:                     end_day = 1                 else:                     end_day = last[2]                  if step == 1 and month > start_month:                     start_day = 1                 elif step == -1 and month < start_month:                     _wd, start_day = calendar.monthrange(year, month)                 else:                     start_day = first[2]                  for day in range(start_day, end_day + step, step):                     results.append((year, month, day))      return results  def nextdate(date):      "Return the date following the given 'date'."      year, month, day = date     _wd, end_day = calendar.monthrange(year, month)     if day == end_day:         if month == 12:             return (year + 1, 1, 1)         else:             return (year, month + 1, 1)     else:         return (year, month, day + 1)  def prevdate(date):      "Return the date preceding the given 'date'."      year, month, day = date     if day == 1:         if month == 1:             return (year - 1, 12, 31)         else:             _wd, end_day = calendar.monthrange(year, month - 1)             return (year, month - 1, end_day)     else:         return (year, month, day - 1)  def nextmonth(date):      "Return the (year, month) tuple following 'date'."      year, month = date     if month == 12:         return (year + 1, 1)     else:         return year, month + 1  def prevmonth(date):      "Return the (year, month) tuple preceding 'date'."      year, month = date     if month == 1:         return (year - 1, 12)     else:         return year, month - 1  def span(start, end):      "Return the difference between 'start' and 'end'."      return end[0] - start[0], end[1] - start[1]  def getEvents(request, category_names, calendar_start=None, calendar_end=None):      """     Using the 'request', generate a list of events found on pages belonging to     the specified 'category_names', using the optional 'calendar_start' and     'calendar_end' month tuples of the form (year, month) to indicate a window     of interest.      Return a list of events, a dictionary mapping months to event lists (within     the window of interest), a list of all events within the window of interest,     the earliest month of an event within the window of interest, and the latest     month of an event within the window of interest.     """      # Re-order the window, if appropriate.      if calendar_start is not None and calendar_end is not None and calendar_start > calendar_end:         calendar_start, calendar_end = calendar_end, calendar_start      events = []     shown_events = {}     all_shown_events = []     processed_pages = set()      earliest = None     latest = None      for category_name in category_names:          # Get the pages and page names in the category.          pages_in_category = getPages(category_name, request)          # Visit each page in the category.          for page_in_category in pages_in_category:             pagename = page_in_category.page_name              # Only process each page once.              if pagename in processed_pages:                 continue             else:                 processed_pages.add(pagename)              # Get a real page, not a result page.              real_page_in_category = Page(request, pagename)             event_details = getEventDetails(real_page_in_category)              # Define the event as the page together with its details.              event = (real_page_in_category, event_details)             events.append(event)              # Test for the suitability of the event.              if event_details.has_key("start") and event_details.has_key("end"):                  start_month = event_details["start"][:2]                 end_month = event_details["end"][:2]                  # Compare the months of the dates to the requested calendar                 # window, if any.                  if (calendar_start is None or end_month >= calendar_start) and \                     (calendar_end is None or start_month <= calendar_end):                      all_shown_events.append(event)                      if earliest is None or start_month < earliest:                         earliest = start_month                     if latest is None or end_month > latest:                         latest = end_month                      # Store the event in the month-specific dictionary.                      first = max(start_month, calendar_start or start_month)                     last = min(end_month, calendar_end or end_month)                      for event_month in daterange(first, last):                         if not shown_events.has_key(event_month):                             shown_events[event_month] = []                         shown_events[event_month].append(event)      return events, shown_events, all_shown_events, earliest, latest  def setEventTimestamps(request, events):      """     Using 'request', set timestamp details in the details dictionary of each of     the 'events': a list of the form (event_page, event_details).      Retutn the latest timestamp found.     """      latest = None      for event_page, event_details in events:          # Get the initial revision of the page.          revisions = event_page.getRevList()         event_page_initial = Page(request, event_page.page_name, rev=revisions[-1])          # Get the created and last modified times.          initial_revision = getPageRevision(event_page_initial)         event_details["created"] = initial_revision["timestamp"]         latest_revision = getPageRevision(event_page)         event_details["last-modified"] = latest_revision["timestamp"]         event_details["sequence"] = len(revisions) - 1         event_details["last-comment"] = latest_revision["comment"]          if latest is None or latest < event_details["last-modified"]:             latest = event_details["last-modified"]      return latest  def compareEvents(event1, event2):      """     Compare 'event1' and 'event2' by start and end date, where both parameters     are of the following form:      (event_page, event_details)     """      event_page1, event_details1 = event1     event_page2, event_details2 = event2     return cmp(         (event_details1["start"], event_details1["end"]),         (event_details2["start"], event_details2["end"])         )  def getOrderedEvents(events):      """     Return a list with the given 'events' ordered according to their start and     end dates. Each list element must be of the following form:      (event_page, event_details)     """      ordered_events = events[:]     ordered_events.sort(compareEvents)     return ordered_events  def getConcretePeriod(calendar_start, calendar_end, earliest, latest):      """     From the requested 'calendar_start' and 'calendar_end', which may be None,     indicating that no restriction is imposed on the period for each of the     boundaries, use the 'earliest' and 'latest' event months to define a     specific period of interest.     """      # Define the period as starting with any specified start month or the     # earliest event known, ending with any specified end month or the latest     # event known.      first = calendar_start or earliest     last = calendar_end or latest      # If there is no range of months to show, perhaps because there are no     # events in the requested period, and there was no start or end month     # specified, show only the month indicated by the start or end of the     # requested period. If all events were to be shown but none were found show     # the current month.      if first is None:         first = last or getCurrentMonth()     if last is None:         last = first or getCurrentMonth()      # Permit "expiring" periods (where the start date approaches the end date).      return min(first, last), last  def getCoverage(start, end, events):      """     Within the period defined by the 'start' and 'end' dates, determine the     coverage of the days in the period by the given 'events', returning a set of     covered days, along with a list of slots, where each slot contains a tuple     of the form (set of covered days, events).     """      all_events = []     full_coverage = set()      # Get event details.      for event in events:         event_page, event_details = event          # Test for the event in the period.          if event_details["start"] <= end and event_details["end"] >= start:              # Find the coverage of this period for the event.              event_start = max(event_details["start"], start)             event_end = min(event_details["end"], end)             event_coverage = set(daterange(event_start, event_end))              # Update the overall coverage.              full_coverage.update(event_coverage)              # Try and fit the event into the events list.              for i, (coverage, covered_events) in enumerate(all_events):                  # Where the event does not overlap with the current                 # element, add it alongside existing events.                  if not coverage.intersection(event_coverage):                     covered_events.append(event)                     all_events[i] = coverage.union(event_coverage), covered_events                     break              # Make a new element in the list if the event cannot be             # marked alongside existing events.              else:                 all_events.append((event_coverage, [event]))      return full_coverage, all_events  # User interface functions.  def getParameter(request, name):     return request.form.get(name, [None])[0]  def getParameterMonth(arg):     n = None      if arg.startswith("current"):         date = getCurrentMonth()         if len(arg) > 8:             n = int(arg[7:])      elif arg.startswith("yearstart"):         date = (getCurrentYear(), 1)         if len(arg) > 10:             n = int(arg[9:])      elif arg.startswith("yearend"):         date = (getCurrentYear(), 12)         if len(arg) > 8:             n = int(arg[7:])      else:         date = getMonth(arg)      if n is not None:         date = monthupdate(date, n)      return date  def getFormMonth(request, calendar_name, argname):     if calendar_name is None:         calendar_prefix = argname     else:         calendar_prefix = "%s-%s" % (calendar_name, argname)      arg = getParameter(request, calendar_prefix)     if arg is not None:         return getParameterMonth(arg)     else:         return None  def getFormMonthPair(request, yeararg, montharg):     year = getParameter(request, yeararg)     month = getParameter(request, montharg)     if year and month:         return (int(year), int(month))     else:         return None  def getPrettyPageName(page):      "Return a nicely formatted title/name for the given 'page'."      if isMoin15():         title = page.split_title(page.request, force=1)     else:         title = page.split_title(force=1)      return title.replace("_", " ").replace("/", u" ? ")  def getMonthLabel(month):      "Return an unlocalised label for the given 'month'."      return month_labels[month - 1] # zero-based labels  def getDayLabel(weekday):      "Return an unlocalised label for the given 'weekday'."      return weekday_labels[weekday]  def linkToPage(request, page, text, query_string=None):      """     Using 'request', return a link to 'page' with the given link 'text' and     optional 'query_string'.     """      text = wikiutil.escape(text)      if isMoin15():         url = wikiutil.quoteWikinameURL(page.page_name)         if query_string is not None:             url = "%s?%s" % (url, query_string)         return wikiutil.link_tag(request, url, text, getattr(page, "formatter", None))     else:         return page.link_to_raw(request, text, query_string)  def getPageURL(request, page):      "Using 'request', return the URL of 'page'."      if isMoin15():         return request.getQualifiedURL(page.url(request))     else:         return request.getQualifiedURL(page.url(request, relative=0))  # vim: tabstop=4 expandtab shiftwidth=4