Eine Überblick bzw. Zusammenfassung von mir über das Thema was euch hoffentlich weiterhelfen wird.

Häwdtfan

Beschreibung

Ein Framework ist selbst noch kein fertiges Programm, sondern stellt den Rahmen
innerhalb dessen der Designer/Developer eine Anwendung erstellt zur Verfügung.

Ein Framework ist eine Reihe von Werkzeugen, Bibliotheken und Best Practices, die uns versuchen Arbeit abzunehmen.Wie? In denn man Routinenaufgaben in generische Module wiederverwendet kann.

• Ein Layout-Framework ist somit ein Arbeitswerkzeug zur Layouterstellung.
• Ein Universelles Layoutkonzept mit vielfältige Variationsmöglichkeiten.
• Eine vorgefertigtes „Gerüst“.
• Ein Arbeitswerkzeug zur Layouterstellung.
• Ein Framework gibt somit in der Regel die Anwendungsarchitektur vor.
• Ein Framework nimmt uns Arbeit ab indem Standardtasks vordefiniert sind.
• Frameworks helfen uns effizient und schnell ans Ziel zu kommen
  (Daher Kostenvorteile was auch an den Kunden weitergegeben wird. )
• Konzetration auf das Wesentliche!

Ziel

Das Ziel ist es, dass der Designer auf Aufgaben, die einzigartig für ein bestimmtes Projekt sich konzentrieren kann, anstatt das Rad jedes Mal neu zu erfinden in denn man Werkzeuge noch mal verwendet.

Produktivitätssteigerung!

Methoden, Arten von Frameworks

• Grid Frameworks (Anwendungsorientierte Baukästen, Grid- Basiertes Layout)
  • Layouterstellung mit HTML
  • Vordefinierte Gridklassen

• CSS Frameworks (Entwicklerorientierte Baukästen, Spaltenbasiertes Layout)
  • Vordefinierter Markup
  • Layouterstellung mit CSS

Beispiele dafür? (Werden nicht alle benannt!)

Grid Frameworks

• Blueprint CSS
• 960.gs
• YUI

CSS Frameworks

• Yaml
• A CSS Framework

Unterschiede

An der Stelle muss ich sagen dass es wirklich besser ist wenn ihr euch die Frameworks runterladet und die selber testet z.B. Yaml Builder und 960.gs. Ich persönlich finde diesen Weg als den besten weil so könnt ihr selber den Unterschied sehen und auch merken in denn man es ausprobiert 

Grid Frameworks

• Vordefinierte Gridklassen
• Layouterstellung mit HTML

CSS Frameworks

• Vordefinierte Markup
• Layouterstellung mit CSS

Beim Frameworks handelt es sich nun um Stylesheets mit einer Auswahl fertiger Klassen für diverse Spaltenraster im eigentlichen Inhaltsbereich einer Webseite.

Inhalte

Mögliche Inhalte bzw. Stylesheets  eines Frameworks:

• Reset.css
• Base.css
• Typography.css
• Layout.css
• Browser.css
• Table.css
• Form.css
• Print.css

„ Yaml liefert zusätzlich die vom Benutzer erstellte Struktur mit. (Html Code)“

Vorteile und Nachteile

Vorteile

• Tabellenfrei (CSS)
• Schnelle Entwicklung, Schnelle Ergebnisse
• Cross-Browser Kompatibilität (IE Bugfixes, Bugprävetion)
• Einheitliche Code Basis
• Normalisierung der Code
• Einhaltung von Standards
• Vermeiden von alltäglichen Fehlern
• Steigerung der Produktivität
• Verbesserter Workflow bei Team-Arbeit
• Flexible und Pflegeleicht
• Modulare Aufbau
• Wohl geformten Markup

Nachteile

• Einarbeitungszeit für das Framework
• Frameworks erzeugen mehr Code als notwendig (Overhead)
• Eigenschränkte Kreativität durch Vorgaben (Individuelle Layouts brauchen individuelle Lösungen);-)

Durante el desarrollo de nuestro proyecto para la Feria de Software tuvimos que tener algunos datos de prueba para las comunas y ciudades de Chile, como no era fundamental tener las regiones simplificamos el modelo propuesto en este sitio al siguiente (escrito en notación YAML)

Para las ciudades:

  ciudad:
   id: ~
   nombre:      { type: varchar(100) }

Para las comunas

  comuna:
   id: ~
   nombre:      { type: varchar(100) }
   ciudad_id:   { type: integer, foreignTable: ciudad, foreignReference: id, onDelete: restrict }

Los cuales, como es de presumir, fueron agregados a nuestro esquema (./config/schema.yml). Hasta aquí nada muy interesante, pero mientas discutíamos la forma más compleja y por ende mejor ( xD ) de cargar los datos,  Camila Maldonado se tomó la ‘molestia’ de pasar la información directamente a un par de archivos yaml para ser cargados como fixtures (./data/fixtures) en nuestro proyecto. Les dejo a continuación los archivos:

Descarga: Fixtures symfony – Ciudades y Comunas de Chile (zip – 5,5 KB)

Es muy posible que falten varias comunas, pero como comenté sólo necesitábamos datos de prueba y éstos se ajustaron bastante bien: 52 ciudades y 345 comunas no está mal

YAML (Yet Another Multicolumn Layout) es un framework para CSS con el que se puede realizar hojas de estilo de una manera ágil y estándar para los múltiples navegadores. YAML combina una serie de características que facilitan mucho el trabajo de la maquetación con CSS.

Este framework es un esquema definido de plantillas que incluye una cabecera, un pie de página y un área para una o más columnas. Es compatible con la mayor parte de los navegadores y posee esquemas de diseño tanto fijos como fluídos. Es importante tener en cuenta que YAML no es una plantilla prefabricada.

Además, nos ofrece una herramienta online, llamada YAML Builder, que nos permite crear nuestras propias plantillas de forma rápida y sencilla. Tan sólo deberemos indicar el tipo de diseño, los tamaños, podremos añadirle elementos HTML y por último recuperar el código fuente.

Here are all the country codes in YAML format for your downloading pleasure! You may place them in your app.yml (for symfony users) and call the list with sfConfig::get(‘app_countries’).

