Python lexers.guess_lexer函数代码示例

 def parse(self):
     """
     pygment highlighting
     """ 
     inner = ''
     for node in self.nodes:
         inner += node.raw_content
     if highlight is None:
         return '<pre>%s</pre>' % inner
     if self.arguments['lang']:
         try:
             lexer = get_lexer_by_name(self.arguments['lang'])
         except ClassNotFound:
             try:
                 lexer = guess_lexer(inner)
             except ClassNotFound:
                 lexer = TextLexer()
     else:
         try:
             lexer = guess_lexer(inner)
         except ClassNotFound:
             lexer = TextLexer()
     hl_line = self.arguments['hl_line']
     if not hl_line.isdigit():
         return self.soft_raise("Code argument hl_line must be digit")
     hl_line = int(hl_line)
     hl_lines = [hl_line] if hl_line else []
     formatter = HtmlFormatter(cssclass='code',
                               noclasses=True,
                               linenos='inline' if self.arguments['linenos'] == '1' else False,
                               hl_lines=hl_lines)
     hilighted = highlight(inner, lexer, formatter)
     return hilighted

    def _highlight_syntax(self):
        """If we have pygments, syntax highlight the file."""
        if self.syntax_format:
            stringified_text = \
                ''.join(str(s.decode("utf-8")) for s in self.read_lines())

            if self.syntax_format is not True:
                lexer = get_lexer_by_name(self.syntax_format)

            elif self.file_name:
                try:
                    lexer = \
                        guess_lexer_for_filename(
                            self.file_name, stringified_text)
                except TypeError:
                    # XXX pygments py3 incompatibility workaround; fixed in tip
                    lexer = guess_lexer(stringified_text)
            else:
                lexer = guess_lexer(stringified_text)

            highlighted_text = \
                highlight(
                    stringified_text, lexer,
                    TerminalFormatter(bg="dark")).split('\n')

            line_num = 1
            try:
                for line in highlighted_text:
                    self._lines[
                        self._find_line_index(line_num)].update_highlight(line)
                    line_num += 1
            except KeyError:
                # our conversions to strings sometimes adds a trailing line
                pass

    def highlight_code(self, string, pattern, lang_pattern):
        """Highlights syntaxes in the given string enclosed in a <syntax> tag.

        string -- String containing the code to highlight.
        pattern -- Compiled regex object for highlight pattern matching.
        lang_pattern -- Compiled regex for obtaining language name (if provided)
        
        """
        codeblocks = re.findall(pattern, string)
        # results: list of tuples of 2 or 3 items
        # item[0] is the whole code block (syntax tag + code to highlight)
        # item[1] is the programming language (optional, depends on usage)
        # item[2] is the code to highlight

        if codeblocks:
            for match, lang, code in codeblocks:
                if lang:
                    lang = re.sub(lang_pattern, '', lang)
                    try:
                        lexer = get_lexer_by_name(lang.lower(), **self.config.PYGMENTS_LEXER)
                    # if the lang is not supported or has a typo
                    # let pygments guess the language
                    except ClassNotFound:
                        lexer = guess_lexer(code, **self.config.PYGMENTS_LEXER)
                else:
                    lexer = guess_lexer(code, **self.config.PYGMENTS_LEXER)

                formatter = HtmlFormatter(**self.config.PYGMENTS_HTML)
                highlighted = highlight(code, lexer, formatter)
                # add 1 arg because replacement should only be done
                # once for each match
                string = string.replace(match, highlighted, 1)

        return string

    def __init__(self, file_content, file_name=None, language=None,
                 private=False):
        self.set_file_content(file_content)
        self.file_name = file_name
        self.language = language
        self.private = private
        self.pub_date = datetime.utcnow()

        # guess language, if needed
        if self.language is None:
            if self.file_name is None:
                lexer = guess_lexer(self.file_content)
            else:
                try:
                    lexer = guess_lexer_for_filename(self.file_name,
                                                     self.file_content)
                except:
                    lexer = guess_lexer(self.file_content)

                # verify if lexer is ok for filename
                found = False
                for pattern in lexer.filenames:
                    if fnmatch(self.file_name, pattern):
                        found = True
                        break
                else:
                    found = True
                if not found:
                    lexer = TextLexer
            self.language = lexer.aliases[0]

