def test_remember_curr_place(self): # Test whether the curr place in history will be remembered between runs. # Make some interesting history. a = "file:///home/trentm/a.txt" b = "file:///home/trentm/current.txt" locs = [ self.history.note_loc(Location(a, 10 * (i + 1), 0)) for i in range(10) ] locs.insert(0, None) # Make locs 1-based current_loc = Location(b, 55, 0) loc_back = self.history.go_back(current_loc, 4) self.assertEqual(loc_back, locs[7]) # Test history before the restart: h = list(self.history.recent_history(loc_back)) for i in range(1, 10): self.assertEqual(h[i][1], locs[11 - i]) # Simulate a restart. self.history.close() self.history = History(self._db_path_) h = list(self.history.recent_history(loc_back)) # Test boundary conditions, then check all in a loop. self.assertEqual(h[0][1], current_loc) # 4 fwd self.assertEqual(h[1][1], locs[10]) # 3 fwd self.assertEqual(h[3][1], locs[8]) # 1 fwd self.assertEqual(h[4][1], locs[7]) # here self.assertEqual(h[5][1], locs[6]) # 1 back h = list(self.history.recent_history(loc_back)) for i in range(1, 10): self.assertEqual(h[i][1], locs[11 - i])
def test_depleted_recent_back_visits(self): # Test the code path that results in the # `HistorySession.recent_back_visits` cache being depleted so that it # needs to be replenished from the db. uri = "file:///home/bob/.bashrc" locs = [ Location(uri, i * 2, 1) for i in range(1, HistorySession.RECENT_BACK_VISITS_CACHE_LENGTH + 10) ] for loc in locs: self.history.note_loc(loc) curr_loc = Location(uri, 666, 1) #self.history.debug_dump_recent_history(curr_loc) session = self.history.get_session() n_to_deplete = len(session.recent_back_visits) \ - HistorySession.RECENT_BACK_VISITS_DEPLETION_LENGTH + 5 for i in range(n_to_deplete): curr_loc = self.history.go_back(curr_loc) self.assertEqual(curr_loc, locs[-(i + 1)]) #self.history.debug_dump_recent_history(curr_loc) # Test going back forward. for j in range(min(n_to_deplete, 20)): curr_loc = self.history.go_forward(curr_loc) self.assertEqual(curr_loc, locs[-(i - j)])
def test_back_then_fwd(self): # See the example in the "When to note a location" section in KD 218 # with this code sample for the scenario being tested here: # 1: def foo(): # 2: # a comment # 3: print "hi" # 4: # 5: foo() uri = "file:///home/bob/src/foo.txt" loc1 = self.history.note_loc(Location("file:///etc/passwd", 10, 4)) loc2 = self.history.note_loc(Location( uri, 5, 1)) # 2. does goto definition: 1,1 # 3. arrow down a couple of lines: 3,1 loc3 = Location(uri, 3, 1) #self.history.debug_dump_recent_history(loc3) # 4. go "Back" one in the history loc4 = self.history.go_back(curr_loc=loc3) self.assertEqual(loc4, loc2) #self.history.debug_dump_recent_history(loc4) # 5. go "Forward" should return us to loc3 loc5 = self.history.go_forward(loc4) #self.history.debug_dump_recent_history(loc5) self.assertEqual(loc5, loc3) # ... Back/Forward should cycle between those two positions. curr_loc = loc5 for i in range(10): curr_loc = self.history.go_back(curr_loc) self.assertEqual(curr_loc, loc4) curr_loc = self.history.go_forward(curr_loc) self.assertEqual(curr_loc, loc5)
def test_no_view_recent_locs(self): a = "file:///home/trentm/a.txt" b = "file:///home/trentm/b.txt" loc1 = self.history.note_loc(Location(a, 10, 10)) loc2 = self.history.note_loc(Location(b, 20, 20)) loc3 = self.history.note_loc(Location(b, 30, 30)) curr_loc = None #self.history.debug_dump_recent_history(curr_loc) h = list(self.history.recent_history(curr_loc)) self.assertEqual(len(h), 4) self.assertEqual(h[0][0], True) self.assertEqual(h[0][1], None) # Go back loc_back = self.history.go_back(curr_loc) self.assertEqual(loc_back, loc3) h = list(self.history.recent_history(loc_back)) self.assertEqual(h[0][1], loc3) # the curr location self.assertEqual(h[1][1], loc2) # "back" one visit self.assertEqual(h[2][1], loc1) # "back" two visits curr_loc = loc_back loc_back = self.history.go_back(curr_loc) self.assertEqual(loc_back, loc2) # Go forward loc_fwd = self.history.go_forward(curr_loc=None) self.assertEqual(loc_fwd, loc3)
def test_simple(self): a = "file:///home/trentm/a.txt" b = "file:///home/trentm/b.txt" loc1 = self.history.note_loc(Location(a, 10, 10)) loc2 = self.history.note_loc(Location(a, 20, 20)) loc3 = self.history.note_loc(Location(b, 30, 30)) loc4 = Location(b, 40, 40) # the current location # No "forward" visits, i.e. the top item of the stack is the # current pos. #self.history.debug_dump_recent_history(loc4) h = list(self.history.recent_history(loc4)) self.assertEqual(h[0][0], True) # Go "back". loc_back = self.history.go_back(loc4) self.assertEqual(loc_back, loc3) #self.history.debug_dump_recent_history(curr_loc) h = list(self.history.recent_history(loc_back)) self.assertEqual(h[0][1], loc4) # one "forward" visit self.assertEqual(h[1][1], loc3) # the curr location self.assertEqual(h[2][1], loc2) # "back" one visit self.assertEqual(h[3][1], loc1) # "back" two visits # Go "forward". loc_fwd = self.history.go_forward(curr_loc=loc_back) self.assertEqual(loc_fwd, loc4) # No "forward" visits remain. #self.history.debug_dump_recent_history(loc_fwd) h = list(self.history.recent_history(loc_fwd)) self.assertEqual(h[0][0], True)
def test_cmp(self): a = Location("a.txt", 1, 1) b = Location("a.txt", 1, 1) c = Location("a.txt", 2, 1) d = Location("b.txt", 1, 1) self.assertEqual(a, b) self.assertNotEqual(a, c) self.assertNotEqual(a, d)
def test_reloading_db(self): """ Build a database with locations from two URIs interleaved. Step one hop at a time until we find a "volatile" URI, and remove it. Verify the remaining visits. Reload the database, verifying that we find all the same items. """ uri_stable = "file:///home/tester/stable.txt" uri_volatile = "file:///home/tester/volatile.txt" uri_current = "file:///home/tester/current.txt" # Create 50 entries in the database, every 3rd is the volatile URI num_items_to_create = 50 volatile_factor = 3 uris = [uri_stable, uri_stable, uri_volatile] locs = [ self.history.note_loc( Location(uris[i % volatile_factor], 10 * (i + 1), 0)) for i in range(num_items_to_create) ] current_loc = Location(uri_current, num_items_to_create + 1, 0) locs.append(current_loc) loc = self.history.go_back(current_loc, 2) self.assertEqual(loc.uri, uri_stable) self.assertEqual(loc.line, 490) current_loc = loc # We want to make 1 step back into a location we'll remove. loc = self.history.go_back(current_loc, 1) self.assertEqual(loc.uri, uri_volatile) self.assertEqual(loc.line, 480) #self.history.debug_dump_recent_history(loc) self.history.obsolete_uri(loc.uri, 1, True) # => #490 #self.history.debug_dump_recent_history(current_loc) v = list(self.history.recent_history(current_loc)) # Make assertions about the culled list vlen = len(v) for i in range((vlen - 1) / 2): self.assertEqual(v[1 + (2 * i)][1], locs[49 - 0 - (3 * i)]) self.assertEqual(v[2 + (2 * i)][1], locs[49 - 1 - (3 * i)]) self.assertEqual(current_loc.line, 490) # Now save the database, reload, and verify some facts about the # new database self.history.close() self.history = History(self._db_path_) self.assertEqual(current_loc.line, 490) #self.history.debug_dump_recent_history(current_loc) # Recheck history v = list(self.history.recent_history(current_loc)) # Make the same assertions about the culled list vlen = len(v) for i in range((vlen - 1) / 2): self.assertEqual(v[1 + (2 * i)][1], locs[49 - 0 - (3 * i)]) self.assertEqual(v[2 + (2 * i)][1], locs[49 - 1 - (3 * i)])
def loc_from_view_info(self, view_type, window_num, tabbed_view_id, view, pos=-1, session_name=""): """Create a Location instance from the given view info. @param view_type {string} @param window_num {int} the identifier for the view's Komodo window. @param tabbed_view_id {int} the identifier for the multi-tabbed view containing `view`. @param view {koIView} a Komodo view. @param pos {int} position of view to record ignored for some non-editor views, conventionally -1 @param session_name {str} the current history session. Default is the empty string. @returns {Location} """ if view.koDoc.file: uri = view.koDoc.file.URI elif view_type == 'editor': # Internal URI scheme used for unsaved buffers uri = "kotemporary://" + view.uid + "/" + view.koDoc.displayPath else: uri = "" if view_type == 'editor': view = view.QueryInterface(components.interfaces.koIScintillaView) scimoz = view.scimoz if pos == -1: pos = scimoz.currentPos line = scimoz.lineFromPosition(pos) loc = Location(uri, line, scimoz.getColumn(pos), view_type) loc.marker_handle = scimoz.markerAdd(line, self.MARKNUM_HISTORYLOC) ciBuf = view.koDoc.ciBuf if ciBuf and hasattr(ciBuf, "curr_section_from_line"): try: section = ciBuf.curr_section_from_line(line + 1) except COMException: # See bug 82776. Don't know why we get this when # ctrl-tabbing across a tab group. log.exception("can't get the section") else: if section: loc.section_title = section.title else: loc = Location(uri, -1, -1, view_type) loc.window_num = window_num loc.tabbed_view_id = tabbed_view_id loc.session_name = session_name return loc
def test_forward_visits_integrity_on_multi_step_moves(self): uri = "file:///home/tester/a.txt" uri_current = "file:///home/tester/current.txt" num_items_to_create = 20 locs = [ self.history.note_loc(Location(uri, i + 1, 0)) for i in range(num_items_to_create) ] locs.insert(0, None) # Simplify code, since we're 1-based first_current_loc = current_loc = Location(uri_current, num_items_to_create + 1, 0) locs.append(first_current_loc) jump_count = 10 loc = self.history.go_back(current_loc, jump_count) current_loc = loc # "Flat" test on individual items at boundaries. # If one of these tests fails, it's easy to determine which. session = self.history.get_session() self.assertEqual(current_loc, locs[num_items_to_create - jump_count + 1]) self.assertEqual(session.forward_visits[-1], locs[num_items_to_create - jump_count + 2]) self.assertEqual(session.forward_visits[1], locs[num_items_to_create]) self.assertEqual(session.forward_visits[0], first_current_loc) # Loop through to verify we found everything. # If one of these fails, we'll need to uncomment the # debug line to figure out what went wrong. #self.history.debug_dump_recent_history(curr_loc) for i in range(jump_count): self.assertEqual(session.forward_visits[i], locs[num_items_to_create - i + 1]) # Verify we don't lose the current spot when we move forward. jump_count = 4 old_cid = current_loc.id # 11 loc = self.history.go_forward(current_loc, jump_count) current_loc = loc self.assertEqual(current_loc, locs[old_cid + jump_count]) # Don't roll this loop -- if one of the tests fail, it's # harder to determine which one failed session = self.history.get_session() self.assertEqual(session.recent_back_visits[0], locs[old_cid + jump_count - 1]) self.assertEqual(session.recent_back_visits[1], locs[old_cid + jump_count - 2]) self.assertEqual(session.recent_back_visits[2], locs[old_cid + jump_count - 3]) self.assertEqual(session.recent_back_visits[3], locs[old_cid + jump_count - 4])
def test_visit_count(self): a = "file:///home/trentm/a.txt" b = "file:///home/trentm/b.txt" db = self.history.db loc_a1 = db.add_loc(Location(a, 10, 10)) db.add_loc(Location(a, 10, 10)) loc_b1 = db.add_loc(Location(b, 10, 10)) self.assertEqual(self._get_visit_count(a), 2) self.assertEqual(self._get_visit_count(b), 1) # Cheat and remove a location (no public DB method for this) to test # that the visit_count gets updated. with db.connect(True) as cu: cu.execute("DELETE FROM history_visit WHERE id=?", (loc_a1.id, )) cu.execute("DELETE FROM history_visit WHERE id=?", (loc_b1.id, )) self.assertEqual(self._get_visit_count(a), 1) self.assertEqual(self._get_visit_count(b), 0)
def test_two_sessions_basic(self): a = "file:///home/tester/a.txt" b = "file:///home/tester/b.txt" locs = ([ self.history.note_loc( Location(a, (i + 1) * 10, 1, session_name="1")) for i in range(10) ] + [ self.history.note_loc( Location(b, 100 + (i + 1) * 10, 1, session_name="2")) for i in range(10) ]) cw1 = "file:///home/tester/cw1.txt" cw2 = "file:///home/tester/cw2.txt" curr_loc_cw1 = Location(cw1, 110, 1, session_name="1") curr_loc_cw2 = Location(cw2, 210, 1, session_name="2") new_loc_w1 = self.history.go_back(curr_loc_cw1, 3) self.assertEqual(new_loc_w1, locs[7]) new_loc_w2 = self.history.go_back(curr_loc_cw2, 7) self.assertEqual(new_loc_w2, locs[13]) self.assertNotEqual(new_loc_w2, locs[14]) # Verify they're different visits_pre_close = [ self.history.get_session("1").recent_back_visits, self.history.get_session("1").forward_visits, self.history.get_session("2").recent_back_visits, self.history.get_session("2").forward_visits, ] self.assertEqual(len(visits_pre_close[0]), 7) self.assertEqual(len(visits_pre_close[1]), 3) self.assertEqual(len(visits_pre_close[2]), 3) self.assertEqual(len(visits_pre_close[3]), 7) # And verify that after we do a close and reopen, the caches are maintained # correctly for each session. self.history.close() self.history = History(self._db_path_) visits_post_close = [ self.history.get_session("1").recent_back_visits, self.history.get_session("1").forward_visits, self.history.get_session("2").recent_back_visits, self.history.get_session("2").forward_visits, ] self.assertEqual(visits_post_close, visits_pre_close)
def test_obsolete_locs_removed(self): uri_stable = "file:///home/tester/stable.txt" uri_volatile = "file:///home/tester/volatile.txt" uri_current = "file:///home/tester/current.txt" # Create 50 entries in the database, every 3rd is the volatile URI num_items_to_create = 50 volatile_factor = 3 uris = [uri_stable, uri_stable, uri_volatile] for i in range(num_items_to_create): self.history.note_loc( Location(uris[i % volatile_factor], 10 * (i + 1), 0)) current_loc = Location(uri_current, num_items_to_create + 1, 0) loc = self.history.go_back(current_loc, 3) self.assertEqual(loc.uri, uri_volatile) self.assertEqual(loc.line, 480) self.history.obsolete_uri(loc.uri, 1, True) # => #490 v = list(self.history.recent_history(current_loc)) volatile_locs = [x for x in v if x[1].uri == uri_volatile] self.assertEqual(len(volatile_locs), 0)
def test_update_referer(self): # Test the code path that results in `Database.update_referer_id` # being called. uri = "file:///home/bob/.bashrc" locs = [Location(uri, i * 2, 1) for i in range(1, 11)] for loc in locs: self.history.note_loc(loc) curr_loc = Location(uri, 42, 1) for i in range(3): curr_loc = Location(curr_loc.uri, curr_loc.line - 1, curr_loc.col) curr_loc = self.history.go_back(curr_loc) self.assertEqual(curr_loc, locs[-(i + 1)]) #self.history.debug_dump_recent_history(curr_loc) last_loc = None for is_curr, loc in self.history.recent_history(curr_loc): if last_loc: self.assertEqual(last_loc.referer_id, loc.id) last_loc = loc
def test_recent_uris_multi_page(self): # Test the "PAGE_SIZE" handling in HistorySession.recent_uris. uris = ["file://home/joe/%s.py" % n for n in range(150)] locs = [ self.history.note_loc(Location(uris[i], i + 1, 1)) for i in range(150) ] #self.history.debug_dump_recent_history() #self.history.debug_dump_recent_uris() recent_uris = list(self.history.recent_uris(120, show_all=True), ) self.assertEqual(len(recent_uris), 120)
def test_recent_uris(self): uris = ["file://home/joe/%s.py" % n for n in range(10)] locs = [ self.history.note_loc(Location(random.choice(uris), i + 1, 1)) for i in range(100) ] #self.history.debug_dump_recent_history() #self.history.debug_dump_recent_uris() recent_uris = list(self.history.recent_uris(10, show_all=True)) self.assertEqual(recent_uris[0], locs[-1].uri) self.assertEqual(set(uris), set(recent_uris))
def test_addloc(self): a = "file:///home/trentm/a.txt" b = "file:///home/trentm/b.txt" db = self.history.db loc1 = db.add_loc(Location(a, 10, 10)) self.assertNotEqual(loc1.id, None) self.assertEqual(loc1.referer_id, None) loc2 = db.add_loc(Location(b, 20, 20), loc1.id) self.assertNotEqual(loc2.id, None) self.assertEqual(loc2.referer_id, loc1.id, "%r doesn't refer to %r" % (loc2, loc1)) with db.connect() as cu: for loc in [loc1, loc2]: cu.execute("SELECT visit_count FROM history_uri WHERE id=?", (loc.uri_id, )) visit_count = cu.fetchone()[0] self.assertEqual(visit_count, 1)
def _populate_history(self, last_dir): this_dir = os.path.abspath(dirname(__file__)) data_dir = join(this_dir, "tmp", last_dir) if not exists(data_dir): os.mkdir(data_dir) fnames = [] uris = [] for i in range(1, 6): fname = join(data_dir, "f%d.txt" % (i, )) f = open(fname, "w") f.write("# Data\n") f.close() fnames.append(fname) uris.append(uriparse.localPathToURI(fname)) line_num = 10 limit = 10 for i in range(limit): uri = uris[i % len(uris)] self.history.note_loc(Location(uri, line_num, 0)) line_num += 10 current_loc = Location(uris[0], line_num, 0) # idx 10, line 110 return fnames, uris, current_loc
def test_simulate_restarted_with_obsolete_loc(self): uri_volatile = "file:///home/tester/volatile.txt" uri_current = "file:///home/tester/current.txt" self.history.note_loc(Location(uri_volatile, 10, 1)) # Now assume we restart Komodo, no loaded buffers current_loc = None v = list(self.history.recent_history(current_loc)) self.assertEqual(len(v), 2) self.assertEqual(len([x for x in v if x[1] is not None]), 1) loc = self.history.go_back(current_loc, 1) self.history.obsolete_uri(loc.uri, 1, True) v = list(self.history.recent_history(current_loc)) self.assertEqual(len(v), 0)
def test_timestamp(self): # Test the machinations of the `history_visit.timestamp` field # which is using (unfamiliar to me) Julian day stuff as per # http://eusqlite.wikispaces.com/dates+and+times a = "file:///home/trentm/a.txt" db = self.history.db loc1 = db.add_loc(Location(a, 1, 1)) # With faster in-memory db use (bug 84569) we need # to sleep a little longer so it takes more # than 2 seconds to add all three locations. time.sleep(1.2) loc2 = db.add_loc(Location(a, 2, 2)) time.sleep(1.2) loc3 = db.add_loc(Location(a, 3, 3)) with db.connect(inMemory=True) as cu: # Get the latest visit. cu.execute(""" SELECT id, datetime(timestamp) FROM history_visit ORDER BY timestamp DESC LIMIT 1; """) row = cu.fetchone() self.assertEqual(row[0], loc3.id) # Get visits in the last 2 seconds (should exclude the first # one). # http://www.sqlite.org/cvstrac/wiki?p=DateAndTimeFunctions cu.execute(""" SELECT id, datetime(timestamp) FROM history_visit WHERE timestamp > julianday('now', '-2.0 seconds'); """) rows = cu.fetchall() # Under high CPU load while testing, we might get the last two # or just the last jump. self.assertTrue(len(rows) < 3) ids = list(sorted(r[0] for r in rows)) self.assertTrue(loc1.id not in ids)
def test_curr_loc_is_jump_back_loc(self): # Test the behaviour when we go_back to a loc that happens to be the # same as the current location. # # The bug is/was that a new location was being added to the history # db, rather than just re-using the one to which we are jumping. # # Note that going forward seems to be fine. # Setup starter recent history. a = "file:///home/tester/a.txt" locs = [ self.history.note_loc(Location(a, (i + 1) * 10, 1)) for i in range(10) ] curr_loc = Location(a, locs[-1].line, locs[-1].col) # haven't moved #self.history.debug_dump_recent_history(curr_loc, merge_curr_loc=False) # Test going back one: verify we don't go anywhere. new_loc = self.history.go_back(curr_loc, 1) #self.history.debug_dump_recent_history(new_loc, merge_curr_loc=False) session = self.history.get_session() self.assertEqual(len(session.forward_visits), 1) self.assertEqual(session.forward_visits[0], new_loc)
def test_obsolete_uri(self): db = self.history.db # Setup test history. a = "file:///home/trentm/a.txt" b = "file:///home/trentm/b.txt" locs = [ self.history.note_loc(Location(uri, (i + 1) * 10, 1)) for i in range(5) for uri in [a, b] ] #self.history.debug_dump_recent_history() # Obsolete a URI ... actual_a_id = db.uri_id_from_uri(a) db.obsolete_uri(a, actual_a_id) # ... and make sure the DB did what we expected. b_id = db.uri_id_from_uri(b, create_if_new=False) self.assertNotEqual(b_id, None) with db.connect() as cu: cu.execute("SELECT id, is_obsolete FROM history_uri WHERE uri=?", (a, )) row = cu.fetchone() self.assertEqual(row[0], actual_a_id) self.assertEqual(row[1], True) a_id = db.uri_id_from_uri(a, create_if_new=False) self.assertEqual(a_id, None) a_id = db.uri_id_from_uri(a) # should revive the URI row self.assertEqual(a_id, actual_a_id) with db.connect() as cu: cu.execute("SELECT id, is_obsolete FROM history_uri WHERE uri=?", (a, )) row = cu.fetchone() a_id = row[0] self.assertEqual(a_id, actual_a_id) self.assertEqual(row[1], False)
def test_cull_unvisited_locations(self): # Assumes that we keep the first 500 locations. uri_base = "file:///home/tester/file%04x" num_items_to_create = 505 for i in range(num_items_to_create): uri = uri_base % i self.history.note_loc(Location(uri, i + 1, 0)) self.history.close() # Now reopen self.history = History(self._db_path_) # Verify that both history_uri and history_visit contain # 500 items limit = self.history.db.URIS_TO_KEEP with self.history.db.connect(True) as cu: cu.execute("select count(*) from history_visit") count = int(cu.fetchone()[0]) self.assertEqual( count, limit, "Expected %d locs in mem:history_visit, got %d" % (limit, count)) cu.execute("select count(*) from history_uri") count = int(cu.fetchone()[0]) self.assertEqual( count, limit, "Expected %d locs in mem:history_uri, got %d" % (limit, count)) with self.history.db.connect(True, inMemory=False) as cu: cu.execute("select count(*) from history_visit") count = int(cu.fetchone()[0]) self.assertEqual( count, limit, "Expected %d locs in file:history_visit, got %d" % (limit, count)) cu.execute("select count(*) from history_uri") count = int(cu.fetchone()[0]) self.assertEqual( count, limit, "Expected %d locs in file:history_uri, got %d" % (limit, count))
def test_move_forward_into_wall(self): uri_stable = "file:///home/tester/stable.txt" uri_volatile = "file:///home/tester/volatile.txt" self.history.note_loc(Location(uri_stable, 10, 0)) self.history.note_loc(Location(uri_stable, 20, 0)) self.history.note_loc(Location(uri_volatile, 30, 0)) self.history.note_loc(Location(uri_volatile, 40, 0)) self.history.note_loc(Location(uri_volatile, 50, 0)) current_loc = Location(uri_volatile, 100, 0) loc = self.history.go_back(current_loc, 4) self.assertEqual(loc.line, 20) current_loc = loc #self.history.debug_dump_recent_history(loc) loc = self.history.go_forward(current_loc, 1) self.assertEqual(loc.line, 30) #self.history.debug_dump_recent_history(loc) self.history.obsolete_uri(loc.uri, 1, False) # => 20 #self.history.debug_dump_recent_history(current_loc) self.assertFalse(self.history.can_go_forward())
def test_move_back_into_wall(self): uri_stable = "file:///home/tester/stable.txt" uri_volatile = "file:///home/tester/volatile.txt" uri_current = "file:///home/tester/current.txt" self.history.note_loc(Location(uri_volatile, 10, 0)) self.history.note_loc(Location(uri_volatile, 20, 0)) self.history.note_loc(Location(uri_volatile, 30, 0)) self.history.note_loc(Location(uri_stable, 40, 0)) self.history.note_loc(Location(uri_stable, 50, 0)) current_loc = Location(uri_current, 100, 0) loc = self.history.go_back(current_loc, 2) self.assertEqual(loc.line, 40) current_loc = loc loc = self.history.go_back(current_loc, 1) self.assertEqual(loc.line, 30) #self.history.debug_dump_recent_history(loc) self.history.obsolete_uri(loc.uri, 1, True) # => 40 #self.history.debug_dump_recent_history(None) self.assertFalse(self.history.can_go_back())
def test_jump_back(self): uri_stable = "file:///home/tester/stable.txt" uri_volatile = "file:///home/tester/volatile.txt" uri_current = "file:///home/tester/current.txt" self.history.note_loc(Location(uri_stable, 10, 0)) self.history.note_loc(Location(uri_stable, 20, 0)) self.history.note_loc(Location(uri_volatile, 30, 0)) self.history.note_loc(Location(uri_stable, 40, 0)) self.history.note_loc(Location(uri_stable, 50, 0)) current_loc = Location(uri_current, 100, 0) loc = self.history.go_back(current_loc, 3) self.assertEqual(loc.line, 30) #self.history.debug_dump_recent_history(loc) #print "Try to get back to loc %r" % current_loc self.history.obsolete_uri(loc.uri, 3, True) # => #100 #self.history.debug_dump_recent_history(None) # Should end up back at 100, moving back 1 takes us to 50 loc = self.history.go_back(current_loc, 1) self.assertEqual(loc.line, 50)
def test_jump_forward(self): uri_stable = "file:///home/tester/stable.txt" uri_volatile = "file:///home/tester/volatile.txt" uri_current = "file:///home/tester/current.txt" self.history.note_loc(Location(uri_stable, 10, 0)) self.history.note_loc(Location(uri_stable, 20, 0)) self.history.note_loc(Location(uri_volatile, 30, 0)) self.history.note_loc(Location(uri_stable, 40, 0)) self.history.note_loc(Location(uri_stable, 50, 0)) current_loc = Location(uri_current, 100, 0) loc = self.history.go_back(current_loc, 5) self.assertEqual(loc.line, 10) current_loc = loc loc = self.history.go_forward(current_loc, 2) self.assertEqual(loc.line, 30) #self.history.debug_dump_recent_history(loc) self.history.obsolete_uri(loc.uri, 2, False) # => #10 #self.history.debug_dump_recent_history(None) loc = self.history.go_forward(current_loc, 1) self.assertEqual(loc.line, 20)
def loc_from_view_info(self, view_type, window_num, tabbed_view_id, view, pos=-1, session_name="", callback=None): """Create a Location instance from the given view info. @param view_type {string} @param window_num {int} the identifier for the view's Komodo window. @param tabbed_view_id {int} the identifier for the multi-tabbed view containing `view`. @param view {koIView} a Komodo view. @param pos {int} position of view to record ignored for some non-editor views, conventionally -1 @param session_name {str} the current history session. Default is the empty string. @param callback {callable} The callback to invoke when the location has been found; takes a single Location argument. """ if view.koDoc.file: uri = view.koDoc.file.URI elif view_type == 'editor': # Internal URI scheme used for unsaved buffers uri = "kotemporary://" + view.uid + "/" + view.koDoc.displayPath else: uri = "" def on_have_location(section=None): if section: loc.section_title = section.title loc.window_num = window_num loc.tabbed_view_id = tabbed_view_id loc.session_name = session_name if hasattr(callback, "onHaveLocation"): callback.onHaveLocation(loc) elif loc: callback(loc) pending = False if view_type == 'editor': view = view.QueryInterface(components.interfaces.koIScintillaView) scimoz = view.scimoz if pos == -1: pos = scimoz.currentPos line = scimoz.lineFromPosition(pos) loc = Location(uri, line, scimoz.getColumn(pos), view_type) loc.marker_handle = scimoz.markerAdd(line, self.MARKNUM_HISTORYLOC) ciBuf = view.koDoc.ciBuf if ciBuf and hasattr(ciBuf, "section_from_line"): try: ciBuf.section_from_line(line + 1, ciBuf.SECTION_CURRENT, False, on_have_location) except COMException: # See bug 82776. Don't know why we get this when # ctrl-tabbing across a tab group. log.exception("can't get the section") else: pending = True else: loc = Location(uri, -1, -1, view_type) if not pending: on_have_location()
def test_move_back_multi(self): uri_stable = "file:///home/tester/stable.txt" uri_volatile = "file:///home/tester/volatile.txt" uri_current = "file:///home/tester/current.txt" self.history.note_loc(Location(uri_stable, 10, 0)) self.history.note_loc(Location(uri_stable, 20, 0)) self.history.note_loc(Location(uri_volatile, 30, 0)) self.history.note_loc(Location(uri_stable, 40, 0)) self.history.note_loc(Location(uri_volatile, 50, 0)) self.history.note_loc(Location(uri_volatile, 60, 0)) self.history.note_loc(Location(uri_volatile, 70, 0)) self.history.note_loc(Location(uri_volatile, 80, 0)) self.history.note_loc(Location(uri_volatile, 90, 0)) self.history.note_loc(Location(uri_stable, 100, 0)) self.history.note_loc(Location(uri_stable, 110, 0)) self.history.note_loc(Location(uri_stable, 120, 0)) current_loc = Location(uri_current, 130, 0) loc = self.history.go_back(current_loc, 2) self.assertEqual(loc.line, 110) current_loc = loc loc = self.history.go_back(current_loc, 4) self.assertEqual(loc.line, 70) #self.history.debug_dump_recent_history(loc) self.history.obsolete_uri(loc.uri, 4, True) # => #110 #self.history.debug_dump_recent_history(current_loc) loc = self.history.go_back(current_loc, 2) self.assertEqual(loc.line, 40) current_loc = loc loc = self.history.go_back(current_loc, 1) self.assertEqual(loc.line, 20) current_loc = loc loc = self.history.go_back(current_loc, 1) self.assertEqual(loc.line, 10) self.assertFalse(self.history.can_go_back()) current_loc = loc loc = self.history.go_forward(current_loc, 5) self.assertEqual(loc.line, 120) current_loc = loc loc = self.history.go_forward(current_loc, 1) self.assertEqual(loc.line, 130) current_loc = loc self.assertFalse(self.history.can_go_forward())
def test_multisession_obsolete_uri(self): a = "file:///home/tester/a.txt" b = "file:///home/tester/b.txt" # an obsolete URI can't be used in more than one session, by the # nature of the type of URIs that can be obsoleted (dbgp, e.g.) a1_obs = "file:///home/tester/a1_obs.txt" b1_obs = "file:///home/tester/b1_obs.txt" a2_obs = "file:///home/tester/a2_obs.txt" b2_obs = "file:///home/tester/b2_obs.txt" self.history.note_loc(Location(a, 10, 1, session_name="1")) self.history.note_loc(Location(a1_obs, 20, 1, session_name="1")) self.history.note_loc(Location(b1_obs, 30, 1, session_name="1")) self.history.note_loc(Location(a, 40, 1, session_name="1")) self.history.note_loc(Location(b, 110, 1, session_name="2")) self.history.note_loc(Location(a2_obs, 120, 1, session_name="2")) self.history.note_loc(Location(b2_obs, 130, 1, session_name="2")) self.history.note_loc(Location(b, 140, 1, session_name="2")) cw1 = "file:///home/tester/cw1.txt" cw2 = "file:///home/tester/cw2.txt" curr_loc_cw1 = Location(cw1, 50, 1, session_name="1") curr_loc_cw2 = Location(cw2, 150, 1, session_name="2") loc = self.history.go_back(curr_loc_cw1, 4) self.assertEqual(loc.line, 10) curr_loc1 = loc # Now close a_obs in session 1 loc = self.history.go_forward(curr_loc1, 1) self.history.obsolete_uri(a1_obs, undo_delta=1, orig_dir_was_back=False, session_name="1") loc = self.history.go_forward(curr_loc1, 2) self.assertEqual(loc.line, 40) # later we'll move back onto b_obs curr_loc1 = loc # Now move to a_obs in session 2 -- it's still alive there loc = self.history.go_back(curr_loc_cw2, 3) self.assertEqual(loc.line, 120) # later we'll move back onto b_obs curr_loc2 = loc # Kill off b_obs loc = self.history.go_forward(curr_loc2, 1) self.history.obsolete_uri(b2_obs, undo_delta=1, orig_dir_was_back=False, session_name="2") loc = self.history.go_forward(curr_loc2, 1) self.assertEqual(loc.line, 140) # at b curr_loc2 = loc # Back to session1, verify b_obs is still there loc = self.history.go_back(curr_loc1, 1) self.assertEqual(loc.line, 30) # And kill it off self.history.obsolete_uri(b1_obs, undo_delta=1, orig_dir_was_back=True, session_name="1") loc = self.history.go_back(curr_loc1, 1) self.assertEqual(loc.line, 10) curr_loc1 = loc # Finally in session2, remove a_obs loc = self.history.go_back(curr_loc2, 1) self.assertEqual(loc.line, 120) # Kill off a_obs self.history.obsolete_uri(a2_obs, undo_delta=1, orig_dir_was_back=True, session_name="2") loc = self.history.go_back(curr_loc2, 1) self.assertEqual(loc.line, 110)
def test_multisession_replenish_caches(self): a = "file:///home/tester/a.txt" b = "file:///home/tester/b.txt" locs = ([ self.history.note_loc( Location(a, (i + 1) * 10, 1, session_name="1")) for i in range(100) ] + [ self.history.note_loc( Location(b, 1000 + (i + 1) * 10, 1, session_name="2")) for i in range(100) ]) cw1 = "file:///home/tester/cw1.txt" cw2 = "file:///home/tester/cw2.txt" curr_loc_cw1 = Location(cw1, 1010, 1, session_name="1") curr_loc_cw2 = Location(cw2, 2010, 1, session_name="2") new_loc_w1 = self.history.go_back(curr_loc_cw1, 30) self.assertEqual(new_loc_w1, locs[70]) new_loc_w2 = self.history.go_back(curr_loc_cw2, 55) self.assertEqual(new_loc_w2, locs[145]) visits1 = [ self.history.get_session("1").recent_back_visits, self.history.get_session("1").forward_visits, self.history.get_session("2").recent_back_visits, self.history.get_session("2").forward_visits, ] self.assertEqual(visits1[0][0], locs[69]) # Go back self.assertEqual(visits1[1][-1], locs[71]) # Go forward self.assertEqual(visits1[2][0], locs[144]) # Go back self.assertEqual(visits1[3][-1], locs[146]) # Go forward # Now move forward 1, should truncate forward visits curr_loc_cw1 = Location(cw1, 1020, 1, session_name="1") curr_loc_cw2 = Location(cw2, 2020, 1, session_name="2") new_loc_w1 = self.history.note_loc(curr_loc_cw1) new_loc_w2 = self.history.note_loc(curr_loc_cw2) visits2 = [ self.history.get_session("1").recent_back_visits, self.history.get_session("1").forward_visits, self.history.get_session("2").recent_back_visits, self.history.get_session("2").forward_visits, ] # Should empty out the forward-visits cache, back-visits should be non-empty self.assertTrue(len(visits2[0]) > 0) self.assertEqual(len(visits2[1]), 0) self.assertTrue(len(visits2[2]) > 0) self.assertEqual(len(visits2[3]), 0) # Finally go back a bit, and verify that each back_visits cache # contains the right kind of URIs curr_loc_cw1 = Location(cw1, 1030, 1, session_name="1") curr_loc_cw2 = Location(cw2, 2030, 1, session_name="2") new_loc_w1 = self.history.go_back(curr_loc_cw1, 40) self.assertEqual(new_loc_w1, locs[31]) new_loc_w2 = self.history.go_back(curr_loc_cw2, 41) self.assertEqual(new_loc_w2, locs[105]) h1 = self.history.recent_history(curr_loc=None, merge_curr_loc=False, session_name="1") h2 = self.history.recent_history(curr_loc=None, merge_curr_loc=False, session_name="2") self.assertFalse( [loc for isCurr, loc in h1 if not isCurr and loc.uri == b]) self.assertFalse( [loc for isCurr, loc in h2 if not isCurr and loc.uri == a])