all:
  .lists:
    countries:
      CA:	Canada
      US:	United States of America
      AD: Andorra
      AE:	United Arab Emirates
      AF:	Afghanistan
      AG:	Antigua & Barbuda
      AI:	Anguilla
      AL:	Albania
      AM:	Armenia
      AN:	Netherlands Antilles
      AO:	Angola
      AQ:	Antarctica
      AR:	Argentina
      AS:	American Samoa
      AT:	Austria
      AU:	Australia
      AW:	Aruba
      AZ:	Azerbaijan
      BA:	Bosnia and Herzegovina
      BB:	Barbados
      BD:	Bangladesh
      BE:	Belgium
      BF:	Burkina Faso
      BG:	Bulgaria
      BH:	Bahrain
      BI:	Burundi
      BJ:	Benin
      BM:	Bermuda
      BN:	Brunei Darussalam
      BO:	Bolivia
      BR:	Brazil
      BS:	Bahama
      BT:	Bhutan
      BU:	Burma (no longer exists)
      BV:	Bouvet Island
      BW:	Botswana
      BY:	Belarus
      BZ:	Belize
      CC:	Cocos (Keeling) Islands
      CF:	Central African Republic
      CG:	Congo
      CH:	Switzerland
      CI:	Côte D'ivoire (Ivory Coast)
      CK:	Cook Iislands
      CL:	Chile
      CM:	Cameroon
      CN:	China
      CO:	Colombia
      CR:	Costa Rica
      CS:	Czechoslovakia (no longer exists)
      CU:	Cuba
      CV:	Cape Verde
      CX:	Christmas Island
      CY:	Cyprus
      CZ:	Czech Republic
      DD:	German Democratic Republic (no longer exists)
      DE:	Germany
      DJ:	Djibouti
      DK:	Denmark
      DM:	Dominica
      DO:	Dominican Republic
      DZ:	Algeria
      EC:	Ecuador
      EE:	Estonia
      EG:	Egypt
      EH:	Western Sahara
      ER:	Eritrea
      ES:	Spain
      ET:	Ethiopia
      FI:	Finland
      FJ:	Fiji
      FK:	Falkland Islands (Malvinas)
      FM:	Micronesia
      FO:	Faroe Islands
      FR:	France
      FX:	France, Metropolitan
      GA:	Gabon
      GB:	United Kingdom (Great Britain)
      GD:	Grenada
      GE:	Georgia
      GF:	French Guiana
      GH:	Ghana
      GI:	Gibraltar
      GL:	Greenland
      GM:	Gambia
      GN:	Guinea
      GP:	Guadeloupe
      GQ:	Equatorial Guinea
      GR:	Greece
      GS:	South Georgia and the South Sandwich Islands
      GT:	Guatemala
      GU:	Guam
      GW:	Guinea-Bissau
      GY:	Guyana
      HK:	Hong Kong
      HM:	Heard & McDonald Islands
      HN:	Honduras
      HR:	Croatia
      HT:	Haiti
      HU:	Hungary
      ID:	Indonesia
      IE:	Ireland
      IL:	Israel
      IN:	India
      IO:	British Indian Ocean Territory
      IQ:	Iraq
      IR:	Islamic Republic of Iran
      IS:	Iceland
      IT:	Italy
      JM:	Jamaica
      JO:	Jordan
      JP:	Japan
      KE:	Kenya
      KG:	Kyrgyzstan
      KH:	Cambodia
      KI:	Kiribati
      KM:	Comoros
      KN:	St. Kitts and Nevis
      KP:	Korea, Democratic People's Republic of
      KR:	Korea, Republic of
      KW:	Kuwait
      KY:	Cayman Islands
      KZ:	Kazakhstan
      LA:	Lao People's Democratic Republic
      LB:	Lebanon
      LC:	Saint Lucia
      LI:	Liechtenstein
      LK:	Sri Lanka
      LR:	Liberia
      LS:	Lesotho
      LT:	Lithuania
      LU:	Luxembourg
      LV:	Latvia
      LY:	Libyan Arab Jamahiriya
      MA:	Morocco
      MC:	Monaco
      MD:	Moldova, Republic of
      MG:	Madagascar
      MH:	Marshall Islands
      ML:	Mali
      MN:	Mongolia
      MM:	Myanmar
      MO:	Macau
      MP:	Northern Mariana Islands
      MQ:	Martinique
      MR:	Mauritania
      MS:	Monserrat
      MT:	Malta
      MU:	Mauritius
      MV:	Maldives
      MW:	Malawi
      MX:	Mexico
      MY:	Malaysia
      MZ:	Mozambique
      NA:	Namibia
      NC:	New Caledonia
      NE:	Niger
      NF:	Norfolk Island
      NG:	Nigeria
      NI:	Nicaragua
      NL:	Netherlands
      "NO":	Norway
      NP:	Nepal
      NR:	Nauru
      NT:	Neutral Zone (no longer exists)
      NU:	Niue
      NZ:	New Zealand
      OM:	Oman
      PA:	Panama
      PE:	Peru
      PF:	French Polynesia
      PG:	Papua New Guinea
      PH:	Philippines
      PK:	Pakistan
      PL:	Poland
      PM:	St. Pierre & Miquelon
      PN:	Pitcairn
      PR:	Puerto Rico
      PT:	Portugal
      PW:	Palau
      PY:	Paraguay
      QA:	Qatar
      RE:	Réunion
      RO:	Romania
      RU:	Russian Federation
      RW:	Rwanda
      SA:	Saudi Arabia
      SB:	Solomon Islands
      SC:	Seychelles
      SD:	Sudan
      SE:	Sweden
      SG:	Singapore
      SH:	St. Helena
      SI:	Slovenia
      SJ:	Svalbard & Jan Mayen Islands
      SK:	Slovakia
      SL:	Sierra Leone
      SM:	San Marino
      SN:	Senegal
      SO:	Somalia
      SR:	Suriname
      ST:	Sao Tome & Principe
      SU:	Union of Soviet Socialist Republics (no longer exists)
      SV:	El Salvador
      SY:	Syrian Arab Republic
      SZ:	Swaziland
      TC:	Turks & Caicos Islands
      TD:	Chad
      TF:	French Southern Territories
      TG:	Togo
      TH:	Thailand
      TJ:	Tajikistan
      TK:	Tokelau
      TM:	Turkmenistan
      TN:	Tunisia
      TO:	Tonga
      TP:	East Timor
      TR:	Turkey
      TT:	Trinidad & Tobago
      TV:	Tuvalu
      TW:	Taiwan, Province of China
      TZ:	Tanzania, United Republic of
      UA:	Ukraine
      UG:	Uganda
      UM:	United States Minor Outlying Islands
      UY:	Uruguay
      UZ:	Uzbekistan
      VA:	Vatican City State (Holy See)
      VC:	St. Vincent & the Grenadines
      VE:	Venezuela
      VG:	British Virgin Islands
      VI:	United States Virgin Islands
      VN:	Viet Nam
      VU:	Vanuatu
      WF:	Wallis & Futuna Islands
      WS:	Samoa
      YD:	Democratic Yemen (no longer exists)
      YE:	Yemen
      YT:	Mayotte
      YU:	Yugoslavia
      ZA:	South Africa
      ZM:	Zambia
      ZR:	Zaire
      ZW:	Zimbabwe
      ZZ:	Unknown or unspecified country

and a quick note, we released a new page about the distribution of supplies. its basicly just a company profile.
Its build with CakePHP and YAML CSS framework. Highlight is the Spamprotect by Capcha.

hqtrading.de

Soeben ist der dritte Artikel der DSL-Serie von Markus und mir bei der dotnetpro erschienen.

Abstract: Mehrspaltige Layouts für Webseiten sind komplex und stellen hohe Ansprüche an den Webprogrammierer. Warum nicht eine Sprache entwickeln, die solche Layouts vereinfacht? Mit Oslo M und dem ASP.NET MVC Framework lässt sich so eine Sprache realisieren.

Inhalt

Hauptsächlich dreht sich der Artikel um MGrammar, den Teil der Sprache Microsoft M (Teil von Microsoft Oslo) mit dem andere Sprachen definiert werden können. Zuerst wird die MGrammar (Arbeitstitel) anhand einer simplen “Hello, World”-Sprache erklärt.

Danach erstellen wir eine DSL zur Beschreibung mehrspaltiger Layouts und bringen diese mittels ASP.NET MVC und YAML ans laufen.

Das Beispiel im Artikel basiert auf der Oslo January CTP, der Quelltext für das Oslo May CTP kann aber bei mir angefragt werden.

Beispiel

Typisches dreispaltiges Portal-Layout.

* Die Berechnung der Restbreite stimmt hier nicht. Richtig wäre:

Rest = (75%* Gesamtbreite) –400px

Dies mag aber von CSS-Framework zu CSS-Framework variieren.

DSL zur Beschreibung

Die Syntaxhervorhebung ergibt sich aus der Grammatik und ein wenig Konfiguration.

En algún post anterior hacía referencia a sitios web con layouts css para hacer C&P. Vía fresherswisdom.com he conocido YAML, una interesante aplicación online que permite, de modo visual, la creación de layouts “limpitos” de modo personalizado.

Es primera vez que meteré manos en el framework MVC para PHP de nombre symfony, no entraré en detalles de sus bondades, sólo diré que me aburrí de re-inventar la rueda cada vez y el proyecto en el que trabajaré los próximos meses merece el uso de este framework.

En esta primera entrada detallaré propondré una configuración  para el IDE Eclipse que permite alivianar un poco la  labor de programar, añadiendo soporte básico para las operaciones (de consola) de symfony y un editor para archivos yml.

Instalación

