ActiveState Code

#! /usr/bin/env python
"""
A Python replacement for java.util.Properties class

Handles Unicode escapes
Preserves comments and order of lines

Created - Anand B Pillai <abpillai@gmail.com>
Updated - Adam Feuer <xxx at pobox.com> (replace xxx with adamf)
"""

import sys,os,codecs
import re
import time

class Properties(object):
   """ A Python replacement for java.util.Properties """
   
   def __init__(self, props=None):
      self._propertyEntries = {}
      self._commentEntries = []
      self.equalOrColonSeparatorWithoutBackslashesRe = re.compile(r'(?<!\\)(\s*\=)|(?<!\\)(\s*\:)')
       
   def loadFromString(self, input):
      lines = input.split('\n')
      self._parse(lines)
       
   def load(self, file):
      """Load properties from an open file stream"""
      unicodeFile = codecs.EncodedFile(file, 'latin-1')
      try:
         lines = unicodeFile.readlines()
         unicodeFile.close()
      except IOError, e:
         raise
      self._parse(lines)

   def getProperty(self, key):
      if self._propertyEntries.has_key(key):
         return self._propertyEntries.get(key)["value"]
      else:
         return ''

   def setProperty(self, key, value):
      if type(key) is str and type(value) is str:
         self._processPair(key, value)
      else:
         raise TypeError,'both key and value should be strings!'

   def propertyNames(self):
      return self._propertyEntries.keys()

   def getAsString(self):
      result = ""
      entries = self._propertyEntries.values() + self._commentEntries
      entries.sort()
      for entry in entries:
         if entry["comment"]:
            result += "%s\n" % entry["line"]
         else:
            result += ''.join((entry["key"],'=',entry["value"],'\n'))
      return result

   def store(self, outFile, header=""):
      self._store(outfile, header)
      outFile.close()

   def _store(self, outFile, header=""):
      unicodeOutFile = codecs.EncodedFile(outFile, 'latin-1')
      unicodeOutFile.write(header)
      unicodeOutFile.write(self.getAsString())

   def getPropertyDict(self):
      propertyDict = {}
      for key, entry in self._propertyEntries.items():
         propertyDict[key] = entry["value"]
      return propertyDict

   def __str__(self):
      s='{'
      for key,entry in self._propertyEntries.items():
         s = ''.join((s,key,'=',entry["value"],', '))
      s=''.join((s[:-2],'}'))
      return s

   def __getitem__(self, name):
      """ To support direct dictionary-like access """
      return self._propertyEntries[name]["value"]

   def __setitem__(self, name, value):
      """ To support direct dictionary-like access """
      self._processPair(name, value)
             
   def __getattr__(self, name):
      """For attributes not found in self, redirect
      to the properties dictionary """
      try:
         return self.__dict__[name]
      except KeyError:
         if hasattr(self._propertyEntries, name):
            return getattr(self._propertyEntries, name)
         else:
            raise AttributeError(name)

   def _parse(self, lines):
      lineIterator = iter(lines)
      self.lineNumber = 0
      for line in lineIterator:
         line = line.strip()
         if not line or self._isCommentLine(line):
            self._commentEntries.append(self._getPropertyEntry(comment=True, line=line))
         else:
            indexOfFirstSeparationChar = self._getIndexOfFirstSeparationChar(line)
            line = self._joinLinesIfNecessary(line, lineIterator)
            key, value = self._splitOnSeparationChar(line, indexOfFirstSeparationChar)
            self._processPair(key, value, line)

   def _processPair(self, key, value, line=''):
      origValue = value
      key, origKey = self._removeWhitespaceFromEndOfKey(key)
      origValue = self._unescape(origValue)
      value = self._unescape(value).strip()
      entry = self._getPropertyEntry(key=key, origKey=origKey, value=value, line=line, comment=False)
      self._propertyEntries[key] = entry

   def _getPropertyEntry(self, **kwargs):
      kwargs["lineNumber"] = self.lineNumber
      self.lineNumber += 1
      return PropertyEntry(**kwargs)
       
   def _getIndexOfFirstSeparationChar(self, line):
      indexOfFirstSeparationChar = -1
      endPos = self._getEndPositionOfSearch(line)
      whiteSpaceSeparatorRe = self._getWhiteSpaceSeparatorRe(line)
      if whiteSpaceSeparatorRe.search(line, 0, endPos):
         first, last = whiteSpaceSeparatorRe.search(line, 0, endPos).span()
         indexOfFirstSeparationChar = first
      elif self.equalOrColonSeparatorWithoutBackslashesRe.search(line):
         first, last = self.equalOrColonSeparatorWithoutBackslashesRe.search(line).span()
         indexOfFirstSeparationChar = last - 1
      return indexOfFirstSeparationChar

   def _getEndPositionOfSearch(self, line):
      matchObj = self.equalOrColonSeparatorWithoutBackslashesRe.search(line)
      if matchObj:
         first, last = matchObj.span()
         return first
      else:
         return len(line)
           
   def _getWhiteSpaceSeparatorRe(self, line):
      whiteSpaceSeparatorRe = re.compile(r'(?<![\\\=\:])(\s)')
      if not self.equalOrColonSeparatorWithoutBackslashesRe.search(line):
        self.equalOrColonSeparatorRe = re.compile(r'(\s*\=)|(\s*\:)')
        if self.equalOrColonSeparatorRe.search(line):
           whiteSpaceSeparatorRe = re.compile(r'(?<![\\])(\s)')
      return whiteSpaceSeparatorRe
           
   def _joinLinesIfNecessary(self, line, lineIterator):
      while line[-1] == '\\':
         nextline = lineIterator.next()
         nextline = nextline.strip()
         line = line[:-1] + nextline
      return line

   def _splitOnSeparationChar(self, line, indexOfFirstSeparationChar):
      if indexOfFirstSeparationChar != -1:
         return line[:indexOfFirstSeparationChar], line[indexOfFirstSeparationChar+1:]
      else:
         return line,''

   def _removeWhitespaceFromEndOfKey(self, key):
      origKey = key
      whitespaceAtEndOfKeyRe = re.compile(r'\\(?!\s$)')
      keyparts = whitespaceAtEndOfKeyRe.split(key)
      lastpart = keyparts[-1]
      if lastpart.find('\\ ') != -1:
         keyparts[-1] = lastpart.replace('\\','')
      key = ''.join(keyparts)
      if lastpart and lastpart[-1] == ' ':
         origKey = origKey.strip()
         key = key.strip()
      return key, origKey
   
   def _escape(self, value):
      newvalue = value.replace(':','\:')
      newvalue = newvalue.replace('=','\=')
      return newvalue

   def _unescape(self, value):
      newvalue = value.replace('\:',':')
      newvalue = newvalue.replace('\=','=')
      return newvalue    

   def _isCommentLine(self, line):
      if line[0] == '#': return True
      if line[0] == '!': return True
      return False
        
class PropertyEntry(dict):
   def __init__(self, **kwargs):
      if kwargs is None:
         kwargs = {}
      dict.__init__(self, kwargs)

   def __cmp__(self, other):
      return self.getLineNumber() - other.getLineNumber() 

   def getLineNumber(self):
      return self.get("lineNumber", -1)