Exemple #1
0
 def test(c):
     m = Mocker()
     regundo = m.replace(mod, 'register_undo_callback')
     convert = m.replace(mod, 'change_indentation')
     doc = m.mock(TextDocument)
     with m.off_the_record():
         dv = Editor(None, document=doc)
     tv = dv.text_view = m.mock(ak.NSTextView)
     if c.convert:
         old_indent = "\t" if c.oldm is TAB else (" " * c.olds)
         new_indent = "\t" if c.newm is TAB else (" " * c.news)
         convert(tv, old_indent, new_indent, c.news)
     if c.oldm != c.newm:
         doc.props.indent_mode = c.newm
     if c.olds != c.news:
         doc.props.indent_size = c.news
     if c.convert or c.convert is None:
         undo_change = m.mock(); undo_change(c.newm, c.news, c.oldm, c.olds, None)
         def _undo(undoman, undo):
             dv.change_indentation = undo_change
             undo()
         undoman = doc.undo_manager >> m.mock(fn.NSUndoManager)
         expect(regundo(undoman, ANY)).call(_undo)
     with m:
         dv.change_indentation(c.oldm, c.olds, c.newm, c.news, c.convert)
Exemple #2
0
 def test(app, c):
     m = Mocker()
     doc = TextDocument(app)
     with m.off_the_record():
         doc.text_storage = ts = m.mock(ak.NSTextStorage)
     app.syntax_factory = m.mock(SyntaxFactory)
     m.property(doc, "syntaxdef")
     m.property(doc, "props")
     syn = doc.syntaxer = m.mock(Highlighter)
     color_text = m.method(doc.color_text)
     syn.filename >> "<filename %s>" % ("0" if c.namechange else "1")
     new = doc.file_path = "<filename 1>"
     colored = False
     if c.namechange:
         syn.filename = new
         sdef = app.syntax_factory.get_definition(new) >> m.mock(SyntaxDefinition)
         doc.syntaxdef >> (None if c.newdef else sdef)
         if c.newdef:
             doc.props.syntaxdef = sdef
             color_text()
             colored = True
     doc.syntax_needs_color = c.needs_color
     if c.needs_color and not colored:
         color_text()
     with m:
         doc.update_syntaxer()
         eq_(doc.syntax_needs_color, False)
Exemple #3
0
 def test(app, has_text_storage, event=None):
     INDENT_SIZE = 42
     m = Mocker()
     ps_class = m.replace(ak, 'NSParagraphStyle')
     doc = TextDocument(app)
     if has_text_storage:
         with m.off_the_record():
             ts = doc.text_storage = m.mock(ak.NSTextStorage)
     else:
         ts = doc.text_storage = None
     font = app.default_font.font
     tabw = ak.NSString.stringWithString_("8" * INDENT_SIZE) \
              .sizeWithAttributes_({ak.NSFontAttributeName: font}).width
     ps = ps_class.defaultParagraphStyle().mutableCopy() >> m.mock()
     ps.setTabStops_([])
     ps.setDefaultTabInterval_(tabw)
     attrs = {
         ak.NSFontAttributeName: font,
         ak.NSParagraphStyleAttributeName: ps,
         ak.NSForegroundColorAttributeName: app.theme.text_color,
     }
     if has_text_storage:
         no_color = {k: v for k, v in attrs.items()
                     if k != ak.NSForegroundColorAttributeName}
         ts.addAttributes_range_(no_color, fn.NSMakeRange(0, ts.length() >> 20))
         ts.setFont_(doc.font.font)
     editors = [m.mock(Editor), m.mock(Editor)]
     m.method(app.iter_editors_of_document)(doc) >> editors
     for editor in editors:
         editor.set_text_attributes(attrs)
     with m:
         doc.reset_text_attributes(INDENT_SIZE, event)
         eq_(doc.default_text_attributes(), attrs)
         eq_(doc.syntax_needs_color,
             has_text_storage and event and event.theme_changed)
Exemple #4
0
def test_TextDocument_color_text_with_null_text_storage(app):
    m = Mocker()
    doc = TextDocument(app)
    with m.off_the_record():
        doc.text_storage = None
    syn = doc.syntaxer = m.mock()
    range = (0, 20)
    with m:
        doc.color_text(range)
