def test_differentOnDisk(self): path = tempfile.mktemp() try: # Init the test file with some content. _writefile(path, "blah\nblah\nblah\n") koDoc = self._koDocFromPath(path, load=False) # Make it look like a remote file. rawFile = UnwrapObject(koDoc.file) rawFile.isLocal = 0 rawFile.isRemoteFile = 1 koDoc.load() # Wait one second, so we generate a different mtime. import time time.sleep(1.1) _writefile(path, "blah\nblah\nblah\nblah\n") self.assertTrue(koDoc.differentOnDisk(), "Remote file change was not detected") # Next time we call it - it should still detect the file as being changed - bug 95690. self.assertTrue(koDoc.differentOnDisk(), "Remote file change was not detected a second time") # Because we are using a fake koIFileEx (or really a local file), # this test can fail if the timestamp between the save and the # differentOnDisk calls has changed. To work around that, we run # multiple checks and only accept one failure. success_count = 0 for tries in range(3): koDoc.save(True) if not koDoc.differentOnDisk(): success_count += 1 self.assertTrue(success_count >= 2, "Remote file change detected after saving the file") finally: if os.path.exists(path): os.unlink(path) # clean up
def deleteRows(self, dataTreeView, rowNums): # @param dataTreeView { koIDBXTableDumpTreeView } # koIDBXTableDumpTreeView: koDatabaseExplorerTreeView.koDatabaseExplorerTreeView # @param rowNums {array of int} column_names = self.getColumnNames() query_names = [] dataTreeView = UnwrapObject(dataTreeView) schemaTreeView = UnwrapObject(dataTreeView.get_schemaTreeView()) for i in range(len(column_names)): is_key = (schemaTreeView.getCellText(i, dbxlib.Column('is_primary_key')).lower() in ('true', '1')) # windows: 'true', linux: '1' if is_key: query_names.append(column_names[i]) if not query_names: raise dbxlib.DBXception("No attributes are keys, can't delete") table_name = self._table_name # return True if any rows are deleted final_res = "" for rowNum in rowNums: query_values = [] for column_name in query_names: query_values.append(dataTreeView.getCellText(rowNum, dbxlib.Column(column_name))) res = self._db.deleteRowByKey(self._table_name, query_names, query_values) if not (res or final_res): final_res = ("Failed to delete keys:%s, values:%s" % (", ".join(query_names), ", ".join([str(x) for x in query_values]))) return final_res
def test_language_reset(self): manifest = [ ("Python", tempfile.mktemp(".py"), """\ #!/usr/bin/env python print 'should be py' """), ("Python3", tempfile.mktemp(".py"), """\ # -*- python3 -*- print('should be py3') """), ("JavaScript", tempfile.mktemp(".js"), """\ alert('should be js') """), ] for lang, name, content in manifest: path = join(self.data_dir, name) _writefile(path, content) koDoc = self._koDocFromPath(path) self.assertEqual(koDoc.language, lang) koDoc.language = "Perl" self.assertEqual(koDoc.language, "Perl") koDoc.language = "" self.assertEqual(koDoc.language, lang) # Validate the documents preference chain - bug 97728. doc = UnwrapObject(koDoc) doc._walkPrefChain(doc.prefs, doPrint=False)
def DOMDeserialize(self, rootElement, parentPref, prefFactory, basedir=None, chainNotifications=0): """We know how to deserialize preferent-set elements.""" # Create a new preference set and rig it into the preference set hierarchy. xpPrefSet = components.classes["@activestate.com/koPreferenceSet;1"] \ .createInstance(components.interfaces.koIPreferenceSet) newPrefSet = UnwrapObject(xpPrefSet) newPrefSet.chainNotifications = chainNotifications try: newPrefSet.id = rootElement.getAttribute('id') or "" except KeyError: newPrefSet.id = "" try: newPrefSet.idref = rootElement.getAttribute('idref') or "" except KeyError: newPrefSet.idref = "" # Iterate over the elements of the preference set, # deserializing them and fleshing out the new preference # set with content. childNodes = rootElement.childNodes for node in childNodes: if node and node.nodeType == minidom.Node.ELEMENT_NODE: if node.hasAttribute('validate'): newPrefSet.setValidation(node.getAttribute('id'), node.getAttribute('validate')) pref = _dispatch_deserializer(self, node, newPrefSet, prefFactory, basedir, chainNotifications) if pref: if pref.id: newPrefSet.setPref(pref.id, pref) else: log.error("Preference has no id - dumping preference:") pref.dump(0) return xpPrefSet
def DOMDeserialize(self, rootElement, parentPref, prefFactory, basedir=None, chainNotifications=0): """We know how to deserialize ordered-preference elements.""" # Create a new ordered preference. xpOrderedPref = components.classes["@activestate.com/koOrderedPreference;1"].createInstance( components.interfaces.koIOrderedPreference ) newOrderedPref = UnwrapObject(xpOrderedPref) try: newOrderedPref.id = rootElement.getAttribute("id") or "" except KeyError: newOrderedPref.id = "" # Iterate over the elements of the preference set, # deserializing them and fleshing out the new preference # set with content. childNodes = rootElement.childNodes for childNode in childNodes: if childNode and childNode.nodeType == minidom.Node.ELEMENT_NODE: pref = _dispatch_deserializer(self, childNode, newOrderedPref, prefFactory, basedir) if pref: newOrderedPref.appendPref(pref) return xpOrderedPref
class KoTerminalProcess(KoRunProcess): _terminal = None def linkIOWithTerminal(self, terminal): # Need to unwrap the terminal handler because we are not actually # passing in koIFile xpcom objects as described by the API, we are # using the subprocess python file handles instead. self._terminal = UnwrapObject(terminal) self._terminal.hookIO(self._process.stdin, self._process.stdout, self._process.stderr, "KoTerminalProcess") # Override the KoRunProcess.wait() method. def wait(self, timeout=None): retval = KoRunProcess.wait(self, timeout) if self._terminal: # Need to wait until the IO is fully synchronized (due to threads) # before returning. Otherwise additional data could arrive after # this call returns. # # Set timeout to 5 seconds due to bugs 89280 and 88439 self._terminal.waitForIOToFinish(timeout=5) self._terminal = None return retval def waitAsynchronously(self, runTerminationListener): t = threading.Thread(target=_terminalProcessWaiter, args=(self, runTerminationListener)) t.setDaemon(True) t.start()
def initialize(self, toolbox_db_svc): global _tbdbSvc _tbdbSvc = self.toolbox_db = toolbox_db_svc self._koToolbox2Service = UnwrapObject(components.classes["@activestate.com/koToolbox2Service;1"].getService(components.interfaces.koIToolbox2Service)) self._koProjectService = UnwrapObject(components.classes["@activestate.com/koPartService;1"].getService(components.interfaces.koIPartService)) self._globalPrefs = components.classes["@activestate.com/koPrefService;1"].\ getService(components.interfaces.koIPrefService).prefs
class KoCodeIntelXPCOMSupportReigstrationHelper(object): """Helper class for codeintel command extension registration; See kd290 / KoCodeIntelManager._send_init_requests.initialization_completed""" _com_interfaces_ = [] _reg_clsid_ = "{3ae458a3-b767-47d8-a5a6-1731d415c54b}" _reg_contractid_ = "@activestate.com/codeintel/xpcom/registration-helper;1" _reg_desc_ = "Komodo XPCOM Code Intelligence Backend Registration Helper" _reg_categories_ = [ ("codeintel-command-extension", _reg_contractid_), ] def __init__(self): self.completer = \ UnwrapObject(Cc[KoCodeIntelXPCOMSupport._reg_contractid_] .getService()) self.data = [ (dirname(__file__), "xpcomJSElements"), ] def __iter__(self): """Iteration for codeintel command extension registration""" return self def next(self): try: return self.data.pop(0) except IndexError: self.completer.send_connection_request() raise StopIteration
def test_differentOnDisk(self): path = tempfile.mktemp() try: # Init the test file with some content. _writefile(path, "blah\nblah\nblah\n") koDoc = self._koDocFromPath(path) # Make it look like a remote file. rawFile = UnwrapObject(koDoc.file) rawFile.isLocal = 0 rawFile.isRemoteFile = 1 koDoc.load() # Wait one second, so we generate a different mtime. import time time.sleep(1.1) _writefile(path, "blah\nblah\nblah\nblah\n") self.assertTrue(koDoc.differentOnDisk(), "Remote file change was not detected") # Next time we call it - it should still detect the file as being changed - bug 95690. self.assertTrue(koDoc.differentOnDisk(), "Remote file change was not detected a second time") koDoc.save(True) self.assertFalse(koDoc.differentOnDisk(), "Remote file change detected after saving the file") finally: if os.path.exists(path): os.unlink(path) # clean up
def _setup_for_xpcom(): # Use a temporary user data dir userDataRoot = tempfile.mkdtemp(prefix="ko-test-userdata-") atexit.register(shutil.rmtree, userDataRoot) os.environ["KOMODO_USERDATADIR"] = userDataRoot # The tests are run outside of Komodo. If run with PyXPCOM up # parts codeintel will try to use the nsIDirectoryService and # will query dirs only provided by nsXREDirProvider -- which # isn't registered outside of Komodo (XRE_main() isn't called). # The KoTestService provides a backup. from xpcom import _xpcom from xpcom import components from xpcom.server import UnwrapObject koTestSvc = components.classes["@activestate.com/koTestService;1"] \ .getService(components.interfaces.koITestService) koTestSvc.init() # Reset the startup-env.tmp file (normally done by komodo.exe), otherwise # we'll be reading stale environment settings from whenever Komodo was last # run on this machine. koEnvironSvc = components.classes["@activestate.com/koUserEnviron;1"] \ .getService(components.interfaces.koIUserEnviron) pyEnvironSvc = UnwrapObject(koEnvironSvc) try: os.remove(pyEnvironSvc.startupEnvFileName) except OSError: # Doesn't exist, or we don't have the correct permissions... ignore. pass pyEnvironSvc._UpdateFromStartupEnv()
def addNewItemToParent(self, parent, item, showNewItem=True): """ This code has a model part and a view part. Call the view part if we need to update it. """ # TODO: if parent is null, use the std toolbox node item = UnwrapObject(item) parent = UnwrapObject(parent) parent_path = self.toolbox_db.getPath(parent.id) item_name = item.name itemIsContainer = item.isContainer if itemIsContainer: # Bug 96486: Can't create folders named "*" on Windows # Now that we're encouraging people to create folders with this name, # we need to quietly change the "*"s to "_"s. I don't # remember why I decided not to do this in general. system_item_name = item_name.replace("*", "_") # Don't do anything else to this name. If there's a dup, or # it contains bad characters, give the user the actual # error message. Which is why we need to try creating # the folder first, before adding its entry. path = join(parent_path, system_item_name) if system_item_name != item_name: # Make sure it's new if os.path.exists(path): for i in range(20): suffix = i + 1 new_path = "%s-%d" % (path, suffix) if not os.path.exists(new_path): path = new_path break item.trailblazeForPath(path) else: path = self._prepareUniqueFileSystemName(parent_path, item_name) try: itemDetailsDict = {} item.fillDetails(itemDetailsDict) if itemIsContainer: new_id = self.toolbox_db.addContainerItem(itemDetailsDict, item.typeName, path, item_name, parent.id) else: new_id = self.toolbox_db.addTool(itemDetailsDict, item.typeName, path, item_name, parent.id) old_id = item.id item.id = new_id # Even if the old and new IDs are the same, we don't want # to keep the old item in the cache. try: del self._tools[old_id] except KeyError: log.error("No self._tools[%r]", old_id) self._tools[new_id] = item item.saveNewToolToDisk(path) if showNewItem: self._koToolboxHView.addNewItemToParent(parent, item) item.added() except: log.exception("addNewItemToParent: failed") raise
def _clonePartList(self, newproject, partList): # clone parts and add them to the project for part in partList: part = UnwrapObject(part) if part.type == 'project': self._clonePartList(newproject, part.children) else: newpart = part.copyToProject(newproject) newproject.addChild(newpart)
def lint(self, request): try: html_linter = UnwrapObject(self._koLintService.getLinterForLanguage("HTML")) return html_linter.lint(request, TPLInfo=self._tplPatterns) except: if "lint" not in self._checkValidVersion_complained: self._checkValidVersion_complained["lint"] = True log.exception("Problem in koPHPLinter.lint") return koLintResults()
def KGit_hookFunction(self): wm = components.classes["@mozilla.org/appshell/window-mediator;1"].getService(components.interfaces.nsIWindowMediator) win = wm.getMostRecentWindow("Komodo") tree = win.document.getElementById('places-files-tree') treebox = tree.boxObject.QueryInterface(components.interfaces.nsITreeBoxObject) pview = UnwrapObject(treebox.view) if pview._buildCellProperties == self.KGit_buildCellProperties: return self._buildCellProperties_old = pview._buildCellProperties pview._buildCellProperties = self.KGit_buildCellProperties
class KoTemplateCategoriesView(TreeView): _com_interfaces_ = [components.interfaces.koITemplateCategoriesView, components.interfaces.nsITreeView] _reg_clsid_ = "{0723776F-EE9D-4F20-B438-3AF893192346}" _reg_contractid_ = "@activestate.com/koTemplateCategoriesView;1" _reg_desc_ = "Komodo Template Categories nsITreeView" def __init__(self): TreeView.__init__(self) #, debug="categories") #XXX self._tree = None self._sortedBy = None # The table used to fill in the tree. It is a list of dicts. Each # dict represents one row in the tree/outliner. This dictionary is # also (because it is convenient) used to store data in addition to # the named rows of the XUL tree. e.g., # [ {"category-name": "My Templates", # row 0 # "node": <Node instance for this category>}, # ... ] # This attribute is re-generated from self.templateTree whenever # the rows change (say, by the user opening a category with # sub-categories). self._data = [] self._prefSvc = components.classes["@activestate.com/koPrefService;1"]\ .getService().prefs # global prefs self.templateTree = None # Working copy of template tree Nodes. self.selectedTemplateByCategory = None self.categoryIsOpen = None self.atomSvc = components.classes["@mozilla.org/atom-service;1"].\ getService(components.interfaces.nsIAtomService) self.folderOpenAtom = self.atomSvc.getAtom("folderOpen") self.folderClosedAtom = self.atomSvc.getAtom("folderClosed") def initialize(self, templateSvc, templatesView): # Need to unwrap these Python XPCOM object because we access # methods on them that are not in the IDL. self.templateSvc = UnwrapObject(templateSvc) self.templatesView = UnwrapObject(templatesView) if not self.templateSvc.loaded: self.templateSvc.loadTemplates() self.templateTree = self.templateSvc.getTemplateTree() # a working copy # Restore the user selections from prefs stbcStr = self._prefSvc.getStringPref("%s_selected_template_by_category" % self.templateSvc.basename) try: self.selectedTemplateByCategory = eval(stbcStr) except SyntaxError, ex: self.selectedTemplateByCategory = {} ocStr = self._prefSvc.getStringPref("%s_open_categories" % self.templateSvc.basename) try: self.categoryIsOpen = eval(ocStr) except SyntaxError, ex: self.categoryIsOpen = {}
def _loadAllLanguages(self): self._allRows = [] langRegistry = components.classes["@activestate.com/koLanguageRegistryService;1"].getService(components.interfaces.koILanguageRegistryService) langRegistry = UnwrapObject(langRegistry) langNames = langRegistry.getLanguageNames() for langName in langNames: isPrimary = langRegistry._primaryLanguageNames.get(langName, False) self._allRows.append({'name':langName, 'name_lc':langName.lower(), 'status':isPrimary, 'origStatus':isPrimary})
def _gatherIconsAux(self, part, icons): part = UnwrapObject(part) icon = part.get_iconurl() if self.test: print "icon [%s]"%icon if not icon.startswith(('chrome://', 'moz-icon://stock/')): newicon = os.path.join('.icons', os.path.basename(icon)) part.set_iconurl(newicon) icons.append((uriparse.URIToLocalPath(icon),newicon)) if hasattr(part, 'getChildren'): for p in part.getChildren(): self._gatherIconsAux(p, icons)
def save(self, prefs): if not self._wasChanged: return langRegistry = UnwrapObject(Cc["@activestate.com/koLanguageRegistryService;1"] .getService(Ci.koILanguageRegistryService)) for row in self._rows: langName, status, origStatus = row['name'], row['status'], row['origStatus'] if status != origStatus: langRegistry.changeLanguageStatus(langName, status) # Update the pref primaryLanguagePref = "languages/%s/primary" % (langName,) prefs.setBoolean(primaryLanguagePref, bool(status)) self.notifyObservers(None, 'primary_languages_changed', '')
def savePrefs(self, kpf): prefSvc = components.classes["@activestate.com/koPrefService;1"]\ .getService().prefs # global prefs # multi tree, we want JUST the project passed in. Get all the # id's from the project, and then get the matching id's from # nodeIsOpen kpf = UnwrapObject(kpf) nodeIsOpen = {} for id in self._nodeIsOpen.keys(): if kpf.getChildById(id): nodeIsOpen[id] = self._nodeIsOpen[id] prefSvc.setStringPref("kpf_open_nodes_%s" % kpf.id, repr(nodeIsOpen))
def paths(self): """Generate all paths for this collection.""" for type, item in self.items: if type == "path": yield item elif type == "file": path = _local_path_from_url(item.url) if path is not None: yield path elif type == "container": container = UnwrapObject(item) for path in container.genLocalPaths(): yield path
def lint_with_text(self, request, text): linters = self._koLintService.getTerminalLintersForLanguage(self._languageName) finalLintResults = koLintResults() for linter in linters: try: newLintResults = UnwrapObject(linter).lint_with_text(request, text) except: log.exception("lint_with_text exception") else: if newLintResults and newLintResults.getNumResults(): if finalLintResults.getNumResults(): finalLintResults = finalLintResults.addResults(newLintResults) else: finalLintResults = newLintResults return finalLintResults
def _get(self, kind, callback): def on_have_catalogs(request, response): try: cb = callback.callback except AttributeError: cb = callback # not XPCOM? items = response.get(kind) if items is None or not response.get("success"): cb(Ci.koIAsyncCallback.RESULT_ERROR, []) else: cb(Ci.koIAsyncCallback.RESULT_SUCCESSFUL, items) cisvc = UnwrapObject(Cc["@activestate.com/koCodeIntelService;1"] .getService()) cisvc.send(command="get-xml-catalogs", callback=on_have_catalogs)
class KoXBLCompileLinter(object): _com_interfaces_ = [components.interfaces.koILinter] _reg_desc_ = "Komodo XBL Compile Linter" _reg_clsid_ = "{4e023df3-4fda-4c74-abe0-b6623d72862e}" _reg_contractid_ = "@activestate.com/koLinter?language=XBL;1" _reg_categories_ = [ ("category-komodo-linter", 'XBL'), ] def __init__(self): koLintService = components.classes["@activestate.com/koLintService;1"].getService(components.interfaces.koILintService) self._html_linter = koLintService.getLinterForLanguage("HTML") self._js_linter = UnwrapObject(koLintService.getLinterForLanguage("JavaScript")) def lint(self, request): try: return UnwrapObject(self._html_linter).lint(request, linters={"JavaScript":self}) except: log.exception("Error linting XBL") # We can't use standard JS linting to handle XBL methods, # so wrap the JSLinter, and filter out results complaining # about return stmts outside functions. def lint_with_text(self, request, text): #log.debug("XBL text: %s", text) jsResults = self._js_linter.lint_with_text(request, text) #log.debug("XBL lint results: %s", # [str(x) for x in jsResults.getResults()]) fixedResults = koLintResults() for res in jsResults.getResults(): if 'return not in function' not in res.description: fixedResults.addResult(res) return fixedResults
class KoEpMojoLinter(object): _com_interfaces_ = [components.interfaces.koILinter] _reg_desc_ = "epMojo Template Linter" _reg_clsid_ = "{3b69f94f-4fb6-47bb-a387-9d3ac372195a}" _reg_contractid_ = "@activestate.com/koLinter?language=epMojo;1" _reg_categories_ = [ ("category-komodo-linter", 'epMojo'), ] def __init__(self): self._koLintService = components.classes[ "@activestate.com/koLintService;1"].getService(components.interfaces.koILintService) self._html_linter = UnwrapObject( self._koLintService.getLinterForLanguage("HTML")) _tplPatterns = ("epMojo", re.compile( '<%='), re.compile(r'%>\s*\Z', re.DOTALL)) def lint(self, request): return self._html_linter.lint(request, TPLInfo=self._tplPatterns) def lint_with_text(self, request, text): # With revised html_linter template processing, the html linter will # pull out Perl parts and dispatch them to the perl linter, so there's # nothing to do here. return None
def linkIOWithTerminal(self, terminal): # Need to unwrap the terminal handler because we are not actually # passing in koIFile xpcom objects as described by the API, we are # using the subprocess python file handles instead. self._terminal = UnwrapObject(terminal) self._terminal.hookIO(self._process.stdin, self._process.stdout, self._process.stderr, "KoTerminalProcess")
def __init__(self): koLintService = components.classes["@activestate.com/koLintService;1"].getService( components.interfaces.koILintService ) # Still need to use HTML's _lint_common_html_request to pull out the # erb directives self._html_linter = UnwrapObject(koLintService.getLinterForLanguage("HTML5"))
def __init__(self): self.completer = \ UnwrapObject(Cc[KoCodeIntelXPCOMSupport._reg_contractid_] .getService()) self.data = [ (dirname(__file__), "xpcomJSElements"), ]
def __init__(self, methodName): unittest.TestCase.__init__(self, methodName) self.__fileStatusSvc = components.classes["@activestate.com/koFileStatusService;1"] \ .getService(components.interfaces.koIFileStatusService) from xpcom.server import UnwrapObject UnwrapObject(self.__fileStatusSvc).init() self.__filesvc = components.classes["@activestate.com/koFileService;1"] \ .getService(components.interfaces.koIFileService)
def deleteRows(self, dataTreeView, rowNums): # @param dataTreeView { koIDBXTableDumpTreeView } # koIDBXTableDumpTreeView: koDatabaseExplorerTreeView.koDatabaseExplorerTreeView # @param rowNums {array of int} column_names = self.getColumnNames() query_names = [] dataTreeView = UnwrapObject(dataTreeView) schemaTreeView = UnwrapObject(dataTreeView.get_schemaTreeView()) for i in range(len(column_names)): is_key = (schemaTreeView.getCellText(i, dbxlib.Column('is_primary_key')) == '1') if is_key: query_names.append(column_names[i]) if not query_names: raise dbxlib.DBXception("No attributes are keys, can't delete") table_name = self._table_name # return True if any rows are deleted final_res = "" for rowNum in rowNums: query_values = [] for column_name in query_names: query_values.append(dataTreeView.getCellText(rowNum, dbxlib.Column(column_name))) res = self._db.deleteRowByKey(self._table_name, query_names, query_values) if not (res or final_res): final_res = ("Failed to delete keys:%s, values:%s" % (", ".join(query_names), ", ".join([str(x) for x in query_values]))) return final_res
def test_12_python_actions(self): """Test Python API with actions""" self.assertEquals(self.nm.notificationCount, 0) nm = UnwrapObject(self.nm) a0_data = { "identifier": "action0", "label": "action0-label", "accessKey": "a", "iconURL": "action-url", "visible": True, "enabled": True } notif = nm.add("summary", ["tags"], "notif-action-py", actions=[a0_data]) self.assertEquals(notif, self._wrap(notif)) # should already be wrapped notif.QueryInterface(Ci.koINotification) # should implement this notif.QueryInterface(Ci.koINotificationActionable) # due to actions= self.assertEquals(self.nm.notificationCount, 1) # added one notification try: self.assertEquals(len(notif.getActions()), 1) self.assertEquals(len(notif.getActions("bad-id")), 0) self.assertEquals(len(notif.getActions("action0")), 1) action = notif.getActions()[0] self.assertEquals(action, self._wrap(action)) for k, v in a0_data.items(): self.assertEquals(getattr(action, k), v) for k in ("label", "accessKey", "iconURL"): with self.check_called(notif, will_call=False): # changing the action won't force an update self.assertNotEquals(getattr(action, k), k) setattr(action, k, k) self.assertEquals(getattr(action, k), k) with self.check_called(notif, old_index=0, new_index=0): # calling the right update API, however, will fire listeners nm.update(notif, actions=[{ "identifier": "action0", "label": "new label" }]) self.assertEquals(action.label, "new label") self.assertRaises(COMException, nm.update, notif, actions=[{ "label": "foo" }]) self.assertRaises(COMException, nm.update, notif, actions=[{ "identifier": "action0", "invalid": "key" }]) finally: nm.remove(notif) self.assertEquals(self.nm.notificationCount, 0)
def __init__(self): try: self.phpInfoEx = components.classes["@activestate.com/koAppInfoEx?app=PHP;1"].\ getService(components.interfaces.koIPHPInfoEx) koLintService = components.classes["@activestate.com/koLintService;1"].getService(components.interfaces.koILintService) self._html_linter = UnwrapObject(koLintService.getLinterForLanguage("HTML")) except: log.exception("Problem getting phpInfoEx") raise
def lint(self, request): # With the "squelching" the multi-language linter does to pull # <% and %>-like tokens out of the lint input stream, there's no # need to map all Ruby code to RHTML if rails_role_from_path(request.koDoc.displayPath): TPLInfo = list(self._tplPatterns) + [{"supportRERB": True}] else: TPLInfo = self._tplPatterns return UnwrapObject(self._html_linter).lint(request, TPLInfo=TPLInfo)
def initialize(self, templateSvc, templatesView): # Need to unwrap these Python XPCOM object because we access # methods on them that are not in the IDL. self.templateSvc = UnwrapObject(templateSvc) self.templatesView = UnwrapObject(templatesView) if not self.templateSvc.loaded: self.templateSvc.loadTemplates() self.templateTree = self.templateSvc.getTemplateTree( ) # a working copy # Restore the user selections from prefs stbcStr = self._prefSvc.getStringPref( "%s_selected_template_by_category" % self.templateSvc.basename) try: self.selectedTemplateByCategory = eval(stbcStr) except SyntaxError, ex: self.selectedTemplateByCategory = {}
def lint_with_text(self, request, text): linters = self._koLintService.getTerminalLintersForLanguage( self._languageName) finalLintResults = koLintResults() for linter in linters: try: newLintResults = UnwrapObject(linter).lint_with_text( request, text) except: log.exception("lint_with_text exception") else: if newLintResults and newLintResults.getNumResults(): if finalLintResults.getNumResults(): finalLintResults = finalLintResults.addResults( newLintResults) else: finalLintResults = newLintResults return finalLintResults
def initialize(self): if self._inited: return self._inited = True koDirSvc = components.classes["@activestate.com/koDirs;1"].getService() self.toolbox_db = UnwrapObject(components.classes["@activestate.com/KoToolboxDatabaseService;1"].\ getService(components.interfaces.koIToolboxDatabaseService)) self._toolsMgrSvc = UnwrapObject(components.classes["@activestate.com/koToolbox2ToolManager;1"].\ getService(components.interfaces.koIToolbox2ToolManager)); self._toolsMgrSvc.initialize(self.toolbox_db) self.db_path = os.path.join(koDirSvc.userDataDir, 'toolbox.sqlite') schemaFile = os.path.join(koDirSvc.supportDir, 'toolbox', 'koToolbox.sql') try: self.db = self.toolbox_db.initialize(self.db_path, schemaFile) self.loadMainToolboxes() except: log.exception("Error initializing toolboxes")
def removeObserver(self, anObserver, aTopic): try: anObserver = UnwrapObject(anObserver) except ValueError: pass self.cv.acquire() try: self._removeObserver(anObserver, aTopic) finally: self.cv.release()
def initialize(self): if self._inited: return self._inited = True koDirSvc = components.classes["@activestate.com/koDirs;1"].getService() self.toolbox_db = UnwrapObject(components.classes["@activestate.com/KoToolboxDatabaseService;1"].\ getService(components.interfaces.koIToolboxDatabaseService)) self._toolsMgrSvc = UnwrapObject(components.classes["@activestate.com/koToolbox2ToolManager;1"].\ getService(components.interfaces.koIToolbox2ToolManager)) self._toolsMgrSvc.initialize(self.toolbox_db) self.db_path = os.path.join(koDirSvc.userDataDir, 'toolbox.sqlite') schemaFile = os.path.join(koDirSvc.supportDir, 'toolbox', 'koToolbox.sql') try: self.db = self.toolbox_db.initialize(self.db_path, schemaFile) self.loadMainToolboxes() except: log.exception("Error initializing toolboxes")
def runCommandInTerminal(self, async_callback, terminalHandler, args, env): # Run asynchronously self.terminalHandler = UnwrapObject(terminalHandler) import koprocessutils currentEnv = koprocessutils.getUserEnv() newEnvParts = env.split(";") for part in newEnvParts: parts = part.split("=") if len(parts) == 2: currentEnv[parts[0]] = parts[1] else: currentEnv[parts[0]] = "" self.env = currentEnv async_svc = components.classes["@activestate.com/koAsyncService;1"].\ getService(components.interfaces.koIAsyncService) async_op = koAsyncOperationBase(self._doRunCommandInTerminal, args) async_svc.run("Stackato %s" % (args[0]), async_op, async_callback, [], False) return async_op
def lint_with_text(self, request, text): linters = self._koLintService.getTerminalLintersForLanguage(self._languageName) finalLintResults = None # Becomes the first results that has entries. for linter in linters: try: newLintResults = UnwrapObject(linter).lint_with_text(request, text) except: log.exception("lint_with_text exception") else: if finalLintResults is None: finalLintResults = newLintResults elif newLintResults: # Keep the lint results that has the most entries, then copy # the other result with lesser entries into it. if newLintResults.getNumResults() > finalLintResults.getNumResults(): # Swap them around, so final has the most entries. finalLintResults, newLintResults = newLintResults, finalLintResults finalLintResults.addResults(newLintResults) return finalLintResults
def run(self, name, aOp, aOpCallback, affected_uris, lock_these_uris): # Test if we can unwrap the operation. This ensure's that aOp is a # Python object! If it is not, then an exception will be raised. aOp = UnwrapObject(aOp) log.debug("Running asynchronous command: %r", name) t = threading.Thread(name=name, target=self.__run, args=(name, aOp, aOpCallback, affected_uris, lock_these_uris)) t.setDaemon(True) t.start()
def KoUserEnviron(startupEnvFileName=None): koEnviron = components.classes[ "@activestate.com/koUserEnviron;1"] \ .createInstance(components.interfaces.koIUserEnviron) if startupEnvFileName: environ = UnwrapObject(koEnviron) environ.__init__(startupEnvFileName) current_encoding = locale.getlocale()[1] # For some reason this can be the value 'None' when running in # the pyxpcom test suite, so fall back to the expected default # platform encoding. if not current_encoding: if sys.platform.startswith('win'): current_encoding = 'mbcs' elif sys.platform.startswith('darwin'): current_encoding = 'mac-roman' elif sys.platform.startswith('linux'): current_encoding = 'utf-8' environ.startupEnvironEncoding = current_encoding return koEnviron
def removeProject(self, kpfWrapped): self._partSvc.removeProject(kpfWrapped) kpf = UnwrapObject(kpfWrapped) self.savePrefs(kpf) needNewCurrentProject = kpfWrapped == self.get_currentProject() # remove rows for project index = self._getIndexByPart(kpf) if index == -1: log.debug("removeProject: can't find project %s", kpf.get_name()) return sibling = self.getNextSiblingIndex(index) if needNewCurrentProject: if index == 0: # first project becomes active, if there is one if sibling < len(self._rows): newCurrentIndex = 0 else: newCurrentIndex = -1 else: # previous project becomes active newCurrentIndex = self._getPrevSiblingIndex(index) #@@@@ self._rows = self._rows[:index] + self._rows[sibling:] if not self._tree: # bug 101553: Could happen at shutdown: there is no more project tree log.warn( "koKPFTreeView.p.py: removeProject: there is no self._tree") return self._tree.rowCountChanged(index, (index - sibling)) if needNewCurrentProject: self._tree.beginUpdateBatch() try: self._tree.invalidateRow(index) if newCurrentIndex != -1: self.set_currentProject(self._rows[newCurrentIndex].part) self._tree.invalidateRow(newCurrentIndex) else: # closing the only project we have, no current project self.set_currentProject(None) finally: self._tree.endUpdateBatch()
def addResults(self, other): # Returns a new object newLintResults = koLintResults() try: other_results = other._results except AttributeError: other_results = UnwrapObject(other)._results newLintResults._results = self._results newLintResults._resultMap = self._resultMap for result in other_results: newLintResults.addResult(result) return newLintResults
def equals(self, other): """ Equality comparision for XPCOM """ if _xpcom_: try: other = UnwrapObject(other) except: pass for attr in ("lang", "path", "blobname", "lpath", "name", "line", "ilk", "citdl", "doc", "signature", "attributes", "returns"): if getattr(self, attr) != getattr(other, attr): return False return True
def packageProject(self, packagePath, project, overwrite): try: if project.isDirty: err = 'Save project before packaging' self.lastErrorSvc.setLastError(1, err) raise ServerException(nsError.NS_ERROR_ILLEGAL_VALUE, err) project = UnwrapObject(project) self._packageParts(packagePath, orig_project=project, live=project.live, extradir=0, overwrite=overwrite) except Exception, e: log.exception(e)
def addFileStatusChecker(self, checkerInstance): self._tlock.acquire() try: log.info("addFileStatusChecker:: added %r", checkerInstance.name) # Try to get the native Python checker instance instead of XPCOM # one - saves CPU cycles by not having to go through XPCOM. try: checkerInstance = UnwrapObject(checkerInstance) except: pass # Keep the XPCOM version then. checkerInstance.initialize() for i in range(len(self._statusCheckers)): checker = self._statusCheckers[i] if checkerInstance.ranking_weight < checker.ranking_weight: self._statusCheckers.insert(i, checkerInstance) break else: self._statusCheckers.append(checkerInstance) #print "Order now: %r" % ([x.name for x in self._statusCheckers]) finally: self._tlock.release()
def _buildCellProperties(self, row, column): prop = [] prop.append("primaryColumn") part = self._rows[row].part prop.append(part.type) if not hasattr(part, 'file'): # We hold a reference to the koFile instance, this causes the file # status service to check/maintain the file's status information. part.file = part.getFile() if part.file and not part.file.isLocal: prop.append("remote") if part.file: f = UnwrapObject(part.file) # missing, sccOk, sccSync, sccConflict, add, delete, edit, # isReadOnly, branch, integrate if hasattr(f, 'exists') and not f.exists: prop.append("missing") else: if hasattr(f, 'get_scc'): scc = f.get_scc() if scc['sccAction']: prop.append(scc['sccAction']) if scc['sccOk']: if isinstance(scc['sccOk'], basestring): if int(scc['sccOk']): prop.append("sccOk") else: prop.append("sccOk") if scc['sccSync']: if isinstance(scc['sccSync'], basestring): if int(scc['sccSync']): prop.append("sccSync") else: prop.append("sccSync") if scc['sccConflict']: prop.append("sccConflict") if hasattr(f, 'isReadOnly') and f.isReadOnly: prop.append("isReadOnly") return prop
def DOMDeserialize(self, rootElement, parentPref, prefFactory, basedir=None, chainNotifications=0): """We know how to deserialize ordered-preference elements.""" # Create a new ordered preference. xpOrderedPref = components.classes["@activestate.com/koOrderedPreference;1"] \ .createInstance(components.interfaces.koIOrderedPreference) newOrderedPref = UnwrapObject(xpOrderedPref) try: newOrderedPref.id = rootElement.getAttribute("id") or "" except KeyError: newOrderedPref.id = "" # Iterate over the elements of the preference set, # deserializing them and fleshing out the new preference # set with content. childNodes = rootElement.childNodes for childNode in childNodes: if childNode and childNode.nodeType == minidom.Node.ELEMENT_NODE: pref = _dispatch_deserializer(self, childNode, newOrderedPref, prefFactory, basedir) if pref: newOrderedPref.appendPref(pref) return xpOrderedPref
def registerLanguage(self, language): import warnings warnings.warn("registerLanguage is deprecated - no longer needed", category=DeprecationWarning) name = language.name assert not self.__languageFromLanguageName.has_key(name), \ "Language '%s' already registered" % (name) log.info("registering language [%s]", name) self.__languageFromLanguageName[name] = language language = UnwrapObject(language) self.__accessKeyFromLanguageName[name] = language.accessKey # Update fields based on user preferences: primaryLanguagePref = "languages/%s/primary" % (language.name,) if self._globalPrefs.hasPref(primaryLanguagePref): language.primary = self._globalPrefs.getBoolean(primaryLanguagePref) # So that we can tell that, for example: # -*- mode: javascript -*- # means language name "JavaScript". if language.modeNames: for modeName in language.modeNames: self._modeName2LanguageName[modeName.lower()] = name else: self._modeName2LanguageName[name.lower()] = name if language.primary: self._primaryLanguageNames[name] = True if language.internal: self._internalLanguageNames[name] = True for pat in language.shebangPatterns: self.shebangPatterns.append((name, pat)) for ns in language.namespaces: self._namespaceMap[ns] = name for id in language.publicIdList: self._publicIdMap[id] = name for id in language.systemIdList: self._systemIdMap[id] = name
def __init__(self, buf, priority, force=False, mtime=None, on_complete=None): if _xpcom_: buf = UnwrapObject(buf) self.buf = buf self.id = buf.path self.priority = priority self.force = force if mtime is None: self.mtime = time.time() else: self.mtime = mtime self.on_complete = on_complete self.complete_event = threading.Event() #XXX use a pool
def test_differentOnDisk(self): path = tempfile.mktemp() try: # Init the test file with some content. _writefile(path, "blah\nblah\nblah\n") koDoc = self._koDocFromPath(path, load=False) # Make it look like a remote file. rawFile = UnwrapObject(koDoc.file) rawFile.isLocal = 0 rawFile.isRemoteFile = 1 koDoc.load() # Wait one second, so we generate a different mtime. import time time.sleep(1.1) _writefile(path, "blah\nblah\nblah\nblah\n") self.assertTrue(koDoc.differentOnDisk(), "Remote file change was not detected") # Next time we call it - it should still detect the file as being changed - bug 95690. self.assertTrue( koDoc.differentOnDisk(), "Remote file change was not detected a second time") # Because we are using a fake koIFileEx (or really a local file), # this test can fail if the timestamp between the save and the # differentOnDisk calls has changed. To work around that, we run # multiple checks and only accept one failure. success_count = 0 for tries in range(3): koDoc.save(True) if not koDoc.differentOnDisk(): success_count += 1 self.assertTrue( success_count >= 2, "Remote file change detected after saving the file") finally: if os.path.exists(path): os.unlink(path) # clean up
def observe(self, subject, topic, data): #print "file status service observed %r %s %s" % (subject, topic, data) try: log.debug("status observer received %s:%s", topic, data) if topic == 'komodo-startup-service': self.init() return if topic == 'xpcom-shutdown': log.debug("file status got xpcom-shutdown, unloading") self.unload() return if topic in ('idle', 'idle-daily'): log.info("Idle - take a break kid") self._is_idle = True return if topic in ('active', 'back'): log.info("Get back to work") self._is_idle = False self._cv.acquire() self._cv.notify() self._cv.release() return # These are other possible topics, they just force the # file status service to update itself immediately #elif topic == "file_changed": #elif topic == "file_update_now": self._cv.acquire() try: if topic in ("file_changed", "file_status_now"): # This notification can come with just about anything for # the subject element, so we need to find the matching # koIFile for the given uri, supplied by the "data" arg. koIFile = self._fileSvc.getFileFromURI(data) self._items_to_check.add((UnwrapObject(koIFile), data, self.REASON_FILE_CHANGED)) log.debug("Forced recheck of uri: %r", data) self._cv.notify() elif topic in ("file_update_now"): import warnings warnings.warn( "'file_update_now' is deprecated, use " "koIFileStatusService.updateStatusForAllFiles " "instead.", DeprecationWarning) self._cv.notify() finally: self._cv.release() except Exception, e: log.exception("Unexpected error in observe")
def _runCommand(cmd, *args, **kwargs): argv = [stackatoPath, cmd] if args: argv += args if not kwargs.get('noJSON', False): argv.append("--json") #qlog.debug("_runCommand: <<%s>>", argv) p = process.ProcessOpen(argv, cwd=None, env=None, stdin=None) stdout, stderr = p.communicate() #qlog.debug("cmd: %s, stdout: %s, stderr: %s", argv, stdout, stderr) koResult = components.classes["@activestate.com/KoStackatoResultBlock;1"].\ createInstance(components.interfaces.koIStackatoResultBlock) UnwrapObject(koResult).initialize(stdout, stderr) return koResult
def is_same(self, trg): """Return True iff the given trigger is (effectively) the same as this one. Dev Note: "Effective" is currently left a little fuzzy. Just comparing enough to fix Komodo Bug 55378. """ if _xpcom_: trg = UnwrapObject(trg) if (self.pos == trg.pos and self.type == trg.type and self.form == trg.form and self.lang == trg.lang): return True else: return False
def registerLanguage(self, language): name = language.name assert not self.__languageFromLanguageName.has_key(name), \ "Language '%s' already registered" % (name) log.info("registering language [%s]", name) self.__languageFromLanguageName[name] = language language = UnwrapObject(language) self.__accessKeyFromLanguageName[name] = language.accessKey # Update fields based on user preferences: languageKey = "languages/" + language.name if self._languageSpecificPrefs.hasPref(languageKey): languagePrefs = self._languageSpecificPrefs.getPref(languageKey) if languagePrefs.hasPref("primary"): language.primary = languagePrefs.getBooleanPref("primary") # So that we can tell that, for example: # -*- mode: javascript -*- # means language name "JavaScript". if language.modeNames: for modeName in language.modeNames: self._modeName2LanguageName[modeName.lower()] = name else: self._modeName2LanguageName[name.lower()] = name if language.primary: self._primaryLanguageNames[name] = True if language.internal: self._internalLanguageNames[name] = True for pat in language.shebangPatterns: self.shebangPatterns.append((name, pat)) for ns in language.namespaces: self._namespaceMap[ns] = name for id in language.publicIdList: self._publicIdMap[id] = name for id in language.systemIdList: self._systemIdMap[id] = name
def _loadAllLanguages(self): self._allRows = [] langRegistry = components.classes[ "@activestate.com/koLanguageRegistryService;1"].getService( components.interfaces.koILanguageRegistryService) langNames = langRegistry.getLanguageNames() for langName in langNames: lang = UnwrapObject(langRegistry.getLanguage(langName)) if not lang.internal: self._allRows.append({ 'name': langName, 'name_lc': langName.lower(), 'status': lang.primary, 'origStatus': lang.primary })
def _addProjectPrologue(self, kpf): self._partSvc.addProject(kpf) unwrapped_kpf = UnwrapObject(kpf) self.restorePrefs(unwrapped_kpf) self._partSvc.currentProject = unwrapped_kpf url = kpf.url # If the project is being added while restoring the view state, # it's possible that this project is already in the tree as # an unopened project in single-project view mode. # Ref bug 92356 for i, row in enumerate(self._rows): if row.uri == url: del self._rows[i] self._tree.rowCountChanged(i, 1) break return unwrapped_kpf
def findDocumentByDisplayPath(self, displayPath): self._cDoc.acquire() try: if displayPath in self._documents: wrappedDoc = self._documents[displayPath]() if not wrappedDoc: del self._documents[displayPath] return None doc = UnwrapObject(wrappedDoc) if doc._refcount == 0: del self._documents[displayPath] return None return wrappedDoc finally: self._cDoc.release() return None
def _getLinterByCID(self, linterCID): if linterCID not in self._linterCache: try: if linterCID.startswith(self.GENERIC_LINTER_AGGREGATOR_CID): languageName = linterCID[len(self.GENERIC_LINTER_AGGREGATOR_CID) + 1:] linter = components.classes[self.GENERIC_LINTER_AGGREGATOR_CID].createInstance(components.interfaces.koILinter) UnwrapObject(linter).initialize(languageName, self) elif linterCID not in components.classes.keys(): linter = None else: linter = components.classes[linterCID].createInstance(components.interfaces.koILinter) except COMException, ex: errmsg = "Internal Error creating a linter with CID '%s': %s"\ % (linterCID, ex) raise ServerException(nsError.NS_ERROR_UNEXPECTED, errmsg) self._linterCache[linterCID] = linter