# HG changeset patch # User Sandrine Ribeau # Date 1227037882 28800 # Node ID c1d04b2fa8c69b96cd3ca9ea05037b3261a51254 # Parent a5c7609de57931aaca25ae60e3fbcaad870d4b9e Add missing images. Initial translation of foundation chapter. diff -r a5c7609de579 -r c1d04b2fa8c6 doc/book/en/02-foundation.en.txt --- a/doc/book/en/02-foundation.en.txt Mon Nov 17 23:54:24 2008 -0800 +++ b/doc/book/en/02-foundation.en.txt Tue Nov 18 11:51:22 2008 -0800 @@ -1,371 +1,355 @@ .. -*- coding: utf-8 -*- -Fondements `CubicWeb` -===================== -Un peu d'histoire... --------------------- +`CubicWeb` concepts +=================== + +A little history... +------------------- + +`CubicWeb` is a web application framework developped by Logilab_ since 2001. -`CubicWeb` est une plate-forme logicielle de développement d'application web -qui est développée par Logilab_ depuis 2001. +Entirely written in Python, `CubicWeb` publishes data from all sorts +of sources such as SQL database, LDAP directory and versioning system such +as subversion. + +`CubicWeb` user interface was designed to let the final user a huge flexibility +on how to select and how to display content. It allows to browse the knowledge +database and to display the results with the best rendering according to +the context. +This interface flexibility gives back the user the control of the +rendering parameters that are usually reserved for developpers. -Entièrement développée en Python, `CubicWeb` publie des données provenant -de plusieurs sources telles que des bases de données SQL, des répertoire -LDAP et des systèmes de gestion de versions tels que subversion. - -L'interface utilisateur de `CubicWeb` a été spécialement conçue pour laisser -à l'utilisateur final toute latitude pour sélectionner puis présenter les données. -Elle permet d'explorer aisément la base de connaissances et d'afficher les -résultats avec la présentation la mieux adaptée à la tâche en cours. -La flexibilité de cette interface redonne à l'utilisateur le contrôle de -paramètres d'affichage et de présentation qui sont habituellement réservés -aux développeurs. +We can list a couple of web applications developped with `CubicWeb`, an online +public phone directory (see http://www.118000.fr/), a system for managing +digital studies and simulations for a research lab, a tool for shared children +babysitting (see http://garde-partagee.atoukontact.fr/), a tool to manage +software developpment (see http://www.logilab.org), etc. -Parmi les applications déjà réalisées, on dénombre un annuaire en ligne pour -le grand public (voir http://www.118000.fr/), un système de gestion d'études -numériques et de simulations pour un bureau d'études, un service de garde -partagée d'enfants (voir http://garde-partagee.atoukontact.fr/), la gestion -du développement de projets logiciels (voir http://www.logilab.org), etc. +In 2008, `CubicWeb` was ported for a new type of source : the datastore +from GoogleAppEngine_. -En 2008, `CubicWeb` a été porté pour un nouveau type de source: le datastore -de GoogleAppEngine_. - -.. _GoogleAppEngine: http://code.google.com/appengine/ - - -Architecture globale --------------------- +Global architecture +------------------- .. image:: images/archi_globale.png -**Note**: en pratique la partie cliente et la partie serveur sont -généralement intégrées dans le même processus et communiquent donc -directement, sans nécessiter des appels distants via Pyro. Il est -cependant important de retenir que ces deux parties sont disjointes -et qu'il est même possible d'en exécuter plusieurs exemplaires dans -des processus distincts pour répartir la charge globale d'un site -sur une ou plusieurs machines. +.. note:: + For real, the client and server sides are integrated in the same + process and interact directly, without the needs for distants + calls using Pyro. It is important to note down that those two + sides, client/server, are disjointed and it is possible to execute + a couple of calls in distincts processes to balance the load of + your web site on one or more machines. + -Concepts et vocabulaire ------------------------ +Terms and vocabulary +-------------------- -*schéma* - le schéma définit le modèle de données d'une application sous forme - d'entités et de relations, grâce à la bibliothèque `yams`_. C'est - l'élément central d'une application. Il est initialement défini sur - le système de fichiers et est stocké dans la base de données lors de - la création d'une instance. `CubicWeb` fournit un certain nombres de - types d'entités inclus systématiquement car nécessaire au noyau - `CubicWeb` et une librairie de cubes devant être inclus - explicitement le cas échéant. +*schema* + the schema defines the data model of an application based on entities + and relations, thanks to the `yams`_ library. This is the core piece + of an application. It is initially defined in the file system and is + stored in the database at the time an instance is created. `CubicWeb` + provides a certain number of system entities included automatically as + it is necessarry for the core of `CubicWeb` and a library of + cubes that can be explicitely included if necessarry. + -*type d'entité* - une entité est un ensemble d'attributs ; l'attribut de - base de toute entité, qui est sa clef, est l'eid +*entity type* + an entity is a set of attributes; the essential attribute of + an entity is its key, named eid -*type de relation* - les entités sont liées entre elles par des relations. Dans `CubicWeb` - les relations sont binaires : par convention on nomme le premier terme - d'une relation son 'sujet' et le second son 'objet'. +*relation type* + entities are linked to each others by relations. In `CubicWeb` + relations are binary: by convention we name the first item of + a relation the `subject` and the second the `object`. -*type d'entité final* - les types finaux correspondent aux types de bases comme les chaînes - de caractères, les nombres entiers... Une propriété de ces types est - qu'ils ne peuvent être utilisés qu'uniquement comme objet d'une - relation. Les attributs d'une entité (non finale) sont des entités - (finales). +*final entity type* + final types corresponds to the basic types such as string of characters, + integers... Those types have a main property which is that they can + only be used as `object` of a relation. The attributes of an entity + (non final) are entities (finals). -*type de relation finale* - une relation est dite finale si son objet est un type final. Cela revient à - un attribut d'une entité. +*final relation type* + a relation is said final if its `object` is a final type. This is equivalent + to an entity attribute. -*entrepôt* - ou *repository*, c'est la partie serveur RQL de `CubicWeb`. Attention à ne pas - confondre avec un entrepôt mercurial ou encore un entrepôt debian. +*repository* + this is the RQL server side of `CubicWeb`. Be carefull not to get + confused with a Mercurial repository or a debian repository. *source* - une source de données est un conteneur de données quelquonque (SGBD, annuaire - LDAP...) intégré par l'entrepôt `CubicWeb`. Un entrepôt possède au moins une source - dite "system" contenant le schéma de l'application, l'index plein-texte et - d'autres informations vitales au système. + a data source is a container of data (SGBD, LDAP directory...) integrated in the + `CubicWeb` repository. This repository has at least one source, `system` which + contains the schema of the application, plain-text index and others + vital informations for the system. *configuration* - il est possible de créer différentes configurations pour une instance : + it is possible to create differents configurations for an instance: - - ``repository`` : entrepôt uniquement, accessible pour les clients via Pyro - - ``twisted`` : interface web uniquement, communiquant avec un entrepôt via Pyro - - ``all-in-one`` : interface web et entrepôt dans un seul processus. L'entrepôt - peut ou non être accessible via Pyro + - ``repository`` : repository only, accessible for clients using Pyro + - ``twisted`` : web interface only, access the repository using Pyro + - ``all-in-one`` : web interface and repository in a single process. + The repository could be or not accessible using Pyro. *cube* - un cube est un modèle regroupant un ou plusieurs types de données et/ou - des vues afin de fournir une fonctionalité précise, ou une application `CubicWeb` - complète utilisant éventuellement d'autres cube. Les différents - cubes disponibles sur une machine sont installés dans - `/path/to/forest/cubicweb/cubes` + a cube is a model grouping one or multiple data types and/or views + to provide a specific functionnality or a complete `CubicWeb` application + potentially using other cubes. The available subes are located in the file + system at `/path/to/forest/cubicweb/cubes` *instance* - une instance est une installation spécifique d'un cube. Sont regroupes - dans une instance tous les fichiers de configurations necessaires au bon - fonctionnement de votre application web. Elle referrera au(x) cube(s) sur - le(s)quel(s) votre application se base. - Par exemple intranet/jpl et logilab.org sont deux instances du cube jpl que - nous avons developpes en interne. - Les instances sont définies dans le répertoire `~/etc/cubicweb.d`. + an instance is a specific installation of a cube. All the required + configuration files necessarry for the well being of your web application + are grouped in an instance. This will refer to the cube(s) your application + is based on. + By example logilab.org and our intranet are two instances of a single + cube jpl, developped internally. + The instances are defined in the directory `~/etc/cubicweb.d`. *application* - le mot application est utilisé parfois pour parler d'une instance et parfois - d'un composant, en fonction du contexte... Mieux vaut donc éviter de - l'utiliser et utiliser plutôt *cube* et *instance*. + the term application is sometime used to talk about an instance + and sometimes to talk of a cube depending on the context. + So we would like to avoid using this term and try to use *cube* and + *instance* instead. *result set* - objet encaspulant les résultats d'une requête RQL et des informations sur - cette requête. + this object contains the results of an RQL query and information on the query. *Pyro* - `Python Remote Object`_, système d'objets distribués pur Python similaire à - Java's RMI (Remote Method Invocation), pouvant être utilisé pour la - communication entre la partie web du framework et l'entrepôt RQL. + `Python Remote Object`_, distributed objects system similar to Java's RMI + (Remote Method Invocation), which can be used for the dialog between the web + side of the framework and the RQL repository. .. _`Python Remote Object`: http://pyro.sourceforge.net/ .. _`yams`: http://www.logilab.org/project/name/yams/ -Moteur `CubicWeb` +`CubicWeb` engine ----------------- -Le moteur web de `CubicWeb` consiste en quelques classes gérant un ensemble d'objets -chargés dynamiquement au lancement de `CubicWeb`. Ce sont ces objets dynamiques, issus -du modèle ou de la librairie, qui construisent le site web final. Les différents -composants dynamiques sont par exemple : +The web engine in `CubicWeb` is a set of classes managing a set of objects loaded +dynamically at the startup of `CubicWeb`. Those dynamics objects, based on the schema +or the library, are building the final web site. The differents dymanic components are +by example: -* coté client et serveur +* client and server side - - les définitions d'entités, contenant la logique permettant la manipulation des - données de l'application + - entities definition, containing the logic which enables application data manipulation -* coté client +* client side - - les *vues* , ou encore plus spécifiquement + - *views*, or more specifically - - les boites - - l'en-tête et le pied de page - - les formulaires - - les gabarits de pages + - boxes + - header and footer + - forms + - page templates - - les *actions* - - les *controleurs* + - *actions* + - *controllers* -* coté serveur +* server side - - les crochets de notification - - les vues de notification + - notification hooks + - notification views -Les différents composants du moteur sont : +The components of the engine are: -* un frontal web (seul twisted disponible pour le moment), transparent du point - de vue des objets dynamiques -* un objet encapsulant la configuration -* un `vregistry` (`cubicweb.cwvreg`) contenant les objets chargés dynamiquements +* a frontal web (only twisted is available so far), transparent for dynamic objects +* an object that encapsulates the configuration +* a `vregistry` (`cubicweb.cwvreg`) containing the dynamic objects loaded automatically -Détail de la procédure d'enregistrement ---------------------------------------- -Au démarage le `vregistry` ou base de registres inspecte un certain nombre de -répertoires à la recherche de définition de classes "compatible". Après une -procédure d'enregistrement les objets sont affectés dans différents registres -afin d'être ensuite séléctionné dynamiquement pendant le fonctionnement de -l'application. + +Details of a recording process +------------------------------ -La classe de base de tout ces objets est la classe `AppRsetObject` (module -`cubicweb.common.appobject`). +At startup, the `vregistry` or registers base, inspects a number of directories +looking for compatible classes definition. After a recording process, the objects +are assigned to registers so that they can be selected dynamically while the +application is running. +The base class of those objects is `AppRsetObject` (module `cubicweb.common.appobject`). API Python/RQL -------------- -Inspiré de la db-api standard, avec un object Connection possédant les méthodes -cursor, rollback et commit principalement. La méthode importante est la méthode -`execute` du curseur : +Inspired from the standard db-api, with a Connection object having the methods +cursor, rollback and commit essentially. The most important method is +the `execute` method of a cursor : `execute(rqlstring, args=None, eid_key=None, build_descr=True)` -:rqlstring: la requête rql à éxécuter (unicode) -:args: si la requête contient des substitutions, un dictionnaire contenant les - valeurs à utiliser +:rqlstring: the RQL query to execute (unicode) +:args: if the query contains substitutions, a dictionnary containing the values to use :eid_key: - un détail d'implémentation du cache de requêtes RQL fait que si une substitution est - utilisée pour introduire un eid *levant des ambiguités dans la résolution de - type de la requête*, il faut spécifier par cet argument la clé correspondante - dans le dictionnaire - -C'est l'objet Connection qui possède les méthodes classiques `commit` et -`rollback`. Vous ne *devriez jamais avoir à les utiliser* lors du développement -d'interface web sur la base du framework `CubicWeb` étant donné que la fin de la -transaction est déterminée par celui-ci en fonction du succès d'éxécution de la -requête. - -NOTE : lors de l'éxécution de requêtes de modification (SET,INSERT,DELETE), si une -requête génère une erreur liée à la sécurité, un rollback est systématiquement -effectuée sur la transaction courante. + an implementation detail of the RQL queries cache implies that if a substitution + is used to introduce an eid *susceptible to raise the ambiguities in the query + type resolution*, then we have to specify the correponding key in the dictionnary + through this argument -La classe `Request` (`cubicweb.web`) ------------------------------------- -Une instance de requête est créée lorsque une requête HTTP est transmise au -serveur web. Elle contient des informations telles que les paramètres de -formulaires, l'utilisateur connecté, etc. +The `Connection` object owns the methods `commit` and `rollback`. You *should +never need to use them* during the development of the web interface based on +the `CubicWeb` framework as it determines the end of the transaction depending +on the query execution success. -**De manière plus générale une requête représente une demande d'un utilisateur, -que se soit par HTTP ou non (on parle également de requête rql coté serveur par -exemple)** +.. note:: + While executing updates queries (SET, INSERT, DELETE), if a query generates + an error related to security, a rollback is automatically done on the current + transaction. + -Une instance de la classe `Request` possède les attributs : +The `Request` class (`cubicweb.web`) +------------------------------------ + +A request instance is created when an HTPP request is sent to the web server. +It contains informations such as forms parameters, user authenticated, etc. -* `user`, instance de`cubicweb.common.utils.User` correspondant à l'utilisateur - connecté -* `form`, dictionaire contenant les valeurs de formulaire web -* `encoding`, l'encodage de caractère à utiliser dans la réponse +**Globally, a request represents a user query, either through HTTP or not +(we also talk about RQL queries on the server side by example)** -Mais encore : +An instance of `Request` has the following attributes: -:Gestion des données de session: - * `session_data()`, retourne un dictionaire contenant l'intégralité des - données de la session - * `get_session_data(key, default=None)`, retourne la valeur associée à - la clé ou la valeur `default` si la clé n'est pas définie - * `set_session_data(key, value)`, associe une valeur à une clé - * `del_session_data(key)`, supprime la valeur associé à une clé +* `user`, instance of `cubicweb.common.utils.User` corresponding to the authenticated + user +* `form`, dictionnary containing the values of a web form +* `encoding`, characters encoding to use in the response + +But also: + +:Session data handling: + * `session_data()`, returns a dictinnary containing all the session data + * `get_session_data(key, default=None)`, returns a value associated to the given + key or the value `default` if the key is not defined + * `set_session_data(key, value)`, assign a value to a key + * `del_session_data(key)`, suppress the value associated to a key -:Gestion de cookie: - * `get_cookie()`, retourne un dictionnaire contenant la valeur de l'entête +:Cookies handling: + * `get_cookie()`, returns a dictionnary containing the value of the header HTTP 'Cookie' - * `set_cookie(cookie, key, maxage=300)`, ajoute un en-tête HTTP `Set-Cookie`, - avec une durée de vie 5 minutes par défault (`maxage` = None donne un cooke - *de session"* expirant quand l'utilisateur ferme son navigateur - * `remove_cookie(cookie, key)`, fait expirer une valeur + * `set_cookie(cookie, key, maxage=300)`, adds a header HTTP `Set-Cookie`, + with a minimal 5 minutes length of duration by default (`maxage` = None + returns a *session* cookie which will expire when the user closes the browser + window + * `remove_cookie(cookie, key)`, forces a value to expire -:Gestion d'URL: - * `url()`, retourne l'url complète de la requête HTTP - * `base_url()`, retourne l'url de la racine de l'application - * `relative_path()`, retourne chemin relatif de la requête +:URL handling: + * `url()`, returns the full URL of the HTTP request + * `base_url()`, returns the root URL of the web application + * `relative_path()`, returns the relative path of the request -:Et encore...: - * `set_content_type(content_type, filename=None)`, place l'en-tête HTTP +:And more...: + * `set_content_type(content_type, filename=None)`, adds the header HTTP 'Content-Type' - * `get_header(header)`, retourne la valeur associé à un en-tête HTTP - arbitraire de la requête - * `set_header(header, value)`, ajoute un en-tête HTTP arbitraire dans la - réponse - * `cursor()` retourne un curseur RQL sur la session - * `execute(*args, **kwargs)`, raccourci vers .cursor().execute() - * `property_value(key)`, gestion des propriétés (`EProperty`) - * le dictionaire `data` pour stocker des données pour partager de - l'information entre les composants *durant l'éxécution de la requête*. + * `get_header(header)`, returns the value associated to an arbitrary header + of the HTTP request + * `set_header(header, value)`, adds an arbitrary header in the response + * `cursor()` returns a RQL cursor on the session + * `execute(*args, **kwargs)`, shortcut to ``.cursor().execute()`` + * `property_value(key)`, properties management (`EProperty`) + * dictionnary `data` to store data to share informations between components + *while a request is executed* -A noter que cette classe est en réalité abstraite et qu'une implémentation -concrète sera fournie par le *frontend* web utilisé (en l'occurent *twisted* -aujourd'hui). Enfin pour les vues ou autres qui sont éxécutés coté serveur, -la majeure partie de l'interface de `Request` est définie sur la session -associée au client. +Please note down that this class is abstract and that a concrete implementation +will be provided by the *frontend* web used (in particular *twisted* as of +today). For the views or others that are executed on the server side, +most of the interface of `Request` is defined in the session associated +to the client. - -La classe `AppObject` +The `AppObject` class --------------------- -En général : +In general: -* on n'hérite pas directement des cette classe mais plutôt d'une classe - plus spécifique comme par exemple `AnyEntity`, `EntityView`, `AnyRsetView`, +* we do not inherit directly from this class but from a more specific + class such as `AnyEntity`, `EntityView`, `AnyRsetView`, `Action`... -* pour être enregistrable, un classe fille doit définir son registre (attribut - `__registry__`) et son identifiant (attribut `id`). Généralement on n'a pas à - s'occuper du registre, uniquement de l'identifiant `id` :) +* to be recordable, a subclass has to define its own register (attribute + `__registry__`) and its identifier (attribute `id`). Usually we do not have + to take care of the register, only the identifier `id`. -On trouve un certain nombre d'attributs et de méthodes définis dans cette classe -et donc commune à tous les objets de l'application : +We can find a certain number of attributes and methods defined in this class +and so common to all the application objects: -A l'enregistrement, les attributs suivants sont ajoutés dynamiquement aux -*classes* filles: +At the recording, the following attributes are dynamically added to +the *subclasses*: -* `vreg`, le `vregistry` de l'application -* `schema`, le schéma de l'application -* `config`, la configuration de l'application +* `vreg`, the `vregistry` of the application +* `schema`, the application schema +* `config`, the application configuration -On trouve également sur les instances les attributs : +We also find on instances, the following attributes: -* `req`, instance de `Request` -* `rset`, le "result set" associé à l'objet le cas échéant -* `cursor`, curseur rql sur la session +* `req`, `Request` instance +* `rset`, the *result set* associated to the object if necessarry +* `cursor`, rql cursor on the session -:Gestion d'URL: - * `build_url(method=None, **kwargs)`, retourne une URL absolue construites à - partir des arguments donnés. Le *controleur* devant gérer la réponse - peut-être spécifié via l'argument spécial `method` (le branchement est - théoriquement bien effectué automatiquement :). +:URL handling: + * `build_url(method=None, **kwargs)`, returns an absolute URL based on + the given arguments. The *controller* supposed to handle the response + can be specified through the special parameter `method` (the connection + is theoretically done automatically :). - * `datadir_url()`, retourne l'url du répertoire de données de l'application - (contenant les fichiers statiques tels que les images, css, js...) + * `datadir_url()`, returns the directory of the application data + (contains static files such as images, css, js...) - * `base_url()`, raccourci sur `req.base_url()` + * `base_url()`, shortcut to `req.base_url()` - * `url_quote(value)`, version *unicode safe* de de la fonction `urllib.quote` + * `url_quote(value)`, version *unicode safe* of the function `urllib.quote` -:Manipulation de données: +:Data manipulation: - * `etype_rset(etype, size=1)`, raccourci vers `vreg.etype_rset()` + * `etype_rset(etype, size=1)`, shortcut to `vreg.etype_rset()` - * `eid_rset(eid, rql=None, descr=True)`, retourne un objet result set pour - l'eid donné - * `entity(row, col=0)`, retourne l'entité correspondant à la position données - du "result set" associé à l'objet + * `eid_rset(eid, rql=None, descr=True)`, returns a *result set* object for + the given eid + * `entity(row, col=0)`, returns the entity corresponding to the data position + in the *result set* associated to the object - * `complete_entity(row, col=0, skip_bytes=True)`, équivalent à `entity` mais - appelle également la méthode `complete()` sur l'entité avant de la retourner + * `complete_entity(row, col=0, skip_bytes=True)`, is equivalent to `entity` but + also call the method `complete()` on the entity before returning it -:Formattage de données: +:Data formatting: * `format_date(date, date_format=None, time=False)` - * `format_time(time)`, + * `format_time(time)` -:Et encore...: +:And more...: - * `external_resource(rid, default=_MARKER)`, accède à une valeur définie dans - le fichier de configuration `external_resource` + * `external_resource(rid, default=_MARKER)`, access to a value defined in the + configuration file `external_resource` * `tal_render(template, variables)`, -**NOTE IMPORTANTE** -Lorsqu'on hérite d'`AppObject` (même indirectement), il faut **toujours** -utiliser **super()** pour récupérer les méthodes et attributs des classes -parentes, et pas passer par l'identifiant de classe parente directement. -(sous peine de tomber sur des bugs bizarres lors du rechargement automatique -des vues). Par exemple, plutôt que d'écrire:: +.. note:: + When we inherit from `AppObject` (even not directly), you *always* have to use + **super()** to get the methods and attributes of the superclasses, and not + use the class identifier. + By example, instead of writting: :: class Truc(PrimaryView): def f(self, arg1): PrimaryView.f(self, arg1) -Il faut écrire:: - + You'd better write: :: + class Truc(PrimaryView): def f(self, arg1): super(Truc, self).f(arg1) - - - +Standard structure for a cube +----------------------------- -Structure standard d'un cube ----------------------------- - -Un cube complexe est structuré selon le modèle suivant : +A complex cube is structured as follows: :: - moncube/ + mycube/ | |-- schema.py | @@ -389,43 +373,39 @@ | \-- __pkginfo__.py -On peut utiliser de simple module python plutôt que des répertoires (packages), -par ex.: +We can use simple Python module instead of packages, by example: :: - moncube/ + mycube/ | |-- entities.py |-- hooks.py \-- views.py -où : +where : -* ``schema`` contient la définition du schéma (coté serveur uniquement) -* ``entities`` contient les définitions d'entités (coté serveur et interface web) -* ``sobjects`` contient les crochets et/ou vues de notification (coté serveur - uniquement) -* ``views`` contient les différents composants de l'interface web (coté interface - web uniquement) -* ``test`` contient les tests spécifiques à l'application (non installé) -* ``i18n`` contient les catalogues de messages pour les langues supportées (coté - serveur et interface web) -* ``data`` contient des fichiers de données arbitraires servis statiquement - (images, css, fichiers javascripts)... (coté interface web uniquement) -* ``migration`` contient le fichier d'initialisation de nouvelles instances - (``postcreate.py``) et générallement un fichier donnant les dépendances `CubicWeb` du - composant en fonction de la version de celui-ci (``depends.map``) -* ``debian`` contient les fichiers contrôlant le packaging debian (vous y - trouverez les fichiers classiques ``control``, ``rules``, ``changelog``... (non - installé) -* le fichier ``__pkginfo__.py`` donne un certain nombre de méta-données sur le - composant, notamment le nom de la distribution et la version courante (coté - serveur et interface web) ou encore les sous-cubes utilisés par ce - cube. +* ``schema`` contains the schema definition (server side only) +* ``entities`` contains the entities definition (server side and web interface) +* ``sobjects`` contains hooks and/or views notifications (server side only) +* ``views`` contains the different components of the web interface (web interface only) +* ``test`` contains tests specifics to the application (not installed) +* ``i18n`` contains the messages catalog for supported languages (server side and + web interface) +* ``data`` contains arbitrary data files served statically + (images, css, javascripts files)... (web interface only) +* ``migration`` contains the initialization file for new instances + (``postcreate.py``) and in general a file containing the `CubicWeb` dependancies + of the cube depending on its version (``depends.map``) +* ``debian`` contains all the files that manages the debian packaging + (you would find there the classical structure with ``control``, ``rules``, + ``changelog``... (not installed) +* the file ``__pkginfo__.py`` provides meta-data on the cube, especially the + distribution name and the current version (server side and web interface) or + also the sub-cubes used by this cube -Le strict minimum étant : +The only required files are: -* le fichier ``__pkginfo__.py`` -* la définition du schéma +* the file ``__pkginfo__.py`` +* the schema definition diff -r a5c7609de579 -r c1d04b2fa8c6 doc/book/en/images/blog-demo-first-page.png Binary file doc/book/en/images/blog-demo-first-page.png has changed diff -r a5c7609de579 -r c1d04b2fa8c6 doc/book/en/images/login-form.png Binary file doc/book/en/images/login-form.png has changed