Conocidas las nociones básicas con las que nos enfrentaremos a lo largo del proceso de desarrollo, comenzaré por configurar nuestro IDE, la idea es no tener que salir tanto del IDE para realizar alguna tarea, para cumplir con esto se requiere un editor de archivos YAML y algún complemento que nos permita ejecutar los comandos de consola que usa symfony. Con esto en mente el IDE que utilizaremos será Eclipse. Por lo que debemos descargar Eclipse y sus plugins de PHP Development Tools (PDT) en su primera versión (la versión 2 no está soportada por el plugin de symfony a utilizar).

Nota importante, me han comentado que el plugin no funciona en la versión 3.5, por ello usaremos la 3.4

Descarga Eclipse Classic: http://www.eclipse.org/downloads/

Descarga PDT v1.05: Runtime o sigue leyendo para ver cómo instalarlo utilizando el repositorio.

Para instalar PDT sólo basta copiar el contenido del archivo descargado en el directorio de Eclipse, respetando claro el árbol de directorios. También puede ser instalado vía repo

Seguiremos complementando Eclipse con algunos plugins, para ello abrimos Eclipse y nos dirigimos a Help/Install New Software (Figura 1). Ahora añadiremos los siguientes repositorios haciendo click en el enlace que dice ‘Available Software Sites’ y luego click en el botón Add.

Repositorios

Estos son los “indespensables”

Figura 1: Instalar Nuevo Software en Eclipse

• Plugins de PDT: provee herramientas para desarrollar aplicaciones en PHP. Repositorio: http://download.eclipse.org/tools/pdt/updates/
• Plugin de symfony: (sin nombre aparentemente) permitirá crear proyectos, aplicaciones y módulos a través de un wizard, gestionar instalaciones de sf para el proyecto en uso, ejecutar comandos sin la necesidad de abrir otra ventana, colorea la sintaxis de archivos yml (pero no tabula correctamente) y es capaz de convertir archivos de Clay en archivos YAML. Repositorio: http://sfdt.borox.ch/updates

Los siguientes son opcionales, pero pueden ayudar en la labor

• Clay Database Modeling – Azzuri: Sencillo editor gráfico para crear tablas y sus relaciones. Repositorio: http://www.azzurri.co.jp/eclipse/plugins
• yEdit YAML Editor: [Recomendado!] Editor muy sencillo que básicamente lo único que hace es interpretar las tabulaciones como “2 espacios” y colorea un poco la sintaxis, justo lo que nececitamos . Repositorio: http://dadacoalition.org/yedit/
• Wicked Shell: Permite tener acceso a terminal o consola de tu sistema operativo a través de una cómoda pestaña. Repositorio: http://www.wickedshell.net/updatesite

Una vez añadidos estos sitios o repositorios hay que instalar los plugins (que quieras), lo que es bastante sencillo, sólo selecciona el repositorio (work with) y luego se elige lo que necesites instalar, es preferente instalar las últimas versiones de cada plugin.

Figura 2: Instalando Nuevo Software

Una vez terminado el proceso de instalación y reiniciado Eclipse tendremos todo lo necesario para desarrollar nuestro proyecto, más cómodamente en Eclipse.

Pruebas

Para ver si todo está funcionando correctamente creemos un nuevo proyecto de symfony.

File ->New -> Project -> Symfony -> SfProject

Figura 3: Creando un proyecto symfony

En el siguiente paso del wizard nos pedirá un directorio donde haya una instalación de symfony para ser usado como librería. Puedes usar tu instalación de PEAR o un sandbox no hay diferencia. El resto son parámetros propios de cualquier proyecto como nombre y ubicación.

Figura 4: Configurando el nuevo proyecto

Con esto se crea automáticamente un nuevo proyecto, el resultado es el mismo que utilizando el comando habitual de symfony:

symfony generate:project nombre-proyecto

Con esto ya estamos listos con la configuración, si quieres ver las características que instalamos continua leyendo,

Revisando Características

Revisemos brevemente nuevas funcionalidades que hemos instalado.

Habilidad de crear aplicaciones y módulos:

Desde ahora se pueden crear módulos y aplicaciones de manera sencilla. Esto se hace simplemente añadiendo un nuevo elemento al proyecto.

Figura 5: Añadiendo componentes al proyecto

Dentro del menú nos encontraremos nuevamente con la sub-categoría Symfony desde allí se pueden crear las módulos aplicaciones y módulos necesarios. ¿Lo malo? no soporta parámetros o flags adicionales por lo que presumo que el comando que (presumo) ejecuta es simplemente generate:module y generate:app respectivamente, así que si necesitas agregar más parámetros, tendrás que utilizar la consola. El resto de los pasos no requiere más explicación que ponerle nombre o indicar a qué aplicación corresponde el nuevo módulo.

Abrir archivos y editar archivos .yml

Ahora el editor de Eclipse reconoce los archivos .yml los abré y colorea, pero no formatea correctamente si presionas tab, lo cual en si no es un problema porque el archivo .yml no utiliza tabulaciones sino 2 espacios por cada nivel de anidación. Si te parece molesto igual que a mí, instala el plugin que recomendé más arriba: yEdit YAML Editor éste reconoce las tabulaciones como 2 espacios (o más dependiendo del nivel de anidación). Una vez instalado, tendrás que abrir estos archivos .yml haciendo click derecho sobre él  -> open with -> YEdit

Crear el Modelo (en Propel) a través de Clay

Si bien, no es mi herramienta favorita para crear, Clay provee un sistema básico y eficaz para crear modelos relacionales. Con el plugin de symfony podemos diseñar el Modelo con esta herramienta y exportarlo al archivo schema.yml (y sólo a ese).



Figura 7: Ejemplo de modelo relacional hecho con Clay.

Ahora si hacemos click derecho sobre el archivo .clay y el menu contextual aparecerá sub-menú de nombre symfony dentro de él se incluye la opción Convert to Symfony YML-Schema. El archivo que se obtiene, para este ejemplo en particular, es el siguiente.

[Pendiente de Revisión, no lo probé]

..propel:

…._attributes:

……package: lib.model

….usuario:

……id:

……..type: INTEGER

……..required: true

……..primaryKey: true

……nombre:

……..type: VARCHAR

……..size: 50

…. mensajes:

…… id:

…..…type: INTEGER

……..required: true

……..primaryKey: true

……mensaje:

……..type: VARCHAR

……..size: 255

……usuario_id:

……..type: INTEGER

……..required: true

……..foreignTable: usuario

……..foreignReference: id

……..onDelete:

……..onUpdate:

……fecha_publicacion:

……..type: CHAR

……..size: 10

Como se puede apreciar la sintaxis utilizada no se parece mucho a la utilizada en la documentación, por lo que para programadores con poco experiencia en esta notación (como yo) resulta un poco confusa.

Conclusiones

Después de haber pasado algunas horas (o quizás más de las que debí) navegando, recopilando información para tratar de obtener un IDE lo más completo posible con lo mejor de cada componente utilizado, quedo con la sensación de que no añadí algo realmente interesante. En particular lo digo por plugin a medias que sólo provee funcionalidades elementales, que final de cuentas me hará recurrir de todas a formas a la consola. Es más, la escasez de alternativas me hacen afirmar que no es indispensable un entorno de desarrollo más completo o complejo que el que construí.

Lo destacable, el editor de archivos yml: YEdit y el esfuerzo de la comunidad en proveer plugins para facilitar el trabajo. Estoy seguro que  las próximas versiones serán más completas y que la incorporación de symfony a NetBeans hará más cómoda esta tarea.

De todo lo propuesto, considero que usando Eclipse + PDT + YEdit es suficiente para tener un entorno de desarrollo para symfony adecuado.

Espero les haya sido de ayuda, saludos!

Here are some excellent resources for working with sfDoctrineGuardPlugin:

Plugin page on symfony (README is possibly out of date)
http://www.symfony-project.org/plugins/sfDoctrineGuardPlugin

Tutorial on how to add a profile to work with sfDoctrineGuardPlugin
http://www.symfony-project.org/blog/2008/11/12/call-the-expert-customizing-sfdoctrineguardplugin

Tutorial on how to add a registration module
http://www.symfony-project.org/blog/2008/12/03/call-the-expert-simple-registration-with-sfdoctrineguardplugin