def colorize(paste_key):
	" Color the paste in a deferred task. "
	
	from pygments import highlight
	from pygments.lexers import get_lexer_by_name
	from pygments.formatters import HtmlFormatter
	from pygments.lexers import guess_lexer
	
	paste = db.get(paste_key)
	
	if paste.syntax == 'auto':
		lexer = guess_lexer(paste.text)
	else:
		lexer = get_lexer_by_name(paste.syntax, stripall=True)
		if lexer is None:
			lexer = guess_lexer(paste.text)
		
	if lexer is None:
		lexer = get_lexer_by_name('text')
		
	formatter = HtmlFormatter(linenos=True, cssclass="highlight")
	paste.syntax = lexer.name
	paste.highlighted = highlight(paste.text, lexer, formatter)
	paste.colorized=True
	paste.put()

def highlight_content(content, lexer_name = None):
    if not lexer_name:
        lexer = guess_lexer(content)
    else:
        try:
            lexer = get_lexer_by_name(lexer_name)
        except ClassNotFound:
            lexer = guess_lexer(content)
    formatter = HtmlFormatter()
    return highlight(content.decode('utf8'), lexer, formatter)

 def get_lexer(self, code, language):
     if language:
         try:
             return get_lexer_by_name(language)
         except pygments.util.ClassNotFound:
             try:
                 return get_lexer_by_name(language.lower())
             except pygments.util.ClassNotFound:
                 return guess_lexer(code)
     else:
         return guess_lexer(code)

def apply_pygments(str):
    lines = str.splitlines()
    str = '\n'.join(lines[1:-1])
    first = lines[0].strip().lstrip('`')
    if first:
        try:
            lexer = get_lexer_by_name(first)
        except:
            lexer = guess_lexer(str)
    else:
        lexer = guess_lexer(str)
    formatter = HtmlFormatter(style='colorful')
    return highlight(str, lexer, formatter)

def highlight(text, filename=None):
    """Guess language in *text* and return its html highlighted version"""
    if filename is not None:
        #Pygments does not know dpr
        filename = filename.replace('dpr', 'pas')
        try:
            lexer = guess_lexer_for_filename(filename, text)
        except pygments.util.ClassNotFound:
            lexer = guess_lexer(text)
    else:
        lexer = guess_lexer(text)
    formatter = HtmlFormatter(style='manni', linenos=True, classprefix="highlight-")
    return formatter.get_style_defs(), p_highlight(text, lexer, formatter)

def get_lexer(filename, data, lexer='auto'):
    """
    Return a particular lexer instance.

    This method wraps pygments' methods guess_lexer_for_filename()
    and guess_lexer(). First guess_lexer_for_filename() is invoked;
    if there is no result the presence of a shebang is checked.
    If the subsequent call to guess_lexer() does not bring any
    results the fallback value TextLexer() is returned.

    Args:
        filename    The name of the file to be displayed
        data        The content of the file (utf-8 encoded)
        lexer       Specifying another value than 'auto' skips any
                    guess_lexer() calls. The pygments method
                    get_lexer_by_name() is used to find a particular
                    lexer class. If nothing has been found, c.py
                    fails.
    """
    filename = filename if filename else '-'
    if lexer == 'auto':
        debug("Trying to guess lexer for filename: '{}'".format(filename))
        try:
            lexer_cls = guess_lexer_for_filename(filename, data)
        except ClassNotFound:
            if data[0:2] == b'#!':
                debug("Shebang '{}' present".format(data.splitlines()[0]))
                lexer_cls = guess_lexer(data.decode())
            elif filename == '-':
                try:
                    debug("Have read from 'stdin'; guessing lexer for content")
                    lexer_cls = guess_lexer(data)
                except ClassNotFound:
                    debug('Guessing failed, using fallback lexer')
                    lexer_cls = TextLexer()
            else:
                debug('No shebang present, using fallback lexer')
                lexer_cls = TextLexer()
        except TypeError:
            debug('Guessing failed, using fallback lexer')
            lexer_cls = TextLexer()
    else:
        try:
            debug("Trying to find lexer: '{}'".format(lexer))
            lexer_cls = get_lexer_by_name(lexer)
        except ClassNotFound:
            print("[Error] No lexer found: '{}'".format(lexer), file=sys.stderr)
            exit(1)

    debug('Using lexer: {}'.format(lexer_cls))
    return lexer_cls

