Python UnwrapObject.lint方法代码示例

# 需要导入模块: from xpcom.server import UnwrapObject [as 别名]
# 或者: from xpcom.server.UnwrapObject import lint [as 别名]
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

# 需要导入模块: from xpcom.server import UnwrapObject [as 别名]
# 或者: from xpcom.server.UnwrapObject import lint [as 别名]
 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()

# 需要导入模块: from xpcom.server import UnwrapObject [as 别名]
# 或者: from xpcom.server.UnwrapObject import lint [as 别名]
class KoEJSLinter(object):
    _com_interfaces_ = [components.interfaces.koILinter]
    _reg_desc_ = "EJS Template Linter"
    _reg_clsid_ = "{4A3A959D-469F-4675-8420-9C0B9878F136}"
    _reg_contractid_ = "@activestate.com/koLinter?language=EJS;1"
    _reg_categories_ = [
        ("category-komodo-linter", 'EJS'),
    ]

    def __init__(self):
        koLintService = components.classes["@activestate.com/koLintService;1"].getService(components.interfaces.koILintService)
        self._html_linter = UnwrapObject(koLintService.getLinterForLanguage("HTML5"))
        
    def lint(self, request):
        #TODO: Hook on parts to pull templatized-parts out of jslint
        return self._html_linter.lint(request, TPLInfo=_tplPatterns,
                                      startCheck=_startCheck)

    def lint_with_text(self, request, text):
        return None

# 需要导入模块: from xpcom.server import UnwrapObject [as 别名]
# 或者: from xpcom.server.UnwrapObject import lint [as 别名]
class KoJSERBLinter(object):
    _com_interfaces_ = [components.interfaces.koILinter]
    _reg_desc_ = "JSERB Template Linter"
    _reg_clsid_ = "{F412478A-6DA6-4DF8-A6D6-E26A1DADF1A4}"
    _reg_contractid_ = "@activestate.com/koLinter?language=JSERB;1"
    _reg_categories_ = [
        ("category-komodo-linter", 'JSERB'),
    ]

    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 lint(self, request):
        #TODO: Hook on parts to pull templatized-parts out of jslint
        return self._html_linter.lint(request, TPLInfo=_tplPatterns)

    def lint_with_text(self, request, text):
        return None

# 需要导入模块: from xpcom.server import UnwrapObject [as 别名]
# 或者: from xpcom.server.UnwrapObject import lint [as 别名]
class KoTemplateToolkitLinter(object):
    _com_interfaces_ = [components.interfaces.koILinter]
    _reg_desc_ = "TemplateToolkit Template Linter"
    _reg_clsid_ = "{72b2df05-86c4-428b-b6bd-27a4f6495806}"
    _reg_contractid_ = "@activestate.com/koLinter?language=TemplateToolkit;1"
    _reg_categories_ = [
        ("category-komodo-linter", 'TemplateToolkit'),
    ]

    def __init__(self):
        self._koLintService = components.classes[
            "@activestate.com/koLintService;1"].getService(components.interfaces.koILintService)
        self._perl_linter = None
        self._html_linter = UnwrapObject(
            self._koLintService.getLinterForLanguage("HTML"))

    @property
    def perl_linter(self):
        if self._perl_linter is None:
            self._perl_linter = UnwrapObject(
                self._koLintService.getLinterForLanguage("Perl"))
        return self._perl_linter

    _ttktMatcher = re.compile(r'''(
         (?:\[%\s+PERL\s+%\].*?\[%\s+END\s+%\])
        |[^\[]+
        |.)''',                  # Catchall
                              re.VERBOSE | re.DOTALL)

    _exprTagRE = re.compile(r'(\[%\s*\w+.*%\])', re.DOTALL)
    _perlTagRE = re.compile(
        r'(\[%\s+PERL\s+%\])(.*?)(\[%\s+END\s+%\])', re.DOTALL)

    def _stripInnerPart(self, m):
        return self._spaceOutNonNewlines(m.group(1))

    def _fixPerlPart(self, text):
        parts = self._ttktMatcher.findall(text)
        if not parts:
            return ""
        i = 0
        lim = len(parts)
        perlTextParts = []
        while i < lim:
            part = parts[i]
            if part.startswith("[") and len(part) > 1:
                m = self._perlTagRE.match(part)
                if m:
                    fixedPart = (self._spaceOutNonNewlines(m.group(1))
                                 + self._exprTagRE.sub(
                                     self._stripInnerPart, m.group(2))
                                 + self._spaceOutNonNewlines(m.group(3)))
                else:
                    log.warn("Thought this would match a perl tag, but no")
                    fixedPart = self._spaceOutNonNewlines(part)
            else:
                fixedPart = self._spaceOutNonNewlines(part)
            perlTextParts.append(fixedPart)
            i += 1
        return "".join(perlTextParts)

    _nonNewlineMatcher = re.compile(r'[^\r\n]')

    def _spaceOutNonNewlines(self, markup):
        return self._nonNewlineMatcher.sub(' ', markup)

    _tplPatterns = ("TemplateToolkit", re.compile(
        r'\[%\s*(?![A-Z])'), re.compile(r'%\]\s*\Z', re.DOTALL))

    def lint(self, request):
        return self._html_linter.lint(request,
                                      udlMapping={"Perl": "TemplateToolkit"},
                                      TPLInfo=self._tplPatterns)

    def lint_with_text(self, request, text):
        perlText = self._fixPerlPart(text)
        if not perlText.strip():
            return
        return self.perl_linter.lint_with_text(request, perlText)