First of all, the schema code in the documentation for sfDoctrineGuard appears to be old:

(be mindful of the lack of proper YAML spacing; I haven’t figured out how to incorporate code into wordpress.com posts yet)

sf_guard_user_profile:
_attributes: { phpName: sfGuardUserProfile }
id:
user_id:     { type: integer, foreignTable: sf_guard_user, foreignReference: id, required: true, onDelete: cascade }
first_name:  varchar(20)
last_name:   varchar(20)
birthday:    date

I replaced it with:

sfGuardUserProfile:
columns:
user_id:     { type: integer, notnull: true, required: true }
first_name:  string(20)
last_name:   string(20)
email:       string(75)
relations:
sfGuardUser: { local: user_id, foreign: id, onDelete: CASCADE }

This schema could be parsed by Doctrine in Symfony 1.2. I ran the symfony doctrine:build-all-reload task again. However it coughed up an error from MySQL:


SQLSTATE[HY000]: General error: 1005 Can't create table 'register.#sql-ae0_25'
(errno: 150). Failing Query: ALTER TABLE sf_guard_user_profile ADD FOREIGN KEY
(user_id) REFERENCES sf_guard_user(id) ON DELETE CASCADE


This seems to be a problem with the field definition. It has to do with user_id being integer (bigint in the SQL), and the id field in the plugin’s schema set to integer(4). Others have run into this error:

http://forums.mysql.com/read.php?22,19755,19755#msg-19755

Anyhow, I changed the definition for user_id to be the primary key. This is how it should be anyway; each user should only have one profile.

sfGuardUserProfile:
columns:
user_id:     { type: integer(4), primary: true }
...etc...

I ran symfony doctrine:build-all-reload again, and everything was fine…

Until I started using fixtures to load some default users and profiles:

sfGuardUser:
sgu_admin:
username:       admin
password:       mr9o1ob7
is_super_admin: true
normal_user:
username:       user
password:       password
is_super_admin: false</code>

sfGuardUserProfile:
sgup_admin:
sfGuardUser:    sgu_admin
first_name:     Jonathan
last_name:      Montgomery
email:          jjmontgo@gmail.com
sgup_user:
sfGuardUser:    normal_user
first_name:     Normal
last_name:      User
email:          noone@gmail.com

sfGuardPermission:
sgp_admin:
name:           admin
description:    Administrator permission

sfGuardGroup:
sgg_admin:
name:           admin
description:    Administrator group

sfGuardGroupPermission:
sggp_admin:
sfGuardGroup:       sgg_admin
sfGuardPermission:  sgp_admin

sfGuardUserGroup:
sgug_admin:
sfGuardGroup:       sgg_admin
sfGuardUser:        sgu_admin

This loaded to the database with user_id set to 0 in the user profile.

I tinkered around a bit more, altered the sfGuardUser relation under the profile schema (which didn’t seem to help), and eventually removed the primary key from user_id.

That worked. I’m not sure why. I don’t see why sfGuardUserProfile should have its own id field as a primary key. Please comment on this if you know the answer.

Here is my final sfGuardUserProfile schema:

sfGuardUserProfile:
actAs: [Timestampable]
columns:
user_id:
type: integer(4)
first_name:  string(20)
last_name:   string(20)
email:       string(75)
relations:
sfGuardUser:
local:     user_id
foreign:   id
type:      one
foreignType: one

While using Eclipse PDT, every time I tried to open a YAML file, the software would try to open the file externally.  Since I had no YAML editor installed, this would generate an error.

Now I could right click and choose Open With –> Text Editor.  But I wanted something a little better than a simple text editor, and I didn’t want the extra clicks.

That’s where Yedit came in, another great plugin for Eclipse.  The plugin can be found here:

http://dadacoalition.org/yedit

It installs easily in Eclipse:

Help –> Software Updates –> Add Site

Enter:

http://dadacoalition.org/yedit

Select the plugin from the list under this site, and click Install…

Remember to restart Eclipse after you install, in order to see the update.  You should now be able to open YAML files in your project easily.

My plan today was to dig into my Swing code, get some tests wrapped around it, and eliminate the duplication that built up last night as I played around with styling. Company business intervened, so I spent most of the day on a project with Eric M. and Caleb working on translating a large set of data into YAML format (with occasional HTML where necessary). As we got started, I realized that my work was going to be extremely error-prone, tedious, and slow if I just copied and pasted things over, formatting as I went. So I hacked up a Ruby script to do the basic import to YAML, which I think saved a lot of time (and I feel much more comfortable with handing this to the client). We did still do a bit of manual work (every export we sampled from our word processing program had limitations), but it wasn’t too bad.

Eventually, I got back over to my Swing code and eliminated a lot of duplication. I’m working on extracting all view/presentation code away from the code that I need to test. I’m not, for instance, going to bother with a test to make sure that the background color is blue. Among other benefits, this will make it clear to me when I’m finished, as I go through and add tests. I read the chapter in Programming in Scala last night on pattern matching, and I’m seeing uses for it everywhere now. I’m going to be very careful to avoid switch statements where polymorphism is possible, but I’m starting to get more comfortable with Scala and find multiple solutions pretty quickly.

There’s been some talk recently on the JRuby mailing list about using Jemmy to write integration tests on Swing code, so I’m excited about its prospects as I delve into my GUI tests.

I ran into a little problem when I converted our apache rewrite rule automated tests to use jruby instead of ruby. These tests use a little ruby driver which makes http requests to a local apache instance. The script reads a few yaml files which contain the url to test, and the expected result after Apache has done its mod_rewrite magic.

Using the MRI ruby meant having to install ruby on all developer machines, build boxes, and keep those ruby installations in sync. So I changed the ant script to pull jruby-complete.jar (1.2.0) from ivy, and run the tests in that. My tests started failing with ParserException messages about “found org.jvyamlb.tokens.KeyToken”. These were all yaml files that MRI ruby handles without complaint.

After much trial-and-error, slicing the yaml files up into smaller chunks to isolate the rules, I found the problem. Commas. In normal ruby, you can have them your values as long as they are not followed by a space. In jruby, you have to quote them. Arguably, JRuby is doing the right thing – I haven’t delved into the yaml spec enough to find out.

Here’s an example irb session with JRuby:

irb(main):001:0> require 'yaml'
=> true
irb(main):002:0> YAML.load("{url: http://someurl/path,with,commas, http_code: 200}")
ArgumentError: syntax error:ParserException while scanning a flow node we had this expected the node content, but found org.jvyamlb.tokens.KeyToken
        from (irb):3

Do the same with quoted strings:

irb(main):004:0> YAML.load("{url: \"http://someurl/path,with,commas\", http_code: 200}")
=> {"url"=>"http://someurl/path,with,commas", "http_code"=>200}

Similarly, unquoted strings containing question marks (“?”) were truncated.

irb(main):005:0> YAML.load("{url: http://someurl/path?with=query, http_code: 200}")
=> {"with=query"=>nil, "url"=>"http://someurl/path", "http_code"=>200}

Again, quoting the value solved the problem. Hopefully this helps anyone else that has YAML parsing problems in JRuby.

LINQ to XML is one of the many technologies introduced with the .NET Framework 3.5, and one that is certainly a step forward in terms of usability. It allows querying in both the functional style (using LINQ and lambda expressions) and the more traditional imperative one, meaning that it’s a great tool for concisely working with XML data in any sort of application, and undoubtedly a significant improvement over the old XML DOM that resides in the System.Xml namespace.

In the spirit of LINQ, and with the advent of YAML, I recntly decided it was about time that this new “markup language” were integrated with LINQ. Surprisingly, there does not already exist anything akin to LINQ to YAML out there (though there are a couple of fairly usable implementations of a YAML reader/writer for .NET). This seemed to me like a good chance to potentially create something that might be used by more than the odd .NET developer or two. My plans are to implement a LINQ to YAML provider either from scratch or on top of one of the existing YAML libraries. (Which option I choose will depend on the state of the existing projects, which I haven’t yet investigated properly. I am however suspecting that it might be worthwhile writing my own, since it would a) teach me all the intricacies of YAML, and b) allow me to support the latest version [1.2], which the existing libraries do not.)

