class SyntaxMgr(object):
"""Class Object for managing loaded syntax data. The manager
is only created once as a singleton and shared amongst all
editor windows
"""
instance = None
first = True
def __init__(self, config=None):
"""Initialize a syntax manager. If the optional
value config is set the mapping of extensions to
lexers will be loaded from a config file.
@keyword config: path of config file to load file extension config from
"""
if SyntaxMgr.first:
object.__init__(self)
SyntaxMgr.first = False
self._extreg = ExtensionRegister()
self._config = config
if self._config:
self._extreg.LoadFromConfig(self._config)
else:
self._extreg.LoadDefault()
self._loaded = dict()
def __new__(cls, config=None):
"""Ensure only a single instance is shared amongst
all objects.
@return: class instance
"""
if cls.instance is None:
cls.instance = object.__new__(cls)
return cls.instance
def _ExtToMod(self, ext):
"""Gets the name of the module that is is associated
with the given extension or None in the event that there
is no association or that the association is plain text.
@param ext: extension string to lookup module for
"""
ftype = self._extreg.FileTypeFromExt(ext)
lexdat = synglob.LANG_MAP.get(ftype)
mod = None
if lexdat:
mod = lexdat[2]
return mod
def GetLangId(self, ext):
"""Gets the language Id that is associated with the file
extension.
@param ext: extension to get lang id for
"""
ftype = self._extreg.FileTypeFromExt(ext)
return synglob.LANG_MAP[ftype][0]
def IsModLoaded(self, modname):
"""Checks if a module has already been loaded
@param modname: name of module to lookup
"""
if modname in self._loaded:
return True
else:
return False
def LoadModule(self, modname):
"""Dynamically loads a module by name. The loading is only
done if the modules data set is not already being managed
@param modname: name of syntax module to load
"""
if modname == None:
return False
if not self.IsModLoaded(modname):
try:
self._loaded[modname] = __import__(modname, globals(),
locals(), [''])
except ImportError, msg:
return False
return True
class SyntaxMgr(object):
"""Class Object for managing loaded syntax data. The manager
is only created once as a singleton and shared amongst all
editor windows
"""
instance = None
first = True
def __init__(self, config=None):
"""Initialize a syntax manager. If the optional
value config is set the mapping of extensions to
lexers will be loaded from a config file.
@keyword config: path of config file to load file extension config from
"""
if self.first:
object.__init__(self)
self.first = False
self._extreg = ExtensionRegister()
self._config = config
if self._config:
self._extreg.LoadFromConfig(self._config)
else:
self._extreg.LoadDefault()
self._loaded = dict()
def __new__(cls, *args, **kargs):
"""Ensure only a single instance is shared amongst
all objects.
@return: class instance
"""
if not cls.instance:
cls.instance = object.__new__(cls, *args, **kargs)
return cls.instance
def _ExtToMod(self, ext):
"""Gets the name of the module that is is associated
with the given extension or None in the event that there
is no association or that the association is plain text.
@param ext: extension string to lookup module for
"""
ftype = self._extreg.FileTypeFromExt(ext)
lexdat = synglob.LANG_MAP.get(ftype)
mod = None
if lexdat:
mod = lexdat[2]
return mod
def GetLangId(self, ext):
"""Gets the language Id that is associated with the file
extension.
@param ext: extension to get lang id for
"""
ftype = self._extreg.FileTypeFromExt(ext)
return synglob.LANG_MAP[ftype][0]
def IsModLoaded(self, modname):
"""Checks if a module has already been loaded
@param modname: name of module to lookup
"""
if modname in self._loaded:
return True
else:
return False
def LoadModule(self, modname):
"""Dynamically loads a module by name. The loading is only
done if the modules data set is not already being managed
@param modname: name of syntax module to load
"""
if modname == None:
return False
if not self.IsModLoaded(modname):
try:
self._loaded[modname] = __import__(modname, globals(),
locals(), [''])
except ImportError:
return False
return True
def SaveState(self):
"""Saves the current configuration state of the manager to
disk for use in other sessions.
@return: whether save was successful or not
"""
if not self._config or not os.path.exists(self._config):
return False
path = os.path.join(self._config, self._extreg.config)
try:
file_h = open(path, "wb")
file_h.write(str(self._extreg))
file_h.close()
except IOError:
return False
return True
def SyntaxData(self, ext):
"""Fetches the language data based on a file extention string. The file
extension is used to look up the default lexer actions from the EXT_REG
dictionary.
@see: L{synglob}
@param ext: a string representing the file extension
@return: Returns a Dictionary of Lexer Config Data
"""
# The Return Value
syn_data = dict()
lex_cfg = synglob.LANG_MAP[self._extreg.FileTypeFromExt(ext)]
syn_data[LEXER] = lex_cfg[LEXER_ID]
if lex_cfg[LANG_ID] == synglob.ID_LANG_TXT:
syn_data[LANGUAGE] = lex_cfg[LANG_ID]
# Check if module is loaded and load if necessary
if not self.LoadModule(lex_cfg[MODULE]):
# Bail out as nothing else can be done at this point
return syn_data
# This little bit of code fetches the keyword/syntax
# spec set(s) from the specified module
mod = self._loaded[lex_cfg[MODULE]] #HACK
syn_data[KEYWORDS] = mod.Keywords(lex_cfg[LANG_ID])
syn_data[SYNSPEC] = mod.SyntaxSpec(lex_cfg[LANG_ID])
syn_data[PROPERTIES] = mod.Properties(lex_cfg[LANG_ID])
syn_data[LANGUAGE] = lex_cfg[LANG_ID]
syn_data[COMMENT] = mod.CommentPattern(lex_cfg[LANG_ID])
if syn_data[LEXER] == wx.stc.STC_LEX_CONTAINER:
syn_data[CLEXER] = mod.StyleText
else:
syn_data[CLEXER] = None
syn_data[INDENTER] = getattr(mod, 'AutoIndenter', None)
return syn_data