Exemple #5
0
 def test(c):
     def end():
         with m:
             doc.reload_document()
             eq_(doc.text, text)
     text = "edit"
     config = " ".join("project" for x in c.view_state)
     with make_file(content="disk") as path, test_app(config) as app:
         if c.url_is_none:
             path = "not-saved"
         elif not c.exists:
             path += "-not-found"
         m = Mocker()
         call_later = m.replace(mod, "call_later")
         doc = TextDocument(app, path)
         reset_text_attributes = m.method(doc.reset_text_attributes)
         doc.text = text
         if c.url_is_none or not c.exists:
             return end()
         undo = doc.undo_manager = m.mock(UndoManager)
         if not c.read2_success:
             os.remove(path)
             os.mkdir(path)
             return end()
         text = "disk"
         tv = m.mock(TextView)
         for i, text_view_exists in enumerate(c.view_state):
             project = app.windows[0].projects[i]
             with m.off_the_record():
                 editor = Editor(project, document=doc)
             editor.text_view = (tv if text_view_exists else None)
             project.editors.append(editor)
         reset_text_attributes()
         if not any(c.view_state):
             # TODO reload without undo
             #doc_ts.replaceCharactersInRange_withString_(range, text)
             undo.removeAllActions()
             return end()
         range = fn.NSRange(0, 4)
         tv.shouldChangeTextInRange_replacementString_(range, text) >> True
         # TODO get edit_state of each document view
         # TODO diff the two text blocks and change chunks of text
         # throughout the document (in a single undo group if possible)
         # also adjust edit states if possible
         # see http://www.python.org/doc/2.5.2/lib/module-difflib.html
         #doc_ts.replaceCharactersInRange_withString_(range, text)
         tv.didChangeText()
         tv.breakUndoCoalescing()
         # TODO restore edit states
         # HACK use timed invocation to allow didChangeText notification
         # to update change count before _clearUndo is invoked
         call_later(0, doc.clear_dirty)
         tv.select((0, 0))
         reset_text_attributes()
         m.method(doc.update_syntaxer)()
         end()
Exemple #6
0
 def test(app, state=None, ts_len=0):
     m = Mocker()
     editor = app.windows[0].projects[0].editors[0]
     proxy_prop = m.property(editor, "proxy")
     soft_wrap_prop = m.property(editor, "soft_wrap")
     text_prop = m.property(editor.document, "text_storage")
     if state is None:
         eq_state = state = {"soft_wrap": const.WRAP_NONE}
     else:
         editor.line_numbers = m.mock(mod.LineNumbers)
         m.off_the_record(editor.line_numbers)
         eq_state = dict(state)
         eq_state.setdefault("selection", [0, 0])
         eq_state.setdefault("scrollpoint", (0, 0))
         eq_state.setdefault("soft_wrap", const.WRAP_NONE)
         point = eq_state["scrollpoint"]
         sel = eq_state["selection"]
         editor.text_view = m.mock(ak.NSTextView)
         editor.scroll_view = m.mock(ak.NSScrollView)
         soft_wrap_prop.value = eq_state["soft_wrap"]
         editor.text_view.layoutManager() \
             .characterIndexForPoint_inTextContainer_fractionOfDistanceBetweenInsertionPoints_(
                 ANY, ANY, ANY) >> (1, 0)
         editor.text_view.bounds().size.height >> 10
         editor.text_view.textContainer()
         editor.scroll_view.verticalRulerView().invalidateRuleThickness()
         editor.text_view.scrollPoint_(fn.NSPoint(*point))
         text = text_prop.value >> m.mock(ak.NSTextStorage)
         text.length() >> ts_len
         if sel[0] > ts_len:
             sel = (ts_len, 0)
         elif sel[0] + sel[1] > ts_len:
             sel = (sel[0], ts_len - sel[0])
         editor.text_view.setSelectedRange_(sel)
         if "updates_path_on_file_move" in state:
             proxy = proxy_prop.value >> m.mock(Editor)
             proxy.updates_path_on_file_move = state["updates_path_on_file_move"]
     with m:
         editor.edit_state = state
     if not isinstance(state, dict):
         eq_(state, eq_state)
Exemple #7
0
def test_TextDocument_on_text_edit(app):
    from editxt.syntax import Highlighter
    m = Mocker()
    doc = TextDocument(app)
    with m.off_the_record():
        ts = doc.text_storage = m.mock(ak.NSTextStorage)
    ts.editedMask() >> -1
    syn = doc.syntaxer = m.mock(Highlighter)
    range = (0, 20)
    syn.color_text(ts, range, timeout=0.05)
    with m:
        doc.on_text_edit(range)
