Python LEXERS.itervalues方法代码示例

# 需要导入模块: from pygments.lexers._mapping import LEXERS [as 别名]
# 或者: from pygments.lexers._mapping.LEXERS import itervalues [as 别名]
def get_lexer_for_filename(_fn, code=None, **options):
    """
    Get a lexer for a filename.  If multiple lexers match the filename
    pattern, use ``analyze_text()`` to figure out which one is more
    appropriate.
    """
    matches = []
    fn = basename(_fn)
    for modname, name, _, filenames, _ in LEXERS.itervalues():
        for filename in filenames:
            if fnmatch.fnmatch(fn, filename):
                if name not in _lexer_cache:
                    _load_lexers(modname)
                matches.append(_lexer_cache[name])
    for cls in find_plugin_lexers():
        for filename in cls.filenames:
            if fnmatch.fnmatch(fn, filename):
                matches.append(cls)

    def get_rating(cls):
        # The class _always_ defines analyse_text because it's included in
        # the Lexer class.  The default implementation returns None which
        # gets turned into 0.0.  Run scripts/detect_missing_analyse_text.py
        # to find lexers which need it overridden.
        d = cls.analyse_text(code)
        #print "Got %r from %r" % (d, cls)
        return d

    if code:
        matches.sort(key=get_rating)
    if matches:
        #print "Possible lexers, after sort:", matches
        return matches[-1](**options)
    raise ClassNotFound('no lexer for filename %r found' % _fn)

# 需要导入模块: from pygments.lexers._mapping import LEXERS [as 别名]
# 或者: from pygments.lexers._mapping.LEXERS import itervalues [as 别名]
def get_all_lexers():
    from pygments.lexers._mapping import LEXERS
    from pygments.plugin import find_plugin_lexers

    for item in LEXERS.itervalues():
        yield item[1:]
    for cls in find_plugin_lexers():
        yield cls.name, cls.aliases, cls.filenames, cls.mimetypes

# 需要导入模块: from pygments.lexers._mapping import LEXERS [as 别名]
# 或者: from pygments.lexers._mapping.LEXERS import itervalues [as 别名]
def get_language(syntax, ext):
    """
    search language of pygments by syntax and after by extension
    """
    if len(ext) == 0 : ext='none'
    if ext[0] == '.': ext = '*' + ext
    if ext[0] != '*': ext = '*.' + ext
    s = os.path.basename(os.path.join(sublime.packages_path(),syntax))
    if s[-len('.tmLanguage'):] == '.tmLanguage':
        s = s[:-len('.tmLanguage')]
        for module_name, name, aliases, exts, mine in LEXERS.itervalues():
            if s.lower() in aliases:
                return s.lower()
        for module_name, name, aliases, exts, mine in LEXERS.itervalues():
            if ext in exts:
                return aliases[0]
    return None

# 需要导入模块: from pygments.lexers._mapping import LEXERS [as 别名]
# 或者: from pygments.lexers._mapping.LEXERS import itervalues [as 别名]
def get_all_lexers():
    """
    Return a generator of tuples in the form ``(name, aliases,
    filenames, mimetypes)`` of all know lexers.
    """
    for item in LEXERS.itervalues():
        yield item[1:]
    for lexer in find_plugin_lexers():
        yield lexer.name, lexer.aliases, lexer.filenames, lexer.mimetypes

# 需要导入模块: from pygments.lexers._mapping import LEXERS [as 别名]
# 或者: from pygments.lexers._mapping.LEXERS import itervalues [as 别名]
def _iter_lexerclasses():
    """
    Return an iterator over all lexer classes.
    """
    for module_name, name, _, _, _ in LEXERS.itervalues():
        if name not in _lexer_cache:
            _load_lexers(module_name)
        yield _lexer_cache[name]
    for lexer in find_plugin_lexers():
        yield lexer

# 需要导入模块: from pygments.lexers._mapping import LEXERS [as 别名]
# 或者: from pygments.lexers._mapping.LEXERS import itervalues [as 别名]
def get_lexer_for_mimetype(_mime, **options):
    """
    Get a lexer for a mimetype.
    """
    for modname, name, _, _, mimetypes in LEXERS.itervalues():
        if _mime in mimetypes:
            if name not in _lexer_cache:
                _load_lexers(modname)
            return _lexer_cache[name](**options)
    for cls in find_plugin_lexers():
        if _mime in cls.mimetypes:
            return cls(**options)
    raise ClassNotFound('no lexer for mimetype %r found' % _mime)

# 需要导入模块: from pygments.lexers._mapping import LEXERS [as 别名]
# 或者: from pygments.lexers._mapping.LEXERS import itervalues [as 别名]
def get_lexer_by_name(_alias, **options):
    """
    Get a lexer by an alias.
    """
    # lookup builtin lexers
    for module_name, name, aliases, _, _ in LEXERS.itervalues():
        if _alias in aliases:
            if name not in _lexer_cache:
                _load_lexers(module_name)
            return _lexer_cache[name](**options)
    # continue with lexers from setuptools entrypoints
    for cls in find_plugin_lexers():
        if _alias in cls.aliases:
            return cls(**options)
    raise ClassNotFound('no lexer for alias %r found' % _alias)