# 需要导入模块: from xpcom.server import UnwrapObject [as 别名]
# 或者: from xpcom.server.UnwrapObject import lint [as 别名]
class KoPHPCompileLinter:
    _com_interfaces_ = [components.interfaces.koILinter]
    _reg_desc_ = "Komodo PHP Linter"
    _reg_clsid_ = "{F6F8507C-21B0-4047-9E78-A648949B118F}"
    _reg_contractid_ = "@activestate.com/koLinter?language=PHP;1"
    _reg_categories_ = [
         ("category-komodo-linter", 'PHP'),
         ]

    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
    
    # linting versions are different than what is required for xdebug
    # debugging, so we have our own version checking
    _checkValidVersion_complained = {}
    def checkValidVersion(self):
        try:
            version = self.phpInfoEx.version
        except:
            if "version" not in self._checkValidVersion_complained:
                self._checkValidVersion_complained["version"] = True
                log.error("Error getting phpInfoEx.version.  Is a PHP interpreter defined?")
            return False
        if not version:
            # Allow for None or empty string
            reject = True
        else:
            # last point can be something like 10-beta
            version = tuple([int(x) for x in re.match(r"(\d+)\.(\d+)\.(\d+)", version).groups()])
            reject = (version < (4,0,5))
        if reject and "checkValidVersion" not in self._checkValidVersion_complained:
            self._checkValidVersion_complained["checkValidVersion"] = True
            errmsg = "Could not find a suitable PHP interpreter for "\
                     "linting, need 4.0.5 or later."
            log.error("koPHPLinter.py: checkValidVersion: %s", errmsg)
        return not reject
        
    _tplPatterns = ("PHP", re.compile('<\?(?:php\s+echo\b[^_]|=)', re.IGNORECASE|re.DOTALL), re.compile(r'\?>\s*\Z', re.DOTALL))
    def lint(self, request):
        try:
            return self._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 lint_with_text(self, request, text):
        """Lint the given PHP content.
        
        Raise an exception if there is a problem.
        """
        cwd = request.cwd
        
        #print "----------------------------"
        #print "PHP Lint"
        #print text
        #print "----------------------------"
        php = self.phpInfoEx.getExecutableFromDocument(request.koDoc)
        if php is None:
            errmsg = "Could not find a suitable PHP interpreter for linting."
            log.exception(errmsg)
            raise COMException(nsError.NS_ERROR_NOT_AVAILABLE, errmsg)

        if not self.checkValidVersion():
            return None

        # save php buffer to a temporary file
        phpfilename = tempfile.mktemp()
        fout = open(phpfilename, 'wb')
        fout.write(text)
        fout.close()

        p = None
        try:
            argv = [php, '-n', '-d', 'display_errors=1',
                    '-d', 'display_startup_errors=1',
                    '-d', 'output_buffering=0',
                    '-d', 'xdebug.remote_enable=off',
                    '-d', 'error_reporting=2047',
                    '-q', '-l', phpfilename]
            env = koprocessutils.getUserEnv()
            cwd = cwd or None
            p = process.ProcessOpen(argv, cwd=cwd, env=env)
            stdout, stderr = p.communicate()
            # The relevant output is contained in stdout.
            lines = stdout.splitlines(1)
        finally:
            os.unlink(phpfilename)
        
        results = koLintResults()
        if lines:
#.........这里部分代码省略.........

# 需要导入模块: from xpcom.server import UnwrapObject [as 别名]
# 或者: from xpcom.server.UnwrapObject import lint [as 别名]
class KoMasonLinter(object):
    _com_interfaces_ = [components.interfaces.koILinter]
    _reg_desc_ = "Mason Template Linter"
    _reg_clsid_ = "{cf3671e8-6981-468c-90d1-9f77ed22b7cd}"
    _reg_contractid_ = "@activestate.com/koLinter?language=Mason;1"
    _reg_categories_ = [
        ("category-komodo-linter", 'Mason'),
    ]


    def __init__(self):
        self._koLintService = components.classes["@activestate.com/koLintService;1"].getService(components.interfaces.koILintService)
        self._perl_linter = None
        self._html_linter = UnwrapObject(self._koLintService.getLinterForLanguage("HTML"))
        
    @property
    def perl_linter(self):
        if self._perl_linter is None:
            self._perl_linter = UnwrapObject(self._koLintService.getLinterForLanguage("Perl"))
        return self._perl_linter
    
    _masonMatcher = re.compile(r'''(
                                (?:</?%\w+\s*.*?>)
        |(?:<%\s+.*?%>)   # Anything in <%...%>
        |(?:^%%?\s[^\n]+)
        |(?:\r?\n)               # Newline
        |(?:<&.*?&>)
        |[^<%\n]+ # Most other non-Perl
        |.)''',                  # Catchall
                                re.MULTILINE|re.VERBOSE|re.DOTALL)

    _blockTagRE = re.compile(r'<(/?)%(\w+).*?>')
    _exprRE = re.compile(r'(<%\s*)(.*?)(%>)', re.DOTALL)
    _perlLineRE = re.compile(r'^(%%?\s)(.*)')

    def _fixPerlPart(self, text):
        parts = self._masonMatcher.findall(text)
        if not parts:
            return "", []
        i = 0
        lim = len(parts)
        perlTextParts = []
        masonLintResults = []
        eols = ("\n", "\r\n")
        
        # states
        currTags = []
        perlTags = ('init', 'perl', 'once') # drop code for other tags.
        lineNo = i
        while i < lim:
            part = parts[i]
            if part in eols:
                perlTextParts.append(part)
            elif part.startswith("%") and (i == 0 or parts[i - 1].endswith("\n")):
                m = self._perlLineRE.match(part)
                if not m:
                    perlTextParts.append(self._spaceOutNonNewlines(part))
                else:
                    perlTextParts.append(self._spaceOutNonNewlines(m.group(1)))
                    perlTextParts.append(m.group(2))
            elif part.startswith("<"):
                m = self._blockTagRE.match(part)
                if m:
                    payload = m.group(2)
                    if m.group(1):
                        unexpectedEndTag = None
                        if currTags:
                            currTag = currTags[-1]
                            if currTag == payload:
                                currTags.pop()
                            else:
                                # Recover by removing everything up to and including the tag
                                unexpectedEndTag = currTags[-1]
                                for idx in range(len(currTags) - 1, -1, -1):
                                    if currTags[idx] == payload:
                                        del currTags[idx:-1]
                                        break
                        else:
                            unexpectedEndTag = "not in a tag block"
                        if unexpectedEndTag is not None:
                            lr = KoLintResult()
                            lr.lineStart = lr.lineEnd = lineNo + 1
                            lr.columnStart = 1
                            lr.columnEnd = 1 + len(text.splitlines()[lineNo])
                            if unexpectedEndTag == "not in a tag block":
                                lr.description = "Got end tag %s, not in a tag" % part
                            else:
                                lr.description = "Expected </%%%s>, got %s" % (
                                    unexpectedEndTag, part)
                            lr.encodedDescription = lr.description
                            lr.severity = lr.SEV_WARNING
                            masonLintResults.append(lr)
                    else:
                        currTags.append(payload)
                    perlTextParts.append(self._spaceOutNonNewlines(part))
                else:
                    m = self._exprRE.match(part)
                    if not m:
                        perlTextParts.append(self._spaceOutNonNewlines(part))
                    else:
#.........这里部分代码省略.........