def __iadd__(self, other):
"""add something to a component
>>> page = Component('<h1>Title</h1>')
>>> page += dict(css='mycss')
>>> page += 'page body goes here'
>>> page += dict(js='myjs')
>>> result = (
... "<Component: {"
... "'css': OrderedSet(['mycss']), "
... "'html': ['<h1>Title</h1>', 'page body goes here'], "
... "'js': OrderedSet(['myjs'])"
... "}>"
... )
>>> #print(page)
>>> #print(result)
>>> result == repr(page)
True
>>> page = Component('test')
>>> page += dict(html='text')
>>> page
<Component: {'html': ['test', 'text']}>
"""
def rendered(obj):
"""call the render method if necessary"""
if not isinstance(obj, Component) and hasattr(obj, 'render'):
return obj.render()
return obj
other = rendered(other)
if isinstance(other, str):
self.parts['html'].append(other)
elif isinstance(other, dict):
for key, value in other.items():
part = self.parts.setdefault(key, OrderedSet())
if key == 'html':
if isinstance(value, list):
part.extend(value)
else:
part.append(value)
else:
if isinstance(value, list):
part |= value
else:
part |= [value]
elif isinstance(other, Component):
for key, value in other.parts.items():
part = self.parts.setdefault(key, OrderedSet())
if key == 'html':
part.extend(value)
else:
part |= value
return self
def __iadd__(self, other):
"""add something to a component
>>> page = Component('<h1>Title</h1>')
>>> page += dict(css='mycss')
>>> page += 'page body goes here'
>>> page += dict(js='myjs')
>>> result = (
... "<Component: {"
... "'html': ['<h1>Title</h1>', 'page body goes here'], "
... "'css': OrderedSet(['mycss']), "
... "'js': OrderedSet(['myjs'])"
... "}>"
... )
>>> result == repr(page)
True
>>> page = Component('test')
>>> page += dict(html='text')
>>> page
<Component: {'html': ['test', 'text']}>
"""
kind = type(other)
if kind == str:
self.parts['html'].append(other)
elif kind == dict:
for key, value in other.items():
part = self.parts.setdefault(key, OrderedSet())
if key == 'html':
if type(value) == list:
part.extend(value)
else:
part.append(value)
else:
if type(value) == list:
part |= value
else:
part |= [value]
elif kind == Component:
for key, value in other.parts.items():
part = self.parts.setdefault(key, OrderedSet())
if key == 'html':
part.extend(value)
else:
part |= value
return self
def load_assets(self):
path = split(abspath(getfile(self.__class__)))[0]
assets = load_assets(path, kind(self))
for k, v in assets.items():
if k == 'html':
self.parts['html'].insert(0, v)
else:
self.parts[k] = OrderedSet([v]) | self.parts.get(k, {})
def get(part, formatter='{}', joiner='\n '):
parts = zoom.system.parts.parts.get(part, OrderedSet())
page_part = getattr(self, part, '')
if page_part:
if isinstance(page_part, (list, tuple)):
parts |= page_part
else:
parts |= [page_part]
return parts and joiner + joiner.join(
formatter.format(part) for part in parts) + '\n' or ''
def get(part, formatter='{}', joiner='\n'):
logger = logging.getLogger(__name__)
logger.debug('getting %r', part)
parts = composition.parts.parts.get(part, OrderedSet())
page_part = getattr(self, part, '')
if page_part:
if isinstance(page_part, (list, tuple)):
parts |= page_part
else:
parts |= [page_part]
logger.debug('get_{}: {}'.format(part, parts))
return parts and joiner.join(
formatter.format(part) for part in parts) or ''
def setup(self,
instance_path=None,
server=request.server,
timer=SystemTimer(timeit.default_timer())):
"""set up the system"""
if instance_path is None:
instance_path = Instance('system').path
self.debugging = True
self.timer = timer
self.start_time = timer.start_time
self.lib_path = os.path.split(os.path.abspath(__file__))[0]
if not os.path.exists(os.path.join(instance_path, 'dz.conf')):
msg = 'instance missing %s' % os.path.abspath(instance_path)
raise Exception(msg)
self.instance_path = os.path.abspath(instance_path)
if '.' not in sys.path:
sys.path.insert(0, '.')
# system config file
self.config = config = cfg.Config(instance_path, server)
# connect to the database and stores
db_engine = config.get('database', 'engine', 'mysql')
db_host = config.get('database', 'dbhost', 'database')
db_name = config.get('database', 'dbname', 'zoomdev')
db_user = config.get('database', 'dbuser', 'testuser')
db_pass = config.get('database', 'dbpass', 'password')
# legacy database module
self.database = old_database(
db_engine,
db_host,
db_name,
db_user,
db_pass,
)
# database module
db_params = dict(
engine=db_engine,
host=db_host,
db=db_name,
user=db_user,
)
if db_pass:
db_params['passwd'] = db_pass
# pylint: disable=invalid-name, star-args
self.db = new_db(**db_params)
self.db_debug = config.get('database', 'debug', '0') not in NEGATIVE
self.db.debug = self.db_debug
self.database.debug = self.db_debug
# message queues
from zoom.queues import Queues
self.queues = Queues(self.db)
from zoom.store import EntityStore
settings_store = EntityStore(self.database, settings.SystemSettings)
self.settings = settings.Settings(settings_store, config, 'system')
if not os.path.exists(config.sites_path):
raise Exception('sites missing %s' % config.sites_path)
self.debugging = config.get('errors', 'debugging', '0') == '1'
self.request = request
self.server = server
self.server_name = server # deprecated
# get current site directory
self.root = request.instance
self.uri = config.get('site', 'uri', '/')
if self.uri[-1] == '/':
self.uri = self.uri[:-1]
# get site info
self.site = Site(
name='',
theme='',
home=os.path.join(config.sites_path, server),
data_path=os.path.join(config.sites_path, server,
config.get('data', 'path', 'data')),
url=self.uri,
tracking_id=config.get('site', 'tracking_id', ''),
)
# csrf validation
self.csrf_validation = (
config.get('site', 'csrf_validation', True) not in
['0', 'False', 'off', 'no', True]
)
# secure cookies
self.secure_cookies = (
config.get('sessions', 'secure_cookies', False) not in
['0', 'False', 'off', 'no', False]
)
# users and groups
self.guest = config.get('users', 'default', 'guest')
self.administrator_group = \
system.config.get('users', 'administrator_group', 'administrators')
self.manager_group = config.get('users', 'manager_group', 'managers')
self.managers = config.get('users', 'managers', 'managers')
self.developers = config.get('users', 'developers', 'developers')
self.administrators = \
config.get('users', 'administrators', 'administrators')
# apps
self.index = config.get('apps', 'index', 'index')
self.home = config.get('apps', 'home', 'home')
# background processing
self.background = config.get('background', 'run', True) not in NEGATIVE
# users (experimental)
self.users = UserStore(self.db)
# email settings
self.from_addr = system.config.get('mail', 'from_addr')
self.mail_delivery = system.config.get('mail', 'delivery', 'immediate')
# load theme
self.themes_path = existing(config.get(
'theme',
'path',
os.path.join(self.root, 'themes'))
)
self.theme = (
self.themes_path and
self.settings.get('theme_name') or
config.get('theme', 'name', 'default')
)
self.set_theme(self.theme)
self.app = NoApp()
self.site_name = ''
self.warnings = []
self.errors = []
self.messages = []
self.styles = OrderedSet()
self.css = OrderedSet()
self.libs = OrderedSet()
self.js = OrderedSet()
self.head = OrderedSet()
self.tail = OrderedSet()
self.helpers = {}
self.show_errors = config.get('error', 'users', '0') == '1'
self.profile = config.get('system', 'profile', '0') == '1'
self.track_visits = config.get(
'system',
'track_visits',
'0').lower() in POSITIVE
self.logging = config.get(
'log',
'logging',
True) not in ['0', 'False', 'off', 'no', False]
self.session = zoom.session.Session(self)
self.session.load_session()
self.is_setup = True
def component(*args, **kwargs):
"""assemble parts of a component
>>> system.setup()
>>> system.css
OrderedSet()
>>> component('test', css='mycss')
'test'
>>> system.css
OrderedSet(['mycss'])
>>> component(100, css='mycss')
'100'
>>> component(css='mycss', html='test')
'test'
>>> system.css
OrderedSet(['mycss'])
>>> component('test', html='more', css='mycss')
'testmore'
>>> system.css
OrderedSet(['mycss'])
>>> component('test', 'two', css=['mycss','css2'], js='myjs')
'testtwo'
>>> system.css
OrderedSet(['mycss', 'css2'])
>>> system.js
OrderedSet(['myjs'])
>>> component('test', js='js2')
'test'
>>> system.js
OrderedSet(['myjs', 'js2'])
>>> component(['test1'], ('test2',), 'test3')
'test1test2test3'
>>> from mvc import DynamicView
>>> class MyThing(DynamicView):
... def __str__(self):
... return self.model
>>> hasattr(MyThing('test'), '__iter__')
False
>>> component(['test1'], ('test2',), 'test3', MyThing('test4'))
'test1test2test3test4'
>>> component(MyThing('test4'))
'test4'
>>> component(MyThing('test4'), MyThing('test5'))
'test4test5'
>>> component((MyThing('test4'), MyThing('test5')))
'test4test5'
>>> args = (MyThing('test4'), MyThing('test5'))
>>> component(args)
'test4test5'
>>> component(*list(args))
'test4test5'
>>> system.setup()
>>> component('test', js=[])
'test'
>>> system.js
OrderedSet()
"""
def is_iterable(item):
return hasattr(item, '__iter__')
def as_iterable(item):
return not is_iterable(item) and (item, ) or item
def flatten(items):
items_as_iterables = list(is_iterable(i) and i or (i, ) for i in items)
#print repr(items_as_iterables)
#return ''
return [i for j in items_as_iterables for i in j]
parts = {
'html': flatten(args),
}
for key, value in kwargs.items():
part = parts.setdefault(key, OrderedSet())
if key == 'html':
part.extend(as_iterable(value))
else:
part |= OrderedSet(as_iterable(value))
for key in ['css', 'js', 'styles', 'libs', 'head', 'tail']:
part = getattr(system, key)
part |= parts.get(key, [])
return ''.join(map(str, parts['html']))