[Zope] Re: Best Practice for including Javascript inZope Applications

Matt Hollingsworth mr.hworth at gmail.com
Wed Jan 2 06:13:12 EST 2008

>Andreas Jung wrote:
>>> Larger JS frameworks like Dojo tend to be split across several files and
>>> directories. The fun starts when such frameworks load/reload stuff
>>> using relative URLs. A co-worker using Dojo intensively had to invest
>>> some time in order to integrate such a JS monster properly. As far as I
>>> remember Extjs also uses multiple files (but not as much as Dojo
>>> does)..so please check in advance.
>> Another point: consider using CMF and putting your library files into a
>> directory system view on the filesystem. This makes your life much
>Or just upload via WEBDAV.
>One of the biggest advantages of Zope is the isolation from physical
>file system.


Thanks to everyone for your help.  I thought about Tres's solution and
quickly discovered that I would be doing a *lot* of clicking/typing if I
wanted to upload all of the files necessary to make the ExtJS framework
available.   I'll look into the WebDAV idea; I didn't think of that until
you mentioned it.

However, I came up with another possible solution that may be generally
useful after some (a lot actually) of coaxing.  I threw this together in the
time between my new year's festivities :) : it's incredibly sloppy at the
moment, but before I worried about cleaning it up, I wanted to get some
feedback from you guys about it (pardon the annoying formatting problems):

def package_home(gdict):
    """Returns the location of the file that calls the function.  You 
    must pass it globals() as the argument for it to work right.  
        gdict : dict
            A dictionary containing all of the global definitions for the
            module.  This is accessible via the python built-in function
    :return: The fully qualified path for the directory in which the calling
        module is residing
    :rtype: string
    filename = gdict["__file__"] 
    return os.path.dirname(filename)

class FileSystemResource(Implicit,Item):
    """FileSystemResource is meant to make it easy to access file system
    through Zope.  It works by taking over the object traversal process to
    recursively return resources, simulating a directory structure, until
    it finally reaches the end (__call__()), when it accesses the file
    and returns it.
    If you do 
    js = FileSystemResource()
    in the class that you are publishing, then 
    would return the contents of all.js.
    :Authors: - Matt
    :Date: 2007-1-1
        """Create a FileSystemResource with the specified name"""
        self.path = path
        self.name= name
        self.cache = cache
        self.persist = persist
        self.sync = sync
        self.rootdir = rootdir
        if cache:
            self._cache = {}
    # Hooks #
    def __before_publishing_traverse__(self,obj,REQUEST):
        """Just print the request path so I can debug easier"""
        #print "REQUEST.path: " + str(REQUEST.path)
        print "REQUEST.path: " + str(REQUEST.path)
    def __bobo_traverse__(self, request, key):
        """Takes the key, meshes it with the request, and
        generates the object from that"""
        full_path = os.path.join(self.path,key)
        if self.cache:
            if self._cache.has_key(key):
                o = self._cache[key]
                fsr = o[0]
                mod_time = o[1]
                file_size = o[4]
                #If modtime isn't the same, refresh the resource
                latest_access_time = time.localtime()
                num_accesses = o[3] + 1
                new_entry =
                self._cache[key] = new_entry
                return new_entry[0]
                o = FileSystemResource(full_path,name=None)
                #Set the modification time
                mod_time = "time" #TODO: Implement
                latest_access_time = time.localtime()
                num_accesses = 1
                file_size = 0 #TODO: Implement
                self._cache[key] =
                return o
        o = FileSystemResource(full_path)
        print "Returning object " + str(o)
        return o
    # ! End Hooks #

    def cleanCache(self):
        #TODO: Not implemented (placeholder vars so I'll remember what's in
the tuples)
        for key,value in self._cache.items():
            file_location = key
            file_obj = value[0]
            mod_time = value[1]
            latest_access_time = value[2]
            num_accesses = value[3]
            file_size = value[4]
    def getResource(self,path):
       """Gets the resource sepcified by the given path.  The path
       should be relative to this particular object's path.
               The path (relative to this object's path) of the file or
               folder that you are looking for
        :return: Returns the content of the specified resource
        :rtype: Zope File object
       #TODO: Implement
    def __call__(self,REQUEST):
        """Gets the representation of the file on the filesystem"""
        #TODO: Cache results
        #TODO: Make it possible to use non-memory cached files        
        fname = os.path.abspath(os.path.join(self.rootdir,self.path))
        type = guess_type(fname)[0]
        if not os.path.exists(fname):
            raise FileNotFoundException("File " + fname + " was not found on
the file system.")
        print "Opening file " + fname
        f = open(fname)
        data = ""
        for line in f:
            data +=line
        tmp_file = File(data)
        ret = FileReadFile(tmp_file)
        #Set the response content type
        return ret.read()
    def __str__(self):
        """Gets the string representation of this FileObject"""
        return self.path

This class is working like a charm as it stands (I have
js=FileSystemResource("js","Javascript Repository") in my published object),
but it is terribly sloppily implemented for the time being, especially in
regard to binary files (doing for line... instead of going over chunks) and
to caching/memory issues (there is no caching except for the intermediate
objects and everything is loaded into memory first [big files = unusable]).
And someone could just pass ../'s to the path to get anywhere on the file
system they wanted, I suppose.  All of these could easily be fixed of
course, but I wanted feedback before I put more than 30 minutes into the
prospect :)

Thanks for all your help!


More information about the Zope mailing list