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 easier.
Or just upload via WEBDAV. One of the biggest advantages of Zope is the isolation from physical file system.
Regards Tino
Hello, 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. :Parameters: gdict : dict A dictionary containing all of the global definitions for the module. This is accessible via the python built-in function globals() :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 objects 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 http://www.domain.com/yourId/js/all.js would return the contents of all.js. :Authors: - Matt :Date: 2007-1-1 """ def __init__(self,path,name,cache=True,persist=False,sync=True,rootdir=package_h ome(globals())): """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 = (fsr,mod_time,latest_access_time,num_accesses,file_size) self._cache[key] = new_entry return new_entry[0] else: 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] = (o,mod_time,latest_access_time,num_accesses,file_size) 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. :Parameters: 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 REQUEST.response.setHeader("Content-Type",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! -Matt