def make_at_clean_outline(self, fn, root, s, rev):
'''
Create a hidden temp outline from lines without sentinels.
root is the @<file> node for fn.
s is the contents of the (public) file, without sentinels.
'''
# A specialized version of at.readOneAtCleanNode.
hidden_c = leoCommands.Commands(fn, gui=g.app.nullGui)
at = hidden_c.atFileCommands
x = hidden_c.shadowController
hidden_c.frame.createFirstTreeNode()
hidden_root = hidden_c.rootPosition()
# copy root to hidden root, including gnxs.
root.copyTreeFromSelfTo(hidden_root, copyGnxs=True)
hidden_root.h = fn + ':' + rev if rev else fn
# Set at.encoding first.
at.initReadIvars(hidden_root, fn)
# Must be called before at.scanAllDirectives.
at.scanAllDirectives(hidden_root)
# Sets at.startSentinelComment/endSentinelComment.
new_public_lines = g.splitLines(s)
old_private_lines = at.write_at_clean_sentinels(hidden_root)
marker = x.markerFromFileLines(old_private_lines, fn)
old_public_lines, junk = x.separate_sentinels(old_private_lines, marker)
assert old_public_lines
new_private_lines = x.propagate_changed_lines(
new_public_lines, old_private_lines, marker, p=hidden_root)
at.fast_read_into_root(
c = hidden_c,
contents = ''.join(new_private_lines),
gnx2vnode = {},
path = fn,
root = hidden_root,
)
return hidden_c
def createHiddenCommander(self, fn):
'''Read the file into a hidden commander (Similar to g.openWithFileName).'''
import leo.core.leoCommands as leoCommands
lm = g.app.loadManager
c2 = leoCommands.Commands(fn, gui=g.app.nullGui)
theFile = lm.openLeoOrZipFile(fn)
if theFile:
c2.fileCommands.openLeoFile(theFile, fn, readAtFileNodesFlag=True, silent=True)
return c2
else:
return None
def make_leo_outline(self, fn, path, s, rev):
"""Create a hidden temp outline for the .leo file in s."""
hidden_c = leoCommands.Commands(fn, gui=g.app.nullGui)
hidden_c.frame.createFirstTreeNode()
root = hidden_c.rootPosition()
root.h = fn + ':' + rev if rev else fn
hidden_c.fileCommands.getLeoFile(
theFile=io.StringIO(initial_value=s),
fileName=path,
readAtFileNodesFlag=False,
silent=False,
checkOpenFiles=False,
)
return hidden_c
def make_at_clean_outline(self, fn, root, s, rev):
'''
Create a hidden temp outline from lines without sentinels.
root is the @<file> node for fn.
s is the contents of the (public) file, without sentinels.
'''
# A specialized version of at.readOneAtCleanNode.
trace = False and not g.unitTesting
hidden_c = leoCommands.Commands(fn, gui=g.app.nullGui)
at = hidden_c.atFileCommands
x = hidden_c.shadowController
hidden_c.frame.createFirstTreeNode()
hidden_root = hidden_c.rootPosition()
# copy root to hidden root, including gnxs.
root.copyTreeFromSelfTo(hidden_root, copyGnxs=True)
hidden_root.h = fn + ':' + rev if rev else fn
# Set at.encoding first.
at.initReadIvars(hidden_root, fn)
# Must be called before at.scanAllDirectives.
at.scanAllDirectives(hidden_root)
# Sets at.startSentinelComment/endSentinelComment.
new_public_lines = g.splitLines(s)
old_private_lines = at.write_at_clean_sentinels(hidden_root)
marker = x.markerFromFileLines(old_private_lines, fn)
old_public_lines, junk = x.separate_sentinels(old_private_lines,
marker)
assert old_public_lines
new_private_lines = x.propagate_changed_lines(new_public_lines,
old_private_lines,
marker,
p=hidden_root)
# Init the input stream used by read-open file.
at.read_lines = new_private_lines
at.read_ptr = 0
# Read the file using the @file read logic.
at.readOpenFile(hidden_root, fn, deleteNodes=True)
# Complete the read.
for p in hidden_root.self_and_subtree():
p.b = ''.join(getattr(p.v, 'tempBodyList', []))
if at.errors: g.trace(at.errors, 'errors!')
if trace: g.trace(len(s), rev, fn, hidden_c)
return None if at.errors else hidden_c
def make_at_file_outline(self, fn, s, rev):
"""Create a hidden temp outline from lines."""
# A specialized version of atFileCommands.read.
hidden_c = leoCommands.Commands(fn, gui=g.app.nullGui)
at = hidden_c.atFileCommands
hidden_c.frame.createFirstTreeNode()
root = hidden_c.rootPosition()
root.h = fn + ':' + rev if rev else fn
at.initReadIvars(root, fn, importFileName=None, atShadow=None)
if at.errors > 0:
g.trace('***** errors')
return None
at.fast_read_into_root(
c=hidden_c,
contents=s,
gnx2vnode={},
path=fn,
root=root,
)
return hidden_c
def setUp(self):
"""
Create a commander using a **null** gui, regardless of g.app.gui.
Create the nodes in the commander.
"""
# Do the import here to avoid circular dependencies.
from leo.core import leoCommands
from leo.core.leoGui import NullGui
# Set g.unitTesting *early*, for guards.
g.unitTesting = True
# Create a new commander for each test.
# This is fast, because setUpClass has done all the imports.
self.c = c = leoCommands.Commands(fileName=None, gui=NullGui())
# Init the 'root' and '@settings' nodes.
self.root_p = c.rootPosition()
self.root_p.h = 'root'
self.settings_p = self.root_p.insertAfter()
self.settings_p.h = '@settings'
# Select the 'root' node.
c.selectPosition(self.root_p)
def create_app():
"""
Create the Leo application, g.app, the Gui, g.app.gui, and a commander.
This method is expensive (about 1 sec) only the first time it is called.
Thereafter, recreating g.app, g.app.gui, and new commands is fast.
"""
# t1 = time.process_time()
from leo.core import leoGlobals as g
from leo.core import leoApp
g.app = leoApp.LeoApp() # Do this first, to avoid circular dependencies.
from leo.core import leoConfig
from leo.core import leoNodes
from leo.core import leoCommands
from leo.core import leoGui
# t2 = time.process_time()
g.app.recentFilesManager = leoApp.RecentFilesManager()
g.app.loadManager = leoApp.LoadManager()
g.app.loadManager.computeStandardDirectories()
if not g.app.setLeoID(useDialog=False, verbose=True):
raise ValueError("unable to set LeoID.")
g.app.nodeIndices = leoNodes.NodeIndices(g.app.leoID)
g.app.config = leoConfig.GlobalConfigManager()
g.app.db = g.TracingNullObject('g.app.db')
g.app.pluginsController = g.NullObject('g.app.pluginsController')
g.app.commander_cacher = g.NullObject('g.app.commander_cacher')
g.app.gui = leoGui.NullGui()
# t3 = time.process_time()
#
# Create a dummy commander, to do the imports in c.initObjects.
c = leoCommands.Commands(fileName=None, gui=g.app.gui)
# t4 = time.process_time()
# if t4 - t3 > 0.1:
# print('create_app\n'
# f" imports: {(t2-t1):.3f}\n"
# f" gui: {(t3-t2):.3f}\n"
# f"commander: {(t4-t2):.3f}\n"
# f" total: {(t4-t1):.3f}\n")
return c
def make_at_file_outline(self, fn, s, rev):
'''Create a hidden temp outline from lines.'''
# A specialized version of atFileCommands.read.
hidden_c = leoCommands.Commands(fn, gui=g.app.nullGui)
at = hidden_c.atFileCommands
hidden_c.frame.createFirstTreeNode()
root = hidden_c.rootPosition()
root.h = fn + ':' + rev if rev else fn
at.initReadIvars(root, fn, importFileName=None, atShadow=None)
at.fromString = s
if at.errors > 0:
g.trace('***** errors')
return None
at.inputFile = g.FileLikeObject(fromString=at.fromString)
at.initReadLine(at.fromString)
at.readOpenFile(root, fn, deleteNodes=True)
at.inputFile.close()
# Complete the read.
for p in root.self_and_subtree():
p.b = ''.join(getattr(p.v, 'tempBodyList', []))
at.scanAllDirectives(root, importing=False, reading=True)
return hidden_c
def create_app(gui_name='null'):
"""
Create the Leo application, g.app, the Gui, g.app.gui, and a commander.
This method is expensive (0.5 sec) only the first time it is called.
Thereafter, recreating g.app, g.app.gui, and new commands is fast.
"""
trace = False
t1 = time.process_time()
#
# Set g.unitTesting *early*, for guards, to suppress the splash screen, etc.
g.unitTesting = True
# Create g.app now, to avoid circular dependencies.
g.app = leoApp.LeoApp()
# Late imports.
warnings.simplefilter("ignore")
from leo.core import leoConfig
from leo.core import leoNodes
from leo.core import leoCommands
from leo.core.leoGui import NullGui
if gui_name == 'qt':
from leo.plugins.qt_gui import LeoQtGui
t2 = time.process_time()
g.app.recentFilesManager = leoApp.RecentFilesManager()
g.app.loadManager = lm = leoApp.LoadManager()
lm.computeStandardDirectories()
g.app.leoID = 'TestLeoId' # 2022/03/06: Use a standard user id for all tests.
g.app.nodeIndices = leoNodes.NodeIndices(g.app.leoID)
g.app.config = leoConfig.GlobalConfigManager()
g.app.db = g.NullObject('g.app.db') # type:ignore
g.app.pluginsController = g.NullObject(
'g.app.pluginsController') # type:ignore
g.app.commander_cacher = g.NullObject(
'g.app.commander_cacher') # type:ignore
if gui_name == 'null':
g.app.gui = NullGui()
elif gui_name == 'qt':
g.app.gui = LeoQtGui()
else:
raise TypeError(f"create_gui: unknown gui_name: {gui_name!r}")
t3 = time.process_time()
# Create a dummy commander, to do the imports in c.initObjects.
# Always use a null gui to avoid screen flash.
# setUp will create another commander.
c = leoCommands.Commands(fileName=None, gui=g.app.gui)
# Create minimal config dictionaries.
settings_d, bindings_d = lm.createDefaultSettingsDicts()
lm.globalSettingsDict = settings_d
lm.globalBindingsDict = bindings_d
c.config.settingsDict = settings_d
c.config.bindingsDict = bindings_d
assert g.unitTesting is True # Defensive.
t4 = time.process_time()
# Trace times. This trace happens only once:
# imports: 0.016
# gui: 0.000
# commander: 0.469
# total: 0.484
if trace and t4 - t3 > 0.1:
print('create_app:\n'
f" imports: {(t2-t1):.3f}\n"
f" gui: {(t3-t2):.3f}\n"
f"commander: {(t4-t2):.3f}\n"
f" total: {(t4-t1):.3f}\n")
return c
