def _get_page_list(self, request, lang):
pages = []
latest_from_blog = []
hero_list = HashableList()
for entry in request['pages'] + request['drafts']:
if entry.context.condition and not entry.context.condition(entry):
continue
try:
e = entry_for_lang(request, lang, entry)
except TranslationNotFound:
e = entry
ident = e.props.identifier
if ident == 'homepage':
pages.append(e)
elif ident == 'callout':
request['env']['callout'] = e
elif 'hero-list' in e.filename.split(os.path.sep):
hero_list.append(e)
for entry in request['entrylist']:
try:
latest_from_blog.append(entry_for_lang(request, lang, entry))
except TranslationNotFound:
pass
request['env']['hero_list'] = hero_list
request['env']['latest'] = HashableList(latest_from_blog[:4])
return pages
def _get_page_list(self, request, lang):
staff_page = HashableList()
for entry in request['pages']:
if entry.identifier == 'staff':
try:
e = entry_for_lang(request, lang, entry)
except TranslationNotFound:
e = entry
staff_page.append(e)
break
return staff_page
def _get_page_list(self, request, lang):
pages = HashableList()
for entry in request['pages']:
if not 'staff' in entry.filename.split(os.path.sep):
continue
if entry.context.condition and not entry.context.condition(entry):
continue
try:
pages.append(entry_for_lang(request, lang, entry))
except TranslationNotFound:
pages.append(entry)
request['env']['stafflist'] = pages
return pages
def resources(self):
"""List of resource file paths that were copied with the entry from
the copy: wildcard"""
res = []
if self.hasproperty('copy'):
res = HashableList(self.getresources(self.props.get('copy')))
return res
def _get_page_list(self, request, lang):
"""Get a list containing the pages to generate for the required
language
"""
pages = HashableList()
for entry in request['pages']:
if entry.context.condition and not entry.context.condition(entry):
continue
try:
p = entry_for_lang(request, lang, entry)
if not p.hasproperty('permalink'):
p.permalink = strip_default_lang(expand(self.path, p), self.conf)
pages.append(p)
except TranslationNotFound:
pages.append(entry)
return pages
def values(self):
for key in self.keys():
if isinstance(self[key], types.FunctionType):
continue
if isinstance(self[key], list):
yield HashableList(self[key])
elif isinstance(self[key], dict):
yield Configuration(self[key])
elif isinstance(self[key], type(None)):
yield -1
else:
yield self[key]
def compile(conf, env):
"""The compilation process."""
hooks.initialize(conf, env)
hooks.run(conf, env, 'pre')
if env.options.force:
cache.clear(conf.get('cache_dir'))
# time measurement
ctime = time.time()
# populate env and corrects some conf things
data = initialize(conf, env)
# load pages/entries and store them in env
rv = dict(
zip(['entrylist', 'pages', 'translations', 'drafts'],
map(HashableList, readers.load(conf))))
entrylist, pages = rv['entrylist'], rv['pages']
translations, drafts = rv['translations'], rv['drafts']
# load references
refs.load(entrylist, pages, translations, drafts)
data.update(rv)
env.globals.update(rv)
# here we store all found filter and their aliases
ns = defaultdict(set)
# [<class head_offset.Headoffset at 0x1014882c0>, <class html.HTML at 0x101488328>,...]
aflist = filters.get_filters()
# ... and get all configured views
_views = views.get_views()
# filters found in all entries, views and conf.py (skip translations, has no items)
found = sum((x.filters
for x in chain(entrylist, pages, drafts, _views, [conf])), [])
for val in found:
# first we for `no` and get the function name and arguments
f = val[2:] if val.startswith('no') else val
fname, fargs = f.split('+')[:1][0], f.split('+')[1:]
try:
# initialize the filter with its function name and arguments
fx = aflist[fname](conf, env, val, *fargs)
if val.startswith('no'):
fx = filters.disable(fx)
except ValueError:
try:
fx = aflist[val.split('+')[:1][0]](conf, env, val, *fargs)
except ValueError:
raise AcrylamidException('no such filter: %s' % val)
ns[fx].add(val)
# include actual used filters to trigger modified state
env.filters = HashableList(iterkeys(ns))
for entry in chain(entrylist, pages, drafts):
for v in _views:
# a list that sorts out conflicting and duplicated filters
flst = filters.FilterList()
# filters found in this specific entry plus views and conf.py
found = entry.filters + v.filters + data['conf']['filters']
for fn in found:
fx, _ = next((k for k in iteritems(ns) if fn in k[1]))
if fx not in flst:
flst.append(fx)
# sort them ascending because we will pop within filters.add
entry.filters.add(sorted(flst, key=lambda k:
(-k.priority, k.name)),
context=v)
# lets offer a last break to populate tags and such
for v in _views:
env = v.context(conf, env, data)
# now teh real thing!
for v in _views:
for entry in chain(entrylist, pages, translations, drafts):
entry.context = v
for var in 'entrylist', 'pages', 'translations', 'drafts':
data[var] = HashableList(filter(v.condition, locals()[var])) \
if v.condition else locals()[var]
tt = time.time()
for buf, path in v.generate(conf, env, data):
try:
helpers.mkfile(buf,
path,
time.time() - tt,
ns=v.name,
force=env.options.force,
dryrun=env.options.dryrun)
except UnicodeError:
log.exception(path)
finally:
buf.close()
tt = time.time()
# copy modified/missing assets to output
assets.compile(conf, env)
# wait for unfinished hooks
hooks.shutdown()
# run post hooks (blocks)
hooks.run(conf, env, 'post')
# save conf/environment hash and new/changed/unchanged references
helpers.memoize('Configuration', hash(conf))
helpers.memoize('Environment', hash(env))
refs.save()
# remove abandoned cache files
cache.shutdown()
# print a short summary
log.info('%i new, %i updated, %i skipped [%.2fs]', event.count('create'),
event.count('update'),
event.count('identical') + event.count('skip'),
time.time() - ctime)