def get_unicode_builder(tmpdir):
proj = Project.from_path(
os.path.join(os.path.dirname(__file__), u"ünicöde-project"))
env = Environment(proj)
pad = Database(env).new_pad()
return pad, Builder(pad, str(tmpdir.mkdir("output")))
def child_sources_test_project_builder(tmpdir):
project = Project.from_path(
os.path.join(os.path.dirname(__file__), "child-sources-test-project"))
env = Environment(project)
pad = Database(env).new_pad()
return Builder(pad, str(tmpdir.mkdir("output")))
def theme_project(theme_project_tmpdir, request):
"""Return the theme project created in a temp dir.
Could be parametrize, if request.param=False themes variables won't be set
"""
try:
with_themes_var = request.param
except AttributeError:
with_themes_var = True
# Create the .lektorproject file
lektorfile_text = textwrap.dedent(
"""
[project]
name = Themes Project
{}
""".format(
"themes = blog_theme, project_theme" if with_themes_var else ""
)
)
theme_project_tmpdir.join("themes.lektorproject").write_text(
lektorfile_text, "utf8", ensure=True
)
return Project.from_path(str(theme_project_tmpdir))
def scratch_project_with_plugin_no_params(
scratch_project_data, request, isolated_cli_runner
):
"""Create a scratch project and add a plugin that has the named event listener.
Return (project, current event, and attached cli_runner).
"""
base = scratch_project_data
# Minimum viable setup.py
current_test_index = (request.param_index,) * 4
setup_text = textwrap.dedent(
u"""
from setuptools import setup
setup(
name='lektor-event-test-no-params{}',
entry_points={{
'lektor.plugins': [
'event-test-no-params{} = lektor_event_test_no_params{}:NoParams{}',
]
}}
)
"""
).format(*current_test_index)
base.join(
"packages", "event-test-no-params{}".format(request.param_index), "setup.py"
).write_text(setup_text, "utf8", ensure=True)
# Minimum plugin code
plugin_text = textwrap.dedent(
u"""
from lektor.pluginsystem import Plugin
import os
class NoParams{}(Plugin):
name = 'Event Test'
description = u'Non-empty string'
def on_{}(self):
pass
"""
).format(request.param_index, request.param, request.param)
base.join(
"packages",
"event-test-no-params{}".format(request.param_index),
"lektor_event_test_no_params{}.py".format(request.param_index),
).write_text(plugin_text, "utf8", ensure=True)
# Move into isolated path.
for entry in os.listdir(str(base)):
entry_path = os.path.join(str(base), entry)
if os.path.isdir(entry_path):
shutil.copytree(entry_path, entry)
else:
shutil.copy2(entry_path, entry)
from lektor.project import Project
yield (Project.from_path(str(base)), request.param, isolated_cli_runner)
def post(ctx, slug=None):
project = Project.discover()
env = project.make_env()
pad = env.new_pad()
blog = pad.get('/blog')
latest_post = blog.children.first()
if latest_post is None:
next_id = 1
else:
next_id = latest_post['id'] + 1
if slug is None:
slug = input('Enter slug: ') or '__new_post__'
new_dirname = os.path.join(
ROOT_DIR, os.path.dirname(blog.source_filename), slug,
)
os.mkdir(new_dirname)
contents_fn = os.path.join(new_dirname, 'contents.lr')
with io.open(contents_fn, mode='w', encoding='utf8') as f:
f.write(blog_post_template.format(
id=next_id,
today=datetime.date.today().strftime(r'%Y-%m-%d'),
))
def setUp(self):
self.project = Project.from_path(
os.path.join(os.path.dirname(__file__), 'demo-project'))
self.env = Environment(self.project)
self.pad = Database(self.env).new_pad()
self.out = tempfile.mkdtemp()
self.builder = Builder(self.pad, self.out)
def release(ctx, path_to_info):
project = Project.discover()
env = project.make_env()
pad = env.new_pad()
later = datetime.datetime.now() + datetime.timedelta(hours=1)
with io.open(path_to_info, encoding='utf8') as f:
info = json.load(f)
info.setdefault('min_sysver', '10.8')
info.setdefault('pub_datetime', later.strftime(r'%Y-%m-%d %H:%M:%S'))
info.setdefault(
'download_url',
'https://github.com/MacDownApp/macdown/releases/download/'
'v{version}/MacDown.app.zip'.format(version=info['version']),
)
download = pad.get('/download')
new_dirname = os.path.join(
ROOT_DIR,
os.path.dirname(download.source_filename),
info['build_number'],
)
os.mkdir(new_dirname)
contents_fn = os.path.join(new_dirname, 'contents.lr')
with io.open(contents_fn, mode='w', encoding='utf8') as f:
f.write(release_template.format(**info))
def project(tmp_path_factory):
site_path = tmp_path_factory.mktemp('site')
project_file = site_path / 'site.lektorproject'
project_file.write_text(u"""
[project]
name = Test Project
""")
return Project.from_file(str(project_file))
def list_local(self):
all_records = []
project = Project.discover()
env = project.make_env()
pad = env.new_pad()
root = pad.root
all_records = self.add_index_children_json(pad, root)
return all_records
def list_local(self):
all_records = []
project = Project.discover()
env = project.make_env()
pad = env.new_pad()
root = pad.root
all_records = self.add_index_children_json(pad, root)
return all_records
def get_project(self, silent=False):
if self._project is not None:
return self._project
if self._project_path is not None:
rv = Project.from_path(self._project_path)
else:
rv = Project.discover()
if rv is None:
if silent:
return None
if self._project_path is None:
raise click.UsageError("Could not automatically discover "
"project. A Lektor project must "
"exist in the working directory or "
"any of the parent directories.")
raise click.UsageError('Could not find project "%s"' %
self._project_path)
self._project = rv
return rv
def child_sources_test_project_builder(request):
from lektor.db import Database
from lektor.environment import Environment
from lektor.project import Project
project = Project.from_path(os.path.join(os.path.dirname(__file__), "child-sources-test-project"))
env = Environment(project)
pad = Database(env).new_pad()
return make_builder(request, pad)
def child_sources_test_project_builder(request):
from lektor.db import Database
from lektor.environment import Environment
from lektor.project import Project
project = Project.from_path(
os.path.join(os.path.dirname(__file__), 'child-sources-test-project'))
env = Environment(project)
pad = Database(env).new_pad()
return make_builder(request, pad)
def child_sources_test_project_builder(tmpdir):
from lektor.db import Database
from lektor.environment import Environment
from lektor.project import Project
from lektor.builder import Builder
project = Project.from_path(
os.path.join(os.path.dirname(__file__), 'child-sources-test-project'))
env = Environment(project)
pad = Database(env).new_pad()
return Builder(pad, str(tmpdir.mkdir("output")))
def get_unicode_builder(tmpdir):
from lektor.project import Project
from lektor.environment import Environment
from lektor.db import Database
from lektor.builder import Builder
proj = Project.from_path(os.path.join(os.path.dirname(__file__),
u'ünicöde-project'))
env = Environment(proj)
pad = Database(env).new_pad()
return pad, Builder(pad, str(tmpdir.mkdir('output')))
def child_sources_test_project_builder(tmpdir):
from lektor.db import Database
from lektor.environment import Environment
from lektor.project import Project
from lektor.builder import Builder
project = Project.from_path(os.path.join(os.path.dirname(__file__),
'child-sources-test-project'))
env = Environment(project)
pad = Database(env).new_pad()
return Builder(pad, str(tmpdir.mkdir("output")))
def get_unicode_builder(tmpdir):
from lektor.project import Project
from lektor.environment import Environment
from lektor.db import Database
from lektor.builder import Builder
proj = Project.from_path(os.path.join(os.path.dirname(__file__),
u'ünicöde-project'))
env = Environment(proj)
pad = Database(env).new_pad()
return pad, Builder(pad, str(tmpdir.mkdir('output')))
def content_file_info_cmd(ctx, files, as_json):
"""Given a list of files this returns the information for those files
in the context of a project. If the files are from different projects
an error is generated.
"""
project = None
def fail(msg):
if as_json:
echo_json({"success": False, "error": msg})
sys.exit(1)
raise click.UsageError("Could not find content file info: %s" % msg)
for filename in files:
this_project = Project.discover(filename)
if this_project is None:
fail("no project found")
if project is None:
project = this_project
elif project.project_path != this_project.project_path:
fail("multiple projects")
if project is None:
fail("no file indicated a project")
project_files = []
for filename in files:
content_path = project.content_path_from_filename(filename)
if content_path is not None:
project_files.append(content_path)
if not project_files:
fail("no files resolve in project")
if as_json:
echo_json(
{
"success": True,
"project": project.to_json(),
"paths": project_files,
}
)
else:
click.echo("Project:")
click.echo(" Name: %s" % project.name)
click.echo(" File: %s" % project.project_file)
click.echo(" Tree: %s" % project.tree)
click.echo("Paths:")
for project_file in project_files:
click.echo(" - %s" % project_file)
def scratch_project(request):
base = tempfile.mkdtemp()
with open(os.path.join(base, 'Scratch.lektorproject'), 'w') as f:
f.write(
'[project]\n'
'name = Scratch\n\n'
'[alternatives.en]\n'
'primary = yes\n'
'[alternatives.de]\n'
'url_prefix = /de/\n'
'[servers.production]\n'
'enabled = yes\n'
'name = Production\n'
'target = rsync://example.com/path/to/website\n'
'name[de] = Produktion\n'
'extra_field = extra_value\n'
)
os.mkdir(os.path.join(base, 'content'))
with open(os.path.join(base, 'content', 'contents.lr'), 'w') as f:
f.write(
'_model: page\n'
'---\n'
'title: Index\n'
'---\n'
'body: Hello World!\n'
)
os.mkdir(os.path.join(base, 'templates'))
with open(os.path.join(base, 'templates', 'page.html'), 'w') as f:
f.write('<h1>{{ this.title }}</h1>\n{{ this.body }}\n')
os.mkdir(os.path.join(base, 'models'))
with open(os.path.join(base, 'models', 'page.ini'), 'w') as f:
f.write(
'[model]\n'
'label = {{ this.title }}\n\n'
'[fields.title]\n'
'type = string\n'
'[fields.body]\n'
'type = markdown\n'
)
def cleanup():
try:
shutil.rmtree(base)
except (OSError, IOError):
pass
request.addfinalizer(cleanup)
from lektor.project import Project
return Project.from_path(base)
def get_meetup_groups():
"""
Loads meetup groups from the Python Colombia lektor database.
This returns only communities that are displayed on the map.
"""
project = Project.discover()
env = project.make_env()
pad = env.new_pad()
groups = [
g for g in pad.query('/usuarios/') if g['type'] == 'comunidad'
and g['map'] and not isinstance(g['meetup_handle'], Undefined)
]
groups = {g['meetup_handle']: g['username'] for g in groups}
return groups
def scratch_project(tmpdir):
base = tmpdir.mkdir("scratch-proj")
lektorfile_text = textwrap.dedent(u"""
[project]
name = Scratch
[alternatives.en]
primary = yes
[alternatives.de]
url_prefix = /de/
""")
base.join("Scratch.lektorproject").write_text(lektorfile_text,
"utf8",
ensure=True)
content_text = textwrap.dedent(u"""
_model: page
---
title: Index
---
body: Hello World!
""")
base.join("content", "contents.lr").write_text(content_text,
"utf8",
ensure=True)
template_text = textwrap.dedent(u"""
<h1>{{ this.title }}</h1>
{{ this.body }}
""")
base.join("templates", "page.html").write_text(template_text,
"utf8",
ensure=True)
model_text = textwrap.dedent(u"""
[model]
label = {{ this.title }}
[fields.title]
type = string
[fields.body]
type = markdown
""")
base.join("models", "page.ini").write_text(model_text, "utf8", ensure=True)
from lektor.project import Project
return Project.from_path(str(base))
def demo_output(site_path, my_plugin_id, my_plugin_cls, tmp_path_factory):
""" Build the demo site.
Return path to output directory.
"""
project = Project.from_path(str(site_path))
env = Environment(project, load_plugins=False)
# Load our plugin
env.plugin_controller.instanciate_plugin(my_plugin_id, my_plugin_cls)
env.plugin_controller.emit('setup-env')
pad = Database(env).new_pad()
output_path = tmp_path_factory.mktemp('demo-site')
builder = Builder(pad, str(output_path))
with CliReporter(env):
failures = builder.build_all()
assert failures == 0
return output_path
def no_alt_pad(tmp_path_factory):
no_alt_project = tmp_path_factory.mktemp("no-alts") / "demo-project"
demo_project = Path(__file__).parent / "demo-project"
shutil.copytree(demo_project, no_alt_project)
project_file = no_alt_project / "Website.lektorproject"
alt_section_re = r"(?ms)^\[alternatives\.\w+\].*?(?=^\[)"
project_file.write_text(
re.sub(alt_section_re, "", project_file.read_text()))
dirs = [no_alt_project]
while dirs:
for child in dirs.pop().iterdir():
if child.is_dir():
dirs.append(child)
elif child.match("contents+*.lr"):
child.unlink()
project = Project.from_path(no_alt_project)
return project.make_env().new_pad()
def scratch_project(request):
base = tempfile.mkdtemp()
with open(os.path.join(base, "Scratch.lektorproject"), "w") as f:
f.write(
"[project]\n"
"name = Scratch\n\n"
"[alternatives.en]\n"
"primary = yes\n"
"[alternatives.de]\n"
"url_prefix = /de/\n"
)
os.mkdir(os.path.join(base, "content"))
with open(os.path.join(base, "content", "contents.lr"), "w") as f:
f.write("_model: page\n" "---\n" "title: Index\n" "---\n" "body: Hello World!\n")
os.mkdir(os.path.join(base, "templates"))
with open(os.path.join(base, "templates", "page.html"), "w") as f:
f.write("<h1>{{ this.title }}</h1>\n{{ this.body }}\n")
os.mkdir(os.path.join(base, "models"))
with open(os.path.join(base, "models", "page.ini"), "w") as f:
f.write(
"[model]\n"
"label = {{ this.title }}\n\n"
"[fields.title]\n"
"type = string\n"
"[fields.body]\n"
"type = markdown\n"
)
def cleanup():
try:
shutil.rmtree(base)
except (OSError, IOError):
pass
request.addfinalizer(cleanup)
from lektor.project import Project
return Project.from_path(base)
def scratch_project(tmpdir):
base = tmpdir.mkdir("scratch-proj")
lektorfile_text = textwrap.dedent(u"""
[project]
name = Scratch
[alternatives.en]
primary = yes
[alternatives.de]
url_prefix = /de/
""")
base.join("Scratch.lektorproject").write_text(lektorfile_text, "utf8", ensure=True)
content_text = textwrap.dedent(u"""
_model: page
---
title: Index
---
body: Hello World!
""")
base.join("content", "contents.lr").write_text(content_text, "utf8", ensure=True)
template_text = textwrap.dedent(u"""
<h1>{{ this.title }}</h1>
{{ this.body }}
""")
base.join("templates", "page.html").write_text(template_text, "utf8", ensure=True)
model_text = textwrap.dedent(u"""
[model]
label = {{ this.title }}
[fields.title]
type = string
[fields.body]
type = markdown
""")
base.join("models", "page.ini").write_text(model_text, "utf8", ensure=True)
from lektor.project import Project
return Project.from_path(str(base))
def theme_project(theme_project_tmpdir, request):
"""Return the theme project created in a temp dir.
Could be parametrize, if request.param=False themes variables won't be set
"""
try:
with_themes_var = request.param
except AttributeError:
with_themes_var = True
from lektor.project import Project
# Create the .lektorproject file
lektorfile_text = textwrap.dedent(u"""
[project]
name = Themes Project
{}
""".format("themes = blog_theme, project_theme"
if with_themes_var else ""))
theme_project_tmpdir.join("themes.lektorproject").write_text(
lektorfile_text, "utf8", ensure=True)
return Project.from_path(str(theme_project_tmpdir))
def demo_output(tmp_path_factory):
""" Build the demo site.
Return path to output director.
"""
site_dir = os.path.join(os.path.dirname(__file__), 'test-site')
project = Project.from_path(site_dir)
env = project.make_env(load_plugins=False)
# Load our plugin
env.plugin_controller.instanciate_plugin('polymorphic-type',
PolymorphicTypePlugin)
env.plugin_controller.emit('setup-env')
output_path = tmp_path_factory.mktemp('output')
builder = Builder(env.new_pad(), str(output_path))
with CliReporter(env):
failures = builder.build_all()
assert failures == 0
return output_path
def project():
from lektor.project import Project
return Project.from_path(
os.path.join(os.path.dirname(__file__), 'demo-project'))
import imghdr
from os.path import abspath, dirname, join, isfile
import pyimagediet
# Lektor stuff
from lektor.pluginsystem import Plugin
from lektor.build_programs import FileAssetBuildProgram, AttachmentBuildProgram, BuildProgram
from lektor.assets import File
from lektor.sourceobj import VirtualSourceObject
from lektor.project import Project
from lektor.db import Image
from werkzeug._internal import _log
# Load and parse the pyimagediet configuration
config_filename = abspath(join(Project.discover().project_path, '..', 'configs', 'minification.yml'))
if not isfile(config_filename):
from pyimagediet.process import DEFAULT_CONFIG as DIET_CONFIG
else:
DIET_CONFIG = pyimagediet.read_yaml_configuration(config_filename)
try:
DIET_CONFIG = pyimagediet.parse_configuration(DIET_CONFIG)
except pyimagediet.ConfigurationErrorDietException, e:
raise Exception(e.msg)
def copy_and_optimize(src, dst):
"""Make sure it's an image, and then optimize on place"""
img_type = imghdr.what(src)
def project():
from lektor.project import Project
return Project.from_path(os.path.join(os.path.dirname(__file__),
'demo-project'))
def scratch_project(scratch_project_data):
base = scratch_project_data
return Project.from_path(str(base))
def scratch_project(scratch_project_data):
from lektor.project import Project
base = scratch_project_data
return Project.from_path(str(base))
def project():
project = Project.from_path(str(ROOT / "example-project"))
assert project
return project
def project(self):
return Project.discover()
def lektor_env():
site_path = os.path.join(os.path.dirname(__file__), 'test-site')
return Project.from_path(site_path).make_env(load_plugins=False)
import os
import sys
# Third party imports
from PIL import Image as ImagePIL
from jinja2 import Undefined
# Local imports
from lektor.db import Image
from lektor.pluginsystem import Plugin
from lektor.project import Project
from lektor.reporter import reporter
from lektor.utils import portable_popen
PY3 = sys.version_info[0] == 3
PROJECT = Project.discover()
ROOT_PATH = os.path.abspath(os.path.dirname(PROJECT.project_path))
CONTENT_PATH = os.path.join(ROOT_PATH, 'content')
class PythonColombiaPlugin(Plugin):
name = 'Python Colombia Custom Lektor Plugin'
description = 'This is a custom local plugin to add extra functionality.'
def on_after_build(self, builder, build_state, source, prog):
if isinstance(source, Image) and source.parent['_model'] == 'user':
w, h = source.width, source.height
fpath = CONTENT_PATH + source.path
if isinstance(w, Undefined):
with ImagePIL.open(fpath) as img:
w, h = img.size
def project(request):
from lektor.project import Project
return Project.from_path(
os.path.join(os.path.dirname(__file__), "demo-project"))
def pntest_project(request):
from lektor.project import Project
return Project.from_path(
os.path.join(os.path.dirname(__file__), "dependency-test-project"))
def pntest_project(request):
from lektor.project import Project
return Project.from_path(os.path.join(os.path.dirname(__file__),
'dependency-test-project'))
def list_local() -> List[Dict[str, Any]]:
project = Project.discover()
env = project.make_env()
pad = env.new_pad()
root = pad.root
return get_all_records(pad, root)
def project(request):
from lektor.project import Project
return Project.from_path(os.path.join(os.path.dirname(__file__), "demo-project"))