def get_language(source, code, language=None):
    """Get the current language we're documenting, based on the extension."""

    if language is not None:
        for l in languages.values():
            if l["name"] == language:
                return l
        else:
            raise ValueError("Unknown forced language: " + language)

    m = re.match(r'.*(\..+)', os.path.basename(source)) if source else None
    if m and m.group(1) in languages:
        return languages[m.group(1)]
    else:
        try:
            lang = lexers.guess_lexer(code).name.lower()
            for l in languages.values():
                if l["name"] == lang:
                    return l
            else:
                raise ValueError()
        except ValueError:
            # If pygments can't find any lexers, it will raise its own
            # subclass of ValueError. We will catch it and raise ours
            # for consistency.
            raise ValueError("Can't figure out the language!")

def _blob_detail(request, project, branch_name, git_object, path_list, branches):
    """Render a blob. Pretty prints using Pygments"""
    breadcrumbs = generate_breadcrumbs(path_list)
    
    file_name = path_list[-1]['name']
    try:
        lexer = guess_lexer_for_filename(file_name, git_object.as_raw_string())
    except:
        lexer = guess_lexer(git_object.as_raw_string())
    formatter = HtmlFormatter(linenos=True)
    pretty_printed_file = highlight(git_object.as_raw_string(), lexer, formatter)
    
    return render_to_response('project/blob.html', {
        'project': project,
        'branch_name': branch_name,
        'object': git_object,
        'path': path_list,
        'breadcrumbs': breadcrumbs,
        'pretty_print': pretty_printed_file,
        'branches': branches,
    }, context_instance=RequestContext(request))
    
    
    
    
    

def get_lexer_name_from_code(code):
    try:
        return guess_lexer(code, encoding=None).aliases[0]
    except ClassNotFound:
        pass
    
    return ''

    def _render(self):
        if self.children:
            if not _pygments_available:
                raise NotAvailableError("Pygments is not available")

            try:
                lex_name = self.haml.split(" ", 1)[1]
            except IndexError:
                lex_name = False

            self.before = self.render_newlines()
            indent_offset = len(self.children[0].spaces)
            text = ''.join(''.join([c.spaces[indent_offset:], c.haml, c.render_newlines()]) for c in self.children)

            try:
                if lex_name:
                    lexer = get_lexer_by_name(lex_name)
                else:
                    lexer = guess_lexer(text)
            except ClassNotFound:
                # if invalid lexer name is given or
                # if no lexer thinks it can handle the content
                # we set default lexer
                lexer = TextLexer()

            self.before += highlight(text, lexer, HtmlFormatter())
        else:
            self.after = self.render_newlines()

def get_line_types(repo, repo_uri, rev, path):
    """Returns an array, where each item means a line of code.
       Each item is labled 'code', 'comment' or 'empty'"""

    #profiler_start("Processing LineTypes for revision %s:%s", (self.rev, self.file_path))
    uri = os.path.join(repo_uri, path) # concat repo_uri and file_path for full path
    file_content = _get_file_content(repo, uri, rev)  # get file_content

    if file_content is None or file_content == '':
        printerr("[get_line_types] Error: No file content for " + str(rev) + ":" + str(path) + " found! Skipping.")
        line_types = None
    else:
        try:
            lexer = get_lexer_for_filename(path)
        except ClassNotFound:
            try:
                printdbg("[get_line_types] Guessing lexer for" + str(rev) + ":" + str(path) + ".")
                lexer = guess_lexer(file_content)
            except ClassNotFound:
                printdbg("[get_line_types] No guess or lexer found for " + str(rev) + ":" + str(path) + ". Using TextLexer instead.")
                lexer = TextLexer()

        if isinstance(lexer, NemerleLexer):
            # this lexer is broken and yield an unstoppable process
            # see https://bitbucket.org/birkenfeld/pygments-main/issue/706/nemerle-lexer-ends-in-an-infinite-loop
            lexer = TextLexer()

        # Not shure if this should be skipped, when the language uses off-side rules (e.g. python,
        # see http://en.wikipedia.org/wiki/Off-side_rule for list)
        stripped_code = _strip_lines(file_content)
        lexer_output = _iterate_lexer_output(lexer.get_tokens(stripped_code))
        line_types_str = _comment_empty_or_code(lexer_output)
        line_types = line_types_str.split("\n")

    return line_types