seeding ghost’s DB

building ghost-powered website’s contents in a scalable way

1. what we’re doing

We’re building a custom website for a particular client, and we’ll be using ghost as our cms. This allows us to quickly bootstrap the website, building a theme based on a custom design our client has previously picked.

2. the problem

To put this in a clear way, there’s three parts of the website we’ll deliver to our client:

  1. ghost, the CMS that will run our site
  2. a custom theme for our client, which has their colors, fonts, etc.
  3. the contents for the theme itself. the theme must have some contents in order to be fully displayed

It’s on the third item in the list where our problem lies on. Maybe it has not been paid too much attention, but there has to be a scalable way of handling the “base” or the “default” data the theme features. Some way in which a developer doesn’t see different contents than his partner when building the UI or when structuring the components and the elements for the webpage.

And it goes further than that – we’ll have:

  • one development environment per development machine (and there’ll be a couple of persons building it simultaneously)
  • a staging environment (or several of them, depending on how big our team) in which will be deployed automatically off from master branch and checked constantly so that we QA this shared env
  • a production environment – which won’t be created right away but needs to be easily deployed (and re-built) with the “initial” data once we are ready to deliver

It’s important for our building team to have a similar copy of each one of these. Keeping everybody in the same page will avoid us misunderstandings.

3. why not use DB dumps?

Well, there’s a few reasons. First, each environment must be using a different DB engine. For convenience, development environments will be using sqlite3 which is better for a bootstrap, while production environments will be running PostgreSQL.

4. the solution

The missing piece must be a program which can create (and re-create) in a one-off-run the “initial” data for the database (aka seed the database) in order to allow us to show correctly our theme

5. how to?

We’ve released a gem, which will read fixtures (yml files) for the models that currently make up ghost’s structure and will create the necessary DB records. This way our contents are written in simple text files rather than hardcoded on the theme itself.

This project has some seed fixtures we can take a look as a sample: github.com/prendho/webpage/tree/master/config/seed/fixtures

And this is the ruby gem, I hope we’ll be documenting in the close future: rubygems.org/gems/ghost-seeder

I’ll be writing some more documentation in our GH repo github.com/noggalito/ghost-seeder but basically at the moment we run the task using rake and it creates (or re-creates) the necessary data to make up the website.

$ rake db:seed

ghost-seeder db:seed task

ghost-seeder db:seed task

TL;DR

We add a ruby gem to our projects, which allows us to run a simple task and based on some “initial” data we deploy the entire website with it’s contents in a few seconds.

PSeInt en Linux

Un pequeño tutorial, para ejecutar PSeInt (Link al post anterior), en Linux.
Para éste(link al link de descarga) paquete (PSeInt.tar.gz), haremos en consola:

  • Nos cambiamos al directorio donde hayamos descargado el paquete (En caso de no estar dentro de la carpeta personal, en descargas, cambiar “Descargas” por el directorio donde se encuentra el paquete):
    ~ $ cd Descargas
  • Descomprimimos el paquete PSeInt.tar.gz(Esto descomprimirá el paquete con los ejecutables y los videos en el directorio actual):
    ~ $ tar -xf PSeInt.tar.gz
  • Ahora, a descomprimir el paquete de los ejecutables; pseint-l6-20090421.tgz:
    ~ $ tar -xf pseint-l6-20090421.tgz
  • Nos cambiamos al directorio donde se encuentran los ejecutables que acabamos de extraer:
    ~ $ cd pseint
  • A darle permisos de ejecución al archivo ejecutable wxPSeInt:
    ~ $ chmod +x wxPSeInt
  • Ejecutemos el wxPSeInt(Ejecutable del programa con interfaz gráfica):
    ~ $ ./wxPSeInt

Listo, tenemos el PSeInt funcionando con interfaz gráfica en nuestro Linux. Pero hagamos un script ejecutable en nuestro escritorio para abrirlo con un click:

  • Abrimos un editor de texto cualquiera (yo prefiero gedit) en el escritorio:
    ~ $ cd Escritorio; gedit
  • Dento del editor de texto, colocamos lo siguiente (Este es el script que se cambiará a al directorio donde está PSeInt y a continuación lo ejecutará):
    !# /bin/bash
    cd Descargas/pseint
    ./wxPSeInt

    Esto en caso de llamarse la carpeta pseint, como en este tutorial; y estar alojada dentro de “Descargas” en la carpeta personal. En caso de no ser así, modificar la segunda línea por el directorio donde se encuentran los ejecutables de PSeInt.
    Una vez terminado, guardar el documento (en mi caso como pseint en el escritorio y cerrar gedit. No hace falta que indiquemos una extensión para el archivo.
  • De nuevo en consola, le damos permisos de ejecución al archivo que acabamos de crear (si su archivo no se llama “pseint”, reemplazar por el nombre de su archivo:
    ~ $ chmod +x pseint

Listo, ahora podemos ejecutar PSeInt con su interfaz gráfica desde el escritorio con un simple “doble click”

Aprendiendo a programar; PSeInt

Esta vez hablaremos de una herramienta, llamada PSeInt, que ayudará a muchos nuevos en el mundo de la programación. A mi parecer, es la manera más rápida y sencilla para aprender a programar. Una de las ventajas es que esta herramienta interpreta el código fuente escrito en pseudocódigo (Mezcla de español y el orden de un lenguaje de programación; realmente fácil de entender para alguien que habla español; y no conoce ningún lenguaje de programación); es decir el lenguaje de programación que utiliza PSeInt es pseudocódigo; español; muy interesante. Incluso existe una opción denominada “paso a paso”, en donde el programa se ejecuta ‘paso a paso’, pudiendo así indicar al programador en donde hay un error de sintaxis, en caso de haberlo.

"Hola mundo!" en PSeInt

Además se puede exportar el código fuente a *.cpp (Extensión de código fuente de C++. Es decir, es posible escribir un programa en pseudocódigo y dejar que PSeInt lo traduzca a código fuente de C++. No hay necesidad de compilar ni de guardar antes de ejecutar el programa recién escrito.

Ejemplo de programa en PSeInt

Como si fuera poco (ésta me ha gustado mucho), nos permite ver un gráfico con el diagrama de flujo del código fuente del programa.

Flujograma creado por PSeInt

Se puede descargar PSeInt desde su página oficial, pero colgaré un enlace para bajarlo desde mi cuenta de Dropbox; la ventaja? Agrego dos videos además del programa, que ayudarán a familiarizarse con PSeInt (Espero no violar (muchos) derechos).
Enlaces:

  • PSeInt (página oficial)
  • PSeInt ( +2 videos; instalador para windows)
  • PSeInt ( +2 videos; paquete ejecutable para Linux; no necesita instalarse. Simplemente descomprimir y ejecutar)

Tal vez te interese ver un tutorial para ejecutar PSeInt con interfaz gráfica en Linux.