Before I launch into an overview of my intended implementation, here is a little bit about YAML itself, for those who aren’t already familiar with it. Although technically YAML isn’t a markup language (after all, the recursive acronym stands for YAML Ain’t Markup Language) – it is rather a serialisation format – it does essentially fulfill the the role that XML  traditionally has, in a variety of common situations. I’m not going to try to sell the format to you right now, but it should suffice to say that you wouldn’t have reached this far in the post if you weren’t already at least intrigued! Without doubt, the format is actively gaining popularity because of it’s ultra-lightweight syntax and suitability for hand editing, perhaps the two points that summarise its advantages over XML.

Anyway, here’s a short example of a YAML document (taken straight from the Wikipedia page), so you can see precisely how pleasant it is to work with (at least for humans).

—

receipt:     Oz-Ware Purchase Invoice
date:        2007-08-06
customer:
    given:   Dorothy
    family:  Gale

items:
    - part_no:   A4786
      descrip:   Water Bucket (Filled)
      price:     1.47
      quantity:  4

    - part_no:   E1628
      descrip:   High Heeled "Ruby" Slippers
      price:     100.27
      quantity:  1

bill-to:  &id001
    street: |
            123 Tornado Alley
            Suite 16
    city:   East Westville
    state:  KS

ship-to:  *id001

specialDelivery:  >
    Follow the Yellow Brick
    Road to the Emerald City.
    Pay no attention to the
    man behind the curtain.
...

Of course, the great thing about YAML, which is demonstrated clearly by this example, is that you don’t have to have any real knowledge about YAML to understand exactly and immediately what the data represents, and as a bonus it doesn’t hurt your eyes to stare at for too long! Even the referencing syntax should be fairly self evident. (&id00 and *id001 would surely be nothing new to C programmers.)

The semantics as well as the syntax of YAML obviously differ to those of XML greatly, although there is almost always some sort of correspondence between the features and possibilities that the two formats offer. The only notable missing feature when contrasted to XML is attributes, yet their usefulness is questionable anyway.

Right, so now I ought to explain a bit about how I actually plan to design this library. The basic framework will be virtually equivalent to that of LINQ to XML. In other words, the hierarchy will be largely based around an abstract YamlObject (YObject?) class, and will look very much like the one contained within System.Xml.Linq.

LINQ to XML class hierarchy

Though LINQ to YAML must of course accomodate for the unique nature of the format, I would initially aim for minimal difference and only significantly adjust the hierarchy when it is found to be necessary. Classes such as XCData and XDocumentType would not apply at all to YAML, yet there would need to be a place for a YReference or such somewhere in the hierarchy. The referencing aspect of YAML will likely prove to be one of the more interesting challenges; while YAML’s lists, maps (dictionaries), and combinations thereof would seem relatively straightforward with regards to emulation of the LINQ to XML design, references would introduce a substantially novel concept. Some sort of implementation of lazy evaluation followed by concrete referencing should be able to solve the problem, but there’s no way to predict how well this might work in practice at this moment.

What I realised only after deciding to create a LINQ to YAML library is that among LINQ providers, LINQ to XML is somewhat special in that the LINQ aspect of it is built on top of LINQ to Objects (i.e. LINQ using IEnumerable<T> objects), with only a relatively small number of extension methods specific to LINQ to XML. Indeed, most LINQ providers (LINQ to Objects and LINQ to SQL among others) require you to implement the IQueryable and IQueryProvider interfaces to provide complex logic for interpreting and returning the results of expressions, as well as evaluating complex expression trees.  All this means that I can pretty much just design a DOM  to a certain style (i.e. one suited to functional code, like LINQ to XML), and let LINQ to Objects to everything else for me.

As I can’t think of anything more worth mentioning about my project at this time, I shall leave any more specific and complex details to a future post. Still, do by all means feel free to query me about my plans – I would be glad to answer any questions, and even gladder to receive some suggestions as how you think I might design LINQ to YAML, or simply a nod that you might find this useful at some point. I don’t anticipate this project to be a very long one, though I must say that both my work and free-time schedule are likely to be fairly messed up for the next month or two, therefore I’m not going to promise when I’ll get around to my initial release. Whenever it so happens, I will duly post the link to the project page on Launchpad (or wherever I decide to host it).

Das Lernziel 3 lautete: «Kennenlernen von JYAML als Basis für ein eigenes Joomla-Template»

Auch in dieser Phase gab es zeitliche Probleme: Um die geplanten 8 Stunden fürs SOL frei zu bekommen, musste ich eine Woche anhängen, sonst hätte es nicht gereicht. Alle Freitage in dieser SOL-Phase waren beruflich ausgebucht, obwohl dies eigentlich mein «Studientag» ist. Typisch fürs SOL war auch wieder, dass die Lernaufgaben immer Vorrang haben! Eigentlich schade, aber verständlich.

Zur Klärung vorneweg: JYAML ist eine Erweiterung zum CMS Joomla, mit der sich Joomla-Templates auf Basis des CSS-Frameworks YAML («Yet Another Multicolumn Layout») erstellen lassen. Beide Produkte stammen übrigens aus Deutschland: YAML wird von Dirk Jesse entwickelt, JYAML von Reinhard Hiebl.

Die vier Teilziele dieser Phase im Detail lauteten:

Ziel 1 (das JYAML-Template untersuchen): Erreicht.

Zunächst gab es Probleme bei der Installation von JYAML: Joomla verweigerte beharrlich die Installation des vollständigen JYAML-Paketes (bestehend aus der «Komponente», dem «Plugin» und dem «Template»). Der Installer meldete immer, gewisse Teile seien bereits vorhanden. Erst mit einer älteren Version von Joomla (1.5.7) klappte es schließlich. So ging schon mal kostbare Zeit verloren…

Ist JYAML einmal installiert, wird es in der Adminstrationsumgebung von Joomla über das Menü «Komponenten» aufgerufen. Der «JYAML Template Konfigurator» ist die Schnittstelle, über die eigene «Designs» erstellt und bearbeitet werden. Grundlage des Templates ist dabei das gesamte YAML-Framework. Es enthält also neben dem HTML-Grundgerüst eine Vielzahl an CSS- und JavaScript-Dateien, die an die Bedürfnisse von Joomla angepasst wurden. Der Code kann im integrierten Editor sogar direkt bearbeitet werden, sofern man weiss, was man tut! Zudem lassen sich eigene Stylesheets einbinden, die man extern erstellt hat. Doch auch dies setzt sehr gute Kenntnisse sowohl von CSS als auch von YAML voraus.

Ziel 2 (die JYAML-Community im Web kennenlernen): Teilweise erreicht.

