def _sections_with_changes(fwd, rev):
# Make the "lefts" (the sections in the files)
before_lines = fwd.to_reference_lines()
after_lines = rev.to_reference_lines()
from kiss_rdb.storage_adapters.eno import \
sections_parsed_coarsely_via_lines as func
before_sects = func(before_lines)
after_sects = func(after_lines)
def sects_with_line_offsets(sects):
offset = 0
for sect in sects:
next_offset = offset + sect.line_count
yield offset, next_offset, sect
offset = next_offset
cbefore_sects = sects_with_line_offsets(before_sects)
cafter_sects = sects_with_line_offsets(after_sects)
# Make the "rights" (change runs in the diff)
def change_runs_of(exte):
return (run for typ, run in exte.to_classified_runs()
if 'no_change' != typ) # noqa: E501
before_change_runs = change_runs_of(fwd)
after_change_runs = change_runs_of(rev)
# Pair the sections with their overlapping changes
before_inters = _find_span_intersections(cbefore_sects, before_change_runs)
after_inters = _find_span_intersections(cafter_sects, after_change_runs)
# Filter out so you only have the ones with changes
def only_these(pairs):
for sect, inters in pairs:
if inters is None:
continue
yield sect, inters
before_pairs = tuple(only_these(before_inters))
after_pairs = tuple(only_these(after_inters))
return before_pairs, after_pairs
def _private_index(self):
eid = self._NCID
if eid is None:
return ('my_state_4_node_was_not_specified',)
# Build the big index under the node
bcoll = self._read_only_collection
itr = big_index_for_one(eid, bcoll, self._listener)
if itr is None:
raise self._stop()
func = higher_level_functions().tree_index_via
tree_index = func(eid, itr)
ddmm = tree_index.document_depth_minmax
if ddmm is None:
# This node is not a document, no documents within the tree.
# We try this older "look up" way second because if it fails
# it emits and doing it second allows us not to hack a listener
return self._look_upwards()
shallowest_depth, deepest_depth = ddmm
if 0 == shallowest_depth:
return 'my_state_2_node_is_part_of_document', 'by_way_of_tree_index', tree_index # noqa: E501
assert 0 < shallowest_depth
return 'my_state_1_node_is_dewey_node', tree_index
def _resolve_business_collection(coll_path, listener):
from pho import read_only_business_collection_via_path_ as func
# (read-only is especially important for #here4)
bcoll = func(coll_path, listener)
if bcoll:
return bcoll
raise _Stop()
def _read_only_business_collection_via(directory):
if not isinstance(directory, str):
directory.build_big_index_ # [#022]
return directory
from pho import read_only_business_collection_via_path_ as func
return func(directory)
def _look_upwards(self):
from .abstract_document_via_notecards import \
document_notecards_in_order_via_any_arbitrary_start_node_ as func
itr = func(self._NCID, self._read_only_collection, self._listener)
if itr is None:
# was gonna be 'my_state_3_node_has_no_documents_above_or_below'
raise self._stop()
return 'my_state_2_node_is_part_of_document', 'by_way_of_look_up', itr
def _main(coll_path, listener, do_rigged_only):
db = _database_via_collection_path(coll_path, listener)
def these():
from modality_agnostic import ModalityAgnosticErrorMonitor as cls
mon = cls(listener)
bcoll = _resolve_business_collection(coll_path, listener)
return bcoll, mon
if do_rigged_only:
bcoll, _mon = these()
from ._update_rigged_documents import func
func(db, bcoll, _Stop, listener)
return
# First pass: load changed file queue from any new commits from HEAD
num = _populate_temporary_table(db, coll_path, listener)
_say_number_of_new_commits(listener, num)
if num:
# If there were some, add files to the files queue
num = _transfer_from_temp_table_to_changed_file_queue(db, listener)
_say_number_of_new_changed_files(listener, num)
# Second pass: touch and stale notecard records from changed file queue
bcoll, mon = these()
nnn, nn, n = _index_each_file_that_changed(db, bcoll, mon)
_say_number_of_entities_to_audit(listener, nnn, nn, n)
# Third pass: run the audit trail on each stale notecard
nn, n = _run_the_audit_trail_on_each_stale_notecard(db, bcoll, mon)
_say_num_entity_edits(listener, nn, n)
# Fourth pass: populate document & document ci tables via unseen commits
nnn, nn, n = _update_document_commit_table(bcoll, db, listener)
_say_document_commits(listener, nnn, nn, n)
# Pass four-point-five lol:
from ._update_rigged_documents import func
func(db, bcoll, _Stop, listener)
def resolve_one_or_more_patch_lines():
from kiss_rdb.vcs_adapters.git import git_diff as func
rc, patch_lines = func(path, listener, opn=opn)
if rc:
raise stop() # assume something emitted
if not patch_lines:
def these_lines():
yield "file is noent, is not in the repo or has no changes:"
yield path
listener('notice', 'expression', 'no_diff', these_lines)
raise stop()
return patch_lines
def lines():
yield "Multiple node trees, choose one:"
for line in func(tree_idens, 24):
yield line
def _read_only_collection(self):
from pho import read_only_business_collection_via_path_ as func
return func(self._collection_path, listener=self._listener)
def _scanner_via_iterator(itr):
assert hasattr(itr, '__next__')
from text_lib.magnetics.scanner_via import scanner_via_iterator as func
return func(itr)
def _database_via_collection_path(coll_path, listener):
from ._model import database_after_updating_schema_ as func
db = func(coll_path, listener)
if db is None:
raise _Stop()
return db
def _commits_not_in_the_commits_table(HEAD_SHA, coll_path):
from ._common import GIT_LOG_NUMSTAT_ as func
return func(coll_path, HEAD_SHA,
('git', 'log', '--numstat', '--', 'entities'))
def bcoll_via(coll_path):
# failure seems somewhat unlikely
from pho import read_only_business_collection_via_path_ as func
return func(coll_path, listener)
def _scanner_via_iterator(itr):
from text_lib.magnetics.scanner_via import scanner_via_iterator as func
return func(itr)
def resolve_extended_patches(patch_lines):
from text_lib.diff_and_patch.classified_lines_via_patch import func
with open(path) as lines:
fwd, rev = func(patch_lines, lines)
return fwd, rev
def _mutable_business_collection_via(collection_path):
def rng(pool_size):
return 11584 # DC6 with two behind it?
from pho import _mutable_business_collection_via as func
return func(collection_path, rng)
