|
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547 |
- import sys
- import tokenize
-
- from pywin import default_scintilla_encoding
-
- from . import PyParse
-
- if sys.version_info < (3,):
- # in py2k, tokenize() takes a 'token eater' callback, while
- # generate_tokens is a generator that works with str objects.
- token_generator = tokenize.generate_tokens
- else:
- # in py3k tokenize() is the generator working with 'byte' objects, and
- # token_generator is the 'undocumented b/w compat' function that
- # theoretically works with str objects - but actually seems to fail)
- token_generator = tokenize.tokenize
-
-
- class AutoIndent:
- menudefs = [
- (
- "edit",
- [
- None,
- ("_Indent region", "<<indent-region>>"),
- ("_Dedent region", "<<dedent-region>>"),
- ("Comment _out region", "<<comment-region>>"),
- ("U_ncomment region", "<<uncomment-region>>"),
- ("Tabify region", "<<tabify-region>>"),
- ("Untabify region", "<<untabify-region>>"),
- ("Toggle tabs", "<<toggle-tabs>>"),
- ("New indent width", "<<change-indentwidth>>"),
- ],
- ),
- ]
-
- keydefs = {
- "<<smart-backspace>>": ["<Key-BackSpace>"],
- "<<newline-and-indent>>": ["<Key-Return>", "<KP_Enter>"],
- "<<smart-indent>>": ["<Key-Tab>"],
- }
-
- windows_keydefs = {
- "<<indent-region>>": ["<Control-bracketright>"],
- "<<dedent-region>>": ["<Control-bracketleft>"],
- "<<comment-region>>": ["<Alt-Key-3>"],
- "<<uncomment-region>>": ["<Alt-Key-4>"],
- "<<tabify-region>>": ["<Alt-Key-5>"],
- "<<untabify-region>>": ["<Alt-Key-6>"],
- "<<toggle-tabs>>": ["<Alt-Key-t>"],
- "<<change-indentwidth>>": ["<Alt-Key-u>"],
- }
-
- unix_keydefs = {
- "<<indent-region>>": [
- "<Alt-bracketright>",
- "<Meta-bracketright>",
- "<Control-bracketright>",
- ],
- "<<dedent-region>>": [
- "<Alt-bracketleft>",
- "<Meta-bracketleft>",
- "<Control-bracketleft>",
- ],
- "<<comment-region>>": ["<Alt-Key-3>", "<Meta-Key-3>"],
- "<<uncomment-region>>": ["<Alt-Key-4>", "<Meta-Key-4>"],
- "<<tabify-region>>": ["<Alt-Key-5>", "<Meta-Key-5>"],
- "<<untabify-region>>": ["<Alt-Key-6>", "<Meta-Key-6>"],
- "<<toggle-tabs>>": ["<Alt-Key-t>"],
- "<<change-indentwidth>>": ["<Alt-Key-u>"],
- }
-
- # usetabs true -> literal tab characters are used by indent and
- # dedent cmds, possibly mixed with spaces if
- # indentwidth is not a multiple of tabwidth
- # false -> tab characters are converted to spaces by indent
- # and dedent cmds, and ditto TAB keystrokes
- # indentwidth is the number of characters per logical indent level.
- # tabwidth is the display width of a literal tab character.
- # CAUTION: telling Tk to use anything other than its default
- # tab setting causes it to use an entirely different tabbing algorithm,
- # treating tab stops as fixed distances from the left margin.
- # Nobody expects this, so for now tabwidth should never be changed.
- usetabs = 1
- indentwidth = 4
- tabwidth = 8 # for IDLE use, must remain 8 until Tk is fixed
-
- # If context_use_ps1 is true, parsing searches back for a ps1 line;
- # else searches for a popular (if, def, ...) Python stmt.
- context_use_ps1 = 0
-
- # When searching backwards for a reliable place to begin parsing,
- # first start num_context_lines[0] lines back, then
- # num_context_lines[1] lines back if that didn't work, and so on.
- # The last value should be huge (larger than the # of lines in a
- # conceivable file).
- # Making the initial values larger slows things down more often.
- num_context_lines = 50, 500, 5000000
-
- def __init__(self, editwin):
- self.editwin = editwin
- self.text = editwin.text
-
- def config(self, **options):
- for key, value in options.items():
- if key == "usetabs":
- self.usetabs = value
- elif key == "indentwidth":
- self.indentwidth = value
- elif key == "tabwidth":
- self.tabwidth = value
- elif key == "context_use_ps1":
- self.context_use_ps1 = value
- else:
- raise KeyError("bad option name: %s" % repr(key))
-
- # If ispythonsource and guess are true, guess a good value for
- # indentwidth based on file content (if possible), and if
- # indentwidth != tabwidth set usetabs false.
- # In any case, adjust the Text widget's view of what a tab
- # character means.
-
- def set_indentation_params(self, ispythonsource, guess=1):
- if guess and ispythonsource:
- i = self.guess_indent()
- if 2 <= i <= 8:
- self.indentwidth = i
- if self.indentwidth != self.tabwidth:
- self.usetabs = 0
-
- self.editwin.set_tabwidth(self.tabwidth)
-
- def smart_backspace_event(self, event):
- text = self.text
- first, last = self.editwin.get_selection_indices()
- if first and last:
- text.delete(first, last)
- text.mark_set("insert", first)
- return "break"
- # Delete whitespace left, until hitting a real char or closest
- # preceding virtual tab stop.
- chars = text.get("insert linestart", "insert")
- if chars == "":
- if text.compare("insert", ">", "1.0"):
- # easy: delete preceding newline
- text.delete("insert-1c")
- else:
- text.bell() # at start of buffer
- return "break"
- if chars[-1] not in " \t":
- # easy: delete preceding real char
- text.delete("insert-1c")
- return "break"
- # Ick. It may require *inserting* spaces if we back up over a
- # tab character! This is written to be clear, not fast.
- have = len(chars.expandtabs(self.tabwidth))
- assert have > 0
- want = int((have - 1) / self.indentwidth) * self.indentwidth
- ncharsdeleted = 0
- while 1:
- chars = chars[:-1]
- ncharsdeleted = ncharsdeleted + 1
- have = len(chars.expandtabs(self.tabwidth))
- if have <= want or chars[-1] not in " \t":
- break
- text.undo_block_start()
- text.delete("insert-%dc" % ncharsdeleted, "insert")
- if have < want:
- text.insert("insert", " " * (want - have))
- text.undo_block_stop()
- return "break"
-
- def smart_indent_event(self, event):
- # if intraline selection:
- # delete it
- # elif multiline selection:
- # do indent-region & return
- # indent one level
- text = self.text
- first, last = self.editwin.get_selection_indices()
- text.undo_block_start()
- try:
- if first and last:
- if index2line(first) != index2line(last):
- return self.indent_region_event(event)
- text.delete(first, last)
- text.mark_set("insert", first)
- prefix = text.get("insert linestart", "insert")
- raw, effective = classifyws(prefix, self.tabwidth)
- if raw == len(prefix):
- # only whitespace to the left
- self.reindent_to(effective + self.indentwidth)
- else:
- if self.usetabs:
- pad = "\t"
- else:
- effective = len(prefix.expandtabs(self.tabwidth))
- n = self.indentwidth
- pad = " " * (n - effective % n)
- text.insert("insert", pad)
- text.see("insert")
- return "break"
- finally:
- text.undo_block_stop()
-
- def newline_and_indent_event(self, event):
- text = self.text
- first, last = self.editwin.get_selection_indices()
- text.undo_block_start()
- try:
- if first and last:
- text.delete(first, last)
- text.mark_set("insert", first)
- line = text.get("insert linestart", "insert")
- i, n = 0, len(line)
- while i < n and line[i] in " \t":
- i = i + 1
- if i == n:
- # the cursor is in or at leading indentation; just inject
- # an empty line at the start and strip space from current line
- text.delete("insert - %d chars" % i, "insert")
- text.insert("insert linestart", "\n")
- return "break"
- indent = line[:i]
- # strip whitespace before insert point
- i = 0
- while line and line[-1] in " \t":
- line = line[:-1]
- i = i + 1
- if i:
- text.delete("insert - %d chars" % i, "insert")
- # strip whitespace after insert point
- while text.get("insert") in " \t":
- text.delete("insert")
- # start new line
- text.insert("insert", "\n")
-
- # adjust indentation for continuations and block
- # open/close first need to find the last stmt
- lno = index2line(text.index("insert"))
- y = PyParse.Parser(self.indentwidth, self.tabwidth)
- for context in self.num_context_lines:
- startat = max(lno - context, 1)
- startatindex = repr(startat) + ".0"
- rawtext = text.get(startatindex, "insert")
- y.set_str(rawtext)
- bod = y.find_good_parse_start(
- self.context_use_ps1, self._build_char_in_string_func(startatindex)
- )
- if bod is not None or startat == 1:
- break
- y.set_lo(bod or 0)
- c = y.get_continuation_type()
- if c != PyParse.C_NONE:
- # The current stmt hasn't ended yet.
- if c == PyParse.C_STRING:
- # inside a string; just mimic the current indent
- text.insert("insert", indent)
- elif c == PyParse.C_BRACKET:
- # line up with the first (if any) element of the
- # last open bracket structure; else indent one
- # level beyond the indent of the line with the
- # last open bracket
- self.reindent_to(y.compute_bracket_indent())
- elif c == PyParse.C_BACKSLASH:
- # if more than one line in this stmt already, just
- # mimic the current indent; else if initial line
- # has a start on an assignment stmt, indent to
- # beyond leftmost =; else to beyond first chunk of
- # non-whitespace on initial line
- if y.get_num_lines_in_stmt() > 1:
- text.insert("insert", indent)
- else:
- self.reindent_to(y.compute_backslash_indent())
- else:
- assert 0, "bogus continuation type " + repr(c)
- return "break"
-
- # This line starts a brand new stmt; indent relative to
- # indentation of initial line of closest preceding
- # interesting stmt.
- indent = y.get_base_indent_string()
- text.insert("insert", indent)
- if y.is_block_opener():
- self.smart_indent_event(event)
- elif indent and y.is_block_closer():
- self.smart_backspace_event(event)
- return "break"
- finally:
- text.see("insert")
- text.undo_block_stop()
-
- auto_indent = newline_and_indent_event
-
- # Our editwin provides a is_char_in_string function that works
- # with a Tk text index, but PyParse only knows about offsets into
- # a string. This builds a function for PyParse that accepts an
- # offset.
-
- def _build_char_in_string_func(self, startindex):
- def inner(offset, _startindex=startindex, _icis=self.editwin.is_char_in_string):
- return _icis(_startindex + "+%dc" % offset)
-
- return inner
-
- def indent_region_event(self, event):
- head, tail, chars, lines = self.get_region()
- for pos in range(len(lines)):
- line = lines[pos]
- if line:
- raw, effective = classifyws(line, self.tabwidth)
- effective = effective + self.indentwidth
- lines[pos] = self._make_blanks(effective) + line[raw:]
- self.set_region(head, tail, chars, lines)
- return "break"
-
- def dedent_region_event(self, event):
- head, tail, chars, lines = self.get_region()
- for pos in range(len(lines)):
- line = lines[pos]
- if line:
- raw, effective = classifyws(line, self.tabwidth)
- effective = max(effective - self.indentwidth, 0)
- lines[pos] = self._make_blanks(effective) + line[raw:]
- self.set_region(head, tail, chars, lines)
- return "break"
-
- def comment_region_event(self, event):
- head, tail, chars, lines = self.get_region()
- for pos in range(len(lines) - 1):
- line = lines[pos]
- lines[pos] = "##" + line
- self.set_region(head, tail, chars, lines)
-
- def uncomment_region_event(self, event):
- head, tail, chars, lines = self.get_region()
- for pos in range(len(lines)):
- line = lines[pos]
- if not line:
- continue
- if line[:2] == "##":
- line = line[2:]
- elif line[:1] == "#":
- line = line[1:]
- lines[pos] = line
- self.set_region(head, tail, chars, lines)
-
- def tabify_region_event(self, event):
- head, tail, chars, lines = self.get_region()
- tabwidth = self._asktabwidth()
- for pos in range(len(lines)):
- line = lines[pos]
- if line:
- raw, effective = classifyws(line, tabwidth)
- ntabs, nspaces = divmod(effective, tabwidth)
- lines[pos] = "\t" * ntabs + " " * nspaces + line[raw:]
- self.set_region(head, tail, chars, lines)
-
- def untabify_region_event(self, event):
- head, tail, chars, lines = self.get_region()
- tabwidth = self._asktabwidth()
- for pos in range(len(lines)):
- lines[pos] = lines[pos].expandtabs(tabwidth)
- self.set_region(head, tail, chars, lines)
-
- def toggle_tabs_event(self, event):
- if self.editwin.askyesno(
- "Toggle tabs",
- "Turn tabs " + ("on", "off")[self.usetabs] + "?",
- parent=self.text,
- ):
- self.usetabs = not self.usetabs
- return "break"
-
- # XXX this isn't bound to anything -- see class tabwidth comments
- def change_tabwidth_event(self, event):
- new = self._asktabwidth()
- if new != self.tabwidth:
- self.tabwidth = new
- self.set_indentation_params(0, guess=0)
- return "break"
-
- def change_indentwidth_event(self, event):
- new = self.editwin.askinteger(
- "Indent width",
- "New indent width (1-16)",
- parent=self.text,
- initialvalue=self.indentwidth,
- minvalue=1,
- maxvalue=16,
- )
- if new and new != self.indentwidth:
- self.indentwidth = new
- return "break"
-
- def get_region(self):
- text = self.text
- first, last = self.editwin.get_selection_indices()
- if first and last:
- head = text.index(first + " linestart")
- tail = text.index(last + "-1c lineend +1c")
- else:
- head = text.index("insert linestart")
- tail = text.index("insert lineend +1c")
- chars = text.get(head, tail)
- lines = chars.split("\n")
- return head, tail, chars, lines
-
- def set_region(self, head, tail, chars, lines):
- text = self.text
- newchars = "\n".join(lines)
- if newchars == chars:
- text.bell()
- return
- text.tag_remove("sel", "1.0", "end")
- text.mark_set("insert", head)
- text.undo_block_start()
- text.delete(head, tail)
- text.insert(head, newchars)
- text.undo_block_stop()
- text.tag_add("sel", head, "insert")
-
- # Make string that displays as n leading blanks.
-
- def _make_blanks(self, n):
- if self.usetabs:
- ntabs, nspaces = divmod(n, self.tabwidth)
- return "\t" * ntabs + " " * nspaces
- else:
- return " " * n
-
- # Delete from beginning of line to insert point, then reinsert
- # column logical (meaning use tabs if appropriate) spaces.
-
- def reindent_to(self, column):
- text = self.text
- text.undo_block_start()
- if text.compare("insert linestart", "!=", "insert"):
- text.delete("insert linestart", "insert")
- if column:
- text.insert("insert", self._make_blanks(column))
- text.undo_block_stop()
-
- def _asktabwidth(self):
- return (
- self.editwin.askinteger(
- "Tab width",
- "Spaces per tab?",
- parent=self.text,
- initialvalue=self.tabwidth,
- minvalue=1,
- maxvalue=16,
- )
- or self.tabwidth
- )
-
- # Guess indentwidth from text content.
- # Return guessed indentwidth. This should not be believed unless
- # it's in a reasonable range (e.g., it will be 0 if no indented
- # blocks are found).
-
- def guess_indent(self):
- opener, indented = IndentSearcher(self.text, self.tabwidth).run()
- if opener and indented:
- raw, indentsmall = classifyws(opener, self.tabwidth)
- raw, indentlarge = classifyws(indented, self.tabwidth)
- else:
- indentsmall = indentlarge = 0
- return indentlarge - indentsmall
-
-
- # "line.col" -> line, as an int
- def index2line(index):
- return int(float(index))
-
-
- # Look at the leading whitespace in s.
- # Return pair (# of leading ws characters,
- # effective # of leading blanks after expanding
- # tabs to width tabwidth)
-
-
- def classifyws(s, tabwidth):
- raw = effective = 0
- for ch in s:
- if ch == " ":
- raw = raw + 1
- effective = effective + 1
- elif ch == "\t":
- raw = raw + 1
- effective = (effective // tabwidth + 1) * tabwidth
- else:
- break
- return raw, effective
-
-
- class IndentSearcher:
- # .run() chews over the Text widget, looking for a block opener
- # and the stmt following it. Returns a pair,
- # (line containing block opener, line containing stmt)
- # Either or both may be None.
-
- def __init__(self, text, tabwidth):
- self.text = text
- self.tabwidth = tabwidth
- self.i = self.finished = 0
- self.blkopenline = self.indentedline = None
-
- def readline(self):
- if self.finished:
- val = ""
- else:
- i = self.i = self.i + 1
- mark = repr(i) + ".0"
- if self.text.compare(mark, ">=", "end"):
- val = ""
- else:
- val = self.text.get(mark, mark + " lineend+1c")
- # hrm - not sure this is correct in py3k - the source code may have
- # an encoding declared, but the data will *always* be in
- # default_scintilla_encoding - so if anyone looks at the encoding decl
- # in the source they will be wrong. I think. Maybe. Or something...
- return val.encode(default_scintilla_encoding)
-
- def run(self):
- OPENERS = ("class", "def", "for", "if", "try", "while")
- INDENT = tokenize.INDENT
- NAME = tokenize.NAME
-
- save_tabsize = tokenize.tabsize
- tokenize.tabsize = self.tabwidth
- try:
- try:
- for typ, token, start, end, line in token_generator(self.readline):
- if typ == NAME and token in OPENERS:
- self.blkopenline = line
- elif typ == INDENT and self.blkopenline:
- self.indentedline = line
- break
-
- except (tokenize.TokenError, IndentationError):
- # since we cut off the tokenizer early, we can trigger
- # spurious errors
- pass
- finally:
- tokenize.tabsize = save_tabsize
- return self.blkopenline, self.indentedline
|