def test_pattern_processor_restore(args, test_name):
input_value, process_escapes = args
ps = ProcessedString(input_value, test_name, process_escapes)
states = ( list(ps.open_pattern_pos), list(ps.close_pattern_pos), int(ps.len_open_pattern_pos), int(ps.len_close_pattern_pos), str(ps.string))
processor.process(ps, safe_process=True)
ps.restore()
return states == (ps.open_pattern_pos, ps.close_pattern_pos, ps.len_open_pattern_pos, ps.len_close_pattern_pos, ps.string)
def test_markup_language(args, test_name):
input_value, markup_language, preserved = args
ps = ProcessedString(input_value, test_name, False)
p = deepcopy(processor)
p.keep_appart_from_markup = preserved
p.process(ps)
ps.process_markup_language(markup_language)
return ps.string.replace('\n', '')
def __init__(self, wrapper, filename):
self.patterns = [
".:GetEntryContent:.", ".:GetEntryPreview:.",
".:PreviewIfInThreadElseContent:."
]
for pattern in self.patterns:
try:
w = wrapper.split(pattern)
if len(w) > 2:
die(messages.too_much_call_of_content.format(filename))
for p in self.patterns:
if p in w[0] or p in w[1]:
die(messages.too_much_call_of_content.format(filename))
self.above = ProcessedString(w[0], filename)
self.below = ProcessedString(w[1], filename)
self.required_content_pattern = pattern
return
except IndexError:
pass
die(messages.missing_entry_content_inclusion)
def __init__(self, wrapper, filename):
pattern_replacement = {
".:GetEntryContent:." : "---VENC-GET-ENTRY-CONTENT---",
".:GetEntryPreview:." : "---VENC-GET-ENTRY-PREVIEW---",
".:PreviewIfInThreadElseContent:." : "---VENC-PREVIEW-IF-IN-THREAD-ELSE-CONTENT---"
}
self.content_type_flag = 0
wrapper_len = len(wrapper)
self.process_get_entry_content = 1 if ".:GetEntryContent:." in wrapper else 0
self.process_get_entry_preview = 1 if ".:GetEntryPreview:." in wrapper else 0
if ".:PreviewIfInThreadElseContent:." in wrapper:
self.process_get_entry_content = 1
self.process_get_entry_preview = 1
for content_pattern in pattern_replacement.keys():
wrapper = wrapper.replace(content_pattern, pattern_replacement[content_pattern])
if len(wrapper) == wrapper_len:
die(messages.missing_entry_content_inclusion.format(filename))
self.processed_string = ProcessedString(wrapper, filename, True)
def __init__(self, theme_folder):
try:
self.header = ProcessedString(open(theme_folder+"chunks/header.html",'r').read(), "header.html")
self.footer = ProcessedString(open(theme_folder+"chunks/footer.html",'r').read(), "footer.html")
self.rss_header = ProcessedString(open(theme_folder+"chunks/rssHeader.xml",'r').read(), "rssHeader.html")
self.rss_footer = ProcessedString(open(theme_folder+"chunks/rssFooter.xml",'r').read(), "rssFooter.html")
self.atom_header = ProcessedString(open(theme_folder+"chunks/atomHeader.xml",'r').read(), "atomHeader.html")
self.atom_footer = ProcessedString(open(theme_folder+"chunks/atomFooter.xml",'r').read(), "atomFooter.html")
self.entry = EntryWrapper(open(theme_folder+"chunks/entry.html",'r').read(), "entry.html")
self.rss_entry = EntryWrapper(open(theme_folder+"chunks/rssEntry.xml",'r').read(),"rssEntry.xxml")
self.atom_entry = EntryWrapper(open(theme_folder+"chunks/atomEntry.xml",'r').read(),"atomEntry.xml")
self.audio = open(theme_folder+"chunks/audio.html",'r').read()
self.video = open(theme_folder+"chunks/video.html",'r').read()
except FileNotFoundError as e:
die(messages.file_not_found.format(str(e.filename)))
def __init__(self, filename, paths, jsonld_callback, date_format, encoding="utf-8", ):
self.previous_entry = None
self.next_entry = None
self.chapter = None
self.schemadotorg = {}
# Loading
raw_data = open(os.getcwd()+"/entries/"+filename,'r').read()
entry_parted = raw_data.split("---VENC-BEGIN-PREVIEW---\n")
if len(entry_parted) == 2:
entry_parted = [entry_parted[0]] + entry_parted[1].split("---VENC-END-PREVIEW---\n")
if len(entry_parted) == 3:
try:
self.preview = ProcessedString(entry_parted[1], filename)
self.content = ProcessedString(entry_parted[2], filename)
except IllegalUseOfEscape:
die(messages.illegal_use_of_escape.format(filename))
try:
metadata = yaml.load(entry_parted[0], Loader=yaml.FullLoader)
except yaml.scanner.ScannerError as e:
die(messages.possible_malformed_entry.format(filename, ''), extra=str(e))
else:
cause = messages.missing_separator_in_entry.format("---VENC-END-PREVIEW---")
die(messages.possible_malformed_entry.format(filename, cause))
else:
cause = messages.missing_separator_in_entry.format("---VENC-BEGIN-PREVIEW---")
die(messages.possible_malformed_entry.format(filename, cause))
# Setting up optional metadata
for key in metadata.keys():
if not key in ["authors", "tags", "categories", "title"]:
if metadata[key] != None:
if key == "https://schema.org":
self.schemadotorg = metadata[key]
else:
setattr(self, key, metadata[key])
else:
notify(messages.invalid_or_missing_metadata.format(key, filename), color="YELLOW")
setattr(self, key, '')
# Fix missing or incorrect metadata
for key in ["authors", "tags", "categories", "title"]:
if key not in metadata.keys() or metadata[key] == None:
notify(messages.invalid_or_missing_metadata.format(key, filename), color="YELLOW")
metadata[key] = ''
self.raw_metadata = metadata
self.filename = filename
self.id = int(filename.split('__')[0])
raw_date = filename.split('__')[1].split('-')
self.date = datetime.datetime(
year=int(raw_date[2]),
month=int(raw_date[0]),
day=int(raw_date[1]),
hour=int(raw_date[3]),
minute=int(raw_date[4])
)
self.formatted_date = self.date.strftime(date_format)
try:
self.title = metadata["title"].replace(".:GetEntryTitle:.",'')
except KeyError:
die(messages.missing_mandatory_field_in_entry.format("title", self.id))
try:
self.authors = [ e.strip() for e in metadata["authors"].split(",")] if type(metadata["authors"]) == str else metadata["authors"]
if type(self.authors) != list:
raise GenericMessage(messages.entry_metadata_is_not_a_list.format("authors", self.id))
except KeyError:
die(messages.missing_mandatory_field_in_entry.format("authors", self.id))
try:
self.tags = [ e.strip() for e in metadata["tags"].split(",")] if type(metadata["tags"]) == str else metadata["tags"]
if type(self.tags) != list:
raise GenericMessage(messages.entry_metadata_is_not_a_list.format("tags", self.id))
except KeyError:
die(messages.missing_mandatory_field_in_entry.format("tags", self.id))
params = {
"entry_id": self.id,
"entry_title": self.title
}
# TODO MAY BE OPTIMIZED
sf = paths["entries_sub_folders"].format(**params)
if encoding == '':
self.sub_folder = quirk_encoding(unidecode.unidecode(sf))+'/' if sf != '' else ''
self.url = "\x1a"+self.sub_folder
if self.sub_folder == '' or paths["entry_file_name"] != "index.html":
self.url += quirk_encoding(
unidecode.unidecode(
paths["entry_file_name"].format(**params)
)
)
else:
try:
self.sub_folder = urllib.parse.quote(sf, encoding=encoding)+'/' if sf != '' else ''
self.url = "\x1a"+self.sub_folder
if self.sub_folder == '' or paths["entry_file_name"] != "index.html":
self.url += urllib.parse.quote(paths["entry_file_name"].format(**params), encoding=encoding)
except UnicodeEncodeError as e:
self.url = "\x1a"+self.sub_folder+paths["entry_file_name"].format(**params)
notify("\"{0}\": ".format(sf+paths["entry_file_name"].format(**params))+str(e), color="YELLOW")
self.categories_leaves = list()
self.raw_categories = [ c.strip() for c in metadata["categories"].split(',')]
try:
for category in self.raw_categories:
category_leaf = category.split(' > ')[-1].strip()
if len(category_leaf) != 0:
category_leaf_path = "\x1a"
for sub_category in category.split(' > '):
category_leaf_path +=sub_category.strip()+'/'
self.categories_leaves.append({
"value": category_leaf,
"path": category_leaf_path,
"branch" : category
})
except IndexError : # when list is empty
pass
self.categories_tree = []
build_categories_tree(-1, self.raw_categories, self.categories_tree, None, -1, encoding=encoding, sub_folders=paths["categories_sub_folders"])
self.html_categories_tree = {}
self.html_tags = {}
self.html_authors = {}
self.html_categories_leaves = {}
self.html_for_metadata = {}
if jsonld_callback != None:
jsonld_callback(self)
def test_pattern_processor(args, test_name):
input_value, process_escapes = args
ps = ProcessedString(input_value, test_name, process_escapes)
processor.process(ps)
return ps.string