Veronica K. B. Olsen
348 lines
10 KiB
Python
348 lines
10 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""novelWriter Project Index
|
||
|
||
novelWriter – Project Index
|
||
=============================
|
||
Class holding the index of tags
|
||
|
||
File History:
|
||
Created: 2019-05-27 [0.1.4]
|
||
|
||
Structure:
|
||
|
||
We need to scan all files to get the novel layout. This is done by heading depth. Each heading
|
||
is recorded in a sorted list. Each such heading again can have a set of meta tags.
|
||
In the other class root folders, each file can have a tag which the meta tags in the novel files
|
||
point to. These tags should be stored in a dictionary where the tag is the key pointing to a single
|
||
file handle. That way we can do lookups on both keys and values.
|
||
The timeline view then consists of novel header elements in the horizontal header, possibly just
|
||
truncated to a Ch or Sc abbreviation, possibly with a number. This can be extracted from the item
|
||
layout. The vertical header column is then whatever notes we want to compare against, and the links
|
||
from the novel files are dots on the row.
|
||
|
||
"""
|
||
|
||
import logging
|
||
import json
|
||
import nw
|
||
|
||
from os import path
|
||
|
||
from nw.project.document import NWDoc
|
||
from nw.enum import nwItemType, nwItemClass
|
||
from nw.constants import nwFiles
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
class NWIndex():
|
||
|
||
TAG_KEY = "@tag"
|
||
POV_KEY = "@pov"
|
||
CHAR_KEY = "@char"
|
||
PLOT_KEY = "@plot"
|
||
TIME_KEY = "@time"
|
||
WORLD_KEY = "@location"
|
||
OBJECT_KEY = "@object"
|
||
CUSTOM_KEY = "@custom"
|
||
|
||
NOTE_KEYS = [TAG_KEY]
|
||
NOVEL_KEYS = [PLOT_KEY, POV_KEY, CHAR_KEY, WORLD_KEY, TIME_KEY, OBJECT_KEY, CUSTOM_KEY]
|
||
TAG_CLASS = {
|
||
CHAR_KEY : [nwItemClass.CHARACTER, 1],
|
||
POV_KEY : [nwItemClass.CHARACTER, 2],
|
||
PLOT_KEY : [nwItemClass.PLOT, 1],
|
||
TIME_KEY : [nwItemClass.TIMELINE, 1],
|
||
WORLD_KEY : [nwItemClass.WORLD, 1],
|
||
OBJECT_KEY : [nwItemClass.OBJECT, 1],
|
||
CUSTOM_KEY : [nwItemClass.CUSTOM, 1],
|
||
}
|
||
|
||
def __init__(self, theProject, theParent):
|
||
|
||
# Internal
|
||
self.theProject = theProject
|
||
self.theParent = theParent
|
||
self.mainConf = self.theParent.mainConf
|
||
|
||
# Indices
|
||
self.tagIndex = {}
|
||
self.refIndex = {}
|
||
self.novelIndex = {}
|
||
|
||
# Lists
|
||
self.novelList = []
|
||
|
||
return
|
||
|
||
def clearIndex(self):
|
||
self.tagIndex = {}
|
||
self.refIndex = {}
|
||
self.novelIndex = {}
|
||
return
|
||
|
||
##
|
||
# Load and Save Index to/from File
|
||
##
|
||
|
||
def loadIndex(self):
|
||
|
||
theData = {}
|
||
indexFile = path.join(self.theProject.projMeta, nwFiles.INDEX_FILE)
|
||
if path.isfile(indexFile):
|
||
logger.debug("Loading index file")
|
||
try:
|
||
with open(indexFile,mode="r") as inFile:
|
||
theJson = inFile.read()
|
||
theData = json.loads(theJson)
|
||
except Exception as e:
|
||
logger.error("Failed to load index file")
|
||
logger.error(str(e))
|
||
return False
|
||
|
||
if "tagIndex" in theData.keys():
|
||
self.tagIndex = theData["tagIndex"]
|
||
if "refIndex" in theData.keys():
|
||
self.refIndex = theData["refIndex"]
|
||
if "novelIndex" in theData.keys():
|
||
self.novelIndex = theData["novelIndex"]
|
||
|
||
return True
|
||
|
||
return False
|
||
|
||
def saveIndex(self):
|
||
|
||
indexFile = path.join(self.theProject.projMeta, nwFiles.INDEX_FILE)
|
||
logger.debug("Saving index file")
|
||
if self.mainConf.debugInfo:
|
||
nIndent = 2
|
||
else:
|
||
nIndent = None
|
||
try:
|
||
with open(indexFile,mode="w+") as outFile:
|
||
outFile.write(json.dumps({
|
||
"tagIndex" : self.tagIndex,
|
||
"refIndex" : self.refIndex,
|
||
"novelIndex" : self.novelIndex,
|
||
}, indent=nIndent))
|
||
except Exception as e:
|
||
logger.error("Failed to save index file")
|
||
logger.error(str(e))
|
||
return False
|
||
|
||
return True
|
||
|
||
##
|
||
# Index Building
|
||
##
|
||
|
||
def scanText(self, tHandle, theText):
|
||
|
||
theItem = self.theProject.getItem(tHandle)
|
||
if theItem is None: return False
|
||
if theItem.itemType != nwItemType.FILE: return False
|
||
itemClass = theItem.itemClass
|
||
itemLayout = theItem.itemLayout
|
||
|
||
logger.debug("Indexing item with handle %s" % tHandle)
|
||
|
||
# Check file type, and reset its old index
|
||
if itemClass == nwItemClass.NOVEL:
|
||
self.novelIndex[tHandle] = []
|
||
self.refIndex[tHandle] = []
|
||
isNovel = True
|
||
else:
|
||
isNovel = False
|
||
|
||
# Also clear references to file in tag index
|
||
clearTags = []
|
||
for aTag in self.tagIndex:
|
||
if self.tagIndex[aTag][1] == tHandle:
|
||
clearTags.append(aTag)
|
||
for aTag in clearTags:
|
||
self.tagIndex.pop(aTag)
|
||
|
||
nLine = 0
|
||
nTitle = 0
|
||
for aLine in theText.splitlines():
|
||
aLine = aLine.strip()
|
||
nLine += 1
|
||
nChar = len(aLine)
|
||
if nChar == 0: continue
|
||
if aLine[0] == "#":
|
||
if isNovel:
|
||
isTitle = self.indexTitle(tHandle, aLine, nLine, itemLayout)
|
||
if isTitle:
|
||
nTitle = nLine
|
||
elif aLine[0] == "@":
|
||
if isNovel:
|
||
self.indexNoteRef(tHandle, aLine, nLine, nTitle)
|
||
else:
|
||
self.indexTag(tHandle, aLine, nLine, itemClass)
|
||
|
||
return True
|
||
|
||
def indexTitle(self, tHandle, aLine, nLine, itemLayout):
|
||
|
||
if aLine.startswith("# "):
|
||
hDepth = 1
|
||
hText = aLine[2:].strip()
|
||
elif aLine.startswith("## "):
|
||
hDepth = 2
|
||
hText = aLine[3:].strip()
|
||
elif aLine.startswith("### "):
|
||
hDepth = 3
|
||
hText = aLine[4:].strip()
|
||
elif aLine.startswith("#### "):
|
||
hDepth = 4
|
||
hText = aLine[5:].strip()
|
||
else:
|
||
return False
|
||
|
||
if hText != "":
|
||
self.novelIndex[tHandle].append([nLine, hDepth, hText, itemLayout.name])
|
||
|
||
return True
|
||
|
||
def indexNoteRef(self, tHandle, aLine, nLine, nTitle):
|
||
|
||
isValid, theBits, thePos = self.scanThis(aLine)
|
||
if not isValid or len(theBits) == 0:
|
||
return False
|
||
|
||
theKey = theBits[0]
|
||
if theKey in self.NOVEL_KEYS:
|
||
for aVal in theBits[1:]:
|
||
self.refIndex[tHandle].append([nLine, theKey, aVal, nTitle])
|
||
|
||
return True
|
||
|
||
def indexTag(self, tHandle, aLine, nLine, itemClass):
|
||
|
||
isValid, theBits, thePos = self.scanThis(aLine)
|
||
if not isValid or len(theBits) != 2:
|
||
return False
|
||
|
||
if theBits[0] == self.TAG_KEY:
|
||
self.tagIndex[theBits[1]] = [nLine, tHandle, itemClass.name]
|
||
|
||
return True
|
||
|
||
##
|
||
# Check @ Lines
|
||
##
|
||
|
||
def scanThis(self, aLine):
|
||
|
||
theBits = []
|
||
thePos = []
|
||
|
||
aLine = aLine.strip()
|
||
nChar = len(aLine)
|
||
if nChar < 2:
|
||
return False, theBits, thePos
|
||
if aLine[0] != "@":
|
||
return False, theBits, thePos
|
||
|
||
cPos = 0
|
||
cKey, cSep, cVals = aLine.partition(":")
|
||
sKey = cKey.strip()
|
||
if sKey == "@":
|
||
return False, theBits, thePos
|
||
|
||
theBits.append(sKey)
|
||
thePos.append(cPos)
|
||
cPos += len(sKey) + 1
|
||
|
||
if cVals == "":
|
||
# No values, so we're done
|
||
return True, theBits, thePos
|
||
|
||
aVals = cVals.split(",")
|
||
for cVal in aVals:
|
||
sVal = cVal.strip()
|
||
rLen = len(cVal.lstrip())
|
||
tLen = len(cVal)
|
||
theBits.append(sVal)
|
||
thePos.append(cPos+tLen-rLen)
|
||
cPos += tLen + 1
|
||
|
||
return True, theBits, thePos
|
||
|
||
def checkThese(self, theBits, tItem):
|
||
|
||
nBits = len(theBits)
|
||
isGood = [False]*nBits
|
||
if nBits == 0:
|
||
return []
|
||
|
||
# If we have a tag, only the first value is accepted, the rest is ignored
|
||
if theBits[0] == self.TAG_KEY and nBits > 1:
|
||
isGood[0] = True
|
||
if theBits[1] in self.tagIndex.keys():
|
||
if self.tagIndex[theBits[1]][1] == tItem.itemHandle:
|
||
isGood[1] = True
|
||
else:
|
||
isGood[1] = False
|
||
else:
|
||
isGood[1] = True
|
||
return isGood
|
||
|
||
# If we're still here, we better check that the references exist
|
||
if tItem.itemClass == nwItemClass.NOVEL:
|
||
isGood[0] = theBits[0] in self.NOVEL_KEYS
|
||
else:
|
||
isGood[0] = theBits[0] in self.NOTE_KEYS
|
||
if not isGood[0] or nBits == 1:
|
||
return isGood
|
||
|
||
for n in range(1,nBits):
|
||
if theBits[n] in self.tagIndex:
|
||
isGood[n] = self.TAG_CLASS[theBits[0]][0].name == self.tagIndex[theBits[n]][2]
|
||
|
||
return isGood
|
||
|
||
##
|
||
# Extract Data
|
||
##
|
||
|
||
def buildNovelList(self):
|
||
|
||
self.novelList = []
|
||
self.novelOrder = []
|
||
for tHandle in self.theProject.treeOrder:
|
||
if tHandle not in self.novelIndex:
|
||
continue
|
||
for tEntry in self.novelIndex[tHandle]:
|
||
self.novelList.append(tEntry)
|
||
self.novelOrder.append("%s:%d" % (tHandle,tEntry[0]))
|
||
|
||
return True
|
||
|
||
def buildTagNovelMap(self, theTags):
|
||
|
||
tagMap = {}
|
||
tagClass = {}
|
||
|
||
for theTag in theTags:
|
||
tagMap[theTag] = [0]*len(self.novelOrder)
|
||
try:
|
||
tagClass[theTag] = nwItemClass[self.tagIndex[theTag][2]]
|
||
except:
|
||
logger.error("Could not map '%s' to nwItemClass" % self.tagIndex[theTag][2])
|
||
tagClass[theTag] = None
|
||
|
||
for tHandle in self.refIndex:
|
||
for nLine, tKey, tTag, nTitle in self.refIndex[tHandle]:
|
||
if tTag in tagMap.keys() and tKey in self.TAG_CLASS:
|
||
try:
|
||
nPos = self.novelOrder.index("%s:%d" % (tHandle, nTitle))
|
||
if self.TAG_CLASS[tKey][0] == tagClass[tTag]:
|
||
tagMap[tTag][nPos] = self.TAG_CLASS[tKey][1]
|
||
except:
|
||
logger.error("Could not find '%s:%d' in novelOrder" % (tHandle, nTitle))
|
||
|
||
return tagMap
|
||
|
||
# END Class NWIndex
|