(or treat as wiki
page, yet to decide).
* Allow specific extensions for certain formatters (.rst, .md, .mdwn, etc)
* Support a readonly mode
Standalone requirements
-----------------------
* Sessions
* Login and logout
* SQLite storage engine for usernames and passwords?
* Subscriptions?
* Generate a nonce for new users, and validate email addresses
(hmm... requires incoming email processing, not that easy for standalone
deployments, and not needed for launchpad integration)
Running behind a reverse proxy
------------------------------
Support getting credentials from elsewhere, and updating author accordingly.
Launchpad integration
---------------------
* A plan for spam! Really needed as we have spammers
* How to handle merges
Page merge hooks?
Ideas not yet fully formed
--------------------------
* Lazy loading of formatters (to reduce install dependancies)
* Customize default rendering engine
* Extend creole to allow specifying format of embedded code
* Look for a wiki-media python library for formatting wiki-media text
Or write one.
* Soundex filename search based on base_name of the files, used when
hitting a missing file to offer suggestions.
python-wikkid_0.4.orig/bin/ 0000755 0000000 0000000 00000000000 11377157600 012704 5 ustar 00 python-wikkid_0.4.orig/disperse.conf 0000644 0000000 0000000 00000000341 14336237474 014625 0 ustar 00 # See https://github.com/jelmer/disperse
timeout_days: 5
tag_name: "v$VERSION"
verify_command: "make check"
update_version {
path: "wikkid/__init__.py"
match: "^version = \"(.*)\"$"
new_line: "version = \"$VERSION\""
}
python-wikkid_0.4.orig/plugin/ 0000755 0000000 0000000 00000000000 11374724564 013440 5 ustar 00 python-wikkid_0.4.orig/pyproject.toml 0000644 0000000 0000000 00000000121 14336176502 015042 0 ustar 00 [build-system]
requires = ["setuptools"]
build-backend = "setuptools.build_meta"
python-wikkid_0.4.orig/setup.cfg 0000644 0000000 0000000 00000001522 14336241273 013753 0 ustar 00 [metadata]
name = Wikkid
description = VCS-backed wiki
long_description = A wiki that is backed by Gitr or Bazaar that allows local branching of the wiki
for later merging. Also doesn't have any page locks and uses three way merging.
version = attr:wikkid.version
author = Wikkid Developers
author_email = wikkid-dev@lists.launchpad.net
url = https://launchpad.net/wikkid
project_urls =
Repository=https://github.com/wikkid-team/wikkid
[options]
scripts = bin/wikkid-serve
packages = find:
package_dir = breezy.plugins.wikkid=plugin
include_package_data = True
install_requires =
breezy
docutils
dulwich
jinja2
merge3
pygments
twisted
webob
zope.interface
tests_require =
testtools
bs4
lxml
[options.package_data]
wikkid/skin =
default/*.html
default/favicon.ico
default/static/*
python-wikkid_0.4.orig/setup.py 0000755 0000000 0000000 00000000153 14336241273 013646 0 ustar 00 #!/usr/bin/python3
from setuptools import setup
setup(data_files=[('share/man/man1', ['wikkid-serve.1'])])
python-wikkid_0.4.orig/wikkid-serve.1 0000644 0000000 0000000 00000001461 11521016061 014606 0 ustar 00 .TH WIKKID-SERVE "1" "January 2011" "wikkid-serve 0.2dev" "User Commands"
.SH NAME
wikkid-serve \- Serve a wiki from a Bazaar branch
.SH SYNOPSIS
.B wikkid-serve
[\fIoptions\fR] \fI\fR
.SH DESCRIPTION
Run a stand-alone Wikkid Wiki server.
.SH OPTIONS
.TP
\fB\-\-version\fR
show program's version number and exit
.TP
\fB\-h\fR, \fB\-\-help\fR
show this help message and exit
.TP
\fB\-\-host\fR=\fIHOST\fR
The interface to listen on. Defaults to 'localhost'
.TP
\fB\-\-port\fR=\fIPORT\fR
The port to listen on. Defaults to 8080.
.TP
\fB\-\-default\-format\fR=\fIDEFAULT_FORMAT\fR
Specify the default wiki format to use. Defaults to
\&'rest'
.SH "LICENSE"
Wikkid is licensed under the
.B GNU Affero General Public License
.SH "SEE ALSO"
The wikkid home page can be found at
.B https://launchpad.net/wikkid
python-wikkid_0.4.orig/wikkid/ 0000755 0000000 0000000 00000000000 11343270653 013413 5 ustar 00 python-wikkid_0.4.orig/bin/_wikkid_path.py 0000644 0000000 0000000 00000000620 11377162340 015706 0 ustar 00 #! /usr/bin/python
#
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""Add the parent directory to the python path to run the scripts."""
import sys
import os.path
current_dir = os.path.dirname(os.path.abspath(__file__))
parent_dir = os.path.dirname(current_dir)
sys.path.insert(0, parent_dir)
python-wikkid_0.4.orig/bin/wikkid-serve 0000755 0000000 0000000 00000007046 14160200415 015227 0 ustar 00 #! /usr/bin/python3
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""The server class for the wiki."""
try:
import _wikkid_path
except ImportError:
# Not running from a branch.
pass
import logging
import optparse
import sys
from wikkid import version
from wikkid.app import WikkidApp
from wikkid.context import (
DEFAULT_FORMAT,
DEFAULT_HOST,
DEFAULT_PORT,
ExecutionContext,
)
def setup_logging():
"""Set up a logger sending to stderr."""
handler = logging.StreamHandler(sys.stderr)
fmt = '%(asctime)s %(levelname)-7s %(message)s'
formatter = logging.Formatter(
fmt=fmt, datefmt="%Y-%m-%d %H:%M:%S")
handler.setFormatter(formatter)
root = logging.getLogger()
root.addHandler(handler)
def main(args):
usage = "Usage: %prog [options] "
parser = optparse.OptionParser(
usage=usage, description="Run a Wikkid Wiki server.", version=version)
parser.add_option('--format', type='choice', default='bzr',
choices=['bzr', 'git'], help=("Default repository format to use."))
parser.add_option(
'--host', type='string', default=DEFAULT_HOST,
help=('The interface to listen on. Defaults to %r' % DEFAULT_HOST))
parser.add_option(
'--port', type='int', default=DEFAULT_PORT,
help=('The port to listen on. Defaults to %s.' % DEFAULT_PORT))
parser.add_option(
'--default-format', type='string', default=DEFAULT_FORMAT,
help=("Specify the default wiki format to use. Defaults to %r"
% DEFAULT_FORMAT))
parser.add_option(
'--script-name',
help=('The SCRIPT_NAME for the environment. This is the prefix for the URLs'))
options, args = parser.parse_args(sys.argv[1:])
execution_context = ExecutionContext(
host=options.host,
port=options.port,
default_format=options.default_format,
script_name=options.script_name)
if len(args) == 0:
print("No branch location specified.")
parser.print_usage()
sys.exit(1)
if len(args) > 1:
print("Unexpected positional args: %s" % args[1:])
parser.print_usage()
sys.exit(1)
branch = args[0]
setup_logging()
logger = logging.getLogger('wikkid')
logger.setLevel(logging.INFO)
if options.format == 'bzr':
from breezy.workingtree import WorkingTree
from wikkid.filestore.bzr import FileStore
from wikkid.user.bzr import LocalBazaarUserMiddleware
import breezy.bzr
import breezy.git
working_tree = WorkingTree.open(branch)
logger.info('Using: %s', working_tree)
filestore = FileStore(working_tree)
elif options.format == 'git':
from wikkid.filestore.git import FileStore
from wikkid.user.git import LocalGitUserMiddleware
filestore = FileStore.from_path(branch)
app = WikkidApp(filestore=filestore, execution_context=execution_context)
if options.format == 'bzr':
app = LocalBazaarUserMiddleware(app, working_tree.branch)
elif options.format == 'git':
app = LocalGitUserMiddleware(app, filestore.repo)
from wsgiref.simple_server import make_server
httpd = make_server(options.host, options.port, app)
logger.info('Serving on http://%s:%s', options.host, options.port)
try:
httpd.serve_forever()
except KeyboardInterrupt:
logger.info('Done.')
if __name__ == "__main__":
main(sys.argv)
python-wikkid_0.4.orig/plugin/__init__.py 0000644 0000000 0000000 00000000227 14160200415 015526 0 ustar 00 from breezy.commands import plugin_cmds
plugin_cmds.register_lazy('cmd_wikkid', ['wiki'],
'breezy.plugins.wikkid.commands')
python-wikkid_0.4.orig/plugin/commands.py 0000644 0000000 0000000 00000003113 14160200415 015565 0 ustar 00 import logging
import sys
from breezy.commands import Command
from breezy.option import Option
from breezy.workingtree import WorkingTree
from wikkid.app import WikkidApp
from wikkid.filestore.bzr import FileStore
from wikkid.user.bzr import LocalBazaarUserMiddleware
DEFAULT_PORT = 8080
def setup_logging():
"""Set up a logger sending to stderr."""
handler = logging.StreamHandler(sys.stderr)
fmt = '%(asctime)s %(levelname)-7s %(message)s'
formatter = logging.Formatter(
fmt=fmt, datefmt="%Y-%m-%d %H:%M:%S")
handler.setFormatter(formatter)
root = logging.getLogger()
root.addHandler(handler)
class cmd_wikkid(Command):
"""Serve branch as a wiki using wikkid."""
aliases = ['wiki']
takes_args = ['branch?']
takes_options = [
Option(
'port',
help='Port to listen, defaults to 8080.',
type=int,
short_name='p')
]
def run(self, branch=u'.', port=8080):
setup_logging()
logger = logging.getLogger('wikkid')
logger.setLevel(logging.DEBUG)
working_tree = WorkingTree.open(branch)
logger.info('Using: %s', working_tree)
filestore = FileStore(working_tree)
app = WikkidApp(filestore)
app = LocalBazaarUserMiddleware(app, working_tree.branch)
from wsgiref.simple_server import make_server
httpd = make_server('localhost', port, app)
logger.info('Serving on http://localhost:%s', port)
try:
httpd.serve_forever()
except KeyboardInterrupt:
logger.info('Done.')
python-wikkid_0.4.orig/wikkid/__init__.py 0000644 0000000 0000000 00000000305 14336241273 015523 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""A Distributed Wiki."""
version = "0.4"
python-wikkid_0.4.orig/wikkid/app.py 0000644 0000000 0000000 00000011004 14160200415 014526 0 ustar 00 # -*- coding: utf-8 -*-
#
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""A WSGI application for Wikkid."""
import logging
import mimetypes
import os.path
import urllib.parse
from wsgiref.util import shift_path_info
from breezy import urlutils
from webob import Request, Response
from webob.exc import HTTPException, HTTPNotFound
from wikkid.context import ExecutionContext
from wikkid.dispatcher import get_view
from wikkid.fileutils import FileIterable
from wikkid.model.factory import ResourceFactory
from wikkid.skin.loader import Skin
from wikkid.view.urls import parse_url
def serve_file(filename):
if os.path.exists(filename):
basename = urlutils.basename(filename)
content_type = mimetypes.guess_type(basename)[0]
res = Response(content_type=content_type, conditional_response=True)
res.app_iter = FileIterable(filename)
res.content_length = os.path.getsize(filename)
res.last_modified = os.path.getmtime(filename)
# Todo: is this the best value for the etag?
# perhaps md5 would be a better alternative
res.etag = '%s-%s-%s' % (
os.path.getmtime(filename), os.path.getsize(filename),
hash(filename))
return res
else:
return HTTPNotFound()
class WikkidApp(object):
"""The main wikkid application."""
def __init__(self, filestore, skin_name=None, execution_context=None):
if execution_context is None:
execution_context = ExecutionContext()
self.execution_context = execution_context
self.filestore = filestore
self.resource_factory = ResourceFactory(self.filestore)
# Need to load the initial templates for the skin.
if skin_name is None:
skin_name = 'default'
self.skin = Skin(skin_name)
self.logger = logging.getLogger('wikkid')
def preprocess_environ(self, environ):
request = Request(environ)
path = urllib.parse.unquote(request.path)
script_name = self.execution_context.script_name
# Firstly check to see if the path is the same as the script_name
if path != script_name and not path.startswith(script_name + '/'):
raise HTTPNotFound()
shifted_prefix = ''
while shifted_prefix != script_name:
shifted = shift_path_info(environ)
shifted_prefix = '{0}/{1}'.format(shifted_prefix, shifted)
# Now we are just interested in the path_info having ignored the
# script name.
path = urllib.parse.unquote(request.path_info)
if path == '':
path = '/' # Explicitly be the root (we need the /)
return request, path
def _get_view(self, request, path):
"""Get the view for the path specified."""
resource_path, action = parse_url(path)
model = self.resource_factory.get_resource_at_path(resource_path)
return get_view(model, action, request, self.execution_context)
def process_call(self, environ):
"""The actual implementation of dealing with the call."""
# TODO: reject requests that aren't GET or POST
try:
request, path = self.preprocess_environ(environ)
except HTTPException as e:
return e
if path == '/favicon.ico':
if self.skin.favicon is not None:
return serve_file(self.skin.favicon)
else:
return HTTPNotFound()
if path.startswith('/static/'):
if self.skin.static_dir is not None:
static_dir = self.skin.static_dir.rstrip(os.sep) + os.sep
static_file = os.path.abspath(
urlutils.joinpath(static_dir, path[8:]))
if static_file.startswith(static_dir):
return serve_file(static_file)
else:
return HTTPNotFound()
else:
return HTTPNotFound()
try:
view = self._get_view(request, path)
return view.render(self.skin)
except HTTPException as e:
return e
def get_view(self, environ):
"""Allow an app user to get the wikkid view for a particular call."""
request, path = self.preprocess_environ(environ)
return self._get_view(request, path)
def __call__(self, environ, start_response):
"""The WSGI bit."""
response = self.process_call(environ)
return response(environ, start_response)
python-wikkid_0.4.orig/wikkid/context.py 0000644 0000000 0000000 00000002477 11766323257 015473 0 ustar 00 # -*- coding: utf-8 -*-
#
# Copyright (C) 2010-2012 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""A means of storing execution context."""
DEFAULT_FORMAT = 'rest'
DEFAULT_HOST = 'localhost'
DEFAULT_PORT = 8080
class ExecutionContext(object):
"""Store run-time execution context data.
This is the Encapsulate Context pattern.
"""
def __init__(self, host=None, port=None, default_format=None,
script_name=None):
"""Create an execution context for the application.
:param host: The hostname that content is being served from.
:param port: The port that is being listened on.
:param default_format: The default wiki format for pages that
don't specify any.
"""
if host is None:
host = DEFAULT_HOST
if port is None:
port = DEFAULT_PORT
if default_format is None:
default_format = DEFAULT_FORMAT
self.host = host
self.port = port
self.default_format = default_format
# TODO: make sure the script_name if set starts with a slash and
# doesn't finish with one.
if script_name is None:
script_name = ''
self.script_name = script_name.rstrip('/')
python-wikkid_0.4.orig/wikkid/contrib/ 0000755 0000000 0000000 00000000000 11371760442 015054 5 ustar 00 python-wikkid_0.4.orig/wikkid/dispatcher.py 0000644 0000000 0000000 00000006257 14160200415 016112 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""The dispatcher for wikkid views.
When this module is loaded, it will automagically load all the other views in
this directory. The views inherit from the BaseView which has a metaclass
which registers the view with the dispatcher.
"""
import os
from breezy.urlutils import dirname, joinpath
from zope.interface import providedBy
from wikkid.context import ExecutionContext
# The view registry needs to map an Interface and a name to a class.
_VIEW_REGISTRY = {}
def get_view(obj, view_name, request, ec=ExecutionContext()):
"""Get the most relevant view for the object for the specified name.
Iterate through the provided interfaces of the object and look in the view
registry for a view.
"""
interfaces = providedBy(obj)
for interface in interfaces:
try:
klass = _VIEW_REGISTRY[(interface, view_name)]
instance = klass(obj, request, ec)
instance.initialize()
return instance
except KeyError:
pass
# For example, if someone asked for 'raw' view on a directory or binary
# object.
return None
def register_view(view_class):
"""Register the view."""
interface = getattr(view_class, 'for_interface', None)
view_name = getattr(view_class, 'name', None)
default_view = getattr(view_class, 'is_default', False)
if view_name is None or interface is None:
# Don't register.
return
key = (interface, view_name)
assert key not in _VIEW_REGISTRY, "key already registered: %r" % (key,)
_VIEW_REGISTRY[key] = view_class
if default_view:
_VIEW_REGISTRY[(interface, None)] = view_class
def unregister_view(view_class):
"""Unregister the view."""
interface = getattr(view_class, 'for_interface', None)
view_name = getattr(view_class, 'name', None)
default_view = getattr(view_class, 'is_default', False)
if view_name is None or interface is None:
# Don't register.
return
key = (interface, view_name)
assert _VIEW_REGISTRY[key] is view_class, \
"key registered with different class: %r: %r != %r" % (
key, _VIEW_REGISTRY[key], view_class)
del _VIEW_REGISTRY[key]
if default_view:
del _VIEW_REGISTRY[(interface, None)]
# We know that the controller (whatever that is going to end up being) will
# load this module to get the 'get_view' function. None of the other view
# modules should be explicitly loaded anywhere else (possible exceptions may
# occur, so this isn't a hard rule).
#
# So... when this module is loaded, we want to load the other modules in the
# wikkid.view package so that when the classes are parsed, they register
# themselves with the view registry.
def load_view_modules():
curr_dir = os.path.abspath(dirname(__file__))
view_dir = joinpath(curr_dir, 'view')
py_files = [
filename for filename in os.listdir(view_dir)
if filename.endswith('.py') and not filename.startswith('__')]
for filename in py_files:
__import__('wikkid.view.%s' % filename[:-3])
load_view_modules()
python-wikkid_0.4.orig/wikkid/filestore/ 0000755 0000000 0000000 00000000000 11361276452 015412 5 ustar 00 python-wikkid_0.4.orig/wikkid/fileutils.py 0000644 0000000 0000000 00000003201 14160200415 015746 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""A method of iterating over file contents
This stops us reading the entire file into memory when we serve it.
"""
class FileIterable(object):
"""An iterable file-like object."""
def __init__(self, filename, start=None, stop=None):
self.filename = filename
self.start = start
self.stop = stop
def __iter__(self):
return FileIterator(self.filename, self.start, self.stop)
def app_iter_range(self, start, stop):
return self.__class__(self.filename, start, stop)
class FileIterator(object):
"""Iterate over a file.
FileIterable provides a simple file iterator, optionally allowing the
user to specify start and end ranges for the file.
"""
chunk_size = 4096
def __init__(self, filename, start, stop):
self.filename = filename
self.fileobj = open(self.filename, 'rb')
if start:
self.fileobj.seek(start)
if stop is not None:
self.length = stop - start
else:
self.length = None
def __iter__(self):
return self
def __next__(self):
if self.length is not None and self.length <= 0:
raise StopIteration
chunk = self.fileobj.read(self.chunk_size)
if not chunk:
raise StopIteration
if self.length is not None:
self.length -= len(chunk)
if self.length < 0:
# Chop off the extra:
chunk = chunk[:self.length]
return chunk
python-wikkid_0.4.orig/wikkid/formatter/ 0000755 0000000 0000000 00000000000 11353614774 015425 5 ustar 00 python-wikkid_0.4.orig/wikkid/interface/ 0000755 0000000 0000000 00000000000 11362277756 015367 5 ustar 00 python-wikkid_0.4.orig/wikkid/model/ 0000755 0000000 0000000 00000000000 11361275416 014515 5 ustar 00 python-wikkid_0.4.orig/wikkid/skin/ 0000755 0000000 0000000 00000000000 11361301511 014343 5 ustar 00 python-wikkid_0.4.orig/wikkid/tests/ 0000755 0000000 0000000 00000000000 11343270653 014555 5 ustar 00 python-wikkid_0.4.orig/wikkid/user/ 0000755 0000000 0000000 00000000000 11361277140 014367 5 ustar 00 python-wikkid_0.4.orig/wikkid/view/ 0000755 0000000 0000000 00000000000 11361275607 014371 5 ustar 00 python-wikkid_0.4.orig/wikkid/contrib/__init__.py 0000644 0000000 0000000 00000000316 11372502521 017156 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""For packages that are not adequately packaged."""
python-wikkid_0.4.orig/wikkid/filestore/__init__.py 0000644 0000000 0000000 00000001134 14160200415 017504 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""Wikkid filestores.
The volatile filestore is primarily used for tests, and the bzr filestore is
where all the main work happens.
"""
class FileExists(Exception):
"""A file was found where a directory is wanted."""
class UpdateConflicts(Exception):
"""Conflicts were found during updating."""
def __init__(self, content, basis_rev):
Exception.__init__(self)
self.content = content
self.basis_rev = basis_rev
python-wikkid_0.4.orig/wikkid/filestore/basefile.py 0000644 0000000 0000000 00000001426 14160200415 017523 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""Base classes for other filestores to use."""
import mimetypes
import breezy.urlutils as urlutils
from wikkid.interface.filestore import FileType
class BaseFile(object):
"""Provide common fields and methods and properties for files."""
def __init__(self, path):
self.path = path
self.base_name = urlutils.basename(path)
self._mimetype = mimetypes.guess_type(self.base_name)[0]
@property
def mimetype(self):
"""If the file_type is a directory, return None."""
if self.file_type == FileType.DIRECTORY:
return None
else:
return self._mimetype
python-wikkid_0.4.orig/wikkid/filestore/bzr.py 0000644 0000000 0000000 00000031230 14336241273 016556 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""A bzr backed filestore."""
from datetime import datetime
import logging
from zope.interface import implementer
from merge3 import Merge3
from breezy.bzr.generate_ids import gen_file_id
from breezy.errors import BinaryFile
from breezy.osutils import splitpath, split_lines
from breezy.revision import NULL_REVISION
from breezy.textfile import check_text_lines
from breezy.transform import FinalPaths, MalformedTransform
from breezy.urlutils import basename, dirname, joinpath
from wikkid.filestore import FileExists, UpdateConflicts
from wikkid.filestore.basefile import BaseFile
from wikkid.interface.filestore import FileType, IFile, IFileStore
def normalize_line_endings(content, ending=b'\n'):
return ending.join(content.splitlines())
def get_line_ending(lines):
"""Work out the line ending used in lines."""
if len(lines) == 0:
return b'\n'
first = lines[0]
if first.endswith(b'\r\n'):
return b'\r\n'
# Default to \n if there are no line endings.
return b'\n'
def get_commit_message(commit_message):
if commit_message is None or commit_message.strip() == '':
return 'No description of change given.'
return commit_message
def normalize_content(content):
# Default to simple '\n' line endings.
content = normalize_line_endings(content)
# Make sure the content ends with a new-line. This makes
# end of file conflicts nicer.
if not content.endswith(b'\n'):
content += b'\n'
return content
def iter_paths(path):
path_segments = splitpath(path)
while len(path_segments) > 0:
tail = path_segments.pop()
if len(path_segments) == 0:
yield '', tail
else:
yield joinpath(*path_segments), tail
def create_parents(tt, path, trans_id):
prev_trans_id = trans_id
for parent_path, tail in iter_paths(path):
trans_id = tt.trans_id_tree_path(parent_path)
if tt.tree_kind(trans_id) is not None:
break
tt.adjust_path(tail, trans_id, prev_trans_id)
tt.create_directory(trans_id)
tt.version_file(trans_id=trans_id, file_id=gen_file_id(basename(path)))
prev_trans_id = trans_id
@implementer(IFileStore)
class FileStore(object):
"""Wraps a Bazaar branch to be a filestore."""
def __init__(self, tree):
self.tree = tree
self.branch = tree.branch
self.logger = logging.getLogger('wikkid')
def basis_tree(self):
return self.tree.basis_tree()
def get_file(self, path):
"""Return an object representing the file at specified path."""
if not self.tree.is_versioned(path):
return None
else:
return File(self, path)
def update_file(self, path, content, author, parent_revision,
commit_message=None):
"""Update the file at the specified path with the content.
This is going to be really interesting when we need to deal with
conflicts.
"""
commit_message = get_commit_message(commit_message)
if parent_revision is None:
parent_revision = NULL_REVISION
# Firstly we want to lock the tree for writing.
with self.tree.lock_write():
# Look to see if the path is there. If it is then we are doing an
# update. If it isn't we are doing an add.
if self.tree.is_versioned(path):
# What if a parent_revision hasn't been set?
self._update_file(
path, content, author, parent_revision,
commit_message)
else:
self._add_file(path, content, author, commit_message)
def _ensure_directory_or_nonexistant(self, dir_path):
"""Ensure the dir_path defines a directory or doesn't exist.
Walk up the dir_path and make sure that the path either doesn't exist
at all, or is a directory. The purpose of this is to make sure we
don't try to add a file in a directory where the directory has the
same name as an existing file.
"""
check = []
while dir_path:
check.append(dir_path)
dir_path = dirname(dir_path)
while len(check):
f = self.get_file(check.pop())
if f is not None:
if not f.is_directory:
raise FileExists(
'%s exists and is not a directory' % f.path)
def _add_file(self, path, content, author, commit_message):
"""Add a new file at the specified path with the content.
Then commit this new file with the specified commit_message.
"""
content = normalize_content(content)
t = self.tree.controldir.root_transport
# Get a transport for the path we want.
self._ensure_directory_or_nonexistant(dirname(path))
t = t.clone(dirname(path))
t.create_prefix()
# Put the file there.
# TODO: UTF-8 encode text files?
t.put_bytes(basename(path), content)
self.tree.smart_add([t.local_abspath('.')])
self.tree.commit(
message=commit_message,
authors=[author])
def _get_final_text(self, content, f, parent_revision):
current_rev = f.last_modified_in_revision
wt = self.tree
current_lines = wt.get_file_lines(f.path)
basis = self.branch.repository.revision_tree(parent_revision)
basis_lines = basis.get_file_lines(f.path)
# need to break content into lines.
ending = get_line_ending(current_lines)
# If the content doesn't end with a new line, add one.
new_lines = split_lines(content)
# Look at the end of the first string.
new_ending = get_line_ending(new_lines)
if ending != new_ending:
# I know this is horribly inefficient, but lets get it working
# first.
content = normalize_line_endings(content, ending)
new_lines = split_lines(content)
if len(new_lines) > 0 and not new_lines[-1].endswith(ending):
new_lines[-1] += ending
merge = Merge3(basis_lines, new_lines, current_lines)
result = b''.join(merge.merge_lines()) # or merge_regions or whatever
conflicted = (b'>>>>>>>' + ending) in result
if conflicted:
raise UpdateConflicts(result, current_rev)
return result
def _update_file(self, path, content, author, parent_revision,
commit_message):
"""Update an existing file with the content.
This method merges the changes in based on the parent revision.
"""
f = File(self, path)
wt = self.tree
with wt.lock_write():
result = self._get_final_text(content, f, parent_revision)
wt.controldir.root_transport.put_bytes(path, result)
wt.commit(
message=commit_message, authors=[author],
specific_files=[path])
def list_directory(self, directory_path):
"""Return a list of File objects for in the directory path.
If the path doesn't exist, returns None. If the path exists but is
empty, an empty list is returned. Otherwise a list of File objects in
that directory.
"""
if directory_path is not None:
directory = self.get_file(directory_path)
if directory is None or directory.file_type != FileType.DIRECTORY:
return None
listing = []
wt = self.tree
with wt.lock_read():
for fp, fc, fkind, entry in wt.list_files(
from_dir=directory_path, recursive=False):
if fc != 'V':
# If the file isn't versioned, skip it.
continue
if directory_path is None:
file_path = fp
else:
file_path = joinpath(directory_path, fp)
listing.append(File(self, file_path))
return listing
@implementer(IFile)
class File(BaseFile):
"""Represents a file in the Bazaar branch."""
def __init__(self, filestore, path):
BaseFile.__init__(self, path)
self.filestore = filestore
# This isn't entirely necessary.
self.tree = self.filestore.tree
self.file_type = self._get_filetype()
self._last_modified_in_revision = None
def _get_filetype(self):
"""Work out the filetype based on the mimetype if possible."""
with self.tree.lock_read():
is_directory = ('directory' == self.tree.kind(self.path))
if is_directory:
return FileType.DIRECTORY
else:
if self._mimetype is None:
binary = self._is_binary
else:
binary = not self._mimetype.startswith('text/')
if binary:
return FileType.BINARY_FILE
else:
return FileType.TEXT_FILE
def get_content(self):
with self.tree.lock_read():
# basis_tree is a revision tree, queries the repositry.
# to get the stuff off the filesystem use the working tree
# which needs to start with that. WorkingTree.open('.').
# branch = tree.branch.
return self.tree.get_file_text(self.path)
@property
def last_modified_in_revision(self):
if self._last_modified_in_revision is None:
try:
self._last_modified_in_revision = self.tree.get_file_revision(
self.path)
except AttributeError:
bt = self.tree.basis_tree()
self._last_modified_in_revision = bt.get_file_revision(
self.path)
return self._last_modified_in_revision
@property
def last_modified_by(self):
"""Return the first author for the revision."""
repo = self.filestore.branch.repository
rev = repo.get_revision(self.last_modified_in_revision)
return rev.get_apparent_authors()[0]
@property
def last_modified_date(self):
"""Return the last modified date for the revision."""
repo = self.filestore.branch.repository
rev = repo.get_revision(self.last_modified_in_revision)
return datetime.utcfromtimestamp(rev.timestamp)
@property
def _is_binary(self):
"""True if the file is binary."""
try:
with self.tree.lock_read():
lines = self.tree.get_file_lines(self.path)
check_text_lines(lines)
return False
except BinaryFile:
return True
@property
def is_directory(self):
"""Is this file a directory?"""
return 'directory' == self.tree.kind(self.path)
def update(self, content, user):
raise NotImplementedError()
class BranchFileStore(FileStore):
def __init__(self, branch):
self.branch = branch
self.tree = branch.basis_tree()
self.logger = logging.getLogger('wikkid')
def basis_tree(self):
return self.tree
def update_file(self, path, content, author, parent_revision,
commit_message=None):
commit_message = get_commit_message(commit_message)
with self.branch.lock_write():
if self.tree.is_versioned(path):
f = File(self, path)
content = self._get_final_text(content, f, parent_revision)
else:
content = normalize_content(content)
if not isinstance(content, bytes):
raise TypeError(content)
with self.tree.preview_transform() as tt:
trans_id = tt.trans_id_tree_path(path)
if tt.tree_kind(trans_id) is not None:
tt.delete_contents(trans_id)
else:
name = splitpath(path)[-1]
tt.version_file(
trans_id=trans_id, file_id=gen_file_id(name))
create_parents(tt, path, trans_id)
tt.create_file([content], trans_id)
try:
tt.commit(self.branch, commit_message, authors=[author])
except MalformedTransform as e:
for conflict in e.conflicts:
if conflict[0] == 'non-directory parent':
path = FinalPaths(tt).get_path(trans_id)
raise FileExists(
'%s exists and is not a directory' %
conflict[1])
raise
self.tree = self.branch.basis_tree()
python-wikkid_0.4.orig/wikkid/filestore/git.py 0000644 0000000 0000000 00000015671 14160200415 016543 0 ustar 00 #
# Copyright (C) 2012 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""A git filestore using Dulwich.
"""
import datetime
import mimetypes
from dulwich.objects import Blob, Tree, ZERO_SHA
from dulwich.object_store import tree_lookup_path
from dulwich.repo import Repo
from dulwich.walk import Walker
import posixpath
import stat
from zope.interface import implementer
from wikkid.filestore import FileExists, UpdateConflicts
from wikkid.interface.filestore import FileType, IFile, IFileStore
@implementer(IFileStore)
class FileStore(object):
"""A filestore that just uses an internal map to store data."""
_encoding = 'utf-8'
@classmethod
def from_path(cls, path):
return cls(Repo(path))
def __init__(self, repo, ref=b'HEAD'):
"""Repo is a dulwich repository."""
self.repo = repo
self.ref = ref
@property
def store(self):
return self.repo.object_store
def _get_root(self, revision=None):
if revision is None:
try:
revision = self.repo.refs[self.ref]
except KeyError:
revision = ZERO_SHA
try:
return (revision, self.repo[revision].tree)
except KeyError:
return None, None
def get_file(self, path):
"""Return an object representing the file."""
commit_id, root_id = self._get_root()
if root_id is None:
return None
try:
(mode, sha) = tree_lookup_path(
self.store.__getitem__,
root_id, path.encode(self._encoding))
except KeyError:
return None
return File(
self.store, mode, sha, path, commit_id, encoding=self._encoding)
def update_file(self, path, content, author, parent_revision,
commit_message=None):
"""The `author` is updating the file at `path` with `content`."""
commit_id, root_id = self._get_root()
if root_id is None:
root_tree = Tree()
else:
root_tree = self.store[root_id]
# Find all tree objects involved
tree = root_tree
trees = [root_tree]
elements = path.strip(posixpath.sep).split(posixpath.sep)
for el in elements[:-1]:
try:
(mode, sha) = tree[el.encode(self._encoding)]
except KeyError:
tree = Tree()
else:
if not stat.S_ISDIR(mode):
raise FileExists(
"File %s exists and is not a directory" % el)
tree = self.store[sha]
trees.append(tree)
if elements[-1] in tree:
(old_mode, old_sha) = tree[elements[-1]]
if stat.S_ISDIR(old_mode):
raise FileExists("File %s exists and is a directory" % path)
if old_sha != parent_revision and parent_revision is not None:
raise UpdateConflicts(
"File conflict %s != %s" % (
old_sha, parent_revision), old_sha)
if not isinstance(content, bytes):
raise TypeError(content)
blob = Blob.from_string(content)
child = (stat.S_IFREG | 0o644, blob.id)
self.store.add_object(blob)
assert len(trees) == len(elements)
for tree, name in zip(reversed(trees), reversed(elements)):
assert name != ""
tree[name.encode(self._encoding)] = child
self.store.add_object(tree)
child = (stat.S_IFDIR, tree.id)
if commit_message is None:
commit_message = ""
if author is not None:
author = author.encode(self._encoding)
self.repo.do_commit(
ref=self.ref, message=commit_message.encode(self._encoding),
author=author, tree=child[1])
def list_directory(self, directory_path):
"""Return a list of File objects for in the directory path.
If the path doesn't exist, returns None. If the path exists but is
empty, an empty list is returned. Otherwise a list of File objects in
that directory.
"""
if directory_path is None:
directory_path = ''
else:
directory_path = directory_path.strip(posixpath.sep)
commit_id, root_id = self._get_root()
if directory_path == '':
sha = root_id
mode = stat.S_IFDIR
else:
if root_id is None:
return None
try:
(mode, sha) = tree_lookup_path(
self.store.__getitem__,
root_id, directory_path.encode(self._encoding))
except KeyError:
return None
if mode is not None and stat.S_ISDIR(mode):
ret = []
for (name, mode, sha) in self.store[sha].items():
ret.append(
File(self.store, mode, sha,
posixpath.join(
directory_path, name.decode(self._encoding)),
commit_id, encoding=self._encoding))
return ret
else:
return None
@implementer(IFile)
class File(object):
"""A Git file object."""
def __init__(self, store, mode, sha, path, commit_sha, encoding):
self.store = store
self.encoding = encoding
self.mode = mode
self.sha = sha
self.path = path
self.commit_sha = commit_sha
self.base_name = posixpath.basename(path)
self.mimetype = mimetypes.guess_type(self.base_name)[0]
@property
def file_type(self):
"""Work out the filetype based on the mimetype if possible."""
if self._is_directory:
return FileType.DIRECTORY
else:
if self.mimetype is None:
binary = self._is_binary
else:
binary = not self.mimetype.startswith('text/')
if binary:
return FileType.BINARY_FILE
else:
return FileType.TEXT_FILE
def get_content(self):
o = self.store[self.sha]
if isinstance(o, Blob):
return o.data
else:
return None
@property
def _is_directory(self):
return stat.S_ISDIR(self.mode)
@property
def _is_binary(self):
return b'\0' in self.get_content()
def _get_last_modified_commit(self):
walker = Walker(
self.store, include=[self.commit_sha],
paths=[self.path.encode(self.encoding)])
return next(iter(walker)).commit
@property
def last_modified_in_revision(self):
return self.sha
@property
def last_modified_by(self):
return self._get_last_modified_commit().author.decode(self.encoding)
@property
def last_modified_date(self):
c = self._get_last_modified_commit()
return datetime.datetime.utcfromtimestamp(c.commit_time)
python-wikkid_0.4.orig/wikkid/filestore/volatile.py 0000644 0000000 0000000 00000011424 14160200415 017567 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""A volatile filestore.
Used primarily for test purposes, this class should be a fully functional
filestore, albiet one that doesn't remember anything persistently.
"""
from datetime import datetime
from itertools import count
from breezy.urlutils import dirname
from zope.interface import implementer
from wikkid.filestore import FileExists
from wikkid.filestore.basefile import BaseFile
from wikkid.interface.filestore import FileType, IFile, IFileStore
@implementer(IFileStore)
class FileStore(object):
"""A filestore that just uses an internal map to store data."""
def __init__(self, files=None):
"""Files is a list of tuples.
If the content is None, the path is assumed to be a directory. If the
content contains a null character, the file is considered binary.
"""
self._integer = count(1)
self.file_id_map = {}
self.path_map = {}
if files is None:
files = []
user = 'First User {0} ".format(cgi.escape(text))
python-wikkid_0.4.orig/wikkid/formatter/registry.py 0000644 0000000 0000000 00000004626 14160200415 017635 0 ustar 00 # -*- coding: utf-8 -*-
#
# Copyright (C) 2010 Wikkid Developers
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""The formatter registry is able to return formatters by name."""
import re
from wikkid.formatter.pygmentsformatter import PygmentsFormatter
from wikkid.formatter.restformatter import RestructuredTextFormatter
# Both textile and markdown are optional.
try:
from wikkid.formatter.markdownformatter import MarkdownFormatter
has_markdown = True
except ImportError:
has_markdown = False
try:
from wikkid.formatter.textileformatter import TextileFormatter
has_textile = True
except ImportError:
has_textile = False
class FormatterRegistry(object):
"""Has a dictionary of formatters based on name."""
def __init__(self):
self.formatters = {
'pygments': PygmentsFormatter(),
'rest': RestructuredTextFormatter(),
}
if has_markdown:
self.formatters['markdown'] = MarkdownFormatter()
if has_textile:
self.formatters['textile'] = TextileFormatter()
def __getitem__(self, formatter):
return self.formatters[formatter]
formatter_registry = FormatterRegistry()
def get_formatter(name):
"""Get a formatter by name."""
return formatter_registry[name]
FORMAT_MATCHER = re.compile(r'^#\s+(\w+).*$')
def get_wiki_formatter(content: str, default_formatter: str) -> str:
"""Choose a wiki formatter based on the first line of content.
Args:
content: The content of the file.
default_formatter: The name of the default formatter.
The first line of the content may specify a formatter using the form:
# formatter-name
For example:
# pygments
The first line must start with a # and the first word must specify
a formatter name. If niether of those match, the default_formatter
is returned. If the default_formatter doesn't exist, a key error
is raised.
"""
end_of_line = content.find('\n')
match = FORMAT_MATCHER.match(content[:end_of_line])
if match is not None:
try:
name = match.group(1).lower()
formatter = formatter_registry[name]
return content[end_of_line + 1:], formatter
except KeyError:
# Fall through to returning the default.
pass
return content, formatter_registry[default_formatter]
python-wikkid_0.4.orig/wikkid/formatter/restformatter.py 0000644 0000000 0000000 00000001324 14160200415 020656 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""A text to html formatter using reStuctured Text."""
from docutils.core import publish_parts
from zope.interface import implementer
from wikkid.interface.formatter import ITextFormatter
@implementer(ITextFormatter)
class RestructuredTextFormatter(object):
"""Format text as HTML using restructured text."""
def format(self, filename, text):
"""Format the text.
I'm almost 100% positive that this method needs more args.
"""
parts = publish_parts(text, writer_name='html')
return parts['html_title'] + parts['body']
python-wikkid_0.4.orig/wikkid/formatter/textileformatter.py 0000644 0000000 0000000 00000001073 14160200415 021360 0 ustar 00 # -*- coding: utf-8 -*-
#
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""A text to html formatter using textile."""
from textile import textile
from zope.interface import implementer
from wikkid.interface.formatter import ITextFormatter
@implementer(ITextFormatter)
class TextileFormatter(object):
"""Format source files as HTML using textile."""
def format(self, filename, text):
"""Format the text.
"""
return textile(text)
python-wikkid_0.4.orig/wikkid/interface/__init__.py 0000644 0000000 0000000 00000000277 11372503456 017474 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""Interfaces for the Wikkid Wiki."""
python-wikkid_0.4.orig/wikkid/interface/filestore.py 0000644 0000000 0000000 00000006060 14160200415 017710 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""Interfaces relating to filestores."""
from zope.interface import Attribute, Interface
class IFileStore(Interface):
"""A file store is how pages are accessed and updated.
This interface defines methods for getting file contents, checking to see
if the file exists, updating files, checking differences, and many other
wiki type thiings.
"""
def get_file(path):
"""Return an object representing the file at specified path."""
def update_file(path, content, author, parent_revision,
commit_message=None):
"""Update a text file at the given path with the content.
:param path: The path of the file.
:param content: The content of the file.
:param author: Who is doing the updating.
:type author: String
:param parent_revision: The revision that the user was editing when
they made the changes. For a new revision this parameter will be
None.
:type parent_revision: String
:param commit_message: An optional commit message. If one isn't
provided, then some sensible default will be used.
"""
def list_directory(path):
"""Return a list of IFile objects.
Each of the IFile objects will be directly in the directory specified
by the path.
If the specified path is None, the files in the root directory of the
branch are returned.
If the specified path doesn't exist, None is returned.
If the specified path exists but has no files, an empty list is
returned.
"""
class FileType(object):
"""Package lazr.enum and use an Enumerated Type."""
MISSING = 1 # The file at the address does not exist.
WIKI_PAGE = 2 # The resource is a wiki page.
DIRECTORY = 3 # The resource is a directory.
TEXT_FILE = 4 # A text file that isn't a wiki page.
BINARY_FILE = 5 # A (most likely) binary file.
class IFile(Interface):
"""A file from the file store."""
path = Attribute(
"The full path of the page with respect to the root of the "
"file store.")
base_name = Attribute("The last part of the path.")
file_type = Attribute("Soon to be a Choice with a lazr.enum.")
mimetype = Attribute(
"The guessed mimetype for the file. Directories don't have a "
"mimetype.")
last_modified_in_revision = Attribute(
"The revision id of the last revision that this file was "
"modified in.")
last_modified_by = Attribute("The person who last modified the file.")
last_modified_date = Attribute(
'The timestamp of the revision that last modified the file. '
'This is a naive datetime object in UTC.')
def get_content():
"""Get the contents of the file.
:return: None if the file doesn't yet exist, or u'' if the file is
empty, otherwise the unicode content of the file.
"""
python-wikkid_0.4.orig/wikkid/interface/formatter.py 0000644 0000000 0000000 00000000642 11372503456 017734 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""Interface for the text formatters."""
from zope.interface import Interface
class ITextFormatter(Interface):
"""A text formatter takes plain text and makes HTML of some form."""
def format(filename, text):
"""Takes text, and returns HTML."""
python-wikkid_0.4.orig/wikkid/interface/resource.py 0000644 0000000 0000000 00000006437 11410375636 017570 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""Interfaces for the different resource types."""
from zope.interface import Attribute, Interface
class IDefaultPage(Interface):
"""A marker interface for the default wiki page."""
class IResource(Interface):
"""The base resource interface."""
path = Attribute('The full path for the resource.')
preferred_path = Attribute('The preferred path for the resource.')
write_filename = Attribute(
'The full path of the file to write to in the filestore. '
'This is either the filename as it directly corresponds to the '
'path, or a related wiki page location.')
root_resource = Attribute(
'The root resource is the object that represents the root of the wiki.'
)
default_resource = Attribute(
'The default resource is the default wiki page.'
)
class IUpdatableResource(IResource):
"""Reflects either a file either missing or actual."""
def put_bytes(bytes, committer, rev_id, commit_msg):
"""Update the content of the resource with the bytes specified.
:param bytes: A byte string reflecting the new file content.
:param committer: The committer string that will be used.
:param rev_id: The base revision id for the text being edited.
None when adding a new file.
:param commit_msg: The message to associate with this edit.
"""
class IFileResource(IUpdatableResource):
"""A resource that relates to a file in the filestore."""
# TODO: think of a better variable name.
file_resource = Attribute(
'An IFile representing the file in the filestore.')
mimetype = Attribute('The mimetype of the file.')
def get_bytes():
"""Returns the bytes of the binary file."""
last_modified_in_revision = Attribute(
'The revision id where the file was last modified.')
last_modified_by = Attribute(
'The author of the revision that last modified the file.')
last_modified_date = Attribute(
'The timestamp of the revision that last modified the file. '
'This is a naive datetime object in UTC.')
class IDirectoryResource(IResource):
"""A resource that relates to a file in the filestore."""
def get_dir_name():
"""Get the full directory name.
This is the full path for the directory from the root.
"""
# TODO: think of a better variable name.
dir_resource = Attribute(
'An IFile representing the directory in the filestore.')
def get_listing():
"""Returns a list of objects."""
class IRootResource(IDirectoryResource):
"""A special resource relating to the root object in the wiki."""
has_home_page = Attribute(
'True if there is a home wiki page defined.')
class IBinaryFile(IFileResource):
"""A marker interface for binary files."""
class ITextFile(IFileResource):
"""A marker interface for text files."""
class IWikiTextFile(ITextFile):
"""A marker interface for a wiki text file."""
class ISourceTextFile(ITextFile):
"""A marker interface for a non-wiki text file."""
class IMissingResource(IResource):
"""A resource that doesn't exist in the filestore."""
python-wikkid_0.4.orig/wikkid/interface/user.py 0000644 0000000 0000000 00000001467 11372503456 016715 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""Interfaces relating to users of the wiki."""
from zope.interface import Attribute, Interface
class IUserFactory(Interface):
"""A factory to create `IUser`s."""
def create(request):
"""Returns an `IUser`."""
class IUser(Interface):
"""Information about the editing user.
Note: probably implementations
- test identity
- bzr identity
- anonymous identity
- launchpad identity
- session identity
"""
email = Attribute("The user's email adderss.")
display_name = Attribute(
"The name that is shown through the user interface.")
committer_id = Attribute("The user's name and email address.")
python-wikkid_0.4.orig/wikkid/model/__init__.py 0000644 0000000 0000000 00000000364 11372503456 016631 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""Model classes for wikkid.
Model objects are those objects that the views hang off.
"""
python-wikkid_0.4.orig/wikkid/model/baseresource.py 0000644 0000000 0000000 00000002576 14160200415 017546 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""The base resource class."""
import breezy.urlutils as urlutils
from wikkid.interface.resource import IRootResource
class BaseResource(object):
"""Information about a resource."""
def __init__(self, server, path, write_filename,
file_resource, dir_resource):
self.factory = server
self.path = path
self.write_filename = write_filename
self.file_resource = file_resource
self.dir_resource = dir_resource
@property
def preferred_path(self):
return self.factory.get_preferred_path(self.path)
@property
def base_name(self):
return urlutils.basename(self.path)
@property
def dir_name(self):
return urlutils.dirname(self.path)
@property
def parent(self):
if IRootResource.providedBy(self):
return None
return self.factory.get_resource_at_path(self.dir_name)
@property
def default_resource(self):
"""Any resource should be able to get to the default resource."""
return self.factory.get_default_resource()
@property
def root_resource(self):
"""Any resource should be able to get to the root resource."""
return self.factory.get_resource_at_path('/')
python-wikkid_0.4.orig/wikkid/model/binary.py 0000644 0000000 0000000 00000001142 14160200415 016334 0 ustar 00 #
# Copyright (C) 2010 Wikkid Developers.
#
# This software is licensed under the GNU Affero General Public License
# version 3 (see the file LICENSE).
"""The binary resource class.
A binary resource is a file that isn't text. This is primarily guessed using
the mimetype library.
"""
from zope.interface import implementer
from wikkid.model.file import FileResource
from wikkid.interface.resource import IBinaryFile
@implementer(IBinaryFile)
class BinaryResource(FileResource):
"""A binary resource is a non-text file."""
def __repr__(self):
return "
| {{ item.name }} |
The directory you are looking for does not exist.
{% endblock %} {% block commands %} {% if view.user %} Edit {% endif %} {% if context.get_dir_name %} Browse {% endif %} {% endblock %} python-wikkid_0.4.orig/wikkid/skin/default/missing-page.html 0000644 0000000 0000000 00000001151 11410375636 021254 0 ustar 00 {% extends "base.html" %} {% block title %}{{ view.title }}{% endblock %} {% block content %}
The page you are looking for isn't here.
Create a new page: {{ view.title }}
{% endblock %} {% block commands %} {% if view.user %} Edit {% endif %} {% if context.get_dir_name %} Browse {% endif %} {% endblock %} python-wikkid_0.4.orig/wikkid/skin/default/page.html 0000644 0000000 0000000 00000001066 11410375636 017612 0 ustar 00 {% extends "base.html" %} {% block title %}{{ view.title }}{% endblock %} {% block content %}{{ view.content }} {% endblock %} {% block commands %} {% if view.user %} Edit {% endif %} Browse {% endblock %} {% block footer %}Last edited by {{ view.last_modified_by.display_name }} on {{ view.last_modified_date }}
{% endblock %} python-wikkid_0.4.orig/wikkid/skin/default/static/ 0000755 0000000 0000000 00000000000 11361301511 017256 5 ustar 00 python-wikkid_0.4.orig/wikkid/skin/default/static/attach.gif 0000644 0000000 0000000 00000001047 11376034245 021230 0 ustar 00 GIF89a æ ±±±¸¸¸ùùù«««¨¨¨ÖÖÖgggèèè‘‘‘yyy\\\ôôôüüüªªª¦¦¦```óóópppæææÎÎΈˆˆššš¯¯¯‹‹‹ÕÕÕœœœ···ìììçç碢¢ÞÞÞÉÉɤ¤¤dddÌÌ̳³³€€€–––fff²²²TTTööö———ïïïÔÔÔVVV©©©“““¬¬¬ããㆆ†§§§¶¶¶ŒŒŒ[[[êêêýýýµµµåååää䟟ŸÁÁÁYYYëëëîîîòòònnnøøøñññ®®®þþþÿÿÿ !ù , „€L‚ƒ‚ 15„„ 7 ("8‹L= L ‹KJ‚@)„K9 /H:6;ƒK3J*! #.‚K >%$ ƒ Ä 0ÊJKA'G + ƒDF‚B2I„&‚?E‹-4 <”L,CJë( ; python-wikkid_0.4.orig/wikkid/skin/default/static/bg-header.gif 0000644 0000000 0000000 00000000764 11376034245 021607 0 ustar 00 GIF89a O æ ðÌ3ôÙNõÜUôÙOõÜTöÞXòÔCößZ÷ãm÷âføår÷äpøåsøævùêˆõÛSùé‚ùé„öàaðÍ5ðÎ6ñÎ8ðË1òÒ@õÚRöábóÕGðÌ6ôØKó×IòÒ?÷áe÷ãiïË0ñÑ=øèòÑ>ïÊ/òÓBñÐ;ñÐ:óÔEöÞYöß[÷âg÷äqøæwñÎ7ùé…ùê†ñÏ9÷ãl÷ácóÖH÷âhøç}ùéƒôÚQó×Köà^óÕEòÓAøæyøè€øèðÌ4õÝWùê‡÷änøçzöà_øæxôØMðÌ2÷ãköß]øåtøç| !ù , O Q€C108@?#7MME>G. L - D3J 6, 4F;K+*B9H : 5<)&= $"'(2/A I!% ; python-wikkid_0.4.orig/wikkid/skin/default/static/bg-navbar.gif 0000644 0000000 0000000 00000000141 11376034245 021615 0 ustar 00 GIF89a ³ ñññþþþáááøøøåååïïïìììéééöööãããýýýúúúçççôôôÿÿÿ !ù , P$ÂŽ) ¡±Tp`(Š ; python-wikkid_0.4.orig/wikkid/skin/default/static/btn-login.gif 0000644 0000000 0000000 00000003164 11376034245 021657 0 ustar 00 GIF89aC ÷ó g’ ’ÉöÅŽD¨96² š mŠ• ˜ ƒ‡M¢Eð÷ï ‹ŠÈ„ŽÌ†ŠÆƒ‰È‚ƒÅ|O§FL¬AM¥EtÇlˆÁƒPGâòáV³JPªF, €Äy‰ÄƒxÀpŒÊ„Ë…R®GT²I^¯U–ÎñùðsÀha¶We·\S°G=—5ˆÃƒs¾jÅä—ʒ_µV3¢&”Í?¬.Áñ¼÷ûöÅäÁÔìÑÄãÁ véõèÒèЋɄ‡½‚üþüK¯<‘χ¤ÕŸ6¢)¬Ù§ rŽz¹t°èª‡¿‚§Ö¢C¬7Æw0–&lÃbšÐ“ºîµ#ˆ pÄáÁj½cl¶e‡Ñ€*ž SÀ; t– –kÀb-‹&˜ ¯Úª™Þãòâª×¥F:\ªU€Ôp"™;§/yËp›Ò” ˜ ÈåÅT¯Jáñߘ̓,Ÿ OD&›ˆ‹ –•ÞˆŒæóå’ÔŒ‘؈F«:;´ Ö‰6¡*4¤& î÷í& ‚Ãò¾” Qº?9®#–P³F¸î²Î‡J¯? –}p¼g —>š6¹î´A§6Ý–†Ç]³SIª>R¿9K´;áðà¥âŸ§ã¡hÀ^ÐéÍ(¿ñ¹” ~‰Àâ¼²ÛØíÖrÆi;³ Çæà 'œ,§yÄrL¤E8¥*ÓêÐi½a¨×£6¯ Âó½” vŸÒ™k²d1¬jÈWH;Š1™'ŠšÜ”jÁanÃez&¢[¸L"“–Ç’pÅg8± /“&L¢F p\ÄF°ê¨eÈPL²?p½fŸÞ˜ºß¶{UµJ™Ð“:§+@ 6wÊn— F¸0j¿a¨æ ~Óm&›c¾Z4° j1®/«{ m$ !,¨ t q)¦'£ wÿÿÿÿÿÿ !ù ó , C ÿ ç (P‘ºXÈ°¡Ã‡#>¬TâÇ‚1ö ÆšŸN†ˆ I²¤É“(Mz 6,N$P1¢”솨;дô1À³§ÏŸ@ƒ ªÉÙmY@Ä‚†[àT›JµªÕ«X³jµÊ«‰ˆ˜ÒÜxƜٳhÓª]˶-[eѾ JŠ·ZæòêÝË·¯ß¿€ïD KŒ±[̸±ãÇ#Kž¼Ø•<8€èçÏ C‹ Mº´iЃ*¼0M ¼×°cËžM»¶íÛ²‹ÝÂÑ#Ü€Mê‚ N|ˆ1âÈ“Ûb#¹sçl¨ZDiõëس¯“×H»÷ìBV ÿùN^;5>í9À¾½û÷äI€¯B‚“íë«è€íC‡þõ" Àg {ÛÌPAj,ààƒF¸€<$D¨C kpB, \Hš "ÊÈ|H¨âƒ\”° Ä(ãŒ4* Ï3® 4 !O:® @+7¶ O FÒÒã56)ã(,(L TViå•È•ÈSe9tY¥–ȳA™P©%–lZeÝ çœtÖI€<Ð9tags, and markdown inserts # newlines. self.assertEqual('Simple sentence.', soup.p.string.strip()) def test_detailed_headings(self): text = dedent("""\ # Heading 1 ## Heading 2 ### Heading 3 #### Heading 4 ##### Heading 5 ###### Heading 6""") result = self.formatter.format('filename', text) soup = BeautifulSoup(result, features="lxml") self.assertEqual('Heading 1', soup.h1.string) self.assertEqual('Heading 2', soup.h2.string) self.assertEqual('Heading 3', soup.h3.string) self.assertEqual('Heading 4', soup.h4.string) self.assertEqual('Heading 5', soup.h5.string) self.assertEqual('Heading 6', soup.h6.string) def test_inline_link(self): # A paragraph containing a wiki word. text = "A link to the [FrontPage](http://127.0.0.1) helps." result = self.formatter.format('filename', text) soup = BeautifulSoup(result, features="lxml") self.assertEqual('http://127.0.0.1', soup.a['href']) def test_reference_link(self): # A paragraph containing a wiki word. text = dedent("""\ This is [an example][id] reference-style link. [id]: http://127.0.0.1 """) result = self.formatter.format('filename', text) soup = BeautifulSoup(result, features="lxml") self.assertEqual('http://127.0.0.1', soup.a['href']) def test_emphasis(self): texts = ('We can have *emphasis* and **strong** as well!', 'We can have _emphasis_ and __strong__ as well!') for text in texts: result = self.formatter.format('filename', text) soup = BeautifulSoup(result, features="lxml") self.assertEqual('emphasis', soup.em.string) self.assertEqual('strong', soup.strong.string) def test_blockquote(self): text = dedent("""\ > This is a block quoted paragraph > that spans multiple lines. """) result = self.formatter.format('filename', text) soup = BeautifulSoup(result, features="lxml") self.assertTrue(soup.blockquote is not None) def test_lists(self): text = dedent("""\ Some Text. * UL 1 * UL 2 * UL 3 Some More Text! 1. OL 1 2. OL 2 7. OL 3 """) result = self.formatter.format('filename', text) soup = BeautifulSoup(result, features="lxml") self.assertIsNot(None, soup.ul) ulNodes = soup.ul.findAll('li') self.assertEqual( ['UL 1', 'UL 2', 'UL 3'], [node.string.strip() for node in ulNodes]) self.assertIsNot(None, soup.ol) olNodes = soup.ol.findAll('li') self.assertEqual( ['OL 1', 'OL 2', 'OL 3'], [node.string.strip() for node in olNodes]) def test_code_blocks(self): text = dedent("""\ Some Normal Text. Some Code inside pre tags More Normal text. """) result = self.formatter.format('filename', text) soup = BeautifulSoup(result, features="lxml") self.assertEqual( soup.pre.code.string.strip(), 'Some Code inside pre tags') def test_hr(self): # test different HR types: texts = ('* * *', '***', '*********', '- - - -', '------------------') for text in texts: result = self.formatter.format('filename', text) soup = BeautifulSoup(result, features="lxml") self.assertIsNot(None, soup.hr) def test_code(self): text = 'use the `printf()` function' result = self.formatter.format('filename', text) soup = BeautifulSoup(result, features="lxml") self.assertEqual('printf()', soup.code.string) def test_unicode(self): # Test the unicode support of the markdown formatter. text = u'\N{SNOWMAN}' result = self.formatter.format('format', text) soup = BeautifulSoup(result, features="lxml") self.assertEqual(soup.p.string.strip(), text) python-wikkid_0.4.orig/wikkid/tests/formatters/test_registry.py 0000644 0000000 0000000 00000004240 14160200415 022211 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers. # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """Tests for wikkid.formatter.registry.""" from textwrap import dedent from wikkid.formatter.registry import get_wiki_formatter from wikkid.tests import TestCase class TestGetWikiFormtter(TestCase): """Tests for get_wiki_formatter.""" def test_default_missing(self): self.assertRaises( KeyError, get_wiki_formatter, 'some content', 'missing') def test_default_exists(self): content, formatter = get_wiki_formatter( 'some content', 'rest') self.assertEqual('some content', content) self.assertEqual( 'RestructuredTextFormatter', formatter.__class__.__name__) def test_specify_missing(self): content, formatter = get_wiki_formatter( dedent("""\ # missing some content """), 'rest') self.assertEqual('# missing\nsome content\n', content) self.assertEqual( 'RestructuredTextFormatter', formatter.__class__.__name__) def test_specify_extra_whitespace(self): content, formatter = get_wiki_formatter( dedent("""\ #\t\tpygments some content """), 'rest') self.assertEqual('some content\n', content) self.assertEqual('PygmentsFormatter', formatter.__class__.__name__) def test_specify_extra_params(self): content, formatter = get_wiki_formatter( dedent("""\ # pygments extra params some content """), 'rest') self.assertEqual('some content\n', content) self.assertEqual('PygmentsFormatter', formatter.__class__.__name__) def test_specify_pygments_case_insensitive(self): content, formatter = get_wiki_formatter( dedent("""\ # pygments some content """), 'rest') self.assertEqual('some content\n', content) self.assertEqual('PygmentsFormatter', formatter.__class__.__name__) python-wikkid_0.4.orig/wikkid/tests/formatters/test_rest.py 0000644 0000000 0000000 00000001734 14336241273 021337 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers. # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """Tests for the wikkid.formatter.rest module.""" from textwrap import dedent from bs4 import BeautifulSoup from wikkid.formatter.restformatter import RestructuredTextFormatter from wikkid.tests import TestCase class TestRestructuredTextFormatter(TestCase): """Tests for the ReST formatter.""" def setUp(self): TestCase.setUp(self) self.formatter = RestructuredTextFormatter() def test_simple_text(self): # A simple heading and a paragraph. text = dedent("""\ Nice Heading ============ Simple sentence. """) result = self.formatter.format('filename', text) soup = BeautifulSoup(result, features="lxml") self.assertEqual('Nice Heading', soup.h1.string) self.assertEqual('Simple sentence.', soup.p.string) python-wikkid_0.4.orig/wikkid/tests/formatters/test_textile.py 0000644 0000000 0000000 00000007276 14160200415 022033 0 ustar 00 # -*- coding: utf-8 -*- # Copyright (C) 2010 Wikkid Developers. # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """Tests for the wikkid.formatter.textileformatter module.""" from textwrap import dedent from bs4 import BeautifulSoup # The textile formatter is optional. If the MarkdownFormatter is not # available, the tests are skipped. try: from wikkid.formatter.textileformatter import TextileFormatter has_textile = True except ImportError: has_textile = False from wikkid.tests import TestCase class TestTextileFormatter(TestCase): """Tests for the textile formatter.""" def setUp(self): TestCase.setUp(self) if has_textile: self.formatter = TextileFormatter() else: self.skip('textile formatter not available') def test_detailed_headings(self): text = dedent("""\ h1. Heading 1 h2. Heading 2 h3. Heading 3 h4. Heading 4 h5. Heading 5 h6. Heading 6 """) result = self.formatter.format('filename', text) soup = BeautifulSoup(result) self.assertEqual('Heading 1', soup.h1.string) self.assertEqual('Heading 2', soup.h2.string) self.assertEqual('Heading 3', soup.h3.string) self.assertEqual('Heading 4', soup.h4.string) self.assertEqual('Heading 5', soup.h5.string) self.assertEqual('Heading 6', soup.h6.string) def test_inline_link(self): # A paragraph containing a wiki word. text = 'A link to the "FrontPage":http://127.0.0.1 helps.' result = self.formatter.format('filename', text) soup = BeautifulSoup(result) self.assertEqual('http://127.0.0.1', soup.a['href']) def test_emphasis(self): text = 'We can have _emphasis_ and *strong* as well!' result = self.formatter.format('filename', text) soup = BeautifulSoup(result) self.assertEqual('emphasis', soup.em.string) self.assertEqual('strong', soup.strong.string) def test_blockquote(self): text = dedent('''\ Some Text bq. This is a block quoted paragraph that spans multiple lines. Some more text. ''') result = self.formatter.format('filename', text) soup = BeautifulSoup(result) self.assertTrue(soup.blockquote is not None) def test_lists(self): text = dedent('''\ Some Text. * UL 1 * UL 2 * UL 3 Some More Text! # OL 1 # OL 2 # OL 3 ''') result = self.formatter.format('filename', text) soup = BeautifulSoup(result) self.assertTrue(soup.ul) ulNodes = soup.ul.findAll('li') for i in range(3): self.assertEqual('UL %d' % (i+1), ulNodes[i].string.strip()) self.assertTrue(soup.ol) olNodes = soup.ol.findAll('li') for i in range(3): self.assertEqual('OL %d' % (i+1), olNodes[i].string.strip()) def test_code_blocks(self): text = dedent('''\ Some Normal Text. @Some Code inside pre tags@ More Normal text. ''') result = self.formatter.format('filename', text) soup = BeautifulSoup(result) self.assertEqual(soup.code.string.strip(), 'Some Code inside pre tags') def test_unicode(self): # Test the unicode support of the textile formatter. text = u'\N{SNOWMAN}' result = self.formatter.format('format', text) soup = BeautifulSoup(result) self.assertEqual(soup.p.string.strip(), text) python-wikkid_0.4.orig/wikkid/tests/views/__init__.py 0000644 0000000 0000000 00000001021 11410375636 020017 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers. # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """The wikkid tests for the wikkid.view package.""" import unittest def test_suite(): names = [ 'breadcrumbs', 'utils', 'edit', 'root', 'urls', 'view', ] module_names = ['wikkid.tests.views.test_' + name for name in names] loader = unittest.TestLoader() return loader.loadTestsFromNames(module_names) python-wikkid_0.4.orig/wikkid/tests/views/test_breadcrumbs.py 0000644 0000000 0000000 00000011216 14160200415 021602 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers. # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """Tests the breadcrumbs for the views.""" from wikkid.tests.factory import ViewTestCase from wikkid.tests.fakes import TestRequest, TestUser class TestBreadcrumbs(ViewTestCase): """The breadcrumbs lead the user back home.""" # Don't test the breadcrumbs for the root object directly here as it will # redirect to Home. TODO: add a test browser test for this. def setUp(self): super(TestBreadcrumbs, self).setUp() self.user = TestUser('test@example.com', 'Test User') self.request = TestRequest() def assertBreadcrumbs(self, view, expected): """Make sure the breadcrumbs from view are the expected ones.""" crumbs = [(crumb.title, crumb.path) for crumb in view.breadcrumbs] self.assertEqual(expected, crumbs) def test_home_missing(self): # If the Home page is selected, but there is no content, the # breadcrumb is still Home. factory = self.make_factory() view = self.get_view(factory, '/Home') self.assertBreadcrumbs( view, [('Home', '/Home')]) def test_page_missing(self): # If the page is at the root of the tree, but isn't home, then the # first breadcrumb is home, and the second is the page. factory = self.make_factory() view = self.get_view(factory, '/SamplePage') self.assertBreadcrumbs( view, [('Home', '/Home'), ('Sample Page', '/SamplePage')]) def test_nested_page_missing(self): # If the Home page is selected, but there is no content, the # breadcrumb is still Home. factory = self.make_factory() view = self.get_view(factory, '/SamplePage/SubPage/Next') self.assertBreadcrumbs( view, [('Home', '/Home'), ('Sample Page', '/SamplePage'), ('Sub Page', '/SamplePage/SubPage'), ('Next', '/SamplePage/SubPage/Next')]) def test_source_file_missing(self): # If a non-wiki style name is selected, the breadcrumbs are as a wiki # page. factory = self.make_factory() view = self.get_view(factory, '/wikkid/views/base.py') self.assertBreadcrumbs( view, [('Home', '/Home'), ('wikkid', '/wikkid'), ('views', '/wikkid/views'), ('base.py', '/wikkid/views/base.py')]) def test_source_file_existing(self): # If the Home page is selected, but there is no content, the # breadcrumb is still Home. factory = self.make_factory([ ('wikkid/views/base.py', 'A python file'), ]) view = self.get_view(factory, '/wikkid/views/base.py') self.assertBreadcrumbs( view, [('Home', '/Home'), ('wiki root', '/+listing'), ('wikkid', '/wikkid/+listing'), ('views', '/wikkid/views/+listing'), ('base.py', '/wikkid/views/base.py')]) def test_directory_breadcrumbs_root(self): # Directory breadcrumbs start with Home, and then list the # directories, where the urls for the directories are the listing # urls. factory = self.make_factory() view = self.get_view(factory, '/', 'listing') self.assertBreadcrumbs( view, [('Home', '/Home'), ('wiki root', '/+listing')]) def test_directory_breadcrumbs_nested(self): # For each directory after the root, a listing crumb is added. # Names are not wiki expanded. factory = self.make_factory([ ('SomePage/SubPage/Nested.txt', 'some text')]) view = self.get_view(factory, '/SomePage/SubPage', 'listing') self.assertBreadcrumbs( view, [('Home', '/Home'), ('wiki root', '/+listing'), ('SomePage', '/SomePage/+listing'), ('SubPage', '/SomePage/SubPage')]) def test_directory_breadcrumbs_nested_with_script_name(self): # For each directory after the root, a listing crumb is added. # Names are not wiki expanded. factory = self.make_factory([ ('SomePage/SubPage/Nested.txt', 'some text')]) view = self.get_view( factory, '/SomePage/SubPage', 'listing', '/p/wiki') self.assertBreadcrumbs( view, [('Home', '/p/wiki/Home'), ('wiki root', '/p/wiki/+listing'), ('SomePage', '/p/wiki/SomePage/+listing'), ('SubPage', '/p/wiki/SomePage/SubPage')]) python-wikkid_0.4.orig/wikkid/tests/views/test_edit.py 0000644 0000000 0000000 00000002050 11410375636 020247 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers. # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """Tests the edit views.""" from wikkid.tests.factory import ViewTestCase from wikkid.tests.fakes import TestUser class TestEdit(ViewTestCase): """Test the edit view.""" def setUp(self): super(TestEdit, self).setUp() self.user = TestUser('test@example.com', 'Test User') def test_title_nested(self): """Test that a nested page returns the expected title""" factory = self.make_factory([ ('SomePage/SubPage/Nested.txt', 'some text')]) view = self.get_view(factory, '/SomePage/SubPage', 'edit') self.assertEqual('Editing "Sub Page"', view.title) def test_urls(self): """Check the urls for saving and cancel.""" factory = self.make_factory() view = self.get_view(factory, '/NewPage', 'edit') self.assertEqual('/NewPage', view.cancel_url) self.assertEqual('/NewPage/+save', view.save_url) python-wikkid_0.4.orig/wikkid/tests/views/test_root.py 0000644 0000000 0000000 00000004020 14336241273 020303 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers. # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """Test views for the root object.""" from bs4 import BeautifulSoup from testtools.matchers import Equals from webob.exc import HTTPSeeOther from wikkid.skin.loader import Skin from wikkid.tests.factory import ViewTestCase class TestRootViews(ViewTestCase): """Test the views on the root object.""" def test_root_redirects(self): """Going to / redirects to the Home page.""" factory = self.make_factory() view = self.get_view(factory, '/') error = self.assertRaises( HTTPSeeOther, view.render, None) self.assertEqual('/Home', error.headers['Location']) def test_root_redirects_with_script_name(self): """Redirection works and respects the script name""" factory = self.make_factory() view = self.get_view(factory, '/', base_url='/p/test') error = self.assertRaises( HTTPSeeOther, view.render, None) self.assertEqual('/p/test/Home', error.headers['Location']) def test_home_rendering(self): """Render the home page and test the elements.""" factory = self.make_factory() view = self.get_view(factory, '/Home') content = view.render(Skin('default')) soup = BeautifulSoup(content.text, features="lxml") [style] = soup.find_all('link', {'rel': 'stylesheet'}) self.assertThat(style['href'], Equals('/static/default.css')) def test_home_rendering_with_script_name(self): """Render the home page and test the elements.""" factory = self.make_factory() view = self.get_view(factory, '/Home', base_url='/p/test') content = view.render(Skin('default')) soup = BeautifulSoup(content.text, features="lxml") [style] = soup.find_all('link', {'rel': 'stylesheet'}) self.assertThat(style['href'], Equals('/p/test/static/default.css')) python-wikkid_0.4.orig/wikkid/tests/views/test_urls.py 0000644 0000000 0000000 00000010052 14160200415 020273 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers. # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """Tests the edit views.""" from testtools.matchers import Equals from webob import Request from wikkid.tests import TestCase from wikkid.tests.factory import FactoryTestCase from wikkid.view.urls import canonical_url, parse_url class TestCanonicalUrl(FactoryTestCase): """Test the wikkid.view.base.canonical_url.""" def assertUrl(self, resource, url, view_name=None, base_url=None): request = Request.blank('/', base_url=base_url) self.assertThat(canonical_url(resource, request, view_name), Equals(url)) def test_root(self): factory = self.make_factory() root = factory.get_resource_at_path('/') self.assertUrl(root, '/') def test_root_listing(self): factory = self.make_factory() root = factory.get_resource_at_path('/') self.assertUrl(root, '/+listing', view_name='listing') def test_default(self): factory = self.make_factory([ ('Home.txt', 'Some content'), ]) root = factory.get_resource_at_path('/') self.assertUrl(root.default_resource, '/Home') def test_default_view(self): factory = self.make_factory([ ('Home.txt', 'Some content'), ]) root = factory.get_resource_at_path('/') self.assertUrl(root.default_resource, '/Home/+edit', view_name='edit') def test_wiki_page(self): factory = self.make_factory([ ('SomeDir/SomePage.txt', 'Some content'), ]) page = factory.get_resource_at_path('/SomeDir/SomePage') self.assertUrl(page, '/SomeDir/SomePage') def test_wiki_page_view(self): factory = self.make_factory([ ('SomeDir/SomePage.txt', 'Some content'), ]) page = factory.get_resource_at_path('/SomeDir/SomePage') self.assertUrl(page, '/SomeDir/SomePage/+edit', view_name='edit') def test_wiki_page_full_url(self): factory = self.make_factory([ ('SomeDir.txt', 'Some content'), ]) page = factory.get_resource_at_path('/SomeDir.txt') self.assertUrl(page, '/SomeDir') def test_wiki_page_full_url_with_view(self): factory = self.make_factory([ ('SomeDir.txt', 'Some content'), ]) page = factory.get_resource_at_path('/SomeDir.txt') self.assertUrl(page, '/SomeDir/+edit', view_name='edit') def test_other_file(self): factory = self.make_factory([ ('simple.py', '#!/usr/bin/python'), ]) page = factory.get_resource_at_path('/simple.py') self.assertUrl(page, '/simple.py') def test_other_file_view(self): factory = self.make_factory([ ('simple.py', '#!/usr/bin/python'), ]) page = factory.get_resource_at_path('/simple.py') self.assertUrl(page, '/simple.py/+edit', view_name='edit') def test_missing(self): factory = self.make_factory() missing = factory.get_resource_at_path('/MissingPage') self.assertUrl(missing, '/MissingPage') def test_missing_view(self): factory = self.make_factory() missing = factory.get_resource_at_path('/MissingPage') self.assertUrl(missing, '/MissingPage/+edit', view_name='edit') class TestParseUrl(TestCase): """Tests for wikkid.view.base.parse_url.""" def test_root(self): path, view = parse_url('/') self.assertEqual('/', path) self.assertIs(None, view) def test_root_view(self): path, view = parse_url('/+listing') self.assertEqual('/', path) self.assertEqual('listing', view) def test_path(self): path, view = parse_url('/some/path') self.assertEqual('/some/path', path) self.assertIs(None, view) def test_path_view(self): path, view = parse_url('/some/path/+view') self.assertEqual('/some/path', path) self.assertEqual('view', view) python-wikkid_0.4.orig/wikkid/tests/views/test_utils.py 0000644 0000000 0000000 00000003041 11372503456 020463 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers. # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """Tests for the wikkid.view module.""" from testtools import TestCase from wikkid.view.utils import expand_wiki_name, title_for_filename class TestExpandWikiName(TestCase): """Tests for expand_wiki_name.""" def test_expand_wiki_name(self): self.assertEqual('simple.txt', expand_wiki_name('simple.txt')) self.assertEqual('nonMatching', expand_wiki_name('nonMatching')) self.assertEqual('README', expand_wiki_name('README')) self.assertEqual('Home', expand_wiki_name('Home')) self.assertEqual('Front Page', expand_wiki_name('FrontPage')) self.assertEqual('FrontPage.txt', expand_wiki_name('FrontPage.txt')) self.assertEqual('A Simple Page', expand_wiki_name('ASimplePage')) self.assertEqual('FTP Example', expand_wiki_name('FTPExample')) self.assertEqual( 'A Simple FTP Example', expand_wiki_name('ASimpleFTPExample')) class TesttitleForFilename(TestCase): """Tests for title_for_filename.""" def test_title_for_filename(self): self.assertEqual('simple', title_for_filename('simple.txt')) self.assertEqual('simple.cpp', title_for_filename('simple.cpp')) self.assertEqual('Front Page', title_for_filename('FrontPage')) self.assertEqual('Front Page', title_for_filename('FrontPage.txt')) self.assertEqual('FrontPage.cpp', title_for_filename('FrontPage.cpp')) python-wikkid_0.4.orig/wikkid/tests/views/test_view.py 0000644 0000000 0000000 00000001761 11410375636 020304 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers. # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """Tests the display views.""" from wikkid.tests.factory import ViewTestCase class TestView(ViewTestCase): """Test the display view.""" def test_wiki_last_modified_by(self): """Test that the last committer is displayed properly""" factory = self.make_factory([ ('SomePage/SubPage/Nested.txt', 'some text')]) view = self.get_view(factory, '/SomePage/SubPage/Nested', 'view') user = view.last_modified_by self.assertEqual('First User', user.display_name) def test_other_last_modified_by(self): """Test that the last committer is displayed properly""" factory = self.make_factory([ ('test.py', 'some text')]) view = self.get_view(factory, '/test.py') user = view.last_modified_by self.assertEqual('First User', user.display_name) python-wikkid_0.4.orig/wikkid/user/__init__.py 0000644 0000000 0000000 00000000267 11372503456 016511 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """User classes for wikkid.""" python-wikkid_0.4.orig/wikkid/user/baseuser.py 0000644 0000000 0000000 00000000776 14160200415 016553 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """The base user implementation. Provides the gravatar support. """ import hashlib class BaseUser(object): @property def gravatar(self): url = "http://www.gravatar.com/avatar/" data = self.email.lower().encode('utf-8', 'replace') url += hashlib.md5(data).hexdigest() url += "?s=50&d=identicon" return url python-wikkid_0.4.orig/wikkid/user/bzr.py 0000644 0000000 0000000 00000003661 14160200415 015533 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """A user factory and user class which uses the bzr identity from the local bazaar config.""" import email import logging from webob import Request from zope.interface import implementer from wikkid.interface.user import IUser, IUserFactory from wikkid.user.baseuser import BaseUser def create_bzr_user_from_author_string(author): name, address = email.utils.parseaddr(author) if name: display_name = name else: display_name = address return User(address, display_name, author) class LocalBazaarUserMiddleware(object): """A middleware to inject a user into the environment.""" def __init__(self, app, branch): self.app = app config = branch.get_config() self.user = create_bzr_user_from_author_string(config.username()) def __call__(self, environ, start_response): environ['wikkid.user'] = self.user req = Request(environ) resp = req.get_response(self.app) return resp(environ, start_response) @implementer(IUserFactory) class UserFactory(object): """Generate a user from local bazaar config.""" def __init__(self, branch): """Use the user config from the branch.""" config = branch.get_config() self.user = create_bzr_user_from_author_string(config.username()) logger = logging.getLogger('wikkid') logger.info( 'Using bzr identity: "%s", "%s"', self.user.display_name, self.user.email) def create(self, request): """Create a User.""" return self.user @implementer(IUser) class User(BaseUser): """A user from the local bazaar config.""" def __init__(self, email, display_name, committer_id): self.email = email self.display_name = display_name self.committer_id = committer_id python-wikkid_0.4.orig/wikkid/user/git.py 0000644 0000000 0000000 00000004002 14160200415 015507 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """A user factory and user class which uses the git identity from the local Git config.""" import email import logging from webob import Request from zope.interface import implementer from wikkid.interface.user import IUser, IUserFactory from wikkid.user.baseuser import BaseUser def create_git_user_from_author_string(author): name, address = email.Utils.parseaddr(author) if name: display_name = name else: display_name = address return User(address, display_name, author) class LocalGitUserMiddleware(object): """A middleware to inject a user into the environment.""" def __init__(self, app, repo): self.app = app config = repo.get_config_stack() email = config.get(("user", ), "email") name = config.get(("user", ), "name") self.user = User(email, name, "%s <%s>" % (name, email)) def __call__(self, environ, start_response): environ['wikkid.user'] = self.user req = Request(environ) resp = req.get_response(self.app) return resp(environ, start_response) @implementer(IUserFactory) class UserFactory(object): """Generate a user from local bazaar config.""" def __init__(self, branch): """Use the user config from the branch.""" config = branch.get_config() self.user = create_git_user_from_author_string(config.username()) logger = logging.getLogger('wikkid') logger.info( 'Using git identity: "%s", "%s"', self.user.display_name, self.user.email) def create(self, request): """Create a User.""" return self.user @implementer(IUser) class User(BaseUser): """A user from the local bazaar config.""" def __init__(self, email, display_name, committer_id): self.email = email self.display_name = display_name self.committer_id = committer_id python-wikkid_0.4.orig/wikkid/view/__init__.py 0000644 0000000 0000000 00000000265 11372503456 016503 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """Views for Wikkid Wiki.""" python-wikkid_0.4.orig/wikkid/view/base.py 0000644 0000000 0000000 00000011323 14160200415 015636 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """The base view class.""" import logging from webob import Response from wikkid.dispatcher import register_view from wikkid.view.urls import canonical_url from wikkid.view.utils import title_for_filename from wikkid.interface.resource import IDefaultPage, IRootResource class BaseViewMetaClass(type): """This metaclass registers the view with the view registry.""" def __new__(cls, classname, bases, classdict): """Called when defining a new class.""" instance = type.__new__(cls, classname, bases, classdict) register_view(instance) return instance class Breadcrumb(object): """Breadcrumbs exist to give the user quick links up the path chain.""" def __init__(self, context, request, view=None, title=None): self.path = canonical_url(context, request, view) if title is None: self.title = title_for_filename(context.base_name) else: self.title = title class BaseView(object, metaclass=BaseViewMetaClass): """The base view class. This is an abstract base class. """ def __init__(self, context, request, execution_context): self.execution_context = execution_context self.context = context self.request = request if request is not None: self.user = request.environ.get('wikkid.user', None) self.logger = logging.getLogger('wikkid') def _create_breadcrumbs(self): crumbs = [Breadcrumb(self.context, self.request)] current = self.context.parent while not IRootResource.providedBy(current): crumbs.append(Breadcrumb(current, self.request)) current = current.parent # And add in the default page if the context isn't the default. if not IDefaultPage.providedBy(self.context): crumbs.append(Breadcrumb(current.default_resource, self.request)) return reversed(crumbs) def initialize(self): """Provide post-construction initialization.""" @property def breadcrumbs(self): return self._create_breadcrumbs() @property def title(self): return title_for_filename(self.context.base_name) @property def last_modified_by(self): return self.context.last_modified_by @property def last_modified_date(self): last_modified = self.context.last_modified_date if last_modified is None: return None return last_modified.strftime('%Y-%m-%d %H:%M:%S') def before_render(self): """A hook to do things before rendering.""" def canonical_url(self, context, view=None): return canonical_url(context, self.request, view) def template_args(self): """Needs to be implemented in the derived classes. :returns: A dict of values. """ return { 'view': self, 'user': self.user, 'context': self.context, 'request': self.request, 'canonical_url': self.canonical_url, } def _render(self, skin): """Get the template and render with the args. If a template isn't going to be used or provide the conent, this is the method to override. """ template = skin.get_template(self.template) content = template.render(**self.template_args()) # Return the encoded content. return self.make_response(content.encode('utf-8')) def make_response(self, body): """Construct the response object for this request. :param body: The body of the response, as a unicode string. :return: A `Response` object. """ return Response(body) def render(self, skin): """Render the page. Return a tuple of content type and content. """ self.before_render() return self._render(skin) class DirectoryBreadcrumbView(BaseView): """A view that uses the directories as breadcrumbs.""" def _create_breadcrumbs(self): crumbs = [] current = self.context view = None while not IRootResource.providedBy(current): crumbs.append(Breadcrumb( current, self.request, view, title=current.base_name)) current = current.parent # Add listings to subsequent urls. view = 'listing' # Add in the root dir. crumbs.append(Breadcrumb(current, self.request, 'listing', title='wiki root')) # And add in the default page. crumbs.append(Breadcrumb(current.default_resource, self.request)) return reversed(crumbs) python-wikkid_0.4.orig/wikkid/view/binary.py 0000644 0000000 0000000 00000001143 11410375636 016224 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """Views associated with binary files.""" from webob import Response from wikkid.interface.resource import IBinaryFile from wikkid.view.base import BaseView class BinaryFile(BaseView): """Renders a binary file with its mimetype.""" for_interface = IBinaryFile name = 'view' is_default = True def _render(self, skin): return Response( body=self.context.get_bytes(), content_type=self.context.mimetype) python-wikkid_0.4.orig/wikkid/view/directory.py 0000644 0000000 0000000 00000004546 14160200415 016741 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """View classes to control the rendering of the content.""" from wikkid.interface.resource import IDirectoryResource from wikkid.view.base import DirectoryBreadcrumbView from wikkid.view.urls import canonical_url class ListingItem(object): """An item to be shown in the directory listing.""" def __init__(self, context, request, view, css_class, name=None): self.context = context self.url = canonical_url(self.context, request, view) if name is None: name = context.base_name self.name = name self.css_class = css_class class DirectoryListingPage(DirectoryBreadcrumbView): """The directory listing shows the content in the directory. This view is shown if there is no matching wiki apge the same name as the directory (i.e. with '.txt' on the end). """ for_interface = IDirectoryResource name = 'listing' is_default = False template = 'view_directory' def before_render(self): """Get the listing and split it into directories and files.""" directories = [] files = [] for item in self.context.get_listing(): if IDirectoryResource.providedBy(item): directories.append(item) else: files.append(item) def sort_key(item): return item.base_name.lower() items = [] # If we are looking at / don't add a parent dir. if self.context.path != '/': parent = self.context.parent items.append( ListingItem(parent, self.request, 'listing', 'up', name='..')) for item in sorted(directories, key=sort_key): items.append( ListingItem(item, self.request, 'listing', 'directory')) for item in sorted(files, key=sort_key): items.append(ListingItem(item, self.request, None, 'file')) self.items = items @property def content(self): return 'Directory listing for %s' % self.path @property def title(self): """The title is just the directory path.""" dir_name = self.context.get_dir_name() if dir_name is None: return 'Wiki Root' else: return dir_name python-wikkid_0.4.orig/wikkid/view/edit.py 0000644 0000000 0000000 00000001422 11755162524 015667 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """View base class for editing text pages.""" from wikkid.view.base import BaseView from wikkid.view.utils import expand_wiki_name class BaseEditView(BaseView): """Base class for editing text.""" name = 'edit' template = 'edit_page' @property def title(self): return 'Editing "%s"' % expand_wiki_name(self.context.base_name) @property def save_url(self): """The link for the cancel button.""" return self.canonical_url(self.context, 'save') @property def cancel_url(self): """The link for the cancel button.""" return self.canonical_url(self.context) python-wikkid_0.4.orig/wikkid/view/missing.py 0000644 0000000 0000000 00000003034 11514702505 016404 0 ustar 00 # -*- coding: utf-8 -*- # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """View classes to control the rendering of the content.""" from wikkid.interface.resource import IMissingResource from wikkid.view.base import BaseView from wikkid.view.edit import BaseEditView from wikkid.view.textfile import SaveNewTextContent class BaseMissingView(BaseView): """A base view for +view and +listing. This view just makes the results actual 404s. """ def make_response(self, body): response = super(BaseMissingView, self).make_response(body) response.status = "404 Not Found" return response class MissingPage(BaseMissingView): """A wiki page that does not exist.""" for_interface = IMissingResource name = 'view' is_default = True template = 'missing' @property def content(self): '%s Not found' % self.path class MissingDirectory(BaseMissingView): """A wiki directory that does not exist.""" for_interface = IMissingResource name = 'listing' template = 'missing-dir' @property def content(self): '%s Not found' % self.path class NewWikiPage(BaseEditView): """Show the edit page with no existing content.""" for_interface = IMissingResource @property def rev_id(self): return None @property def content(self): return '' class SaveNewTextFile(SaveNewTextContent): for_interface = IMissingResource python-wikkid_0.4.orig/wikkid/view/root.py 0000644 0000000 0000000 00000001340 11755162524 015724 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """View classes for the wiki root.""" from webob.exc import HTTPSeeOther from wikkid.interface.resource import IRootResource from wikkid.view.base import BaseView class RootPage(BaseView): """The default view for the root page redirects to the home page.""" for_interface = IRootResource name = 'view' is_default = True def _render(self, skin): """Redirect to Home (or the default page).""" default_resource = self.context.default_resource location = self.canonical_url(default_resource) raise HTTPSeeOther(location=location) python-wikkid_0.4.orig/wikkid/view/sourcetext.py 0000644 0000000 0000000 00000001460 11374734156 017154 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """View classes to control the rendering of the content.""" from wikkid.formatter.pygmentsformatter import PygmentsFormatter from wikkid.interface.resource import ISourceTextFile from wikkid.view.base import DirectoryBreadcrumbView class SourceTextPage(DirectoryBreadcrumbView): """Any other non-binary file is considered other text. Will be rendered using pygments. """ for_interface = ISourceTextFile name = 'view' is_default = True template = 'view_page' @property def content(self): formatter = PygmentsFormatter() return formatter.format( self.context.base_name, self.context.get_bytes()) python-wikkid_0.4.orig/wikkid/view/textfile.py 0000644 0000000 0000000 00000005430 14160200415 016552 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """View classes to control the rendering of text pages.""" import logging from webob.exc import HTTPSeeOther from wikkid.filestore import UpdateConflicts from wikkid.interface.resource import ITextFile from wikkid.view.edit import BaseEditView from wikkid.view.wiki import format_content class EditTextFile(BaseEditView): """The page shows the text content in a large edit field.""" for_interface = ITextFile @property def rev_id(self): return self.context.last_modified_in_revision @property def content(self): # We want to pass unicode to the view. byte_string = self.context.get_bytes() try: return byte_string.decode('utf-8') except UnicodeDecodeError: try: return byte_string.decode('latin-1') except UnicodeDecodeError: return byte_string.decode('ascii', 'replace') class SaveNewTextContent(BaseEditView): """Update the text of a file.""" name = 'save' def _render(self, skin): """Save the text file. If it conflicts, render the edit, otherwise render the page (ideally redirect back to the plain page. """ # TODO: barf on a GET # TODO: barf if there is no user. params = self.request.params content = params['content'] description = params['description'] rev_id = ( params['rev-id'].encode('utf-8') if 'rev-id' in params else None) preview = params.get('preview', None) if preview is not None: self.rev_id = rev_id self.description = description self.content = content default_format = self.execution_context.default_format self.preview_content = format_content( content, self.context.base_name, default_format) else: try: self.context.put_bytes( content.encode('utf-8'), self.user.committer_id, rev_id, description) location = self.canonical_url(self.context) raise HTTPSeeOther(location=location) except UpdateConflicts as e: # Show the edit page again. logger = logging.getLogger('wikkid') logger.info('Conflicts detected: \n%r\n', e.content) self.rev_id = e.basis_rev self.content = e.content self.message = "Conflicts detected during merge." self.description = description return super(SaveNewTextContent, self)._render(skin) class UpdateTextFile(SaveNewTextContent): for_interface = ITextFile python-wikkid_0.4.orig/wikkid/view/urls.py 0000644 0000000 0000000 00000001607 14160200415 015715 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """View URL functions.""" import re VIEW_MATCHER = re.compile(r'^(.*)/\+(\w+)$') def parse_url(path): """Convert a path into a resource path and a view.""" match = VIEW_MATCHER.match(path) if match is not None: resource_path, view = match.groups() if resource_path == '': resource_path = '/' return (resource_path, view) else: return (path, None) def canonical_url(context, request, view=None): """The one true URL for the context object.""" path = context.preferred_path if view is None: return '{0}{1}'.format(request.script_name, path) else: if path == '/': path = '' return '{0}{1}/+{2}'.format(request.script_name, path, view) python-wikkid_0.4.orig/wikkid/view/utils.py 0000644 0000000 0000000 00000001561 11372503456 016104 0 ustar 00 # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """Utility methods for wikkid views.""" import re WIKI_PAGE = re.compile('^([A-Z]+[a-z]*)+$') WIKI_PAGE_ELEMENTS = re.compile('([A-Z][a-z]+)') def expand_wiki_name(name): """A wiki name like 'FrontPage' is expanded to 'Front Page'. Names that don't match wiki names are unaltered. """ if WIKI_PAGE.match(name): name_parts = [ part for part in WIKI_PAGE_ELEMENTS.split(name) if part] return ' '.join(name_parts) else: return name def title_for_filename(filename): """Generate a title based on the basename of the file object.""" if filename.endswith('.txt'): return expand_wiki_name(filename[:-4]) else: return expand_wiki_name(filename) python-wikkid_0.4.orig/wikkid/view/wiki.py 0000644 0000000 0000000 00000003637 14160200415 015700 0 ustar 00 # -*- coding: utf-8 -*- # # Copyright (C) 2010 Wikkid Developers # # This software is licensed under the GNU Affero General Public License # version 3 (see the file LICENSE). """View classes to control the rendering of wiki pages.""" from webob.exc import HTTPTemporaryRedirect from wikkid.formatter.registry import get_wiki_formatter from wikkid.interface.resource import IWikiTextFile from wikkid.view.base import BaseView def format_content(bytes, base_name, default_format): """ Format the content with the right formatter. Check the first line of the content to see if it specifies a formatter. The default is currently ReST, but we should have it configurable shortly. """ content, formatter = get_wiki_formatter(bytes, default_format) return formatter.format(base_name, content) class WikiPage(BaseView): """A wiki page is a page that is going to be rendered for viewing.""" for_interface = IWikiTextFile name = 'view' is_default = True template = 'view_page' @property def content(self): bytes = self.context.get_bytes() try: text = bytes.decode('utf-8') except UnicodeDecodeError: try: text = bytes.decode('latin-1') except UnicodeDecodeError: text = bytes.decode('ascii', 'replace') default_format = self.execution_context.default_format return format_content(text, self.context.base_name, default_format) def _render(self, skin): """If the page is not being viewed with the preferred path, redirect. For example, /FrontPage.txt will redirect to /FrontPage """ preferred = self.context.preferred_path if self.context.path != preferred: location = self.canonical_url(self.context) raise HTTPTemporaryRedirect(location=location) else: return super(WikiPage, self)._render(skin)