def get_template(category, template): '''Returns a Template object for a template name or file path @param category: the template category (e.g. "html"). Use to resolve the template if a template name is given @param template: the template name or file path ''' assert isinstance(template, basestring) if is_path_re.match(template): file = File(template) else: file = None for dir in data_dirs(('templates', category)): for basename in dir.list(): name = basename.rsplit('.')[0] # robust if no '.' in basename if basename == template or name == template: file = dir.file(basename) if file.exists(): # is a file break if file and file.exists(): break else: file = File(template) if not file.exists(): raise PathLookupError, _('Could not find template "%s"') % template # T: Error message in template lookup if not file.exists(): raise PathLookupError, _('No such file: %s') % file # T: Error message in template lookup logger.info('Loading template from: %s', file) #~ basename, ext = file.basename.rsplit('.', 1) #~ resources = file.dir.subdir(basename) return Template(file)
def testAttachFileDialog(self): '''Test AttachFileDialog''' tmp_dir = self.create_tmp_dir('testAttachFileDialog') file = File((tmp_dir, 'file_to_be_attached')) file.write('Test 1 2 3\n') newfile = File((tmp_dir, 'attachments', 'Test', 'foo', 'file_to_be_attached')) self.assertTrue(file.exists()) self.assertFalse(newfile.exists()) dialog = zim.gui.AttachFileDialog(self.ui, path=Path('Test:foo')) dialog.set_file(file)
def testAttachFileDialog(self): '''Test AttachFileDialog''' tmp_dir = self.create_tmp_dir('testAttachFileDialog') file = File((tmp_dir, 'file_to_be_attached')) file.write('Test 1 2 3\n') newfile = File( (tmp_dir, 'attachments', 'Test', 'foo', 'file_to_be_attached')) self.assertTrue(file.exists()) self.assertFalse(newfile.exists()) dialog = zim.gui.AttachFileDialog(self.ui, path=Path('Test:foo')) dialog.set_file(file)
class PlantumlGenerator(ImageGeneratorClass): def __init__(self, plugin, notebook, page): ImageGeneratorClass.__init__(self, plugin, notebook, page) self.dotfile = TmpFile('umldiagram.puml') self.dotfile.touch() self.pngfile = File(self.dotfile.path[:-5] + '.png') # len('.puml') == 5 def generate_image(self, text): # Write to tmp file self.dotfile.writelines(text) # Call PlantUML try: dot = Application(dotcmd) dot.run((self.pngfile, self.dotfile)) except ApplicationError: return None, None # Sorry, no log else: if self.pngfile.exists(): return self.pngfile, None else: # When supplying a dot file with a syntax error, the dot command # doesn't return an error code (so we don't raise # ApplicationError), but we still don't have a png file to # return, so return None. return None, None def cleanup(self): self.dotfile.remove() self.pngfile.remove()
def get_template(format, template): '''Returns a Template object for a template name, file path, or File object''' # NOTE: here the "category" needs to be a format at the same time ! if isinstance(template, File): file = template else: if not is_path_re.match(template): file = None path = list(data_dirs(('templates', format))) path.reverse() for dir in path: for basename in dir.list(): name = basename.rsplit('.')[0] # robust if no '.' in basename if name == template: file = dir.file(basename) if file.exists(): # is a file break if not file: file = File(template) else: file = File(template) logger.info('Loading template from: %s', file) if not file.exists(): raise AssertionError, 'No such file: %s' % file basename, ext = file.basename.rsplit('.', 1) resources = file.dir.subdir(basename) return Template(file.readlines(), format, name=file.path, resources_dir=resources)
def testSaveCopyDialog(self): '''Test SaveCopyDialog''' tmp_dir = self.create_tmp_dir('testSaveCopyDialog') file = File((tmp_dir, 'save_copy.txt')) self.assertFalse(file.exists()) dialog = zim.gui.SaveCopyDialog(self.ui) dialog.set_file(file)
def get_template(format, template): '''Returns a Template object for a template name, file path, or File object''' # NOTE: here the "category" needs to be a format at the same time ! if isinstance(template, File): file = template else: if not is_path_re.match(template): file = None path = list(data_dirs(('templates', format))) path.reverse() for dir in path: for basename in dir.list(): name = basename.rsplit('.')[ 0] # robust if no '.' in basename if name == template: file = dir.file(basename) if file.exists(): # is a file break if not file: file = File(template) else: file = File(template) logger.info('Loading template from: %s', file) if not file.exists(): raise AssertionError, 'No such file: %s' % file basename, ext = file.basename.rsplit('.', 1) resources = file.dir.subdir(basename) return Template(file.readlines(), format, name=file.path, resources_dir=resources)
def testImportPageDialog(self): '''Test ImportPageDialog''' tmp_dir = self.create_tmp_dir('testImportPageDialog') file = File((tmp_dir, 'import_page.txt')) file.write('test 123\n') self.assertTrue(file.exists()) dialog = zim.gui.ImportPageDialog(self.ui) dialog.set_file(file)
def runTest(self): tmp_dir = self.create_tmp_dir() file = File((tmp_dir, 'test.txt')) file.write('test 123') self.assertTrue(file.exists()) dialog = FileDialog(None, 'Test') dialog.set_file(file)
def set_basedirs(_ignore_test=False): '''This method sets the global configuration paths for according to the freedesktop basedir specification. Called automatically when module is first loaded, should be called explicitly only when environment has changed. ''' global ZIM_DATA_DIR global XDG_DATA_HOME global XDG_DATA_DIRS global XDG_CONFIG_HOME global XDG_CONFIG_DIRS global XDG_CACHE_HOME # Cast string to folder import zim zim_data_dir = File(zim.ZIM_EXECUTABLE).dir.subdir('data') if zim_data_dir.exists(): ZIM_DATA_DIR = zim_data_dir if os.name == 'nt': APPDATA = os.environ['APPDATA'] XDG_DATA_HOME = Dir( os.environ.get('XDG_DATA_HOME', APPDATA + r'\zim\data')) XDG_DATA_DIRS = \ _split_environ_dir_list(os.environ.get('XDG_DATA_DIRS'), ('~/.local/share/',)) # Backwards compatibility XDG_CONFIG_HOME = Dir( os.environ.get('XDG_CONFIG_HOME', APPDATA + r'\zim\config')) XDG_CONFIG_DIRS = \ _split_environ_dir_list(os.environ.get('XDG_CONFIG_DIRS'), ('~/.config/',)) # Backwards compatibility XDG_CACHE_HOME = Dir( os.environ.get('XDG_CACHE_HOME', APPDATA + r'\zim\cache')) else: XDG_DATA_HOME = Dir( os.environ.get('XDG_DATA_HOME', '~/.local/share/')) XDG_DATA_DIRS = \ _split_environ_dir_list(os.environ.get('XDG_DATA_DIRS'), ('/usr/share/', '/usr/local/share/')) XDG_CONFIG_HOME = Dir( os.environ.get('XDG_CONFIG_HOME', '~/.config/')) XDG_CONFIG_DIRS = \ _split_environ_dir_list(os.environ.get('XDG_CONFIG_DIRS'), ('/etc/xdg/',)) XDG_CACHE_HOME = Dir( os.environ.get('XDG_CACHE_HOME', '~/.cache')) if os.environ.get('ZIM_TEST_RUNNING') and not _ignore_test: # See tests/__init__.py, we load more folders then we really want # because the needs of Gtk, but want to restrict it here for all # zim internal use XDG_DATA_DIRS = [Dir(os.environ['TEST_XDG_DATA_DIRS'])]
def _get_path_object(path): if isinstance(path, str): file = File(path) if file.exists(): # exists and is a file path = file else: path = Dir(path) else: assert isinstance(path, (File, Dir)) return path
def get_file(self): file = File(self.uistate['output_file']) if file.exists(): ok = QuestionDialog(self, ( _('File exists'), # T: message heading _('This file already exists.\n' 'Do you want to overwrite it?' ) # T: detailed message, answers are Yes and No ) ).run() if not ok: return None return file
def get_file(self): file = File(self.uistate['output_file']) if file.exists(): ok = QuestionDialog(self, ( _('File exists'), # T: message heading _('This file already exists.\n' 'Do you want to overwrite it?') # T: detailed message, answers are Yes and No )).run() if not ok: return None return file
def delete_file(self, file=None, refresh=False): '''Deletes a file and refreshes the treeview if refresh == True''' if not file: file = self.selected_file refresh = True logger.debug('Deleting %s' % file) file = File(file) if file.exists(): file.cleanup() if refresh: self.treeview.model.remove(self.iter)
def set_basedirs(): '''This method sets the global configuration paths for according to the freedesktop basedir specification. Called automatically when module is first loaded, should be called explicitly only when environment has changed. ''' global ZIM_DATA_DIR global XDG_DATA_HOME global XDG_DATA_DIRS global XDG_CONFIG_HOME global XDG_CONFIG_DIRS global XDG_CACHE_HOME # Cast string to folder import zim zim_data_dir = File(zim.ZIM_EXECUTABLE).dir.subdir('data') if zim_data_dir.exists(): ZIM_DATA_DIR = zim_data_dir if os.name == 'nt': APPDATA = environ['APPDATA'] XDG_DATA_HOME = Dir( environ.get('XDG_DATA_HOME', APPDATA + r'\zim\data')) XDG_DATA_DIRS = map(Dir, environ.get_list('XDG_DATA_DIRS', '~/.local/share/')) # Backwards compatibility XDG_CONFIG_HOME = Dir( environ.get('XDG_CONFIG_HOME', APPDATA + r'\zim\config')) XDG_CONFIG_DIRS = map(Dir, environ.get_list('XDG_CONFIG_DIRS', '~/.config/')) # Backwards compatibility XDG_CACHE_HOME = Dir( environ.get('XDG_CACHE_HOME', APPDATA + r'\zim\cache')) else: XDG_DATA_HOME = Dir( environ.get('XDG_DATA_HOME', '~/.local/share/')) XDG_DATA_DIRS = map(Dir, environ.get_list('XDG_DATA_DIRS', ('/usr/share/', '/usr/local/share/'))) XDG_CONFIG_HOME = Dir( environ.get('XDG_CONFIG_HOME', '~/.config/')) XDG_CONFIG_DIRS = map(Dir, environ.get_list('XDG_CONFIG_DIRS', ('/etc/xdg/',))) XDG_CACHE_HOME = Dir( environ.get('XDG_CACHE_HOME', '~/.cache'))
def testAttachFileDialog(self): '''Test AttachFileDialog''' tmp_dir = self.create_tmp_dir('testAttachFileDialog') file = File((tmp_dir, 'file_to_be_attached')) file.write('Test 1 2 3\n') newfile = File( (tmp_dir, 'attachments', 'Test', 'foo', 'file_to_be_attached')) self.assertTrue(file.exists()) self.assertFalse(newfile.exists()) mainwindow = tests.MockObject() mainwindow.pageview = tests.MockObject() mainwindow.ui = self.ui dialog = zim.gui.AttachFileDialog(mainwindow, self.ui.notebook, path=Path('Test:foo')) dialog.set_file(file) tests.gtk_process_events() dialog.assert_response_ok() self.assertTrue(file.exists()) # No move or delete happened self.assertTrue(newfile.exists()) self.assertTrue(newfile.compare(file))
class DiagramGenerator(ImageGeneratorClass): uses_log_file = False object_type = 'diagram' scriptname = 'diagram.dot' imagename = 'diagram.png' def __init__(self, plugin): ImageGeneratorClass.__init__(self, plugin) self.dotfile = TmpFile(self.scriptname) self.dotfile.touch() self.pngfile = File(self.dotfile.path[:-4] + '.png') # len('.dot') == 4 def generate_image(self, text): if isinstance(text, basestring): text = text.splitlines(True) # Write to tmp file self.dotfile.writelines(text) # Call GraphViz try: dot = Application(dotcmd) dot.run((self.pngfile, self.dotfile)) except ApplicationError: return None, None # Sorry, no log else: if self.pngfile.exists(): return self.pngfile, None else: # When supplying a dot file with a syntax error, the dot command # doesn't return an error code (so we don't raise # ApplicationError), but we still don't have a png file to # return, so return None. return None, None def cleanup(self): self.dotfile.remove() self.pngfile.remove()
def testError(self): def creator_with_failure(*a): raise ThumbnailCreatorFailure def creator_with_error(*a): raise ValueError file = File('./data/zim.png') self.assertTrue(file.exists()) self.assertTrue(file.isimage()) for creator in creator_with_failure, creator_with_error: #~ print ">>", creator.__name__ queue = ThumbnailQueue(creator) queue.queue_thumbnail_request(file, 64) with tests.LoggingFilter('zim.plugins.attachmentbrowser', 'Exception'): queue.start() while not queue.queue_empty(): r = queue.get_ready_thumbnail() self.assertIsNone(r[0], None)
def set_basedirs(): '''This method sets the global configuration paths for according to the freedesktop basedir specification. Called automatically when module is first loaded, should be called explicitly only when environment has changed. ''' global ZIM_DATA_DIR global XDG_DATA_HOME global XDG_DATA_DIRS global XDG_CONFIG_HOME global XDG_CONFIG_DIRS global XDG_CACHE_HOME # Cast string to folder import zim zim_data_dir = File(zim.ZIM_EXECUTABLE).dir.subdir('data') if zim_data_dir.exists(): ZIM_DATA_DIR = zim_data_dir if os.name == 'nt': APPDATA = environ['APPDATA'] XDG_DATA_HOME = Dir( environ.get('XDG_DATA_HOME', APPDATA + r'\zim\data')) XDG_DATA_DIRS = map(Dir, environ.get_list('XDG_DATA_DIRS', '~/.local/share/')) # Backwards compatibility XDG_CONFIG_HOME = Dir( environ.get('XDG_CONFIG_HOME', APPDATA + r'\zim\config')) XDG_CONFIG_DIRS = map(Dir, environ.get_list('XDG_CONFIG_DIRS', '~/.config/')) # Backwards compatibility try: import _winreg as wreg wreg_key = wreg.OpenKey( wreg.HKEY_CURRENT_USER, r'Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders') cache_dir = str(wreg.QueryValueEx(wreg_key, "Cache")[0].replace(u'%USERPROFILE%', environ['USERPROFILE'])) wreg.CloseKey(wreg_key) except: cache_dir = APPDATA + r'\zim\cache' # Not using TMP here because it is cleaned too often XDG_CACHE_HOME = Dir( environ.get('XDG_CACHE_HOME', cache_dir + r'\zim')) else: XDG_DATA_HOME = Dir( environ.get('XDG_DATA_HOME', '~/.local/share/')) XDG_DATA_DIRS = map(Dir, environ.get_list('XDG_DATA_DIRS', ('/usr/share/', '/usr/local/share/'))) XDG_CONFIG_HOME = Dir( environ.get('XDG_CONFIG_HOME', '~/.config/')) XDG_CONFIG_DIRS = map(Dir, environ.get_list('XDG_CONFIG_DIRS', ('/etc/xdg/',))) XDG_CACHE_HOME = Dir( environ.get('XDG_CACHE_HOME', '~/.cache'))
def set_basedirs(): '''This method sets the global configuration paths for according to the freedesktop basedir specification. Called automatically when module is first loaded, should be called explicitly only when environment has changed. ''' global ZIM_DATA_DIR global XDG_DATA_HOME global XDG_DATA_DIRS global XDG_CONFIG_HOME global XDG_CONFIG_DIRS global XDG_CACHE_HOME # Cast string to folder import zim zim_data_dir = File(zim.ZIM_EXECUTABLE).dir.subdir('data') if zim_data_dir.exists(): ZIM_DATA_DIR = zim_data_dir if os.name == 'nt': APPDATA = environ['APPDATA'] XDG_DATA_HOME = Dir( environ.get('XDG_DATA_HOME', APPDATA + r'\zim\data')) XDG_DATA_DIRS = map(Dir, environ.get_list( 'XDG_DATA_DIRS', '~/.local/share/')) # Backwards compatibility XDG_CONFIG_HOME = Dir( environ.get('XDG_CONFIG_HOME', APPDATA + r'\zim\config')) XDG_CONFIG_DIRS = map( Dir, environ.get_list('XDG_CONFIG_DIRS', '~/.config/')) # Backwards compatibility try: import _winreg as wreg wreg_key = wreg.OpenKey( wreg.HKEY_CURRENT_USER, r'Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders' ) cache_dir = str( wreg.QueryValueEx(wreg_key, "Cache")[0].replace(u'%USERPROFILE%', environ['USERPROFILE'])) wreg.CloseKey(wreg_key) except: cache_dir = APPDATA + r'\zim\cache' # Not using TMP here because it is cleaned too often XDG_CACHE_HOME = Dir(environ.get('XDG_CACHE_HOME', cache_dir + r'\zim')) else: XDG_DATA_HOME = Dir(environ.get('XDG_DATA_HOME', '~/.local/share/')) XDG_DATA_DIRS = map( Dir, environ.get_list('XDG_DATA_DIRS', ('/usr/share/', '/usr/local/share/'))) XDG_CONFIG_HOME = Dir(environ.get('XDG_CONFIG_HOME', '~/.config/')) XDG_CONFIG_DIRS = map( Dir, environ.get_list('XDG_CONFIG_DIRS', ('/etc/xdg/', ))) XDG_CACHE_HOME = Dir(environ.get('XDG_CACHE_HOME', '~/.cache'))
def runTest(self): plugins = PluginManager.list_installed_plugins() self.assertTrue(len(plugins) > 10) self.assertTrue('spell' in plugins) self.assertTrue('linkmap' in plugins) pluginindex = File('data/manual/Plugins.txt').read() seen = { 'name': set(), 'description': set(), 'help': set(), } for name in plugins: #~ print '>>', name klass = PluginManager.get_plugin_class(name) # test plugin info for key in ('name', 'description', 'author'): self.assertTrue( klass.plugin_info.get(key), 'Plugin %s misses info field \'%s\'' % (name, key) ) for key in ('name', 'description', 'help'): self.assertIn(key, klass.plugin_info, 'Plugin %s missing "%s"' % (name, key)) value = klass.plugin_info[key] self.assertFalse( value in seen[key], 'Value for \'%s\' in %s seen before - copy-paste error ?' % (key, name) ) seen[key].add(value) # test manual page present and at least documents preferences page = klass.plugin_info['help'] self.assertTrue(page.startswith('Plugins:'), 'Help page for %s not valid' % name) rellink = "+%s" % page[8:] self.assertIn(rellink, pluginindex, 'Missing links "%s" in manual/Plugins.txt' % rellink) file = File('data/manual/' + page.replace(':', '/').replace(' ', '_') + '.txt') self.assertTrue(file.exists(), 'Missing file: %s' % file) manual = file.read() for pref in klass.plugin_preferences: label = pref[2] if '\n' in label: label, x = label.split('\n', 1) label = label.rstrip(',') self.assertIn(label, manual, 'Preference "%s" for %s plugin not documented in manual page' % (label, name)) # test dependencies data dep = klass.check_dependencies() self.assertTrue(isinstance(dep,tuple)) check, dep = dep self.assertTrue(isinstance(check,bool)) self.assertTrue(isinstance(dep,list)) for i in range(len(dep)): self.assertTrue(isinstance(dep[i],tuple)) self.assertTrue(isinstance(dep[i][0],str)) self.assertTrue(isinstance(dep[i][1],bool)) self.assertTrue(isinstance(dep[i][2],bool))
class ConfigFile(object): '''Container object for a config file Maps to a "base" file in the home folder, used to write new values, and one or more default files, e.g. in C{/usr/share/zim}, which are the fallback to get default values @ivar file: the underlying file object for the base config file in the home folder @note: this class implement similar API to the L{File} class but is explicitly not a sub-class of L{File} because config files should typically not be moved, renamed, etc. It just implements the reading and writing methods. ''' def __init__(self, path, file=None): '''Constructor @param path: either basename as string or tuple with relative path, is resolved relative to the default config dir for zim. @param file: optional argument for some special case to override the base file in the home folder. ''' if isinstance(path, basestring): path = (path,) self._path = tuple(path) if file: self.file = file else: self.file = File((XDG_CONFIG_HOME, 'zim') + self._path) def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self.file.path) def __eq__(self, other): return isinstance(other, ConfigFile) \ and other._path == self._path \ and other.file == self.file @property def basename(self): return self.file.basename def default_files(self): '''Generator that yields default config files (read-only) to use instead of the standard file when it is still empty. Typically only the first one is used. ''' for dir in config_dirs(): default = dir.file(self._path) if default.exists(): yield default def touch(self): '''Ensure the custom file in the home folder exists. Either by copying a default config file, or touching an empty file. Intended to be called before trying to edit the file with an external editor. ''' if not self.file.exists(): for file in self.default_files(): file.copyto(self.file) break else: self.file.touch() # create empty file def read(self, fail=False): '''Read the base file or first default file @param fail: if C{True} a L{FileNotFoundError} error is raised when neither the base file or a default file are found. If C{False} it will return C{''} for a non-existing file. @returns: file content as a string ''' try: return self.file.read() except FileNotFoundError: for file in self.default_files(): return file.read() else: if fail: raise else: return '' def readlines(self, fail=False): '''Read the base file or first default file @param fail: if C{True} a L{FileNotFoundError} error is raised when neither the base file or a default file are found. If C{False} it will return C{[]} for a non-existing file. @returns: file content as a list of lines ''' try: return self.file.readlines() except FileNotFoundError: for file in self.default_files(): return file.readlines() else: if fail: raise else: return [] # Not implemented: read_async and readlines_async def write(self, text): '''Write base file, see L{File.write()}''' self.file.write(text) def writelines(self, lines): '''Write base file, see L{File.writelines()}''' self.file.writelines(lines) def write_async(self, text, callback=None, data=None): '''Write base file async, see L{File.write_async()}''' return self.file.write_async(text, callback=callback, data=data) def writelines_async(self, lines, callback=None, data=None): '''Write base file async, see L{File.writelines_async()}''' return self.file.writelines_async(lines, callback=callback, data=data) def remove(self): '''Remove user file, leaves default files in place''' if self.file.exists(): return self.file.remove()
def main(argv): """Run the main program Depending on the commandline given and whether or not there is an instance of zim running already, this method may return immediatly, or go into the mainloop untill the program is exitted. @param argv: commandline arguments, e.g. from C{sys.argv} @raises UsageError: when number of arguments is not correct @raises GetOptError: when invalid options are found """ global ZIM_EXECUTABLE # FIXME - this returns python.exe on my windows test ZIM_EXECUTABLE = argv[0] zim_exec_file = File(ZIM_EXECUTABLE) if zim_exec_file.exists(): # We were given an absolute path, e.g. "python ./zim.py" ZIM_EXECUTABLE = zim_exec_file.path # Check for special commandline args for ipc, does not return # if handled import zim.ipc zim.ipc.handle_argv() # Let getopt parse the option list short = "".join(shortopts.keys()) for s, l in shortopts.items(): if l.endswith("="): short = short.replace(s, s + ":") long = list(longopts) + list(commands) for opts in commandopts.values(): long.extend(opts) opts, args = gnu_getopt(argv[1:], short, long) # First figure out which command to execute cmd = "gui" # default if opts: o = opts[0][0].lstrip("-") if o in shortopts: o = shortopts[o].rstrip("=") if o in commands: opts.pop(0) cmd = o # If it is a simple command execute it and return if cmd == "version": print "zim %s\n" % __version__ print __copyright__, "\n" print __license__ return elif cmd == "help": print usagehelp.replace("zim", argv[0]) print optionhelp return # Otherwise check the number of arguments if cmd in maxargs and len(args) > maxargs[cmd]: raise UsageError # --manual is an alias for --gui /usr/share/zim/manual if cmd == "manual": cmd = "gui" args.insert(0, data_dir("manual").path) # Now figure out which options are allowed for this command allowedopts = list(longopts) allowedopts.extend(commandopts[cmd]) # Convert options into a proper dict optsdict = {} for o, a in opts: o = str(o.lstrip("-")) # str() -> no unicode for keys if o in shortopts: o = shortopts[o].rstrip("=") if o + "=" in allowedopts: o = o.replace("-", "_") optsdict[o] = a elif o in allowedopts: o = o.replace("-", "_") optsdict[o] = True else: raise GetoptError, ("--%s is not allowed in combination with --%s" % (o, cmd), o) # --port is the only option that is not of type string if "port" in optsdict and not optsdict["port"] is None: try: optsdict["port"] = int(optsdict["port"]) except ValueError: raise GetoptError, ("--port takes an integer argument", "port") # set logging output level for logging root (format has been set in zim.py) if not ZIM_EXECUTABLE[-4:].lower() == ".exe": # for most platforms level = logging.WARN else: # if running from Windows compiled .exe level = logging.ERROR if optsdict.pop("verbose", False): level = logging.INFO if optsdict.pop("debug", False): level = logging.DEBUG # no "elif" ! logging.getLogger().setLevel(level) logger.info("This is zim %s", __version__) if level == logging.DEBUG: logger.debug("Python version is %s", str(sys.version_info)) logger.debug("Platform is %s", os.name) logger.debug(get_zim_revision()) log_basedirs() # Now we determine the class to handle this command # and start the application ... logger.debug("Running command: %s", cmd) if cmd in ("export", "index", "search"): if not len(args) >= 1: default = _get_default_or_only_notebook() if not default: raise UsageError handler = NotebookInterface(notebook=default) else: handler = NotebookInterface(notebook=args[0]) handler.load_plugins() # should this go somewhere else ? if cmd == "search": if not len(args) == 2: raise UsageError optsdict["query"] = args[1] elif len(args) == 2: optsdict["page"] = args[1] method = getattr(handler, "cmd_" + cmd) method(**optsdict) elif cmd == "gui": notebook = None page = None if args: from zim.notebook import resolve_notebook notebook, page = resolve_notebook(args[0]) if not notebook: notebook = File(args[0]).uri # make sure daemon approves of this uri and proper # error dialog is shown as a result by GtkInterface if len(args) == 2: page = args[1] if "list" in optsdict: del optsdict["list"] # do not use default elif not notebook: import zim.notebook default = _get_default_or_only_notebook() if default: notebook = default logger.info("Opening default notebook") # DGT: HACK for debuger if "standalone" in optsdict or DEBUG: import zim.gui try: del optsdict["standalone"] except: pass if not notebook: import zim.gui.notebookdialog notebook = zim.gui.notebookdialog.prompt_notebook() if not notebook: return # User canceled notebook dialog handler = zim.gui.GtkInterface(notebook, page, **optsdict) handler.main() else: from zim.ipc import start_server_if_not_running, ServerProxy if not notebook: import zim.gui.notebookdialog notebook = zim.gui.notebookdialog.prompt_notebook() if not notebook: return # User canceled notebook dialog start_server_if_not_running() server = ServerProxy() gui = server.get_notebook(notebook) gui.present(page, **optsdict) logger.debug( """ NOTE FOR BUG REPORTS: At this point zim has send the command to open a notebook to a background process and the current process will now quit. If this is the end of your debug output it is probably not useful for bug reports. Please close all zim windows, quit the zim trayicon (if any), and try again. """ ) elif cmd == "server": standalone = optsdict.pop("standalone", False) # No daemon support for server, so no option doesn't # do anything for now gui = optsdict.pop("gui", False) if gui: import zim.gui.server zim.gui.server.main(*args, **optsdict) else: import zim.www zim.www.main(*args, **optsdict) elif cmd == "plugin": import zim.plugins try: pluginname = args.pop(0) except IndexError: raise UsageError module = zim.plugins.get_plugin_module(pluginname) module.main(*args)
def runTest(self): plugins = PluginManager.list_installed_plugins() self.assertTrue(len(plugins) > 10) self.assertTrue('spell' in plugins) self.assertTrue('linkmap' in plugins) pluginindex = File('data/manual/Plugins.txt').read() seen = { 'name': set(), 'description': set(), 'help': set(), } for name in plugins: #~ print('>>', name) klass = PluginManager.get_plugin_class(name) # test plugin info for key in ('name', 'description', 'author'): self.assertTrue( klass.plugin_info.get(key), 'Plugin %s misses info field \'%s\'' % (name, key) ) for key in ('name', 'description', 'help'): self.assertIn(key, klass.plugin_info, 'Plugin %s missing "%s"' % (name, key)) value = klass.plugin_info[key] self.assertFalse( value in seen[key], 'Value for \'%s\' in %s seen before - copy-paste error ?' % (key, name) ) seen[key].add(value) # test manual page present and at least documents preferences page = klass.plugin_info['help'] self.assertTrue(page.startswith('Plugins:'), 'Help page for %s not valid' % name) rellink = "+%s" % page[8:] self.assertIn(rellink, pluginindex, 'Missing links "%s" in manual/Plugins.txt' % rellink) file = File('data/manual/' + page.replace(':', '/').replace(' ', '_') + '.txt') self.assertTrue(file.exists(), 'Missing file: %s' % file) manual = file.read() ignore = getattr(klass, 'hide_preferences', []) for pref in klass.plugin_preferences: if pref[0] in ignore: continue label = pref[2] if '\n' in label: label, x = label.split('\n', 1) label = label.rstrip(',') self.assertIn(label, manual, 'Preference "%s" for %s plugin not documented in manual page' % (label, name)) # test dependencies data dep = klass.check_dependencies() self.assertTrue(isinstance(dep, tuple)) check, dep = dep self.assertTrue(isinstance(check, bool)) self.assertTrue(isinstance(dep, list)) for i in range(len(dep)): self.assertTrue(isinstance(dep[i], tuple)) self.assertTrue(isinstance(dep[i][0], str)) self.assertTrue(isinstance(dep[i][1], bool)) self.assertTrue(isinstance(dep[i][2], bool))