# -*- coding: iso-8859-1 -*- """     MoinMoin - MoinSupport library (derived from EventAggregatorSupport)      @copyright: 2008, 2009, 2010, 2011, 2012 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 DateSupport import * from MoinMoin.Page import Page from MoinMoin import config, search, wikiutil from StringIO import StringIO from shlex import shlex import re import time  __version__ = "0.2"  # Content type parsing.  encoding_regexp_str = ur'(?P<content_type>[^\s;]*)(?:;\s*charset=(?P<encoding>[-A-Za-z0-9]+))?' encoding_regexp = re.compile(encoding_regexp_str)  # Accept header parsing.  accept_regexp_str = ur';\s*q=' accept_regexp = re.compile(accept_regexp_str)  # Extraction of shared fragments.  marker_regexp_str = r"([{]{3,}|[}]{3,})" marker_regexp = re.compile(marker_regexp_str, re.MULTILINE | re.DOTALL) # {{{... or }}}...  # Extraction of headings.  heading_regexp = re.compile(r"^(?P<level>=+)(?P<heading>.*?)(?P=level)$", re.UNICODE | re.MULTILINE)  # Category extraction from pages.  category_regexp = None  # Simple content parsing.  verbatim_regexp = re.compile(ur'(?:'     ur'<<Verbatim\((?P<verbatim>.*?)\)>>'     ur'|'     ur'\[\[Verbatim\((?P<verbatim2>.*?)\)\]\]'     ur'|'     ur'!(?P<verbatim3>.*?)(\s|$)?'     ur'|'     ur'`(?P<monospace>.*?)`'     ur'|'     ur'{{{(?P<preformatted>.*?)}}}'     ur')', re.UNICODE)  # Category discovery.  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  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 getCategoryPages(pagename, request):      """     Return the pages associated with the given category 'pagename' using the     'request'.     """      query = search.QueryParser().parse_query('category:%s' % pagename)     results = search.searchPages(request, query, "page_name")     return filterCategoryPages(results, request)  def filterCategoryPages(results, request):      "Filter category pages from the given 'results' using the 'request'."      cat_pattern = getCategoryPattern(request)     pages = []     for page in results.hits:         if not cat_pattern.match(page.page_name):             pages.append(page)     return pages  def getAllCategoryPages(category_names, request):      """     Return all pages belonging to the categories having the given     'category_names', using the given 'request'.     """      pages = []     pagenames = set()      for category_name in category_names:          # Get the pages and page names in the category.          pages_in_category = getCategoryPages(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 pagenames:                 continue             else:                 pagenames.add(pagename)              pages.append(page_in_category)      return pages  def getPagesForSearch(search_pattern, request):      """     Return result pages for a search employing the given 'search_pattern' and     using the given 'request'.     """      query = search.QueryParser().parse_query(search_pattern)     results = search.searchPages(request, query, "page_name")     return filterCategoryPages(results, request)  # WikiDict functions.  def getWikiDict(pagename, request):      """     Return the WikiDict provided by the given 'pagename' using the given     'request'.     """      if pagename and Page(request, pagename).exists() and request.user.may.read(pagename):         if hasattr(request.dicts, "dict"):             return request.dicts.dict(pagename)         else:             return request.dicts[pagename]     else:         return None  # Searching-related functions.  def getPagesFromResults(result_pages, request):      "Return genuine pages for the given 'result_pages' using the 'request'."      return [Page(request, page.page_name) for page in result_pages]  # Region/section parsing.  def getRegions(s, include_non_regions=False):      """     Parse the string 's', returning a list of explicitly declared regions.      If 'include_non_regions' is specified as a true value, fragments will be     included for text between explicitly declared regions.     """      regions = []     marker = None     is_block = True      # Start a region for exposed text, if appropriate.      if include_non_regions:         regions.append("")      for match_text in marker_regexp.split(s):          # Capture section text.          if is_block:             if marker or include_non_regions:                 regions[-1] += match_text          # Handle section markers.          else:              # Close any open sections, returning to exposed text regions.              if marker:                  # Add any marker to the current region, regardless of whether it                 # successfully closes a section.                  regions[-1] += match_text                  if match_text.startswith("}") and len(marker) == len(match_text):                     marker = None                      # Start a region for exposed text, if appropriate.                      if include_non_regions:                         regions.append("")              # Without a current marker, start a new section.              else:                 marker = match_text                 regions.append("")                  # Add the marker to the new region.                  regions[-1] += match_text          # The match text alternates between text between markers and the markers         # themselves.          is_block = not is_block      return regions  def getFragmentsFromRegions(regions):      """     Return fragments from the given 'regions', each having the form     (format, attributes, body text).     """      fragments = []      for region in regions:         format, attributes, body, header, close = getFragmentFromRegion(region)         fragments.append((format, attributes, body))      return fragments  def getFragmentFromRegion(region):      """     Return a fragment for the given 'region' having the form (format,     attributes, body text, header, close), where the 'header' is the original     declaration of the 'region' or None if no explicit region is defined, and     'close' is the closing marker of the 'region' or None if no explicit region     is defined.     """      if region.startswith("{{{"):          body = region.lstrip("{")         level = len(region) - len(body)         body = body.rstrip("}").lstrip()          # Remove any prelude and process metadata.          if body.startswith("#!"):              try:                 declaration, body = body.split("\n", 1)             except ValueError:                 declaration = body                 body = ""              arguments = declaration[2:]              # Get any parser/format declaration.              if arguments and not arguments[0].isspace():                 details = arguments.split(None, 1)                 if len(details) == 2:                     format, arguments = details                 else:                     format = details[0]                     arguments = ""             else:                 format = None              # Get the attributes/arguments for the region.              attributes = parseAttributes(arguments, False)              # Add an entry for the format in the attribute dictionary.              if format and not attributes.has_key(format):                 attributes[format] = True              return format, attributes, body, level * "{" + declaration + "\n", level * "}"          else:             return None, {}, body, level * "{" + "\n", level * "}"      else:         return None, {}, region, None, None  def getFragments(s, include_non_regions=False):      """     Return fragments for the given string 's', each having the form     (format, arguments, body text).      If 'include_non_regions' is specified as a true value, fragments will be     included for text between explicitly declared regions.     """      return getFragmentsFromRegions(getRegions(s, include_non_regions))  # Heading extraction.  def getHeadings(s):      """     Return tuples of the form (level, title, span) for headings found within the     given string 's'. The span is itself a (start, end) tuple indicating the     matching region of 's' for a heading declaration.     """      headings = []      for match in heading_regexp.finditer(s):         headings.append(             (len(match.group("level")), match.group("heading"), match.span())             )      return headings  # Region/section attribute parsing.  def parseAttributes(s, escape=True):      """     Parse the section attributes string 's', returning a mapping of names to     values. If 'escape' is set to a true value, the attributes will be suitable     for use with the formatter API. If 'escape' is set to a false value, the     attributes will have any quoting removed.     """      attrs = {}     f = StringIO(s)     name = None     need_value = False      for token in shlex(f):          # Capture the name if needed.          if name is None:             name = escape and wikiutil.escape(token) or strip_token(token)          # Detect either an equals sign or another name.          elif not need_value:             if token == "=":                 need_value = True             else:                 attrs[name.lower()] = escape and "true" or True                 name = wikiutil.escape(token)          # Otherwise, capture a value.          else:             # Quoting of attributes done similarly to wikiutil.parseAttributes.              if token:                 if escape:                     if token[0] in ("'", '"'):                         token = wikiutil.escape(token)                     else:                         token = '"%s"' % wikiutil.escape(token, 1)                 else:                     token = strip_token(token)                  attrs[name.lower()] = token             name = None             need_value = False      # Handle any name-only attributes at the end of the collection.      if name and not need_value:         attrs[name.lower()] = escape and "true" or True      return attrs  def strip_token(token):      "Return the given 'token' stripped of quoting."      if token[0] in ("'", '"') and token[-1] == token[0]:         return token[1:-1]     else:         return token  # Request-related classes and associated functions.  class Form:      """     A wrapper preserving MoinMoin 1.8.x (and earlier) behaviour in a 1.9.x     environment.     """      def __init__(self, form):         self.form = form      def has_key(self, name):         return not not self.form.getlist(name)      def get(self, name, default=None):         values = self.form.getlist(name)         if not values:             return default         else:             return values      def __getitem__(self, name):         return self.form.getlist(name)      def __delitem__(self, name):         del self.form[name]      def keys(self):         return self.form.keys()      def items(self):         return self.form.items(True)  class ActionSupport:      """     Work around disruptive MoinMoin changes in 1.9, and also provide useful     convenience methods.     """      def get_form(self):         return get_form(self.request)      def _get_selected(self, value, input_value):          """         Return the HTML attribute text indicating selection of an option (or         otherwise) if 'value' matches 'input_value'.         """          return input_value is not None and value == input_value and 'selected="selected"' or ''      def _get_selected_for_list(self, value, input_values):          """         Return the HTML attribute text indicating selection of an option (or         otherwise) if 'value' matches one of the 'input_values'.         """          return value in input_values and 'selected="selected"' or ''      def get_option_list(self, value, values):          """         Return a list of HTML element definitions for options describing the         given 'values', selecting the option with the specified 'value' if         present.         """          options = []         for available_value in values:             selected = self._get_selected(available_value, value)             options.append('<option value="%s" %s>%s</option>' % (                 escattr(available_value), selected, wikiutil.escape(available_value)))         return options      def _get_input(self, form, name, default=None):          """         Return the input from 'form' having the given 'name', returning either         the input converted to an integer or the given 'default' (optional, None         if not specified).         """          value = form.get(name, [None])[0]         if not value: # true if 0 obtained             return default         else:             return int(value)  def get_form(request):      "Work around disruptive MoinMoin changes in 1.9."      if hasattr(request, "values"):         return Form(request.values)     else:         return request.form  class send_headers_cls:      """     A wrapper to preserve MoinMoin 1.8.x (and earlier) request behaviour in a     1.9.x environment.     """      def __init__(self, request):         self.request = request      def __call__(self, headers):         for header in headers:             parts = header.split(":")             self.request.headers.add(parts[0], ":".join(parts[1:]))  def get_send_headers(request):      "Return a function that can send response headers."      if hasattr(request, "http_headers"):         return request.http_headers     elif hasattr(request, "emit_http_headers"):         return request.emit_http_headers     else:         return send_headers_cls(request)  def escattr(s):     return wikiutil.escape(s, 1)  def getPathInfo(request):     if hasattr(request, "getPathinfo"):         return request.getPathinfo()     else:         return request.path  def getHeader(request, header_name, prefix=None):      """     Using the 'request', return the value of the header with the given     'header_name', using the optional 'prefix' to obtain protocol-specific     headers if necessary.      If no value is found for the given 'header_name', None is returned.     """      if hasattr(request, "getHeader"):         return request.getHeader(header_name)     elif hasattr(request, "headers"):         return request.headers.get(header_name)     else:         return request.env.get((prefix and prefix + "_" or "") + header_name.upper())  def writeHeaders(request, mimetype, metadata, status=None):      """     Using the 'request', write resource headers using the given 'mimetype',     based on the given 'metadata'. If the optional 'status' is specified, set     the status header to the given value.     """      send_headers = get_send_headers(request)      # Define headers.      headers = ["Content-Type: %s; charset=%s" % (mimetype, config.charset)]      # Define the last modified time.     # NOTE: Consider using request.httpDate.      latest_timestamp = metadata.get("last-modified")     if latest_timestamp:         headers.append("Last-Modified: %s" % latest_timestamp.as_HTTP_datetime_string())      if status:         headers.append("Status: %s" % status)      send_headers(headers)  # Content/media type and preferences support.  class MediaRange:      "A content/media type value which supports whole categories of data."      def __init__(self, media_range, accept_parameters=None):         self.media_range = media_range         self.accept_parameters = accept_parameters or {}          parts = media_range.split(";")         self.media_type = parts[0]         self.parameters = getMappingFromParameterStrings(parts[1:])          # The media type is divided into category and subcategory.          parts = self.media_type.split("/")         self.category = parts[0]         self.subcategory = "/".join(parts[1:])      def get_parts(self):          "Return the category, subcategory parts."          return self.category, self.subcategory      def get_specificity(self):          """         Return the specificity of the media type in terms of the scope of the         category and subcategory, and also in terms of any qualifying         parameters.         """          if "*" in self.get_parts():             return -list(self.get_parts()).count("*")         else:             return len(self.parameters)      def permits(self, other):          """         Return whether this media type permits the use of the 'other' media type         if suggested as suitable content.         """          if not isinstance(other, MediaRange):             other = MediaRange(other)          category = categoryPermits(self.category, other.category)         subcategory = categoryPermits(self.subcategory, other.subcategory)          if category and subcategory:             if "*" not in (category, subcategory):                 return not self.parameters or self.parameters == other.parameters             else:                 return True         else:             return False      def __eq__(self, other):          """         Return whether this media type is effectively the same as the 'other'         media type.         """          if not isinstance(other, MediaRange):             other = MediaRange(other)          category = categoryMatches(self.category, other.category)         subcategory = categoryMatches(self.subcategory, other.subcategory)          if category and subcategory:             if "*" not in (category, subcategory):                 return self.parameters == other.parameters or \                     not self.parameters or not other.parameters             else:                 return True         else:             return False      def __ne__(self, other):         return not self.__eq__(other)      def __hash__(self):         return hash(self.media_range)      def __repr__(self):         return "MediaRange(%r)" % self.media_range  def categoryMatches(this, that):      """     Return the basis of a match between 'this' and 'that' or False if the given     categories do not match.     """      return (this == "*" or this == that) and this or \         that == "*" and that or False  def categoryPermits(this, that):      """     Return whether 'this' category permits 'that' category. Where 'this' is a     wildcard ("*"), 'that' should always match. A value of False is returned if     the categories do not otherwise match.     """      return (this == "*" or this == that) and this or False  def getMappingFromParameterStrings(l):      """     Return a mapping representing the list of "name=value" strings given by 'l'.     """      parameters = {}      for parameter in l:         parts = parameter.split("=")         name = parts[0].strip()         value = "=".join(parts[1:]).strip()         parameters[name] = value      return parameters  def getContentPreferences(accept):      """     Return a mapping from media types to parameters for content/media types     extracted from the given 'accept' header value. The mapping is returned in     the form of a list of (media type, parameters) tuples.      See: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1     """      preferences = []      for field in accept.split(","):          # The media type with parameters (defined by the "media-range") is         # separated from any other parameters (defined as "accept-extension"         # parameters) by a quality parameter.          fparts = accept_regexp.split(field)          # The first part is always the media type.          media_type = fparts[0].strip()          # Any other parts can be interpreted as extension parameters.          if len(fparts) > 1:             fparts = ("q=" + ";q=".join(fparts[1:])).split(";")         else:             fparts = []          # Each field in the preferences can incorporate parameters separated by         # semicolon characters.          parameters = getMappingFromParameterStrings(fparts)         media_range = MediaRange(media_type, parameters)         preferences.append(media_range)      return ContentPreferences(preferences)  class ContentPreferences:      "A wrapper around content preference information."      def __init__(self, preferences):         self.preferences = preferences      def __iter__(self):         return iter(self.preferences)      def get_ordered(self, by_quality=0):          """         Return a list of content/media types in descending order of preference.         If 'by_quality' is set to a true value, the "q" value will be used as         the primary measure of preference; otherwise, only the specificity will         be considered.         """          ordered = {}          for media_range in self.preferences:             specificity = media_range.get_specificity()              if by_quality:                 q = float(media_range.accept_parameters.get("q", "1"))                 key = q, specificity             else:                 key = specificity              if not ordered.has_key(key):                 ordered[key] = []              ordered[key].append(media_range)          # Return the preferences in descending order of quality and specificity.          keys = ordered.keys()         keys.sort(reverse=True)         return [ordered[key] for key in keys]      def get_acceptable_types(self, available):          """         Return content/media types from those in the 'available' list supported         by the known preferences grouped by preference level in descending order         of preference.         """          matches = {}         available = set(available[:])          for level in self.get_ordered():             for media_range in level:                  # Attempt to match available types.                  found = set()                 for available_type in available:                     if media_range.permits(available_type):                         q = float(media_range.accept_parameters.get("q", "1"))                         if not matches.has_key(q):                             matches[q] = []                         matches[q].append(available_type)                         found.add(available_type)                  # Stop looking for matches for matched available types.                  if found:                     available.difference_update(found)          # Sort the matches in descending order of quality.          all_q = matches.keys()          if all_q:             all_q.sort(reverse=True)             return [matches[q] for q in all_q]         else:             return []      def get_preferred_types(self, available):          """         Return the preferred content/media types from those in the 'available'         list, given the known preferences.         """          preferred = self.get_acceptable_types(available)         if preferred:             return preferred[0]         else:             return []  # Content type parsing.  def getContentTypeAndEncoding(content_type):      """     Return a tuple with the content/media type and encoding, extracted from the     given 'content_type' header value.     """      m = encoding_regexp.search(content_type)     if m:         return m.group("content_type"), m.group("encoding")     else:         return None, None  # Page access functions.  def getPageURL(page):      "Return the URL of the given 'page'."      request = page.request     return request.getQualifiedURL(page.url(request, relative=0))  def getFormat(page):      "Get the format used on the given 'page'."      return page.pi["format"]  def getMetadata(page):      """     Return a dictionary containing items describing for the given 'page' the     page's "created" time, "last-modified" time, "sequence" (or revision number)     and the "last-comment" made about the last edit.     """      request = page.request      # Get the initial revision of the page.      revisions = page.getRevList()      if not revisions:         return {}      event_page_initial = Page(request, page.page_name, rev=revisions[-1])      # Get the created and last modified times.      initial_revision = getPageRevision(event_page_initial)      metadata = {}     metadata["created"] = initial_revision["timestamp"]     latest_revision = getPageRevision(page)     metadata["last-modified"] = latest_revision["timestamp"]     metadata["sequence"] = len(revisions) - 1     metadata["last-comment"] = latest_revision["comment"]      return metadata  def getPageRevision(page):      "Return the revision details dictionary for the given '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      # Similar to Page.mtime_usecs behaviour...      if line:         timestamp = line.ed_time_usecs         mtime = wikiutil.version2timestamp(long(timestamp)) # must be long for py 2.2.x         comment = line.comment     else:         mtime = 0         comment = ""      # Leave the time zone empty.      return {"timestamp" : DateTime(time.gmtime(mtime)[:6] + (None,)), "comment" : comment}  # Page parsing and formatting of embedded content.  def getPageParserClass(request):      "Using 'request', return a parser class for the current page's format."      return getParserClass(request, getFormat(request.page))  def getParserClass(request, format):      """     Return a parser class using the 'request' for the given 'format', returning     a plain text parser if no parser can be found for the specified 'format'.     """      try:         return wikiutil.searchAndImportPlugin(request.cfg, "parser", format or "plain")     except wikiutil.PluginMissingError:         return wikiutil.searchAndImportPlugin(request.cfg, "parser", "plain")  def getFormatterClass(request, format):      """     Return a formatter class using the 'request' for the given output 'format',     returning a plain text formatter if no formatter can be found for the     specified 'format'.     """      try:         return wikiutil.searchAndImportPlugin(request.cfg, "formatter", format or "plain")     except wikiutil.PluginMissingError:         return wikiutil.searchAndImportPlugin(request.cfg, "formatter", "plain")  def formatText(text, request, fmt, inhibit_p=True, parser_cls=None):      """     Format the given 'text' using the specified 'request' and formatter 'fmt'.     Suppress line anchors in the output, and fix lists by indicating that a     paragraph has already been started.     """      if not parser_cls:         parser_cls = getPageParserClass(request)     parser = parser_cls(text, request, line_anchors=False)      old_fmt = request.formatter     request.formatter = fmt     try:         return redirectedOutput(request, parser, fmt, inhibit_p=inhibit_p)     finally:         request.formatter = old_fmt  def redirectedOutput(request, parser, fmt, **kw):      "A fixed version of the request method of the same name."      buf = StringIO()     request.redirect(buf)     try:         parser.format(fmt, **kw)         if hasattr(fmt, "flush"):             buf.write(fmt.flush(True))     finally:         request.redirect()     text = buf.getvalue()     buf.close()     return text  # Textual representations.  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 getEncodedWikiText(text):      "Encode the given 'text' in a verbatim representation."      return "<<Verbatim(%s)>>" % text  def getPrettyTitle(title):      "Return a nicely formatted version of the given 'title'."      return title.replace("_", " ").replace("/", u" ? ")  # User interface functions.  def getParameter(request, name, default=None):      """     Using the given 'request', return the value of the parameter with the given     'name', returning the optional 'default' (or None) if no value was supplied     in the 'request'.     """      return get_form(request).get(name, [default])[0]  def getQualifiedParameter(request, prefix, argname, default=None):      """     Using the given 'request', 'prefix' and 'argname', retrieve the value of the     qualified parameter, returning the optional 'default' (or None) if no value     was supplied in the 'request'.     """      argname = getQualifiedParameterName(prefix, argname)     return getParameter(request, argname, default)  def getQualifiedParameterName(prefix, argname):      """     Return the qualified parameter name using the given 'prefix' and 'argname'.     """      if not prefix:         return argname     else:         return "%s-%s" % (prefix, argname)  # Page-related functions.  def getPrettyPageName(page):      "Return a nicely formatted title/name for the given 'page'."      title = page.split_title(force=1)     return getPrettyTitle(title)  def linkToPage(request, page, text, query_string=None, anchor=None, **kw):      """     Using 'request', return a link to 'page' with the given link 'text' and     optional 'query_string' and 'anchor'.     """      text = wikiutil.escape(text)     return page.link_to_raw(request, text, query_string, anchor, **kw)  def linkToResource(url, request, text, query_string=None, anchor=None):      """     Using 'request', return a link to 'url' with the given link 'text' and     optional 'query_string' and 'anchor'.     """      if anchor:         url += "#%s" % anchor      if query_string:         query_string = wikiutil.makeQueryString(query_string)         url += "?%s" % query_string      formatter = request.page and getattr(request.page, "formatter", None) or request.html_formatter      output = []     output.append(formatter.url(1, url))     output.append(formatter.text(text))     output.append(formatter.url(0))     return "".join(output)  def getFullPageName(parent, title):      """     Return a full page name from the given 'parent' page (can be empty or None)     and 'title' (a simple page name).     """      if parent:         return "%s/%s" % (parent.rstrip("/"), title)     else:         return title  # vim: tabstop=4 expandtab shiftwidth=4