Exemple #8
0
 def test(kw):
     m = Mocker()
     doc = m.mock(TextDocument)
     if "state" in kw:
         path = kw["state"]["path"]
     elif "path" in kw:
         path = kw["path"]
     else:
         path = None
         kw["document"] = doc
     proj = m.mock(Project)
     doc_class = m.replace(editxt.document, 'TextDocument')
     default_state = m.replace(Editor, 'edit_state')
     if path is not None:
         doc = proj.window.app.document_with_path(path) >> doc
     m.off_the_record(doc.props)
     m.off_the_record(doc.text_storage)
     doc.undo_manager.on(ANY)
     with m:
         result = Editor(proj, **kw)
         eq_(result.project, proj)
         eq_(result.document, doc)
         eq_(result.edit_state, kw.get("state", default_state))
Exemple #9
0
 def test(c):
     m = Mocker()
     regundo = m.replace(mod, 'register_undo_callback')
     repnl = m.replace(mod, 'replace_newlines')
     doc = m.mock(TextDocument)
     with m.off_the_record():
         dv = Editor(None, document=doc)
     proxy = m.property(dv, 'proxy')
     with m.order():
         (getattr(doc, c.attr) << c.default).count(2 if c.value != c.default else 3)
         if c.value != c.default:
             c.do(TestConfig(**locals()))
             getattr(doc, c.attr) >> c.value
     with m:
         property_value_util(c, dv)
Exemple #10
0
 def test(app, success):
     m = Mocker()
     data = "<data>"
     doc = TextDocument(app)
     doc.document_attrs = INIT_ATTRS = {"attr": 0,
         ak.NSCharacterEncodingDocumentAttribute: "<encoding>"}
     with m.off_the_record():
         ts = doc.text_storage = m.mock(ak.NSTextStorage)
     analyze = m.method(doc.analyze_content)
     m.method(doc.default_text_attributes)() >> "<text attributes>"
     (ts.readFromData_options_documentAttributes_error_(data, ANY, None, None)
         << (success, "<attrs>", None)).count(1 if success else 2)
     with m:
         result = doc.read_from_data(data)
         eq_(result, (success, None))
         eq_(doc.document_attrs, ("<attrs>" if success else INIT_ATTRS))
Exemple #11
0
 def test(app, c):
     if c.eol_char != "\n":
         c.text = c.text.replace("\n", eol_char)
     m = Mocker()
     doc = TextDocument(app)
     eq_((doc.newline_mode, doc.indent_mode, doc.indent_size),
         (const.NEWLINE_MODE_UNIX, const.INDENT_MODE_SPACE, 4),
         'invalid initial state')
     with m.off_the_record():
         doc.text_storage = ts = m.mock(ak.NSTextStorage)
     ts.string() >> fn.NSString.stringWithString_(c.text)
     with m:
         doc.analyze_content()
     eq_((doc.newline_mode, doc.indent_mode, doc.indent_size),
         (
             c._get("eol", const.NEWLINE_MODE_UNIX),
             c._get("imode", const.INDENT_MODE_SPACE),
             c._get("isize", 4),
         ))
Exemple #12
0
 def test(app, c):
     m = Mocker()
     doc = m.mock(TextDocument)
     project = app.windows[0].projects[0]
     with m.off_the_record():
         dv = Editor(project, document=doc)
     m.property(dv, "soft_wrap")
     m.property(dv, "file_path")
     doc.updates_path_on_file_move >> True
     if c.tv_is_none:
         if c.set_state:
             dv.edit_state = state = dict(key="value")
         else:
             state = {}
         state["soft_wrap"] = const.WRAP_NONE
     else:
         dv.text_view = m.mock(ak.NSTextView)
         dv.scroll_view = m.mock(ak.NSScrollView)
         sel = m.mock(fn.NSRange)
         sp = m.mock(fn.NSPoint)
         dv.text_view.selectedRange() >> sel
         dv.scroll_view.documentVisibleRect().origin >> sp
         sel.location >> "<sel.location>"
         sel.length >> "<sel.length>"
         sp.x >> "<sp.x>"
         sp.y >> "<sp.y>"
         dv.soft_wrap >> c.soft_wrap
         state = dict(
             selection=["<sel.location>", "<sel.length>"],
             scrollpoint=["<sp.x>", "<sp.y>"],
             soft_wrap=c.soft_wrap,
         )
     (dv.file_path << "<path>").count(1, 2)
     state["path"] = "<path>"
     with m:
         result = dv.edit_state
         eq_(result, state)
         if c.tv_is_none and c.set_state:
             assert result is not state, \
                 "identity check should fail: must be a new (mutable) dict"