# 需要导入模块: from pygments.lexers._mapping import LEXERS [as 别名]
# 或者: from pygments.lexers._mapping.LEXERS import itervalues [as 别名]
def find_lexer_class(name):
    """
    Lookup a lexer class by name. Return None if not found.
    """
    if name in _lexer_cache:
        return _lexer_cache[name]
    # lookup builtin lexers
    for module_name, lname, aliases, _, _ in LEXERS.itervalues():
        if name == lname:
            _load_lexers(module_name)
            return _lexer_cache[name]
    # continue with lexers from setuptools entrypoints
    for cls in find_plugin_lexers():
        if cls.name == name:
            return cls

# 需要导入模块: from pygments.lexers._mapping import LEXERS [as 别名]
# 或者: from pygments.lexers._mapping.LEXERS import itervalues [as 别名]
def get_lexer_for_filename(_fn, **options):
    """
    Get a lexer for a filename.
    """
    fn = basename(_fn)
    for modname, name, _, filenames, _ in LEXERS.itervalues():
        for filename in filenames:
            if fnmatch.fnmatch(fn, filename):
                if name not in _lexer_cache:
                    _load_lexers(modname)
                return _lexer_cache[name](**options)
    for cls in find_plugin_lexers():
        for filename in cls.filenames:
            if fnmatch.fnmatch(fn, filename):
                return cls(**options)
    raise ClassNotFound('no lexer for filename %r found' % _fn)

# 需要导入模块: from pygments.lexers._mapping import LEXERS [as 别名]
# 或者: from pygments.lexers._mapping.LEXERS import itervalues [as 别名]
def get_lexer_for_filename(_fn, code=None, **options):
    """
    Get a lexer for a filename.  If multiple lexers match the filename
    pattern, use ``analyze_text()`` to figure out which one is more
    appropriate.
    """
    matches = []
    fn = basename(_fn)
    for modname, name, _, filenames, _ in LEXERS.itervalues():
        for filename in filenames:
            if fnmatch.fnmatch(fn, filename):
                if name not in _lexer_cache:
                    _load_lexers(modname)
                matches.append((_lexer_cache[name], filename))
    for cls in find_plugin_lexers():
        for filename in cls.filenames:
            if fnmatch.fnmatch(fn, filename):
                matches.append((cls, filename))

    if sys.version_info > (3,) and isinstance(code, bytes):
        # decode it, since all analyse_text functions expect unicode
        code = code.decode('latin1')

    def get_rating(info):
        cls, filename = info
        # explicit patterns get a bonus
        bonus = '*' not in filename and 0.5 or 0
        # The class _always_ defines analyse_text because it's included in
        # the Lexer class.  The default implementation returns None which
        # gets turned into 0.0.  Run scripts/detect_missing_analyse_text.py
        # to find lexers which need it overridden.
        if code:
            return cls.analyse_text(code) + bonus
        return cls.priority + bonus

    if matches:
        matches.sort(key=get_rating)
        #print "Possible lexers, after sort:", matches
        return matches[-1][0](**options)
    raise ClassNotFound('no lexer for filename %r found' % _fn)

# 需要导入模块: from pygments.lexers._mapping import LEXERS [as 别名]
# 或者: from pygments.lexers._mapping.LEXERS import itervalues [as 别名]
import posixpath

if __name__ == "__main__":
    os.environ['DJANGO_SETTINGS_MODULE'] = "pylucid_project.settings"
    virtualenv_file = "../../../../../bin/activate_this.py"
    execfile(virtualenv_file, dict(__file__=virtualenv_file))

from django import forms
from django.conf import settings
from django.utils.translation import ugettext_lazy as _

from pygments.lexers._mapping import LEXERS


SOURCE_CHOICES = []
for lexer in LEXERS.itervalues():
    name = lexer[1]
    aliases = lexer[2]
    try:
        alias = aliases[0]
    except IndexError:
        # Bug in Pygments v1.6rc1
        # Fixed in https://bitbucket.org/birkenfeld/pygments-main/issue/837/windows-registry-lexer-does-not-include
        # XXX remove if new bugfixed version on Pygments was released!
        continue
    SOURCE_CHOICES.append((alias, name))
SOURCE_CHOICES.sort()


class HighlightCodeForm(forms.Form):
    sourcecode = forms.CharField(widget=forms.Textarea)

# 需要导入模块: from pygments.lexers._mapping import LEXERS [as 别名]
# 或者: from pygments.lexers._mapping.LEXERS import itervalues [as 别名]
def _iter_lexerinfo():
    for info in LEXERS.itervalues():
        yield info
    for cls in find_plugin_lexers():
        yield cls.__module__, cls.name, cls.aliases, cls.filenames, cls.mimetypes