Example #1
0
def openPackageResource(package, path):
    __import__(package)
    pkg = sys.modules[package]
    try:
        loader = pkg.__loader__
    except AttributeError:
        relpath = os.path.join(*path.split("/"))
        for dir in pkg.__path__:
            filename = os.path.join(dir, relpath)
            if os.path.exists(filename):
                break
        else:
            raise ZConfig.SchemaResourceError("schema component not found",
                                              filename=path,
                                              package=package,
                                              path=pkg.__path__)
        url = "file:" + pathname2url(filename)
        url = ZConfig.url.urlnormalize(url)
        return urllib2.urlopen(url)
    else:
        for dir in pkg.__path__:
            loadpath = os.path.join(dir, path)
            try:
                return StringIO.StringIO(
                    loader.get_data(loadpath).decode('utf-8'))
            except Exception:
                pass
        raise ZConfig.SchemaResourceError("schema component not found",
                                          filename=path,
                                          package=package,
                                          path=pkg.__path__)
Example #2
0
def openPackageResource(package, path):
    __import__(package)
    pkg = sys.modules[package]
    try:
        loader = pkg.__loader__
    except AttributeError:
        relpath = os.path.join(*path.split("/"))
        for dirname in pkg.__path__:
            filename = os.path.join(dirname, relpath)
            if os.path.exists(filename):
                break
        else:
            raise ZConfig.SchemaResourceError("schema component not found",
                                              filename=path,
                                              package=package,
                                              path=pkg.__path__)
        url = "file:" + pathname2url(filename)
        url = ZConfig.url.urlnormalize(url)
        return urllib2.urlopen(url)
    else:
        v, tb = (None, None)
        for dirname in pkg.__path__:
            loadpath = os.path.join(dirname, path)
            try:
                return StringIO(loader.get_data(loadpath).decode('utf-8'))
            except Exception as e:
                v = ZConfig.SchemaResourceError(
                    "error opening schema component: " + repr(e),
                    filename=path,
                    package=package,
                    path=pkg.__path__)
                tb = sys.exc_info()[2]

        if v is not None:
            try:
                reraise(type(v), v, tb)
            finally:
                del tb

        raise ZConfig.SchemaResourceError("schema component not found",
                                          filename=path,
                                          package=package,
                                          path=pkg.__path__)
Example #3
0
 def schemaComponentSource(self, package, filename):
     parts = package.split(".")
     if not parts:  # pragma: no cover
         raise ZConfig.SchemaError("illegal schema component name: " +
                                   repr(package))
     if "" in parts:
         # '' somewhere in the package spec; still illegal
         raise ZConfig.SchemaError("illegal schema component name: " +
                                   repr(package))
     filename = filename or "component.xml"
     try:
         __import__(package)
     except ImportError as e:
         raise ZConfig.SchemaResourceError("could not load package %s: %s" %
                                           (package, str(e)),
                                           filename=filename,
                                           package=package)
     pkg = sys.modules[package]
     if not hasattr(pkg, "__path__"):
         raise ZConfig.SchemaResourceError(
             "import name does not refer to a package",
             filename=filename,
             package=package)
     return "package:%s:%s" % (package, filename)
Example #4
0
 def schemaComponentSource(self, package, file):
     parts = package.split(".")
     if not parts:
         raise ZConfig.SchemaError(
             "illegal schema component name: " + `package`)
     if "" in parts:
         # '' somewhere in the package spec; still illegal
         raise ZConfig.SchemaError(
             "illegal schema component name: " + `package`)
     file = file or "component.xml"
     try:
         __import__(package)
     except ImportError, e:
         raise ZConfig.SchemaResourceError(
             "could not load package %s: %s" % (package, str(e)),
             filename=file,
             package=package)
Example #5
0
class SchemaLoader(BaseLoader):
    def __init__(self, registry=None):
        if registry is None:
            registry = ZConfig.datatypes.Registry()
        BaseLoader.__init__(self)
        self.registry = registry
        self._cache = {}

    def loadResource(self, resource):
        if resource.url and self._cache.has_key(resource.url):
            schema = self._cache[resource.url]
        else:
            schema = ZConfig.schema.parseResource(resource, self)
            self._cache[resource.url] = schema
        return schema

    # schema parser support API

    def schemaComponentSource(self, package, file):
        parts = package.split(".")
        if not parts:
            raise ZConfig.SchemaError("illegal schema component name: " +
                                      ` package `)
        if "" in parts:
            # '' somewhere in the package spec; still illegal
            raise ZConfig.SchemaError("illegal schema component name: " +
                                      ` package `)
        file = file or "component.xml"
        try:
            __import__(package)
        except ImportError, e:
            raise ZConfig.SchemaResourceError("could not load package %s: %s" %
                                              (package, str(e)),
                                              filename=file,
                                              package=package)
        pkg = sys.modules[package]
        if not hasattr(pkg, "__path__"):
            raise ZConfig.SchemaResourceError(
                "import name does not refer to a package",
                filename=file,
                package=package)
        return "package:%s:%s" % (package, file)