def check_image(filename, context):
if vfs.exists(filename) is False:
print u"(WW) The filename '%s' doesn't exist" % filename
filename = context.image_not_found_path
im = None
if filename.startswith('http://'):
# Remote file
# If the image is a remote file, we create a StringIO
# object contains the image data to avoid reportlab problems ...
data = vfs.open(filename).read()
my_file = context.get_tmp_file()
filename = my_file.name
my_file.write(data)
my_file.close()
im = Image(string=data)
if im is None:
im = ro_database.get_handler(filename, Image)
x, y = im.get_size()
if not (x or y):
print u'image not valid : %s' % filename
filename = context.image_not_found_path
im = ro_database.get_handler(filename, Image)
x, y = im.get_size()
return filename, (x, y)
def get_template_from_skin_key(self, skin_key, web_path, warning):
local_path = skin_key + web_path
# 3. Get the handler
handler = ro_database.get_handler(local_path, soft=True)
if handler:
if warning:
print warning
return handler
# 4. Not an exact match: trigger language negotiation
folder_path, name = local_path.rsplit('/', 1)
name = name + '.'
n = len(name)
languages = []
for x in lfs.get_names(folder_path):
if x[:n] == name:
language = x[n:]
if has_language(language):
languages.append(language)
if not languages:
return None
# 4.1 Get the best variant
accept = self.accept_language
language = accept.select_language(languages)
# Print Warning
if warning:
print warning
# 4.2 By default use whatever variant
# (XXX we need a way to define the default)
if language is None:
language = languages[0]
local_path = '%s.%s' % (local_path, language)
return ro_database.get_handler(local_path)
def check_image(filename, context):
if vfs.exists(filename) is False:
print u"(WW) The filename '%s' doesn't exist" % filename
filename = context.image_not_found_path
im = None
if filename.startswith('http://'):
# Remote file
# If the image is a remote file, we create a StringIO
# object contains the image data to avoid reportlab problems ...
data = vfs.open(filename).read()
my_file = context.get_tmp_file()
filename = my_file.name
my_file.write(data)
my_file.close()
im = Image(string=data)
if im is None:
im = ro_database.get_handler(filename, Image)
x, y = im.get_size()
if not (x or y):
print u'image not valid : %s' % filename
filename = context.image_not_found_path
im = ro_database.get_handler(filename, Image)
x, y = im.get_size()
return filename, (x, y)
def get_template_from_skin_key(self, skin_key, web_path, warning):
local_path = skin_key + web_path
# 3. Get the handler
handler = ro_database.get_handler(local_path, soft=True)
if handler:
if warning:
print warning
return handler
# 4. Not an exact match: trigger language negotiation
folder_path, name = local_path.rsplit('/', 1)
name = name + '.'
n = len(name)
languages = []
for x in lfs.get_names(folder_path):
if x[:n] == name:
language = x[n:]
if has_language(language):
languages.append(language)
if not languages:
return None
# 4.1 Get the best variant
accept = self.accept_language
language = accept.select_language(languages)
# Print Warning
if warning:
print warning
# 4.2 By default use whatever variant
# (XXX we need a way to define the default)
if language is None:
language = languages[0]
local_path = '%s.%s' % (local_path, language)
return ro_database.get_handler(local_path)
def make_template(source, target):
source_handler = ro_database.get_handler(source, XHTMLFile)
language = target.rsplit('.', 1)[1]
po = ro_database.get_handler('locale/%s.po' % language)
data = source_handler.translate(po)
with open(target, 'w') as f:
f.write(data)
def make_template(source, target):
source_handler = ro_database.get_handler(source, XHTMLFile)
language = target.rsplit('.', 1)[1]
po = ro_database.get_handler('locale/%s.po' % language)
data = source_handler.translate(po)
with open(target, 'w') as f:
f.write(data)
def init_resource(self, **kw):
kw['website_is_open'] = 'extranet'
# TODO allow to choose language at website creation
default_language = 'en'
# Initialize ikaaro website (Parent class)
WebSite.init_resource(self, **kw)
# Init bars
Website_BarAware.init_resource(self, **kw)
# Add a sitemap
self.make_resource('sitemap.xml', self.sitemap_class)
# Create Robots.txt
self.make_resource('robots.txt', RobotsTxt)
# Add an image folder
self.make_resource('images', Folder)
# Tags
self.make_resource('tags', self.tagsfolder_class,
language=default_language)
# Add default news folder
self.make_resource('news', self.newsfolder_class)
# About
self.make_resource('about-itws', AboutITWS,
title={default_language: MSG(u'About ITWS').gettext()})
# Add link to news in menu
theme = self.get_resource('theme')
menu = theme.get_resource('menu/menu')
menu.add_new_record({'path': '/news/',
'title': Property(MSG(u'News').gettext(),
language='en')})
# Create a 'Welcome' html-content item in ws-data
# Order this item in the contentbar
path = get_abspath(self.first_contenbar)
handler = ro_database.get_handler('%s.%s' % (path, default_language),
XHTMLFile)
ws_data = self.get_resource('ws-data')
ws_data.make_resource('welcome', HTMLContent,
title={default_language: MSG(u'Welcome').gettext()},
state='public',
display_title=True,
body=handler.to_str(),
language=default_language)
table = ws_data.get_resource('order-contentbar')
table.add_new_record({'name': 'welcome'})
# Create a 'Welcome' html-content item in repository
# Order this item in the sidebar
path = get_abspath(self.first_sidebar)
handler = ro_database.get_handler('%s.%s' % (path, default_language),
XHTMLFile)
repository = self.get_resource('repository')
repository.make_resource('first-sidebar', HTMLContent,
title={default_language: MSG(u'My first sidebar').gettext()},
state='public',
display_title=True,
body=handler.to_str(),
language=default_language)
table = ws_data.get_resource('order-sidebar')
table.add_new_record({'name': 'first-sidebar'})
def make_template(source, target):
# Import some packages so we can compile templates
from itools.html import XHTMLFile
import itools.gettext
import itools.stl
import itools.pdf
# Get file
source_handler = ro_database.get_handler(source, XHTMLFile)
language = target.rsplit('.', 1)[1]
po = ro_database.get_handler('locale/%s.po' % language)
data = source_handler.translate(po)
with open(target, 'w') as f:
f.write(data)
def _make_resource(cls, folder, name, *args, **kw):
ShopFolder._make_resource(cls, folder, name, *args, **kw)
# Image
body = lfs.open(get_abspath(cls.img)).read()
img = Image._make_resource(Image, folder,
'%s/logo.png' % name, body=body,
**{'state': 'public'})
# Load zones
shop = get_context().resource.parent
zones = []
handler = shop.get_resource('countries-zones').handler
for record in handler.get_records():
zones.append(handler.get_record_value(record, 'title'))
# Create history
cls.shipping_history_cls._make_resource(cls.shipping_history_cls,
folder, '%s/history' % name)
# Import CSV with prices
ShippingPrices._make_resource(ShippingPrices, folder,
'%s/prices' % name)
if getattr(cls, 'csv', None):
table = ShippingPricesTable()
csv = ro_database.get_handler(get_abspath(cls.csv), ShippingPricesCSV)
for row in csv.get_rows():
table.add_record(
{'zone': str(zones.index(row.get_value('zone'))),
'max-weight': row.get_value('max-weight'),
'price': row.get_value('price')})
folder.set_handler('%s/prices' % name, table)
def register_shop(package, name):
base_path = '../%s/%s' % (package, name)
# Register shop
shops.append(name)
# Import project
exec('import %s.%s' % (package, name))
# Get config
config_path = get_abspath('%s/setup.conf' % base_path)
config = ro_database.get_handler(config_path, ITWSHOPConfig)
# Register skin
register_shop_skin(u'Skin %s' % name, package, '%s/ui/' % name, name, config)
# Register domain for i18n
register_domain(name, get_abspath('%s/locale' % base_path))
# Register modules
project_modules = []
modules_path = get_abspath(join_paths(base_path, 'modules'))
if exists(modules_path) or name == 'ecox':
project_modules = [f for f in listdir(modules_path)
if isdir(get_abspath('%s/%s' % (modules_path, f)))]
for m in project_modules:
exec('import %s.%s.modules.%s' % (package, name, m))
# Print
print 'Name: ', name
print 'URL: ', config.get_value('url')
print 'Modules: [%s], %s' % (len(project_modules), project_modules)
def register_shop(package, name):
base_path = '../%s/%s' % (package, name)
# Register shop
shops.append(name)
# Import project
exec('import %s.%s' % (package, name))
# Get config
config_path = get_abspath('%s/setup.conf' % base_path)
config = ro_database.get_handler(config_path, ITWSHOPConfig)
# Register skin
register_shop_skin(u'Skin %s' % name, package, '%s/ui/' % name, name,
config)
# Register domain for i18n
register_domain(name, get_abspath('%s/locale' % base_path))
# Register modules
project_modules = []
modules_path = get_abspath(join_paths(base_path, 'modules'))
if exists(modules_path) or name == 'ecox':
project_modules = [
f for f in listdir(modules_path)
if isdir(get_abspath('%s/%s' % (modules_path, f)))
]
for m in project_modules:
exec('import %s.%s.modules.%s' % (package, name, m))
# Print
print 'Name: ', name
print 'URL: ', config.get_value('url')
print 'Modules: [%s], %s' % (len(project_modules), project_modules)
def build(parser):
# Extract options and arguments
options, args = parser.parse_args()
if len(args) != 2:
parser.error('incorrect number of arguments')
source, catalog_name = args
# The SRX file
if options.srx is not None:
srx_handler = ro_database.get_handler(options.srx)
else:
srx_handler = None
# Check for ODF files
if is_zipfile(source) and options.output is None:
parser.error('The option -o is needed\n')
# Load the source handler (check the API)
handler = ro_database.get_handler(source)
try:
translate = handler.translate
except AttributeError:
print 'Error: Unable to translate "%s", unsupported format.' % source
return
# Load the Catalog handler (check the API)
catalog = ro_database.get_handler(catalog_name)
try:
catalog.gettext
except AttributeError:
print('Error: The file "%s" is not a supported '
'catalog.') % catalog_name
return
# Translate
data = translate(catalog, srx_handler=srx_handler)
# Save
if options.output is None:
sys.stdout.write(data)
else:
output = open(options.output, 'w')
try:
output.write(data)
finally:
output.close()
def get_template(self, web_path):
web_path = normalize_path(web_path)
# 1. Find local root
web_roots = ui_registry.keys()
web_roots.sort(reverse=True)
for web_root in web_roots:
if web_path.startswith(web_root):
break
else:
raise ValueError, 'unexpected %s' % repr(web_path)
# 2. Get the local path
local_root = ui_registry[web_root]
local_path = local_root + web_path[len(web_root):]
# 3. Get the handler
handler = ro_database.get_handler(local_path, soft=True)
if handler:
return handler
# 4. Not an exact match: trigger language negotiation
folder_path, name = local_path.rsplit('/', 1)
name = name + '.'
n = len(name)
languages = []
for x in lfs.get_names(folder_path):
if x[:n] == name:
language = x[n:]
if has_language(language):
languages.append(language)
if not languages:
return None
# 4.1 Get the best variant
accept = self.accept_language
language = accept.select_language(languages)
# 4.2 By default use whatever variant
# (XXX we need a way to define the default)
if language is None:
language = languages[0]
local_path = '%s.%s' % (local_path, language)
return ro_database.get_handler(local_path)
def get_template(self, web_path):
web_path = normalize_path(web_path)
# 1. Find local root
web_roots = ui_registry.keys()
web_roots.sort(reverse=True)
for web_root in web_roots:
if web_path.startswith(web_root):
break
else:
raise ValueError, 'unexpected %s' % repr(web_path)
# 2. Get the local path
local_root = ui_registry[web_root]
local_path = local_root + web_path[len(web_root):]
# 3. Get the handler
handler = ro_database.get_handler(local_path, soft=True)
if handler:
return handler
# 4. Not an exact match: trigger language negotiation
folder_path, name = local_path.rsplit('/', 1)
name = name + '.'
n = len(name)
languages = []
for x in lfs.get_names(folder_path):
if x[:n] == name:
language = x[n:]
if has_language(language):
languages.append(language)
if not languages:
return None
# 4.1 Get the best variant
accept = self.accept_language
language = accept.select_language(languages)
# 4.2 By default use whatever variant
# (XXX we need a way to define the default)
if language is None:
language = languages[0]
local_path = '%s.%s' % (local_path, language)
return ro_database.get_handler(local_path)
def build(parser):
# Extract options and arguments
options, args = parser.parse_args()
if len(args) != 2:
parser.error('incorrect number of arguments')
source, catalog_name = args
# The SRX file
if options.srx is not None:
srx_handler = ro_database.get_handler(options.srx)
else:
srx_handler = None
# Check for ODF files
if is_zipfile(source) and options.output is None:
parser.error('The option -o is needed\n')
# Load the source handler (check the API)
handler = ro_database.get_handler(source)
try:
translate = handler.translate
except AttributeError:
print 'Error: Unable to translate "%s", unsupported format.' % source
return
# Load the Catalog handler (check the API)
catalog = ro_database.get_handler(catalog_name)
try:
catalog.gettext
except AttributeError:
print ('Error: The file "%s" is not a supported '
'catalog.') % catalog_name
return
# Translate
data = translate(catalog, srx_handler=srx_handler)
# Save
if options.output is None:
sys.stdout.write(data)
else:
output = open(options.output, 'w')
try:
output.write(data)
finally:
output.close()
def test_parameters_save(self):
table = Books(string=books_file)
table.save_state_to('tests/books')
# Load
table = ro_database.get_handler('tests/books', Books)
table.load_state()
# Test
record_0 = table.get_record(0)
value = table.get_record_value(record_0, 'title', language='es')
self.assertEqual(value, u'El Capital')
def _make_resource(cls, folder, name, *args, **kw):
OrderedTable._make_resource(cls, folder, name)
table = BaseCountriesZones()
zones = []
csv = ro_database.get_handler(get_abspath('data/countries.csv'), CSVFile)
for line in csv.get_rows():
zone = unicode(line[1], 'utf-8')
if zone not in zones:
zones.append(zone)
table.add_record({'title': Property(zone, language='fr')})
folder.set_handler(name, table)
def test_vtimezone(self):
handler = ro_database.get_handler('tests/test_vtimezone.ics', iCalendar)
tz = handler.get_components('VTIMEZONE')
self.assertEqual(len(tz), 1)
tz = tz[0]
self.assertEqual(tz.__class__, VTimezone)
self.assertTrue(isinstance(tz, tzinfo))
for dt, (tzname, dst, utcoffset) in tz_file_test:
dt = datetime(*dt, tzinfo=tz)
self.assertEqual(tz.tzname(dt), tzname)
self.assertEqual(tz.dst(dt), timedelta(*dst))
self.assertEqual(tz.utcoffset(dt), timedelta(*utcoffset))
def test_set_state_in_file_resource(self):
handler = rw_database.get_handler('tests/test.csv', CSVFile)
handler.add_row(['d1', 'e1', 'f1'])
handler.save_state()
handler2 = rw_database.get_handler('tests/test.csv', CSVFile)
self.assertEqual(handler2.get_row(3), ['d1', 'e1', 'f1'])
handler2.del_row(3)
handler2.save_state()
handler = ro_database.get_handler('tests/test.csv', CSVFile)
self.assertEqual(handler.get_nrows(), 3)
def _make_resource(cls, folder, name, *args, **kw):
OrderedTable._make_resource(cls, folder, name)
table = BaseCountriesZones()
zones = []
csv = ro_database.get_handler(get_abspath('data/countries.csv'),
CSVFile)
for line in csv.get_rows():
zone = unicode(line[1], 'utf-8')
if zone not in zones:
zones.append(zone)
table.add_record({'title': Property(zone, language='fr')})
folder.set_handler(name, table)
def test_vtimezone(self):
handler = ro_database.get_handler('tests/test_vtimezone.ics',
iCalendar)
tz = handler.get_components('VTIMEZONE')
self.assertEqual(len(tz), 1)
tz = tz[0]
self.assertEqual(tz.__class__, VTimezone)
self.assertTrue(isinstance(tz, tzinfo))
for dt, (tzname, dst, utcoffset) in tz_file_test:
dt = datetime(*dt, tzinfo=tz)
self.assertEqual(tz.tzname(dt), tzname)
self.assertEqual(tz.dst(dt), timedelta(*dst))
self.assertEqual(tz.utcoffset(dt), timedelta(*utcoffset))
def _make_resource(cls, folder, name, *args, **kw):
Table._make_resource(cls, folder, name)
# Import CSV with list of countries
zones = []
table = BaseCountries()
csv = ro_database.get_handler(get_abspath('data/countries.csv'), CSVFile)
for line in csv.get_rows():
country = unicode(line[0], 'utf-8')
zone = unicode(line[1], 'utf-8')
if zone not in zones:
zones.append(zone)
table.add_record({'title': Property(country, language='fr'),
'zone': str(zones.index(zone)),
'enabled': True})
folder.set_handler(name, table)
def view(self):
# Load the STL template
handler = ro_database.get_handler('TaskTracker_view.xml')
# Build the namespace
namespace = {}
namespace['tasks'] = []
for i, task in enumerate(self.tasks):
namespace['tasks'].append({'id': i,
'title': task.title,
'description': task.description,
'state': task.state,
'is_open': task.state == 'open'})
# Process the template and return the output
return stl(handler, namespace, mode='xhtml')
def test_save(self):
agenda = Agenda(string=agenda_file)
agenda.save_state_to('tests/agenda')
# Change
agenda = rw_database.get_handler('tests/agenda', Agenda)
fake = agenda.add_record({'firstname': u'Toto', 'lastname': u'Fofo'})
agenda.add_record({'firstname': u'Albert', 'lastname': u'Einstein'})
agenda.del_record(fake.id)
agenda.save_state()
# Test
agenda = ro_database.get_handler('tests/agenda', Agenda)
ids = [ x.id for x in agenda.search(firstname=u'Toto') ]
self.assertEqual(len(ids), 0)
ids = [ x.id for x in agenda.search(firstname=u'Albert') ]
self.assertEqual(len(ids), 1)
# Clean
lfs.remove('tests/agenda')
def view(self):
# Load the STL template
handler = ro_database.get_handler('TaskTracker_view.xml')
# Build the namespace
namespace = {}
namespace['tasks'] = []
for i, task in enumerate(self.tasks):
namespace['tasks'].append({
'id': i,
'title': task.title,
'description': task.description,
'state': task.state,
'is_open': task.state == 'open'
})
# Process the template and return the output
return stl(handler, namespace, mode='xhtml')
def _make_resource(cls, folder, name, *args, **kw):
Table._make_resource(cls, folder, name)
# Import CSV with list of countries
zones = []
table = BaseCountries()
csv = ro_database.get_handler(get_abspath('data/countries.csv'),
CSVFile)
for line in csv.get_rows():
country = unicode(line[0], 'utf-8')
zone = unicode(line[1], 'utf-8')
if zone not in zones:
zones.append(zone)
table.add_record({
'title': Property(country, language='fr'),
'zone': str(zones.index(zone)),
'enabled': True
})
folder.set_handler(name, table)
def init_resource(self, **kw):
# Init resource
BaseTheme.init_resource(self, **kw)
# Get language
website = self.parent
language = website.get_default_language()
# Banner (background set with CSS)
path = get_abspath("data/k2-banner-ties.jpg")
image = ro_database.get_handler(path, FileHandler)
self.make_resource(
"banner-itws",
Image,
body=image.to_str(),
extension="jpg",
filename="banner-itws.jpg",
format="image/jpeg",
state="public",
)
# Set banner title
vhosts = website.get_property("vhosts")
if vhosts:
banner_title = vhosts[0]
else:
banner_title = website.get_title()
self.set_property("banner_title", banner_title, language=language)
# CSS file
# TODO Add an API in ikaaro that allow to easily change CSS...
path = get_abspath("ui/themes/style.css")
body = open(path).read()
style = self.get_resource("style")
style.handler.load_state_from_string(body)
style.handler.set_changed()
# Custom 404
self.make_resource("404", NotFoundPage)
# Add footer
self.make_resource("footer", FooterFolder)
menu = self.get_resource("footer/menu")
title = Property(MSG(u"Powered by itws").gettext(), language=language)
menu.add_new_record({"title": title, "path": "/about-itws"})
title = Property(MSG(u"Contact us").gettext(), language=language)
menu.add_new_record({"title": title, "path": "/;contact"})
# Turning footer
self.make_resource("turning-footer", TurningFooterFolder)
def get_available_languages(self):
"""Returns the language codes for the user interface.
"""
source = itools_source_language
target = itools_target_languages
# A package based on itools
cls = self.__class__
if cls is not Root:
exec('import %s as pkg' % cls.__module__.split('.', 1)[0])
config = Path(pkg.__path__[0]).resolve_name('setup.conf')
config = ro_database.get_handler(str(config), ConfigFile)
source = config.get_value('source_language', default=source)
target = config.get_value('target_languages', default=target)
target = target.split()
if source in target:
target.remove(source)
target.insert(0, source)
return target
def init_resource(self, **kw):
# Init resource
BaseTheme.init_resource(self, **kw)
# Get language
website = self.parent
language = website.get_default_language()
# Banner (background set with CSS)
path = get_abspath('data/k2-banner-ties.jpg')
image = ro_database.get_handler(path, FileHandler)
self.make_resource('banner-itws', Image, body=image.to_str(),
extension='jpg', filename='banner-itws.jpg',
format='image/jpeg', state='public')
# Set banner title
vhosts = website.get_property('vhosts')
if vhosts:
banner_title = vhosts[0]
else:
banner_title = website.get_title()
self.set_property('banner_title', banner_title, language=language)
# Drop logo property since itws uses banner_path property
self.del_property('logo')
# CSS file
# TODO Add an API in ikaaro that allow to easily change CSS...
path = get_abspath('ui/themes/style.css')
body = open(path).read()
style = self.get_resource('style')
style.handler.load_state_from_string(body)
style.handler.set_changed()
# Custom 404
self.make_resource('404', NotFoundPage)
# Add footer
self.make_resource('footer', FooterFolder)
menu = self.get_resource('footer/menu')
title = Property(MSG(u'Powered by itws').gettext(),
language=language)
menu.add_new_record({'title': title, 'path': '/about-itws'})
title = Property(MSG(u'Contact us').gettext(),
language=language)
menu.add_new_record({'title': title, 'path': '/;contact'})
# Turning footer
self.make_resource('turning-footer', TurningFooterFolder)
def test_load_file(self):
handler = ro_database.get_handler('tests/hello.txt')
self.assertEqual(handler.data, u'hello world\n')
from config import Configuration
from config_register import RegisterForm, TermsOfService_View
from context import CMSContext
from fields import Char_Field
from folder import Folder
from resource_views import LoginView
from skins import skin_registry
from root_views import PoweredBy, ContactForm
from root_views import NotFoundView, ForbiddenView, NotAllowedView
from root_views import UploadStatsView, UpdateDocs, UnavailableView
from update import UpdateInstanceView
# itools source and target languages
config = get_abspath('setup.conf')
config = ro_database.get_handler(config, ConfigFile)
itools_source_language = config.get_value('source_language')
itools_target_languages = config.get_value('target_languages')
# Force email to send UTF-8 mails in plain text
add_charset('utf-8', QP, None, 'utf-8')
add_codec('utf-8', 'utf_8')
class CtrlView(BaseView):
access = True
def GET(self, resource, context):
def get_config():
return ro_database.get_handler('setup.conf', SetupConf)
def get_config(target):
return ro_database.get_handler('%s/config.conf' % target, ServerConfig)
def get_template(self, resource, context):
path = get_abspath('twitter.stl')
return ro_database.get_handler(path, XMLFile)
(style_uri, 'default-page-layout'),
(style_uri, 'list-level-label-alignment'),
]
###########################################################################
# Make the namespaces
###########################################################################
def duplicate_ns(namespaces, first_uri, second_uri):
ns = copy(namespaces[first_uri])
ns.uri = second_uri
ns.prefix = None
namespaces[second_uri] = ns
# Read the Relax NG schema
rng_file = get_abspath('OpenDocument-strict-schema-v1.1.rng')
rng_file = ro_database.get_handler(rng_file, RelaxNGFile)
namespaces = rng_file.get_namespaces()
# Apply the metadata
for uri, element_name in inline_elements:
element = namespaces[uri].get_element_schema(element_name)
element.is_inline = True
for uri, element_name in skip_content_elements:
element = namespaces[uri].get_element_schema(element_name)
element.skip_content = True
for uri, element_name in unknown_elements:
elements = namespaces[uri].elements
if element_name in elements:
raise ValueError, 'element "%s" is defined twice' % element_name
elements[element_name] = ElementSchema(element_name,
default_datatype=String)
def get_config():
return ro_database.get_handler('setup.conf', SetupConf)
def get_template(self, resource, context):
style = resource.get_property('style')
path = get_abspath('addthis_%s.stl' % style)
return ro_database.get_handler(path, XMLFile)
#########################################################################
# Web Interface
#########################################################################
def view(self):
# Load the STL template
handler = ro_database.get_handler('TaskTracker_view.xml')
# Build the namespace
namespace = {}
namespace['tasks'] = []
for i, task in enumerate(self.tasks):
namespace['tasks'].append({'id': i,
'title': task.title,
'description': task.description,
'state': task.state,
'is_open': task.state == 'open'})
# Process the template and return the output
return stl(handler, namespace, mode='xhtml')
register_handler_class(TaskTracker)
if __name__ == '__main__':
task_tracker = ro_database.get_handler('itools.tt')
print task_tracker.view()
# Format
if options.format == 'po':
cls = POFile
elif options.format == 'tmx':
cls = TMXFile
elif options.format == 'xliff':
cls = XLFFile
else:
parser.error(
"available output formats are 'po' (default), 'tmx' and 'xliff'.")
# The SRX file
if options.srx is None:
srx_handler = None
else:
srx_handler = ro_database.get_handler(options.srx)
# Make the output handler
out_handler = cls()
for filename in args:
handler = ro_database.get_handler(filename)
try:
get_units = handler.get_units
except AttributeError:
message = 'ERROR: The file "%s" could not be processed\n'
sys.stderr.write(message % filename)
continue
# Extract the messages
for source, context, line in get_units(srx_handler=srx_handler):
out_handler.add_unit(filename, source, context, line)
data = out_handler.to_str()
def test_wrapped_quote_value(self):
# Init data
value = "\"HELLO, WORLD!\""
self._init_test(value)
# Write data
config = rw_database.get_handler(self.config_path, ConfigFile)
try:
config.set_value("test", value)
except SyntaxError, e:
self.fail(e)
config.save_state()
# Read data
config2 = ro_database.get_handler(self.config_path, ConfigFile)
try:
config2_value = config2.get_value("test")
except SyntaxError, e:
self.fail(e)
finally:
lfs.remove(self.config_path)
# Test data
self.assertEqual(config2_value, value)
###########################################################################
# Archive files
###########################################################################
class ArchiveTestCase(TestCase):
# Read configuration for languages
config = get_config()
src_language = config.get_value('source_language', default='en')
# Get local folder
package_root = config.get_value('package_root')
if lfs.exists(package_root):
locale_folder_path = Path('{0}/locale'.format(package_root))
else:
locale_folder_path = Path('locale/')
locale_folder = lfs.open(locale_folder_path)
# The SRX file
if options.srx is not None:
srx_handler = ro_database.get_handler(options.srx)
else:
srx_handler = None
# Initialize message catalog
po = POFile()
lines = []
for line in open('MANIFEST').readlines():
line = line.strip()
if line.split(sep)[0] not in ('archive', 'docs', 'skeleton', 'test'):
lines.append(line)
# Process Python and HTML files
write('* Extract text strings')
extensions = ['.py', '.xhtml.%s' % src_language, '.xml.%s' % src_language]
for lang in (source_language, ) + target_languages:
print lang,
stdout.flush()
call(
['msgfmt',
'locale/%s.po' % lang, '-o',
'locale/%s.mo' % lang])
# Add to the manifest
manifest.append('locale/%s.mo' % lang)
print
# Load message catalogs
message_catalogs = {}
for lang in target_languages:
path = 'locale/%s.po' % lang
handler = ro_database.get_handler(path)
message_catalogs[lang] = (handler, lfs.get_mtime(path))
# Build the templates in the target languages
good_files = compile('.*\\.x.*ml.%s$' % source_language)
exclude = frozenset(['.git', 'build', 'dist'])
lines = get_files(exclude, filter=lambda x: good_files.match(x))
lines = list(lines)
if lines:
print '* Build XHTML files',
stdout.flush()
for path in lines:
# Load the handler
src_mtime = lfs.get_mtime(path)
src = ro_database.get_handler(path, XHTMLFile)
done = False
def setUp(self):
self.rss = ro_database.get_handler('tests/sample-rss-2.xml', RSSFile)
version = 'itools %s' % itools.__version__
description = (
'Anonymizes and ODF file, replacing text by latin boilerplate and '
'images by other dumb images.')
parser = OptionParser(usage, version=version, description=description)
parser.add_option('-o', '--output', help='The output will be written to'
' the given file, instead of printed to the standard output.')
# Parse the command line
options, args = parser.parse_args()
if len(args) != 1:
parser.error('incorrect number of arguments')
# Load the ODF handler
filename = args[0]
handler = ro_database.get_handler(filename)
if not isinstance(handler, ODFFile):
parser.error('the given file is not an ODF file')
# Anonymize
data = handler.greek()
# Save
if options.output is None:
stdout.write(data)
else:
file_out = open(options.output, 'w')
try:
file_out.write(data)
finally:
file_out.close()
def setUp(self):
self.doc = ro_database.get_handler('odf/Document.odp', ODPFile)
def get_template(self, resource, context):
path = get_abspath('google_analytics.stl')
return ro_database.get_handler(path, XMLFile)
def test_input(self):
"""Test input.
"""
xliff = ro_database.get_handler('tests/gettext_en_es.xlf', XLFFile)
xliff.to_str()
def get_template(self):
path = get_abspath('google_analytics_graph.stl')
return ro_database.get_handler(path, XMLFile)
description = (
'Anonymizes and ODF file, replacing text by latin boilerplate and '
'images by other dumb images.')
parser = OptionParser(usage, version=version, description=description)
parser.add_option(
'-o',
'--output',
help='The output will be written to'
' the given file, instead of printed to the standard output.')
# Parse the command line
options, args = parser.parse_args()
if len(args) != 1:
parser.error('incorrect number of arguments')
# Load the ODF handler
filename = args[0]
handler = ro_database.get_handler(filename)
if not isinstance(handler, ODFFile):
parser.error('the given file is not an ODF file')
# Anonymize
data = handler.greek()
# Save
if options.output is None:
stdout.write(data)
else:
with open(options.output, 'w') as file_out:
file_out.write(data)
while center:
if (center[0][0] == START_FORMAT and center[-1][0] == END_FORMAT and
center[0][1][1] == center[-1][1][1]):
left.append(center.pop(0))
right.insert(0, center.pop())
else:
break
# (4) Remove the spaces
left, center, right = _remove_spaces(left, center, right, keep_spaces)
return left, center, right
default_srx_handler = get_abspath('srx/default.srx', 'itools')
default_srx_handler = ro_database.get_handler(default_srx_handler, SRXFile)
def _split_message(message, srx_handler=None):
# Concatenation!
concat_text = []
for type, value, line in message:
if type == TEXT:
concat_text.append(value[0])
concat_text = u''.join(concat_text)
# Get the rules
if srx_handler is None:
srx_handler = default_srx_handler
# XXX we must handle the language here!
rules = srx_handler.get_compiled_rules('en')
# Get the breaks
def test_input(self):
"""Test input.
"""
tmx = ro_database.get_handler('tests/localizermsgs.tmx', TMXFile)
tmx.to_str()
# Format
if options.format == 'po':
cls = POFile
elif options.format == 'tmx':
cls = TMXFile
elif options.format == 'xliff':
cls = XLFFile
else:
parser.error(
"available output formats are 'po' (default), 'tmx' and 'xliff'.")
# The SRX file
if options.srx is None:
srx_handler = None
else:
srx_handler = ro_database.get_handler(options.srx)
# Make the output handler
out_handler = cls()
for filename in args:
handler = ro_database.get_handler(filename)
try:
get_units = handler.get_units
except AttributeError:
message = 'ERROR: The file "%s" could not be processed\n'
sys.stderr.write(message % filename)
continue
# Extract the messages
for source, context, line in get_units(srx_handler=srx_handler):
out_handler.add_unit(filename, source, context, line)
data = out_handler.to_str()
def test_table(self):
handler = ro_database.get_handler('pml/table.xml', XMLFile)
story, stylesheet = stl_pmltopdf_test(handler, path='pml/table.xml')
self.assertEqual(len(story), 1)
def test_table(self):
handler = ro_database.get_handler('pml/table.xml', XMLFile)
story, stylesheet = stl_pmltopdf_test(handler, path='pml/table.xml')
self.assertEqual(len(story), 1)
]
###########################################################################
# Make the namespaces
###########################################################################
def duplicate_ns(namespaces, first_uri, second_uri):
ns = copy(namespaces[first_uri])
ns.uri = second_uri
ns.prefix = None
namespaces[second_uri] = ns
# Read the Relax NG schema
rng_file = get_abspath('OpenDocument-strict-schema-v1.1.rng')
rng_file = ro_database.get_handler(rng_file, RelaxNGFile)
namespaces = rng_file.get_namespaces()
# Apply the metadata
for uri, element_name in inline_elements:
element = namespaces[uri].get_element_schema(element_name)
element.is_inline = True
for uri, element_name in skip_content_elements:
element = namespaces[uri].get_element_schema(element_name)
element.skip_content = True
for uri, element_name in unknown_elements:
elements = namespaces[uri].elements
if element_name in elements:
raise ValueError, 'element "%s" is defined twice' % element_name
elements[element_name] = ElementSchema(element_name,
default_datatype=String)
def test_get_handler(self):
cls = ro_database.get_handler_class('handlers/test.tar.gz')
self.assertEqual(cls, TGZFile)
file = ro_database.get_handler('handlers/test.tar.gz')
self.assertEqual(file.__class__, TGZFile)