def _insert_import(self, name, module):
lineno = self.autoimport.find_insertion_line(self.source)
current = lisp.point()
lisp.goto_line(lineno)
newimport = 'from %s import %s\n' % (module, name)
lisp.insert(newimport)
lisp.goto_char(current + len(newimport))
def occurrences_goto():
if lisp.line_number_at_pos() < 1:
lisp.forward_line(1 - lisp.line_number_at_pos())
lisp.end_of_line()
end = lisp.point()
lisp.beginning_of_line()
line = lisp.buffer_substring_no_properties(lisp.point(), end)
tokens = line.split()
semicolon_tokens = line.split(":")
project_root = lisp.rope_get_project_root()
if tokens and semicolon_tokens:
# Mark this line with an arrow
lisp('''
(remove-overlays (point-min) (point-max))
(overlay-put (make-overlay (line-beginning-position) (line-end-position))
'before-string
(propertize "A" 'display '(left-fringe right-triangle)))
''')
filename = project_root + "/" + semicolon_tokens[0]
offset = int(tokens[-1])
resource = _interface._get_resource(filename)
LispUtils().find_file(resource.real_path, other=True)
lisp.goto_char(offset + 1)
def get_line_offset():
"""Return number of characters cursor is offset from margin. """
user_pos = lisp.point()
lisp.beginning_of_line()
line_start = lisp.point()
lisp.goto_char(user_pos)
return user_pos - line_start
def convert():
remember_where = lisp.point()
block_begin, block_end, content = get_block_content("\n\n", "\n\n")
# alttaki listeye dokunulmamasi istenen kelimeler tek ogeli
# tuple olarak yazilir, ("kelime",) gibi. eger degisim isteniyorsa
# ("kelime","degisim") olarak bir tuple eklenir.
r_list = [("verisi", ), ("Calculus", ), ("AIC", ), ("estimator", ),
(" ise", ), ("kontur", ), ("ODE", ), ("Oklit", u'Öklit'),
("karekok", u'karekök'), ("kismi", u'kısmi'), ("integral", ),
("oldugu", u'olduğu'), ("parcaci", u"parçacı"),
("acilimi", u'açılımı'), ("acilim", u'açılım'),
("acisini", u'açısını'), ("acisi", u'açısı'), ("aci", u'açı'),
("minimize", ), ("gayri", u'gayrı'), ("Pandas", ),
("algoritma", ), ("gayri", u'gayrı'), ("sigma", ),
("volatility", ), ("matris", ), ("frac", "frac"),
("sonum", u"sönüm"), ("eksen", ), ("sonusur", u"sonuşur"),
("amaci", u"amacı"), ("amacimiz", u"amacımız"),
("sarsim", u"sarsım"), ("Sarsim", u"Sarsım"), (u"olduğu", )]
r_list_coded = []
for x in r_list:
r_list_coded.append((x[0], str(int(random.random() * 1000000))))
for x in r_list_coded:
content = content.replace(x[0], x[1])
result = to_tr(content)
for x in r_list_coded:
result = result.replace(x[1], x[0])
for x in r_list:
if len(x) == 2: result = result.replace(x[0], x[1])
lisp.delete_region(block_begin, block_end)
lisp.insert(result)
lisp.goto_char(remember_where)
def find_imports():
print "test hello"
fname=lisp.buffer_file_name()
print "remember:" + lisp.buffer_name()
os.environ['BUFFER'] = lisp.buffer_name()
remember_where = lisp.point()
try:
fname=lisp.buffer_file_name()
project = Project(fname)
thing, start = thing_at_point_regex("\W", "\W")
print "thing:"+thing
imports = project.find_file_for_import(thing)
if (len(imports) > 1):
ready_output()
lisp.insert("\n")
for item in imports:
lisp.insert(item)
lisp.insert("\n")
elif (len(imports) == 1):
put_import(fname, imports[0])
elif (len(imports) == 0):
lisp.message("No import found for " + imports[0])
lisp.goto_char(remember_where)
except Exception, e:
lisp.message(e)
def emacs_engine(self, flag, find_limits):
"""\
Rebox text while obeying FLAG. Call FIND_LIMITS to discover the extent
of the boxed comment.
"""
# `C-u -' means that box style is to be decided interactively.
if flag == lisp['-']:
flag = self.ask_for_style()
# If FLAG is zero or negative, only change default box style.
if isinstance(flag, int) and flag <= 0:
self.default_style = -flag
lisp.message("Default style set to %d" % -flag)
return
# Decide box style and refilling.
if flag is None:
style = self.default_style
refill = True
elif isinstance(flag, int):
if self.default_style is None:
style = flag
else:
style = merge_styles(self.default_style, flag)
refill = True
else:
flag = flag.copy()
if isinstance(flag, list):
style = self.default_style
refill = False
else:
lisp.error("Unexpected flag value %s" % flag)
# Prepare for reboxing.
lisp.message("Reboxing...")
checkpoint = lisp.buffer_undo_list.value()
start, end = find_limits()
text = lisp.buffer_substring(start, end)
width = lisp.fill_column.value()
tabify = lisp.indent_tabs_mode.value() is not None
point = lisp.point()
if start <= point < end:
position = point - start
else:
position = None
# Rebox the text and replace it in Emacs buffer.
old_style, new_style, text, position = engine(
text, style=style, width=width,
refill=refill, tabify=tabify, position=position)
if text is None:
lisp.error("Cannot rebox to style %d" % new_style)
lisp.delete_region(start, end)
lisp.insert(text)
if position is not None:
lisp.goto_char(start + position)
# Collapse all operations into a single one, for Undo.
self.clean_undo_after(checkpoint)
# We are finished, tell the user.
if old_style == new_style:
lisp.message("Reboxed with style %d" % old_style)
else:
lisp.message("Reboxed from style %d to %d"
% (old_style, new_style))
def _make_buffer(self,
name,
contents,
empty_goto=True,
switch=False,
window='other',
modes=[],
fit_lines=None):
"""Make an emacs buffer
`window` can be one of `None`, 'current' or 'other'.
"""
new_buffer = lisp.get_buffer_create(name)
lisp.set_buffer(new_buffer)
lisp.toggle_read_only(-1)
lisp.erase_buffer()
if contents or empty_goto:
lisp.insert(contents)
for mode in modes:
lisp[mode + '-mode']()
lisp.buffer_disable_undo(new_buffer)
lisp.toggle_read_only(1)
if switch:
if window == 'current':
lisp.switch_to_buffer(new_buffer)
else:
lisp.switch_to_buffer_other_window(new_buffer)
lisp.goto_char(lisp.point_min())
elif window == 'other':
new_window = lisp.display_buffer(new_buffer)
lisp.set_window_point(new_window, lisp.point_min())
if fit_lines and lisp.fboundp(lisp['fit-window-to-buffer']):
lisp.fit_window_to_buffer(new_window, fit_lines)
lisp.bury_buffer(new_buffer)
return new_buffer
def _make_buffer(self, name, contents, empty_goto=True, switch=False,
window='other', modes=[], fit_lines=None):
"""Make an emacs buffer
`window` can be one of `None`, 'current' or 'other'.
"""
new_buffer = lisp.get_buffer_create(name)
lisp.set_buffer(new_buffer)
lisp.toggle_read_only(-1)
lisp.erase_buffer()
if contents or empty_goto:
lisp.insert(contents)
for mode in modes:
lisp[mode + '-mode']()
lisp.buffer_disable_undo(new_buffer)
lisp.toggle_read_only(1)
if switch:
if window == 'current':
lisp.switch_to_buffer(new_buffer)
else:
lisp.switch_to_buffer_other_window(new_buffer)
lisp.goto_char(lisp.point_min())
elif window == 'other':
new_window = lisp.display_buffer(new_buffer)
lisp.set_window_point(new_window, lisp.point_min())
if fit_lines and lisp.fboundp(lisp['fit-window-to-buffer']):
lisp.fit_window_to_buffer(new_window, fit_lines)
lisp.bury_buffer(new_buffer)
return new_buffer
def get_line_offset():
"""Return number of characters cursor is offset from margin. """
user_pos = lisp.point()
lisp.beginning_of_line()
line_start = lisp.point()
lisp.goto_char(user_pos)
return user_pos - line_start
def emacs_engine(self, flag, find_limits):
"""\
Rebox text while obeying FLAG. Call FIND_LIMITS to discover the extent
of the boxed comment.
"""
# `C-u -' means that box style is to be decided interactively.
if flag == lisp['-']:
flag = self.ask_for_style()
# If FLAG is zero or negative, only change default box style.
if isinstance(flag, int) and flag <= 0:
self.default_style = -flag
lisp.message("Default style set to %d" % -flag)
return
# Decide box style and refilling.
if flag is None:
style = self.default_style
refill = True
elif isinstance(flag, int):
if self.default_style is None:
style = flag
else:
style = merge_styles(self.default_style, flag)
refill = True
else:
flag = flag.copy()
if isinstance(flag, list):
style = self.default_style
refill = False
else:
lisp.error("Unexpected flag value %s" % flag)
# Prepare for reboxing.
lisp.message("Reboxing...")
checkpoint = lisp.buffer_undo_list.value()
start, end = find_limits()
text = lisp.buffer_substring(start, end)
width = lisp.fill_column.value()
tabify = lisp.indent_tabs_mode.value() is not None
point = lisp.point()
if start <= point < end:
position = point - start
else:
position = None
# Rebox the text and replace it in Emacs buffer.
old_style, new_style, text, position = engine(
text, style=style, width=width,
refill=refill, tabify=tabify, position=position)
if text is None:
lisp.error("Cannot rebox to style %d" % new_style)
lisp.delete_region(start, end)
lisp.insert(text)
if position is not None:
lisp.goto_char(start + position)
# Collapse all operations into a single one, for Undo.
self.clean_undo_after(checkpoint)
# We are finished, tell the user.
if old_style == new_style:
lisp.message("Reboxed with style %d" % old_style)
else:
lisp.message("Reboxed from style %d to %d"
% (old_style, new_style))
def convert():
remember_where = lisp.point()
block_begin, block_end, content = get_block_content("\n\n","\n\n")
# alttaki listeye dokunulmamasi istenen kelimeler tek ogeli
# tuple olarak yazilir, ("kelime",) gibi. eger degisim isteniyorsa
# ("kelime","degisim") olarak bir tuple eklenir.
r_list = [("verisi",),("Calculus",),("AIC",),("estimator",),(" ise",),
("kontur",),("ODE",),("Oklit",u'Öklit'),("karekok",u'karekök'),
("kismi", u'kısmi'),("integral",),("oldugu",u'olduğu'),
("acilimi",u'açılımı'),("acilim",u'açılım'),("aci",u'açı'),
("minimize",),("gayri",u'gayrı'),("Pandas",),("algoritma",),
("gayri",u'gayrı'),("sigma",),("volatility",),("matris",)]
r_list_coded = []
for x in r_list: r_list_coded.append((x[0],str(int(random.random() * 1000000))))
for x in r_list_coded: content = content.replace(x[0],x[1])
result = to_tr(content)
for x in r_list_coded: result = result.replace(x[1],x[0])
for x in r_list:
if len(x)==2: result = result.replace(x[0],x[1])
lisp.delete_region(block_begin, block_end)
lisp.insert(result)
lisp.goto_char(remember_where)
def get_buffer_content_prev(bend):
where_am_i = lisp.point()
lisp.beginning_of_buffer()
st = lisp.point()
s = lisp.buffer_substring(st, bend)
lisp.goto_char(where_am_i)
return s
def get_block_content(start_tag, end_tag):
remember_where = lisp.point()
block_begin = lisp.search_backward(start_tag)
lisp.goto_char(remember_where)
block_end = lisp.search_forward(end_tag)
content = lisp.buffer_substring(block_begin, block_end)
lisp.goto_char(remember_where)
return block_begin, block_end, content
def get_block_content(start_tag, end_tag):
remember_where = lisp.point()
block_begin = lisp.search_backward(start_tag)
block_end = lisp.search_forward(end_tag)
block_end = lisp.search_forward(end_tag)
content = lisp.buffer_substring(block_begin, block_end)
lisp.goto_char(remember_where)
return block_begin, block_end, content
def from_rest():
text = get_text()
parts = docutils.core.publish_parts(text, writer=Writer())
lisp.weblogger_start_entry()
lisp.insert(parts['title'])
lisp.goto_char(lisp.point_max())
lisp.insert(parts['body'])
def _goto_location(self, resource, lineno, point=None, other=False):
if resource:
self.env.find_file(str(resource.real_path),
resource.project != self.project, other=other)
if point:
lisp.goto_char(point)
if lineno:
self.env.goto_line(lineno)
def get_block_content(start_tag, end_tag):
remember_where = lisp.point()
block_end = lisp.search_forward(end_tag)
block_begin = lisp.search_backward(start_tag)
content = lisp.buffer_substring(block_begin, block_end)
content = re.sub("\\\\begin{minted}.*?{python}","",content)
content = re.sub("\\\\end{minted}","",content)
lisp.goto_char(remember_where)
return block_begin, block_end, content
def occurrences_next(arg, reset):
lisp.switch_to_buffer_other_window('*rope-occurrences*', True)
if reset:
lisp.goto_char(lisp.point_min())
lisp.forward_line(arg)
if lisp.eobp():
lisp.message("Cycling rope occurences")
lisp.goto_char(lisp.point_min())
occurrences_goto()
def genall():
remem = lisp.point()
lisp.beginning_of_buffer()
res = True
while res:
res = lisp.re_search_forward("$$[[:ascii:][:nonascii:]]*?$$",None,lisp.t)
lisp.backward_char(3)
show()
lisp.goto_char(remem)
def get_block_content(start_tag, end_tag):
remember_where = lisp.point()
block_end = lisp.search_forward(end_tag)
block_begin = lisp.search_backward(start_tag)
content = lisp.buffer_substring(block_begin, block_end)
content = re.sub("\\\\begin{minted}.*?{python}", "", content)
content = re.sub("\\\\end{minted}", "", content)
lisp.goto_char(remember_where)
return block_begin, block_end, content
def occurrences_next(arg, reset):
lisp.switch_to_buffer_other_window('*rope-occurrences*', True)
if reset:
lisp.goto_char(lisp.point_min())
lisp.forward_line(arg)
if lisp.eobp():
lisp.message("Cycling rope occurences")
lisp.goto_char(lisp.point_min())
occurrences_goto()
def pop_excursion(self):
method, (buffer, point_marker, mark_marker) = self.stack[-1]
assert method == 'excursion', self.stack[-1]
del self.stack[-1]
lisp.set_buffer(buffer)
lisp.goto_char(point_marker)
lisp.set_mark(mark_marker)
lisp.set_marker(point_marker, None)
if mark_marker is not None: # needed for xemacs
lisp.set_marker(mark_marker, None)
def genall():
remem = lisp.point()
lisp.beginning_of_buffer()
res = True
while res:
res = lisp.re_search_forward("$$[[:ascii:][:nonascii:]]*?$$", None,
lisp.t)
lisp.backward_char(3)
show()
lisp.goto_char(remem)
def pop_excursion(self):
method, (buffer, point_marker, mark_marker) = self.stack[-1]
assert method == 'excursion', self.stack[-1]
del self.stack[-1]
lisp.set_buffer(buffer)
lisp.goto_char(point_marker)
lisp.set_mark(mark_marker)
lisp.set_marker(point_marker, None)
if mark_marker is not None: # needed for xemacs
lisp.set_marker(mark_marker, None)
def verb_exists():
remem = lisp.point()
lisp.forward_line(2)
lisp.beginning_of_line()
verb_line_b = lisp.point()
lisp.end_of_line()
verb_line_e = lisp.point()
verb_line = lisp.buffer_substring(verb_line_b, verb_line_e)
lisp.goto_char(remem)
if "\\begin{verbatim}" in verb_line: return True
else: return False
def goto_definition():
"""
go to definition/declaration of the pointer we are looking at
"""
fname=lisp.buffer_file_name()
a = Project(fname)
thing, start = thing_at_point(RIGHT1, LEFT1)
lisp.message(thing)
pos = lisp.point()
type, pos = a.find_declaration_type(thing, fname, pos)
lisp.goto_char(pos)
def verb_exists():
remem = lisp.point()
lisp.forward_line(1)
lisp.beginning_of_line()
verb_line_b = lisp.point()
lisp.end_of_line()
verb_line_e = lisp.point()
verb_line = lisp.buffer_substring(verb_line_b, verb_line_e)
lisp.goto_char(remem)
if "```text" in verb_line: return True
else: return False
def insert_text(text,offset=0):
"""Insert text in buffer and move cursor to a certain offset.
If called with no offset, leaves the cursor at the current position."""
# save undo state so we can roll everything into a single operation for undo
checkpoint = lisp.buffer_undo_list.value()
user_pos = lisp.point()
lisp.insert(text)
lisp.goto_char(user_pos+offset)
# Collapse all operations into a single one, for Undo.
clean_undo_after(checkpoint)
def occurrences_goto_occurrence(self):
self._check_project()
start = lisp.line_beginning_position()
end = lisp.line_end_position()
line = lisp.buffer_substring_no_properties(start, end)
tokens = line.split()
if tokens:
resource = self.project.get_resource(tokens[0])
offset = int(tokens[2])
lisp.find_file_other_window(resource.real_path)
lisp.goto_char(offset + 1)
lisp.switch_to_buffer_other_window('*rope-occurrences*')
def insert_text(text, offset=0):
"""Insert text in buffer and move cursor to a certain offset.
If called with no offset, leaves the cursor at the current position."""
# save undo state so we can roll everything into a single operation for undo
checkpoint = lisp.buffer_undo_list.value()
user_pos = lisp.point()
lisp.insert(text)
lisp.goto_char(user_pos + offset)
# Collapse all operations into a single one, for Undo.
clean_undo_after(checkpoint)
def occurrences_goto():
if lisp.line_number_at_pos() < 3:
lisp.forward_line(3 - lisp.line_number_at_pos())
lisp.end_of_line()
end = lisp.point()
lisp.beginning_of_line()
line = lisp.buffer_substring_no_properties(lisp.point(), end)
tokens = line.split()
if tokens:
filename = tokens[0]
offset = int(tokens[-1])
resource = _interface._get_resource(filename)
LispUtils().find_file(resource.real_path, other=True)
lisp.goto_char(offset + 1)
def occurrences_goto():
if lisp.line_number_at_pos() < 3:
lisp.forward_line(3 - lisp.line_number_at_pos())
lisp.end_of_line()
end = lisp.point()
lisp.beginning_of_line()
line = lisp.buffer_substring_no_properties(lisp.point(), end)
tokens = line.split()
if tokens:
filename = tokens[0]
offset = int(tokens[-1])
resource = _interface._get_resource(filename)
LispUtils().find_file(resource.real_path, other=True)
lisp.goto_char(offset + 1)
def occurrences_goto_occurrence():
lisp.end_of_line()
end = lisp.point()
lisp.beginning_of_line()
start = lisp.point()
line = lisp.buffer_substring_no_properties(start, end)
tokens = line.split()
if tokens:
filename = tokens[0]
offset = int(tokens[-1])
resource = _interface._get_resource(filename)
LispUtils().find_file(resource.real_path, other=True)
lisp.goto_char(offset + 1)
lisp.switch_to_buffer_other_window('*rope-occurrences*')
def pick_method():
'''
pick the whole line from the list of function calls (completions)
'''
print "in pick method"
thing, start = thing_at_point(RIGHT2, LEFT2)
prev_buffer = os.environ['BUFFER']
print "-"+prev_buffer+"-"
lisp.kill_buffer(lisp.get_buffer("*PyJde*"))
lisp.switch_to_buffer(prev_buffer)
lisp.insert(thing)
pos = lisp.point()
print "pos="+(str(pos-1))
lisp.goto_char(pos-1)
lisp.delete_other_windows()
def put_import (fname, imp):
print "in put_import"
print fname
print imp
content = lisp.buffer_substring(1, lisp.point())
print content
for m in re.finditer("(import\s.*?);", content):
print "mgroup="+m.group(1)
print imp
if (re.search(imp, m.group(1))):
lisp.message("Already imported")
return
insert_where = re.search("import\s.*;", content).span()[1]
lisp.goto_char(insert_where + 1)
lisp.insert("\nimport " + imp + ";")
def convert():
remember_where = lisp.point()
block_begin, block_end, content = get_block_content("\n\n","\n\n")
content = content.replace("verisi","WWXXD1")
content = content.replace("Calculus","WWXXD2")
content = content.replace("AIC","WWXXD3")
content = content.replace("estimator","WWXXD5")
content = content.replace(" ise","WWXXD7")
content = content.replace("kontur","WWXXD8")
content = content.replace("ODE","WWXXD9")
content = content.replace("Oklit","WWXXDx3")
content = content.replace("karekok","WWXXDx4")
content = content.replace("kismi","WWXXDx5")
content = content.replace("integral","WWXXDx7")
content = content.replace("acilimi","WWXXDx8")
content = content.replace(" aci","WWXXDy1")
content = content.replace("gayri","WWXXDy2")
content = content.replace("oldugu","WWXXDy3")
content = content.replace("Pandas","WWXXDy4")
content = content.replace("algoritma","WWXXDy5")
content = content.replace("minimize","WWXXDy6")
result = to_tr(content)
result = result.replace("WWXXD1","verisi")
result = result.replace("WWXXD2","Calculus")
result = result.replace("WWXXD3","AIC")
result = result.replace("WWXXD5","estimator")
result = result.replace("WWXXD7"," ise" )
result = result.replace("WWXXD8","kontur" )
result = result.replace("WWXXD9","ODE" )
result = result.replace('WWXXDx3',u'Öklit' )
result = result.replace('WWXXDx4',u'karekök' )
result = result.replace('WWXXDx5',u'kısmi' )
result = result.replace('WWXXDx7',u'integral' )
result = result.replace('WWXXDx8',u'acılımı' )
result = result.replace('WWXXDy1',u' açı' )
result = result.replace('WWXXDy2',u' gayrı' )
result = result.replace('WWXXDy3',u'olduğu' )
result = result.replace('WWXXDy4',u'Pandas' )
result = result.replace('WWXXDy5',u'algoritma' )
result = result.replace('WWXXDy6',u'minimize' )
lisp.delete_region(block_begin, block_end)
lisp.insert(result)
lisp.goto_char(remember_where)
def insert_indented_text(text,offset):
"""Insert indented text in buffer and move cursor to a certain offset."""
# save undo state so we can roll everything into a single operation for undo
checkpoint = lisp.buffer_undo_list.value()
# figure out if we are indented or not, and adapt text accordingly
indent_level = get_line_offset()
if indent_level > 0:
text = indent(text,indent_level)
# perform actual insertion with proper cursor positioning
offset += indent_level
lisp.beginning_of_line()
user_pos = lisp.point()
lisp.insert(text)
lisp.goto_char(user_pos+offset)
# Collapse all operations into a single one, for Undo.
clean_undo_after(checkpoint)
def insert_indented_text(text, offset):
"""Insert indented text in buffer and move cursor to a certain offset."""
# save undo state so we can roll everything into a single operation for undo
checkpoint = lisp.buffer_undo_list.value()
# figure out if we are indented or not, and adapt text accordingly
indent_level = get_line_offset()
if indent_level > 0:
text = indent(text, indent_level)
# perform actual insertion with proper cursor positioning
offset += indent_level
lisp.beginning_of_line()
user_pos = lisp.point()
lisp.insert(text)
lisp.goto_char(user_pos + offset)
# Collapse all operations into a single one, for Undo.
clean_undo_after(checkpoint)
def pop_mark(self):
marker_ring = self.get('marker_ring')
if lisp.ring_empty_p(marker_ring):
self.message("There are no more marked buffers in \
the rope-marker-ring")
else:
oldbuf = lisp.current_buffer()
marker = lisp.ring_remove(marker_ring, 0)
marker_buffer = lisp.marker_buffer(marker)
if marker_buffer is None:
lisp.message("The marked buffer has been deleted")
return
marker_point = lisp.marker_position(marker)
lisp.set_buffer(marker_buffer)
lisp.goto_char(marker_point)
#Kill that marker so it doesn't slow down editing.
lisp.set_marker(marker, None, None)
if not lisp.eq(oldbuf, marker_buffer):
lisp.switch_to_buffer(marker_buffer)
def display_results(end_block, res):
lisp.goto_char(end_block)
lisp.forward_line(2)
lisp.beginning_of_line()
verb_line_b = lisp.point()
lisp.end_of_line()
verb_line_e = lisp.point()
verb_line = lisp.buffer_substring(verb_line_b, verb_line_e)
if "\\begin{verbatim}" in verb_line:
verb_begin,verb_end,content = get_block_content("\\begin{verbatim}","\\end{verbatim}")
lisp.delete_region(verb_begin, verb_end)
lisp.goto_char(verb_begin)
else:
lisp.backward_line_nomark(1)
lisp.insert("\n")
res=res.replace("\r","")
lisp.insert("\\begin{verbatim}\n")
lisp.insert(res)
lisp.insert("\\end{verbatim}")
def pop_mark(self):
marker_ring = self.get('marker_ring')
if lisp.ring_empty_p(marker_ring):
self.message("There are no more marked buffers in \
the rope-marker-ring")
else:
oldbuf = lisp.current_buffer()
marker = lisp.ring_remove(marker_ring, 0)
marker_buffer = lisp.marker_buffer(marker)
if marker_buffer is None:
lisp.message("The marked buffer has been deleted")
return
marker_point = lisp.marker_position(marker)
lisp.set_buffer(marker_buffer)
lisp.goto_char(marker_point)
#Kill that marker so it doesn't slow down editing.
lisp.set_marker(marker, None, None)
if not lisp.eq(oldbuf, marker_buffer):
lisp.switch_to_buffer(marker_buffer)
def pexec():
global glob
start = time.time()
remember_where = lisp.point()
block_begin, block_end, content = get_block_content("\n","\n")
if "=" in content or "import" in content:
c = compile(source=content,filename="",mode="single")
eval(c,glob)
else:
c = compile(source=content,filename="",mode="eval")
res = eval(c,glob)
lisp.forward_line(2)
bb1, be2, bc2 = get_block_content("\n","\n")
lisp.delete_region(bb1,be2)
lisp.insert("\n")
lisp.insert(str(res))
lisp.goto_char(remember_where)
elapsed = (time.time() - start)
lisp.message("Ran in " + str(elapsed) + " seconds")
def show():
b,e,res = get_block_content("$$","$$")
d = hash(res)
foutsimple = "_preview/f-%d.png" % d
if os.path.isfile(foutsimple): return # do nothing
latex(res)
curr_dir = os.path.dirname(lisp.buffer_file_name())
fout = "%s/_preview/f-%d.png" % (curr_dir,d)
shutil.copy(dir + "\standalone.png",fout)
remem = lisp.point()
lisp.goto_char(e)
lisp.forward_line(1)
lisp.beginning_of_line(); bb = lisp.point()
lisp.end_of_line(); ee = lisp.point()
lisp.delete_region(bb,ee)
lisp.insert("%{{" + foutsimple + "}}")
lisp.goto_char(remem)
lisp.iimage_mode(1)
def pick_import():
'''
pick the whole line from the list of imports
'''
print "in pick import"
thing, start = thing_at_point_regex("\n", "\n")
prev_buffer = os.environ['BUFFER']
print "-"+prev_buffer+"-"
lisp.kill_buffer(lisp.get_buffer("*PyJde*"))
lisp.switch_to_buffer(prev_buffer)
remember_where = lisp.point()
content = lisp.buffer_substring(1, lisp.point())
insert_where = re.search("package\s.*;", content).span()[1]
lisp.goto_char(insert_where + 1)
lisp.insert("\n\nimport " + thing + ";")
lisp.message(thing + " is imported")
lisp.goto_char(remember_where)
lisp.delete_other_windows()
def show():
b, e, res = get_block_content("$$", "$$")
d = hash(res)
foutsimple = "_preview/f-%d.png" % d
if os.path.isfile(foutsimple): return # do nothing
latex(res)
curr_dir = os.path.dirname(lisp.buffer_file_name())
fout = "%s/_preview/f-%d.png" % (curr_dir, d)
shutil.copy(dir + "\standalone.png", fout)
remem = lisp.point()
lisp.goto_char(e)
lisp.forward_line(1)
lisp.beginning_of_line()
bb = lisp.point()
lisp.end_of_line()
ee = lisp.point()
lisp.delete_region(bb, ee)
lisp.insert("%{{" + foutsimple + "}}")
lisp.goto_char(remem)
lisp.iimage_mode(1)
def convert():
remember_where = lisp.point()
block_begin, block_end, content = get_block_content("\n\n", "\n\n")
content = content.replace("verisi", "WWXXD1")
content = content.replace("Calculus", "WWXXD2")
content = content.replace("AIC", "WWXXD3")
content = content.replace("\sigma", "WWXXD4")
content = content.replace("estimator", "WWXXD5")
content = content.replace("\frac", "WWXXD6")
content = content.replace("entegral", "didibin")
content = content.replace(" ise", "WWXXD7")
result = to_tr(content)
result = result.replace("WWXXD1", "verisi")
result = result.replace("WWXXD2", "Calculus")
result = result.replace("WWXXD3", "AIC")
result = result.replace("WWXXD4", "\sigma")
result = result.replace("WWXXD5", "estimator")
result = result.replace("WWXXD6", "\frac")
result = result.replace("didibin", "entegral")
result = result.replace("WWXXD7", " ise")
lisp.delete_region(block_begin, block_end)
lisp.insert(result)
lisp.goto_char(remember_where)
def run_py_code():
remember_where = lisp.point()
# check if the line contains \inputminted
lisp.beginning_of_line()
l1 = lisp.point()
lisp.end_of_line()
l2 = lisp.point()
line = lisp.buffer_substring(l1, l2)
# if code comes from file
# get code content from latex
block_begin, block_end, content = get_block_content("```python", "```\n")
# we have code content at this point
# scan content to find plt.plot(). if there is, scan buffer
# previous to *here* to determine order of _this_ plt.plot(), and
# give it an appropiate index that will be appended to the end of
# the .png image file, i.e. [buffer name]_[index].png. plt.plot()
# commands will be replaced by the corresponding plt.savefig
# command.
# generate savefig for execution code (no output in emacs yet)
bc = lisp.buffer_string()
plt_count_before = len(re.findall('plt\.savefig\(', bc))
base = os.path.splitext(lisp.buffer_name())[0]
f = '%s_%s.png' % (base, two_digit(plt_count_before + 1))
rpl = "plt.savefig('%s')" % f
show_replaced = True if "plt.show()" in content else False
content = content.replace("plt.show()", rpl)
content = "plt.figure();\n" + content
include_graphics_command = "" % f
# we have code content at this point
start = time.time()
with capture_output() as io:
res_code = get_ip().run_cell(content)
res = io.stdout
elapsed = (time.time() - start)
if len(res) > 0:
display_results(block_end, res) # display it
if show_replaced:
lisp.goto_char(block_end)
lisp.forward_line(2) # skip over end verbatim, leave one line emtpy
lisp.insert('\n' + include_graphics_command + '\n')
lisp.scroll_up(1) # skip over end verbatim, leave one line emtpy
lisp.goto_char(remember_where)
lisp.replace_string("plt.show()", rpl, None, block_begin, block_end)
lisp.goto_char(remember_where)
lisp.message("Ran in " + str(elapsed) + " seconds")
def display_results(end_block, res):
remem = lisp.point()
res = res.replace("\r", "")
lisp.goto_char(end_block)
verb_begin = None
# if there is output block, remove it whether there output or not
# because it will be replaced anyway if something exists
if verb_exists():
verb_begin, verb_end, content = get_block_content("```text", "```\n")
lisp.delete_region(verb_begin, verb_end)
lisp.goto_char(remem)
# now if there _is_ output, then go to beginning of old verbatim
# output (if removed), if not, this is brand new output, move
# down 2 lines, insert the output
if verb_begin:
lisp.goto_char(verb_begin)
else:
lisp.forward_line(1)
lisp.insert("```text\n")
lisp.insert(res)
lisp.insert("```\n")
def find_comment(self):
"""\
Find and return the limits of the block of comments following or enclosing
the cursor, or return an error if the cursor is not within such a block
of comments. Extend it as far as possible in both directions.
"""
let = Let().push_excursion()
try:
# Find the start of the current or immediately following comment.
lisp.beginning_of_line()
lisp.skip_chars_forward(' \t\n')
lisp.beginning_of_line()
if not language_matcher[0](self.remainder_of_line()):
temp = lisp.point()
if not lisp.re_search_forward('\\*/', None, lisp.t):
lisp.error("outside any comment block")
lisp.re_search_backward('/\\*')
if lisp.point() > temp:
lisp.error("outside any comment block")
temp = lisp.point()
lisp.beginning_of_line()
lisp.skip_chars_forward(' \t')
if lisp.point() != temp:
lisp.error("text before start of comment")
lisp.beginning_of_line()
start = lisp.point()
language = guess_language(self.remainder_of_line())
# Find the end of this comment.
if language == 2:
lisp.search_forward('*/')
if not lisp.looking_at('[ \t]*$'):
lisp.error("text after end of comment")
lisp.end_of_line()
if lisp.eobp():
lisp.insert('\n')
else:
lisp.forward_char(1)
end = lisp.point()
# Try to extend the comment block backwards.
lisp.goto_char(start)
while not lisp.bobp():
if language == 2:
lisp.skip_chars_backward(' \t\n')
if not lisp.looking_at('[ \t]*\n[ \t]*/\\*'):
break
if lisp.point() < 2:
break
lisp.backward_char(2)
if not lisp.looking_at('\\*/'):
break
lisp.re_search_backward('/\\*')
temp = lisp.point()
lisp.beginning_of_line()
lisp.skip_chars_forward(' \t')
if lisp.point() != temp:
break
lisp.beginning_of_line()
else:
lisp.previous_line(1)
if not language_matcher[language](
self.remainder_of_line()):
break
start = lisp.point()
# Try to extend the comment block forward.
lisp.goto_char(end)
while language_matcher[language](self.remainder_of_line()):
if language == 2:
lisp.re_search_forward('[ \t]*/\\*')
lisp.re_search_forward('\\*/')
if lisp.looking_at('[ \t]*$'):
lisp.beginning_of_line()
lisp.forward_line(1)
end = lisp.point()
else:
lisp.forward_line(1)
end = lisp.point()
return start, end
finally:
let.pops()
def run_py_code():
remember_where = lisp.point()
# check if the line contains \inputminted
lisp.beginning_of_line()
l1 = lisp.point()
lisp.end_of_line()
l2 = lisp.point()
line = lisp.buffer_substring(l1, l2)
# if code comes from file
if "\\inputminted" in line:
block_begin = lisp.point()
lisp.message(line)
py_file = re.search("\{python\}\{(.*?)\}", line).groups(1)[0]
# get code content from file
curr_dir = os.path.dirname(lisp.buffer_file_name())
content = open(curr_dir + "/" + py_file).read()
block_end = l2 # end of block happens to be end of include file line
lisp.goto_char(remember_where)
else:
# get code content from latex
block_begin, block_end, content = get_block_content(
"\\begin{minted}", "\\end{minted}")
# we have code content at this point
# scan content to find plt.plot(). if there is, scan buffer
# previous to *here* to determine order of _this_ plt.plot(), and
# give it an appropiate index that will be appended to the end of
# the .png image file, i.e. [buffer name]_[index].png. plt.plot()
# commands will be replaced by the corresponding plt.savefig
# command.
# generate savefig for execution code (no output in emacs yet)
bc = lisp.buffer_string()
plt_count_before = len(re.findall('plt\.savefig\(', bc))
base = os.path.splitext(lisp.buffer_name())[0]
f = '%s_%s.png' % (base, two_digit(plt_count_before + 1))
rpl = "plt.savefig('%s')" % f
show_replaced = True if "plt.show()" in content else False
content = content.replace("plt.show()", rpl)
content = "plt.figure()\n" + content
include_graphics_command = "\\includegraphics[height=6cm]{%s}" % f
#(ip) = get_kernel_pointer(lisp.buffer_name())
start = time.time()
with capture_output() as io:
res_code = get_ip().run_cell(content)
res = io.stdout
elapsed = (time.time() - start)
display_results(block_end, res) # display it
# generate includegraphics command
if show_replaced:
lisp.forward_line(2) # skip over end verbatim, leave one line emtpy
lisp.insert(include_graphics_command + '\n')
lisp.scroll_up(1) # skip over end verbatim, leave one line emtpy
lisp.goto_char(remember_where)
lisp.replace_string("plt.show()", rpl, None, block_begin, block_end)
lisp.goto_char(remember_where)
if "plt.savefig" in content: lisp.preview_buffer()
lisp.message("Ran in " + str(elapsed) + " seconds")
def run_py_code():
remember_where = lisp.point()
# check if the line contains \inputminted
lisp.beginning_of_line()
l1 = lisp.point()
lisp.end_of_line()
l2 = lisp.point()
line = lisp.buffer_substring(l1, l2)
# if code comes from file
if "\\inputminted" in line:
lisp.message(line)
py_file = re.search("\{python\}\{(.*?)\}", line).groups(1)[0]
# get code content from file
curr_dir = os.path.dirname(lisp.buffer_file_name())
content = open(curr_dir + "/" + py_file).read()
block_end = l2 # end of block happens to be end of include file line
lisp.goto_char(remember_where)
else:
# get code content from latex
block_begin, block_end, content = get_block_content(
"\\begin{minted}", "\\end{minted}")
#lisp.message(content)
# we have code content at this point
# scan content to find plt.plot(). if there is, scan buffer
# previous to *here* to determine order of _this_ plt.plot(), and
# give it an appropiate index that will be appended to the end of
# the .png image file, i.e. [buffer name]_[index].png. plt.plot()
# commands will be replaced by the corresponding plt.savefig
# command.
# generate savefig for execution code (no output in emacs yet)
bc = get_buffer_content_prev(block_begin)
plt_count_before = len(re.findall('plt\.savefig\(', bc))
base = os.path.splitext(lisp.buffer_name())[0]
f = '%s_%s.png' % (base, two_digit(plt_count_before + 1))
rpl = "plt.savefig('%s')" % f
show_replaced = True if "plt.show()" in content else False
content = content.replace("plt.show()", rpl)
include_graphics_command = "\\includegraphics[height=6cm]{%s}" % f
(kc, kernel, ip) = get_kernel_pointer(lisp.buffer_name())
start = time.time()
res = ''
with capture_output() as io:
ip.run_cell(content)
res = io.stdout
if kernel.shell.last_known_outflag:
etype, value, tb = kernel.shell._get_exc_info()
res = str(etype) + " " + str(value) + "\n"
elapsed = (time.time() - start)
# replace this unnecessary message so output becomes blank
if res and len(res) > 0: # if result not empty
res = res.replace(
"Populating the interactive namespace from numpy and matplotlib\n",
"")
display_results(block_end, res) # display it
else:
display_results(block_end, "")
lisp.goto_char(block_end)
# generate includegraphics command
if show_replaced:
lisp.forward_line(2) # skip over end verbatim, leave one line emtpy
lisp.insert(include_graphics_command + '\n')
lisp.backward_line_nomark(
1) # skip over end verbatim, leave one line emtpy
lisp.goto_char(remember_where)
lisp.replace_string("plt.show()", rpl, None, block_begin, block_end)
lisp.goto_char(remember_where)
if "plt.savefig" in content: lisp.preview_buffer()
lisp.message("Ran in " + str(elapsed) + " seconds")
def insert_line(self, line, lineno):
current = lisp.point()
lisp.goto_line(lineno)
lisp.insert(line + '\n')
lisp.goto_char(current + len(line) + 1)