Dokumentiert ist JYAML auf www.jyaml.de, aber die Community diskutiert im YAML Community Forum (http://forum.yaml.de). Ich habe mich dort zaghaft (als Anfänger) und nur kurz (wegen der fehlenden Zeit) umgeschaut. Mein Eindruck: vor allem für «Nerds» geeignet, die ganz spezifische Fragen haben. Reinhard Hiebl gibt als Moderator rasch und kompetent Antwort. Für Anfänger ist das Forum weniger geeignet.

Ziel 3 (die Eignung von JYAML als Basis eines eigenen Templates abschätzen): Erreicht.

Wer mit dem Framework YAML sattelfest ist und deshalb weiss, was er tut, für den kann JYAML ein leistungsfähiges Werkzeug sein, um eigene Joomla-Templates zu erstellen. Die Probleme mit der Installation haben mich allerdings etwas vorsichtig werden lassen: Wird JYAML mit zukünftigen Joomla-Versionen kompatibel sein? Macht man sich nicht zu sehr abhängig von einem einzigen Entwickler (Reinhard Hiebl)? Aus meiner Sicht wird das Erstellen von Joomla-Templates letztlich nicht einfacher, die Komplexität verlagert sich einfach, denn ohne gute YAML-Kenntnisse bringt auch JYAML nichts. Ernüchterndes Fazit: Das Erstellen von eigenen Joomla-Templates ist und bleibt eine zeitaufwendige, komplizierte Sache!

Ziel 4 (eine Liste von Massnahmen für die konkrete (spätere) Umsetzung erstellen): Nicht erreicht.

Dieses Ziel ist schlicht und ergreifend dem Zeitdruck zum Opfer gefallen. Im Moment steht auch keine konkrete Umsetzung an.

Hi All,

If you are planning to get started with REST in WCF, the following information might be helpful.

What is REST?

Representational state transfer (REST) is a style of software architecture for distributed hypermedia systems such as the World Wide Web. As such, it is not strictly a method for building “web services.” The terms “representational state transfer” and “REST” were introduced in 2000 in the doctoral dissertation of Roy Fielding,^[1] one of the principal authors of the Hypertext Transfer Protocol (HTTP) specification.

REST strictly refers to a collection of network architecture principles which outline how resources are defined and addressed. The term is often used in a looser sense to describe any simple interface which transmits domain-specific data over HTTP without an additional messaging layer such as SOAP or session tracking via HTTP cookies. These two meanings can conflict as well as overlap. It is possible to design a software system in accordance with Fielding’s REST architectural style without using HTTP and without interacting with the World Wide Web.^[2] It is also possible to design simple XML+HTTP interfaces which do not conform to REST principles, and instead follow a model of remote procedure call. The difference between the uses of the term “REST” therefore causes some confusion in technical discussions.

Systems which follow Fielding’s REST principles are often referred to as “RESTful“.

What are RESTful Web Services?

A RESTFul web service is a simple web service implemented using HTTP and the principles of REST. Such a web service can be thought about as a collection of resources. The definition of such a web service can be thought of as comprising three aspects:

• The URI for the web service such as http://example.com/resources/cars
• The MIME type of the data supported by the web service. This is often JSON , XML or YAML but can be anything.
• The set of operations supported by the web service using HTTP methods (e.g. POST, GET, PUT or DELETE).

Members of the collection are addressed by ID using URIs of the form <baseURI>/<ID>. The ID can be any unique identifier. For example if a RESTFul web service representing a collection of cars for sale might have the URI http://example.com/resources/cars. f the service uses the car registration number as the ID then a particular car might be present in the collection as http://example.com/resources/cars/yxz123.

The following table shows how the HTTP verbs are typically used to implement a web service.

What are WCF Rest Services?

WCF Rest Services are normal WCF Services that have added functionality so that they can be consumed in a RESTful manner (URI vs URL, Usage of HTTTP Verbs, Usage of Different Data Transfer Formats like JSON, YAML, etc…). So for example, if you had a stock ticker web service that you built in WCF, instead of requiring the caller to use a heavy WSDL implementation and ASMX, you could just use the WCF Rest functionality to publish that service as a JSON service instead and have it consumed via AJAX without having to point to an ASMX resource.

An example of WCF REST Service in .Net Framework 3.5:

WCF 3.5 provides explicit support for RESTful communication using a new binding named WebHttpBinding.
The below code shows how to expose a RESTful service

[ServiceContract]
interface IStock
{
[OperationContract]
[WebGet]
int GetStock(string StockId);
}

Microsoft has released a white paper in early 2007 comparing different distributed communication technologies with WCF. (including REST Services).

You can download this whitepaper from here (http://msdn.microsoft.com/en-us/library/bb310550.aspx)

Though there are loads of information on REST these days, i found the following links to be very insightful and helpful in understanding this technology.

How-to create a WCF Restful Service Video ( http://channel9.msdn.com/pdc2008/TL35/)

An Introduction to WCF Restful Web Services by Jon Flanders in MSDN Magazine  Jan 2009

A Guide to Designing and Building Restful Web Services using WCF 3.5 by Aaron Skonnard on MSDN in Oct 2008

WCF Blog Series:

• REST in WCF – Part I (REST Overview)
• REST in WCF – Part II (AJAX Friendly Services, Creating The Service)
• REST in WCF – Part III (AJAX Friendly Services, Consuming The Service)
• REST in WCF – Part IV (HI-REST – Exposing a service via GET – Configuring the service)
• REST in WCF – Part V (HI-REST – Exposing a service via GET – The ServiceContract and Implementation)
• REST in WCF – Part VI (HI-REST – Consuming our GET service via AJAX)
• REST in WCF – Part VII (HI-REST – Implementing Insert and Update
• REST in WCF – Part VIII (HI-REST – Implementing Delete)
• REST in WCF – Part IX – Controlling the URI
• REST in WCF – Part X – Supporting Caching and Conditional GET

Screencast Series on Channel9:

• endpoint.tv – Controlling the URI in RESTful WCF with Rob Bagby
• deCast – Creating a HI-REST GET Service with WCF 3.5
• deCast – Consuming a HI-REST GET Service From Silverlight 2 (Beta 2)
• endpoint.tv – Caching and Conditional Get with Rob Bagby
• deCast – Creating an AJAX-Friendly WCF Service
• deCast – Creating a HI-REST PUT Service That Exposes Insert and Update
• endpoint.tv – Securing RESTful services with ASP.NET Membership
• endpoint.tv – Content Negotiation with RESTful services
• deCast – Tunneling a PUT through POST with RESTful WCF

MSDN WebCasts:

REST and WCF 3.5 - Adnan Masood (LEVEL 200)

VS 2008, WCF and REST – (Level 200)

REST and ASP.Net MVC - Brian Hitney (Level 200)

REST and ADO.Net Services – Chad Brookes (Level 200)

REST Developer Center on MSDN

MSDN Code Samples:

REST and POX (http://msdn.microsoft.com/en-us/library/aa395208.aspx)

For further queries on troubleshooting and general advice, you can also check out REST Forums from MSDN.

Enjoy!

Ah yes, it’s that wonderful time of year again: fantasy baseball time.  Anyone who plays fantasy sports can tell you that other than getting a check for winning your league (something I would know nothing about), the best part of the season is the draft.

My fantasy draft preparation always involves the creation of a spreadsheet.  This nugget of gold will start with ratings and stats from various sites and sources before getting my own personal notes, organization, and shuffling (aka “messing it up”).  and what kind of card-carrying software engineer would do such a compilation by hand…

My basic strategy for compiling this sucker this year:

1. Scrape some stats and rankings from a few popular sites and dump them locally.
2. Load the stats from local, merge em, and kick out a csv.
3. Mess with stuff in the spreadsheet.
4. Win millions.

Scraping

I’ve used hpricot in the past but wanted a bit of a refresher — Man, this thing makes this task nice and easy.  Most of the sites have a fairly sane markup scheme for the tables they store players data in, so it’s normally as simple as (this is Ruby btw):

doc = Hpricot(open(url))
players = doc.search(".playerDataRow")
players.each do |player|
  meta = player.search("td .playerMeta")
  stats = player.search("td .playerStats")
  < do stuff >
end

Local Storage

Last year, I wrote this as a single script (scrape -> csv). Things got hairy when I needed to tweak the merger and thus had to re-run the whole thing (annoying) or hack it to run only a portion… and the same portion on each site (annoying). So, this year I got a little smart and wanted to dump the scrape results locally.

I fully intended to evaluate a few options here but as it turns out, the first try was just dead simple and worked perfectly: yaml. My scrapers each end up with a couple Arrays: one for hitters and one for pitchers. Each entry is a Hash of player data. I considered skipping the Array here but didn’t want to have the logic for name collisions in the scraper.

How hard was it to write my +player_data+ Hash to yaml?

YAML.dump(player_data, File.open(File.dirname(__FILE__) + "/yaml/" + filename, "w"))

Merging the scrape sources

This is a separate script here now…

Resurrecting the player data proved as simple as storing it in the first place.

YAML.load(File.open(File.dirname(__FILE__) + "/yaml/" + filename))

First pass I just wanted to merge based on player names – ignoring the imperfections that surely come with that… I was pleasantly surprised at how well things actually came out. I wrote a little throwaway script (as if this whole thing isn’t throwaway) to tell me how much of a problem I actually have. Basically: how many players in the top 400 of any site don’t have a match from the other sites? The answer was basically: a lot of Latin guys and a few others.

So, one problem I had was character sets used in the Latin player names. This is an area where “you’re going to throw this away” came into play: I just grabbed the few codes that I was having trouble with and regex’d to replace them with their friendlier counterparts. This is now on my list of “things to figure out how to do right”.

That out of the way, I re-ran and found that I really only had problems with about 20 guys. People with names like “Mike Smith”, that were “Michael Smith” in the other set. Here again: cheated. 20 guys? I can handle typing 20 names instead of figuring this one out, so I just modified the yaml manually here (this immediately breaks down if I have to re-run the scraper, but… I didn’t).

After determining which of the dumped data I wanted to keep (and which site could trump the others when they both had something like HRs), I created my csv with FasterCSV and I was rockin’.

In the spreadsheet

At this point, I was realizing that I should have created some new fields in that script… maybe look for things like big differences between sources (why does Y! think this guy is #20 and ESPN thinks he’s #100?) or even just: what’s the average of all the sites scraped. I was enamored with my spreadsheet though and haven’t had to been able to work with formulas in spreadsheets since my consulting-at-AmFam days, so I thought I’d give it a spin… and was quickly reminded of how easy they make it… to bash your head against the wall:

=IF(AND(P13="n/a";F13="");M13;IF(P13="n/a";(M13+F13)/2;IF(F13="";(M13+P13)/2;(M13+P13+F13)/3)))

YAML, like XML (but don’t say that around YAML fans, because they will insist that YAML is nothing like XML), is a faddish structured text format that, by virtue of its generality and abstractness, ends up being harder to work with even with a parser already written than an appropriately designed one-off flat text format.

Gems is Ruby’s way of dealing with distributions with lousy package managers and operating systems where there are no package managers, at the expense of sanity for the minority who could handle it better themselves. To be fair, they are open to this getting fixed; unfortunately, thanks to the immense suckiness of YAML, this is not straightforward.

The metadata for every Gem hosted on RubyForge is available in a really huge YAML file, whose format, rather surprisingly, is properly documented. There’s a standard tool for hosting things this way too, so presumably other repositories could easily do the same thing. This isn’t particularly nice, but it’s a huge improvement over CPAN’s lack of anything consistently useful…

Well, it would be a huge improvement, except the YAML file isn’t YAML.

Let’s run it through libyaml’s example-reformatter:

# Snip zillions of lines of output
  extlib-0.9.3: !ruby/object:Gem::Specification
    name: extlib
    version: !ruby/object:Gem::Version
Scanner error: while scanning for the next token at line 343989, column 18
found character that cannot start any token at line 343989, column 18

Oops. Oh well. Let’s run it through yaml-cpp, nominee for the “biggest screw-up of a build system, even taking into account the cmake handicap” award:

Error at line 343989, col 18: unknown token

Mmm. So what’s going on there?

343974   extra-1.0: !ruby/object:Gem::Specification
343975     name: extra
343976     version: !ruby/object:Gem::Version
343977       version: "1.0"
343978     platform: ruby
343979     authors:
343980     - Matthew Harris
343981     autorequire: extra
343982     bindir: bin
343983     cert_chain: []
343984 
343985     date: 2006-05-10 11:00:00 -04:00
343986     default_executable:
343987     dependencies: []
343988 
343989     description: `ruby-extra' is a package full of simple/fun/useful methods that are added to the
             core classes and modules of Ruby. It is quite similar to Facets but is still minimal.
343990     email: shugotenshi@gmail.com
343991     executables: []
343992 
343993     extensions: []
343994 
343995     extra_rdoc_files: []
343996 
343997     files: []
343998 
343999     has_rdoc: true
344000     homepage: http://ruby-extra.rubyforge.org
344001     post_install_message:
344002     rdoc_options: []
344003 
344004     require_paths:
344005     - lib
344006     required_ruby_version: !ruby/object:Gem::Requirement
344007       requirements:
344008       - - ">"
344009         - !ruby/object:Gem::Version
344010           version: 0.0.0
344011       version:
344012     required_rubygems_version:
344013     requirements: []
344014 
344015     rubyforge_project: ruby-extra
344016     rubygems_version: 1.3.1
344017     signing_key:
344018     specification_version: 1
344019     summary: Adds useful methods to built-in/core Ruby classes and modules.
344020     test_files: []

Looks like that backtick might be causing problems. According to the specification:

The “@” (#40, at) and “`” (#60, grave accent) are reserved for future use.

So libyaml and yaml-cpp are quite correct in barfing. Wonderful.

Next step: what generates that file, and how can we get it fixed?

Turns out the file is created by serialising a load of Gem::Specification objects. The serialisation is done by a library called Syck. Syck correctly escapes characters outside the safely printable range, but doesn’t care about @ or `. Patch time!

But things are never that simple. Syck’s most recent release was in 2005. Even getting at the source is somewhat tricky. According to Syck’s homepage, the source is in CVS. I’ve deliberately purged all knowledge of CVS from my brain, but it looks like the most recent commit was in September 2005.

According to this news item from November 2005, Syck is now in SVN instead. The link given 404s. Hunting around finds this, and from there this. After waiting for three and a half weeks for a git fetch (because Github is slooooooooooow), it seems that there’s at least some recent activity here.

But this isn’t the Syck used by Ruby. Ruby SVN includes its own copy of Syck. A quick look at the svn log shows that:

• Various fixes in the Syck on Github aren’t in Ruby’s copy.
• Various fixes in Ruby’s copy, including at least one with security implications, aren’t fixed in the Syck on Github.
• Neither has fixed the problem we care about.

So at this point I’m more or less giving up. The Gems YAML file isn’t YAML at all, and can only be parsed by Syck, which is at best badly maintained in at least two different places, with no coordination between the two. Brilliant.

Currently, I am twiddling around with /var/lib/apt/lists/*Packages for a small project. Those /var/lib/apt/lists/*Package files are about what Debian packages are available on a system. The files are used by aptitude too.

I saw a few Perl modules to deal with the Package files, though no Ruby one. A victim of Debian’s Ruby/Ruby gems policy?

However, the structure of the package files is almost YAML, but not quite. Actually, the file is subdivided into blocks, separated by \n\n sequences. Each such block is almost a dictionary — each pair separated from each other by a newline, and a key as the first word in line, followed by a colon and a space, then the value. With one exception — the Description field may contain multiple lines as the value part of the pair, each contiguous line starting with a space.

Once you fix those contiguous lines of the Description field, it’s easy — but to create a Hash of what originally might have been a hash already cries for an elegant solution. And here it is… apeiros_ and zibba__ of the IRC #Ruby channel pointed out that bit:

[20:31:40] <dagobart> is there an easy way to convert a colon/newline separated hash to a Hash?
[20:32:04] <zibba__> dagobart: can you paste some example input?
[20:32:06] <apeiros_> you mean string?
[20:32:08] <dagobart> (whereby the original is strings, coming from a file)
[20:32:21] <zibba__> "key: value \n" ?
[20:32:33] <dagobart> zibba__ yepp. that's it
[20:32:38] <apeiros_> Hash[*string.split(/[:\n]/)]
[20:32:41] <zibba__> dagobart: there you go
[20:32:58] <dagobart> apeiros_, zibba__ thank you:)
[20:33:24] <zibba__> what does the * do with string?[20:33:38] <apeiros_> nothing
[20:33:49] <apeiros_> precedence is:
[20:33:55] <apeiros_> Hash[*(string.split(/[:\n]/))]
[20:34:22] <apeiros_> and * for args means "expand to multiple args". e.g. foo(*[1,2,3]) is equivalent to foo(1,2,3)
[20:35:19] <dagobart> apeiros_: cool construct
[20:35:38] <dagobart> though I doubt I yet understand it fully
[20:35:45] <zibba__> apeiros_: I learn something new all the time. I have never seen that construct.
[20:35:59] <zibba__> dagobart: who needs understanding when you have a one liner...
[20:36:01] <apeiros_> dagobart, take it apart, play with it. irb is your friend with that.
[20:36:26] <apeiros_> zibba_, the point of being a 1 liner is moot
[20:36:29] <zibba__> it's basically like Hash[key1, value1, key2, value2]
[20:36:38] <apeiros_> but using only 2 method calls is quite nice.
[20:37:56] <dagobart> apeiros_: now I get it -- I mistook :\n as symbol-\n
[20:38:28] <dagobart> apeiros_: though it's obvious at second glance; it's a regex at all
[20:38:57] <dagobart> ...has its beauty, that construct

As this might be not the solution everyone might come up with at once, I liked to share it. I hope it’s useful for you.

Acho que a maioria dos programadores Java, assim como eu, sempre que vão aderir a uma nova tecnologia, procuram abstrações similares às quais temos no mundo Java. 

Pois bem, me vi na necessidade de parametrizar um código escrito em Ruby. A primeira coisa que me veio na cabeça: ARQUIVO PROPERTIES! Seria maravilhoso se existisse em Ruby um conceito exatamente igual, de forma que não fosse necessário gastar muito tempo com isso.

Foi aí que me deparei com o fato de que Ruby não tem um parser para arquivo properties! Pior que isso, nenhuma outra linguagem é obrigada a ter parser para arquivo properties, pois este tipo de arquivos foi criado no mundo Java! É claro que não é difícil de construir um no Ruby (mostrei uma implementação disso no post anterior 10 boas práticas em Ruby WATIR, na Boa Prática 9 - Recuperar mensagens de arquivos de texto), mas seria ideal se houvesse algum recurso similar nativo do Ruby…

Então passei a conhecer YAML. YAML é mais uma daquelas siglas recursivas, e significa YAML Ain’t Markup Language. É uma especificação de um padrão de serialização de dados que seja amigável a humanos, e compatível com todas as linguagens de programação. Seu site oficial é http://www.yaml.org/.

É um projeto muito bacana e simplório, tendo como objetivo fugir da complexidade das linguagens de marcação. Além disso, apresenta parsers para C/C++, Java, Python, Ruby, Perl, C#/.NET, PHP, Javascript, Actionscript e outros.

E o melhor: em Ruby é incrivelmente fácil de se trabalhar com YAML! Veja só:

a) Para carregar uma parametrização de um arquivo YAML em um dictionary:

require "yaml"

# (...)

  # This will load options.yml into config dictionary
  options_file = 'options.yml'
  config = YAML.load_file(options_file)

  # Now it has been loaded. This will get param1 parameter
  # into param1 variable.
  param1 = config['param1']

b) Para serializar dados de um dictionary e gravar em um arquivo YAML:

require "yaml"

# (...)

  config = {
    'param1' => 'value1',
    'param2' => 'value2',
    'param3' => 'value3'
  }

  File.open('options.yml', 'w') do |out|
    YAML.dump(config, out)
  end

Além disso, YAML pode também serializar dados de objetos, arrays, etc. E como possui parsers em diversas linguagens, agora ficou muito mais fácil e econômico para realizar serialização de dados entre sistemas construídos em linguagens diferentes, contrapondo o XML! YAML não causará o overhead causado por arquivos XML.

É claro que YAML não tem todo o potencial de XML, pois é apenas um formato de serialização de dados. Outro contraponto é que YAML não possui parsers mais complexos como os parsers de XML em Java e .NET. Mas para muitos propósitos, YAML pode ser mais adequado que XML.

Indeed, I often feel that XML documents, when compared with equivalent YAML files, demonstrate all the grace and calm reserve of a Pee-wee Herman chase scene (complete with rope swing, speedboat, sleigh, and man in a Godzilla costume).

That’s a quote from this book by André Ben Hamou, and it’s pretty much exactly how I feel about data serialisation. YAML has become my go-to format for just about everything. Why I love YAML:

• It’s really easy to map out and visualise complex data structures, especially in languages like Perl where this can be a bit of a pain.
• It’s completely cross-platform. so I can transport stuff between all the languages I write (yeah, OK, both of them if you don’t count 37 dialects of shell).
• It’s safe — no eval required
• Once your code is built to marshal/unmarshal using YAML, adding support for more formats (JSON, XML, language-native formats) is a piece of piss.

I will never write a config file parser again, nor hinky semi-structured report formats.

Das Lernziel 1 lautete: “Auffrischen der CSS-Grundlagen und Kennenlernen des YAML-Frameworks”

Gemessen an der Zielerreichung verlief die erste Phase des SOL recht erfolgreich. Für das erste Lernziel hatte ich dank den Weihnachtsferien viel Zeit und konnte mich in CSS und YAML vertiefen. Für die nächsten Meilensteine muss ich aber knapper kalkulieren und mich stärker an die Ziele halten, d.h. weniger „abschweifen“, auch wenn es durchaus interessant wäre, den vielen Links zum Thema zu folgen.

Es hat sich wieder einmal gezeigt, dass ich eher ein Nachtmensch bin, fand doch das SOL vorwiegend nach Sonnenuntergang statt. Zudem lerne ich nicht gerne verteilt in „kleinen Häppchen“, sondern lieber vertieft in größeren Blöcken.

CSS ist faszinierend, da man quasi jeden Pixel der Webseite damit steuern kann (von den Launen der Browser einmal abgesehen). Und man kann lernen durch Ausprobieren und sieht sofort das Ergebnis, ähnlich wie beim Programmieren. Das liegt mir.

Die vier Teilziele dieser Phase im Detail:

Ziel 1 (meine CSS-Kenntnisse repetieren): Erreicht.

Parallel zum SOL habe ich das Skript für einen dreitägigen HTML-/CSS-Kurs überarbeitet, den ich ab Februar als Weiterbildung für Geomatiker halten werde. Es war hilfreich, ein konkretes Ergebnis der Repetition vor Augen zu haben. Manchmal habe ich mich auch schlicht in den Möglichkeiten von CSS verloren und dabei mehr Zeit investiert als geplant.

Die Syntax von CSS ist zwar einfach, aber wegen der Vererbung von Styles (das „Cascading“) kann es rasch komplex werden. Bei der Analyse der Vererbung hat mir Firebug sehr geholfen. Eine Eigenschaft von CSS, “float”, hat es besonders in sich: das Verhalten von Elementen auf einer Webseite wird damit rasch unkontrollierbar! Das Buch Little Boxes 1 fand ich dabei so hilfreich, so dass ich mich entschloss, auch den Folgeband zu kaufen. (Den zu lesen habe ich aus Zeitgründen aber noch nicht begonnen.)

Ziel 2 (CSS-Framework YAML installieren und ausprobieren): Erreicht.

YAML ist sehr gut dokumentiert, und der YAML-Builder erlaubt es, per Drag and Drop sein eigenes mehrspaltiges Layout zu gestalten, ohne CSS händisch einzugeben. Wirklich beeindruckend.

Ziel 3 (einen Einblick in die YAML-Community im Web gewinnen): Nicht erreicht.

Aus Zeitgründen habe ich nur die Online-Dokumentation auf www.yaml.de studiert, aber sonst nicht nach Informationen im Web gesucht. Auch auf den Kauf des Buches von Dirk Jesse, dem Erfinder von YAML, habe ich bisher verzichtet (D. Jesse: CSS-Layout. Praxislösungen mit YAML. Galileo Press 2007).

Ziel 4 (Vor- und Nachteile des YAML-Frameworks abschätzen): Teilweise erreicht.

Einsicht: Mehrspaltige Layouts sind nicht “from scratch”, sondern nur mit Frameworks wie YAML zu schaffen! Vor allem nicht-CSS-konforme Browser (berüchtigt: IE 6) erschweren das Leben. YAML versucht mit diversen “Patches” die Fehler der Browser auszubügeln. Während die Vorteile von YAML somit auf der Hand liegen, sind mir die Schwächen des Frameworks noch nicht so klar. Da brauche ich noch mehr Einarbeitungszeit, um seine Grenzen auszuloten.