muff/muffuniv.py

   1 # Copyright (c) 2005 mudpy, Jeremy Stanley <fungi@yuggoth.org>, all rights reserved.
   2 # Licensed per terms in the LICENSE file distributed with this software.
   3
   4 # persistent variables are stored in ini-style files supported by ConfigParser
   5 import ConfigParser
   6
   7 # need to know the directory separator
   8 import os
   9
  10 # hack to load all modules in the muff package
  11 import muff
  12 for module in muff.__all__:
  13         exec("import " + module)
  14
  15 class Element:
  16         """An element of the universe."""
  17         def __init__(self, key, universe, origin=""):
  18                 """Default values for the in-memory element variables."""
  19                 self.key = key
  20                 if self.key.find(":") > 0:
  21                         self.category, self.subkey = self.key.split(":", 1)
  22                 else:
  23                         self.category = "other"
  24                         self.subkey = self.key
  25                 if not self.category in universe.categories: self.category = "other"
  26                 universe.categories[self.category][self.subkey] = self
  27                 self.origin = origin
  28                 if not self.origin: self.origin = universe.default_origins[self.category]
  29                 if not self.origin.startswith(os.sep):
  30                         self.origin = os.getcwd() + os.sep + self.origin
  31                 universe.contents[self.key] = self
  32                 if not self.origin in universe.files:
  33                         DataFile(self.origin, universe)
  34                 if not universe.files[self.origin].data.has_section(self.key):
  35                         universe.files[self.origin].data.add_section(self.key)
  36         def delete(self):
  37                 muffmisc.log("Deleting: " + self.key + ".")
  38                 universe.files[self.origin].data.remove_section(self.key)
  39                 del universe.categories[self.category][self.subkey]
  40                 del universe.contents[self.key]
  41                 del self
  42         def facets(self):
  43                 """Return a list of facets for this element."""
  44                 return universe.files[self.origin].data.options(self.key)
  45         def get(self, facet):
  46                 """Retrieve values."""
  47                 if universe.files[self.origin].data.has_option(self.key, facet):
  48                         return universe.files[self.origin].data.get(self.key, facet)
  49                 else:
  50                         return ""
  51         def getboolean(self, facet, default=False):
  52                 """Retrieve values as boolean type."""
  53                 if universe.files[self.origin].data.has_option(self.key, facet):
  54                         return universe.files[self.origin].data.getboolean(self.key, facet)
  55                 else:
  56                         return default
  57         def getint(self, facet):
  58                 """Convenience method to coerce return values as type int."""
  59                 value = self.get(facet)
  60                 if not value: value = 0
  61                 elif type(value) is str: value = value.rstrip("L")
  62                 return int(value)
  63         def getfloat(self, facet):
  64                 """Convenience method to coerce return values as type float."""
  65                 value = self.get(facet)
  66                 if not value: value = 0
  67                 elif type(value) is str: value = value.rstrip("L")
  68                 return float(value)
  69         def set(self, facet, value):
  70                 """Set values."""
  71                 if not type(value) is str: value = repr(value)
  72                 universe.files[self.origin].data.set(self.key, facet, value)
  73
  74 class DataFile:
  75         """A file containing universe elements."""
  76         def __init__(self, filename, universe):
  77                 filedir = os.sep.join(filename.split(os.sep)[:-1])
  78                 self.data = ConfigParser.SafeConfigParser()
  79                 if os.access(filename, os.R_OK): self.data.read(filename)
  80                 self.filename = filename
  81                 universe.files[filename] = self
  82                 if "categories" in self.data.sections():
  83                         for option in self.data.options("categories"):
  84                                 universe.default_origins[option] = self.data.get("categories", option)
  85                                 if not option in universe.categories:
  86                                         universe.categories[option] = {}
  87                 for section in self.data.sections():
  88                         if section == "categories" or section == "include":
  89                                 for option in self.data.options(section):
  90                                         includefile = self.data.get(section, option)
  91                                         if not includefile.startswith(os.sep):
  92                                                 includefile = filedir + os.sep + includefile
  93                                         DataFile(includefile, universe)
  94                         elif section != "control":
  95                                 Element(section, universe, filename)
  96         def save(self):
  97                 if self.data.sections() and not ( "control" in self.data.sections() and self.data.getboolean("control", "read_only") ):
  98                         basedir = os.sep.join(self.filename.split(os.sep)[:-1])
  99                         if not os.access(basedir, os.F_OK): os.makedirs(basedir)
 100                         file_descriptor = file(self.filename, "w")
 101                         self.data.write(file_descriptor)
 102                         file_descriptor.flush()
 103                         file_descriptor.close()
 104
 105 class Universe:
 106         """The universe."""
 107         def __init__(self, filename=""):
 108                 """Initialize the universe."""
 109                 self.categories = {}
 110                 self.contents = {}
 111                 self.default_origins = {}
 112                 self.files = {}
 113                 if not filename:
 114                         possible_filenames = [
 115                                 ".mudpyrc",
 116                                 ".mudpy/mudpyrc",
 117                                 ".mudpy/mudpy.conf",
 118                                 "mudpy.conf",
 119                                 "etc/mudpy.conf",
 120                                 "/usr/local/mudpy/mudpy.conf",
 121                                 "/usr/local/mudpy/etc/mudpy.conf",
 122                                 "/etc/mudpy/mudpy.conf",
 123                                 "/etc/mudpy.conf"
 124                                 ]
 125                         for filename in possible_filenames:
 126                                 if os.access(filename, os.R_OK): break
 127                 if not filename.startswith(os.sep):
 128                         filename = os.getcwd() + os.sep + filename
 129                 DataFile(filename, self)
 130         def save(self):
 131                 """Save the universe to persistent storage."""
 132                 for key in self.files: self.files[key].save()
 133
 134 # if there is no universe, create an empty one
 135 if not "universe" in locals(): universe = Universe()
 136