Asegurarse de tener limites amplios del sistema operativo para abrir archivos y manejar memoria, por ejemplo superiores a los siguientes en /etc/systctl.conf

    kern.shminfo.shmmni=1024
    kern.seminfo.semmns=2048
    kern.shminfo.shmmax=50331648
    kern.shminfo.shmall=51200
    kern.maxfiles=20000

El usuario desde el cual desarrollará o ejecutará aplicaciones también debe tener límites amplios, en particular su clase de login (por ejemplo staff). Debe tener al menos los siguientes en /etc/login.conf

    staff:\
            :datasize-cur=1536M:\
            :datasize-max=infinity:\
            :maxproc-max=4096:\
            :maxproc-cur=4096:\
            :openfiles-max=8090:\
            :openfiles-cur=8090:\
            :ignorenologin:\
            :requirehome@:\
            :tc=default:

(Si modifica el archivo /etc/login.conf debe reconstruir su versión binaria con doas cap_mkdb /etc/login.conf).

Para facilitar su exploración del lenguaje ruby, puede usar irb (ver {4}), pero antes verifique que su archivo ~/.irbrc tenga las siguientes líneas (añadidas por defecto en adJ a la cuenta de administrador):

    # Configuración de irb
    # Basado en archivo de ordenes disponible en <http://girliemangalo.wordpress.com/2009/02/20/using-irbrc-file-to-configure-your-irb/>
    require 'irb/completion'
    require 'pp'
    IRB.conf[:AUTO_INDENT] = true
    IRB.conf[:USE_READLINE] = true

    def clear
        system('clear')
    end

A continuación ingrese a irb y escriba por ejemplo 4. y presione la tecla [Tab] 2 veces para ver los métodos de la clase Integer.

El paquete ruby incluye rubygems que maneja gemas (es decir librerías) con el programa gem.

El directorio donde se instalan las gemas globales es /usr/local/lib/ruby/gems/3.0/ donde sólo pueden instalarse con doas. Recomendamos iniciar un directorio para instalar gemas como usuario normal en /var/www/bundler/ruby/3.0, por 3 razones (1) evitar riesgos de seguridad al instalar gemas como root, (2) evitar problemas de permisos y la dificultad de programas como bundler para usar doas en lugar de sudo y (3) alistar infraestructura para que sus aplicaciones corran en una jaula chroot en /var/www

Prepare ese directorio con:

    doas mkdir -p /var/www/bundler/ruby/3.0/
    doas chown -R $USER:www /var/www/bundler

Y cuando requiera instalar una gema allí emplee:

    gem install --install-dir /var/www/bundler/ruby/3.0/ json -v '2.0'

O si llega a tener problemas de permisos con:

    doas gem install --install-dir /var/www/bundler/ruby/3.0/ bcrypt -v '3.1.11'

Para facilitar compilación de algunas extensiones (como las de nokogiri) se recomienda instalar pkg-config globalmente:

    doas gem install pkg-config

Para facilitar el manejo de varias gemas (y sus interdependencias) en un proyecto es típico emplear bundler que instala con:

    doas gem install bundler
    if (test -x /usr/local/bin/bundle30) then {
       doas ln -sf /usr/local/bin/bundle30 /usr/local/bin/bundle;
    } fi

Configúrelo para que instale gemas localmente en /var/www/bundler/ruby/3.0 con:

  bundle config path /var/www/bundler/

Esto creará el directorio ~/.bundler/ y dentro de este el archivo ~/bundle/config con el siguiente contenido:

---
BUNDLE_PATH: "/var/www/bundler/"

Puede experimentar descargando un proyecto para ruby ya hecho, seguramente verá un archivo Gemfile, donde bundler examina de que librerías depende la aplicación y genera un archivo Gemfile.lock con las versiones precisas por instalar de cada gema.

Una vez tenga un proyecto asegure que este emplea las gemas de /var/www/bundler/ruby/3.0 ejecutando dentro del directorio del proyecto:

    mkdir .bundle
    cat > .bundle/config <<EOF
    ---
    BUNDLE_PATH: "/var/www/bundler"
    BUNDLE_DISABLE_SHARED_GEMS: "true"
    EOF

E instale con

    bundle install

Si eventualmente no logra instalar algunas –por problemas de permisos típicamente– puede instalar con

    doas gem install --install-dir /var/www/bundler/ruby/3.0 json -v '2.0'

Cuando actualice la versión del sistema operativo al igual que con gemas es importante reinstalar las gemas de las que depende una aplicación –necesariamente las que tengan extensiones en C. Esto es sencillo con versiones de bundler posteriores a la 1.15.4:

    bundle pristine

y después instalando una a una las gemas que sean extensiones, por ejemplo

    doas gem install --install-dir /var/www/bundler/ruby/3.0 nokogiri -v '2.0'

Se trata de una popular gema que facilita mucho la creación de sitios dinámicos.

Para instalarla globalmente (en /usr/local/bin y /usr/local/lib/ruby/gems/) la versión estable más reciente de Rails ejecute

    doas gem install rails

Rails requiere en el servidor un intérprete de JavaScript, por lo que recomendamos node.js (ver {1}) incluido en adJ 6.8 y que se configurará automáticamente.

La gran mayoría de gemas usadas por rails instalarán de la misma forma que se explicó. Algunos casos especiales son:

        doas gem install --install-dir /var/www/bundler/ruby/3.0/ nokogiri -- --use-system-libraries

        QMAKE=qmake-qt5 MAKE=gmake doas gem install capybara-webkit

Si su aplicación rails emplea coffescript necesitará un programa que pueda ejecutar javascript al lado del servidor, recomendamos node.js incluido en adJ. Actualice a la versión más reciente de npm con:

    doas npm install npm -g

Instale coffeescript con:

    doas npm install -g coffee-script

Las aplicaciones Ruby on Rails posteriores a 6.0 requieren el manejador de paquetes Javascript yarn. Lo puede instalar más fácil con bash y con:

doas pkg_add bash
curl --compressed -o- -L https://yarnpkg.com/install.sh | bash

Si durante la ejecución de yarn ve fallas del estilo:

/tmp/yarn--1602506143839-0.91595986516731/node[3]:
/tmp/yarn--1602506143839-0.91595986516731/../node: not found

que hemos visto por ejemplo con @fortawesome/fontawesome-free, se recomienda enlazar el binario de node en /tmp:

doas ln -s /usr/local/bin/node /tmp/

Para emplear vim como editor se recomienda asegurarse de haber ejecutado:

    cd ~
    mkdir -p .vim
    cd .vim
    cp -rf /usr/local/share/vim/vim83/* .

y si no tiene archivo ~/.vimrc ejecutar:

    cp /usr/local/share/vim/vim83/vimrc_example.vi ~/.vimrc

así como agregar el archivo ~/.vim/ftplugin/ruby.vim las siguientes líneas:

    setlocal shiftwidth=2
    setlocal tabstop=2
    set expandtab

Genere una nueva aplicación:

    rails new aplicacion
    cd aplicacion
    mkdir .bundle
    cat > .bundle/config <<EOF
    ---
    BUNDLE_PATH: "/var/www/bundler"
    BUNDLE_DISABLE_SHARED_GEMS: "true"
    EOF
    bundle install

Esto creará una nueva aplicación de ejemplo e instalará todas sus dependencias. Las gemas que no logre instalar por falta de permisos, como se explicó anteriormente instálelas con doas gem install y la opción --install-dir /var/www/bundler/

Una vez haya logrado que bundle install se ejecute completo puede ejecutar:

    rails server

Tras esto puede ver con un navegador la aplicación en el puerto 3000 del computador donde instaló: http://127.0.0.1:3000/

Notará que se generan los siguientes directorios y archivos:

Puede crear un primer recurso (digamos Departamento) con modelo, controlador simple y vistas para operaciones CRUD y RESTful con:

    rails g scaffold Departamento nombre:string{500} latitud:float longitud:float fechadeshabilitacion:date
    rake db:migrate

Tras esto y volver a iniciar el servidor (más breve con rails s) podrá realizar las operaciones básicas sobre departamentos desde: http://127.0.0.1:3000/departamentos/

El scaffold genera tablas (con una migración), modelo, controlador, vistas y rutas iniciales que con una interfaz muy simple le permitirán listar departamentos, ver detalles de cada uno, crear nuevos, editar existentes y eliminar.

Los archivos generados son:

Por convención de Ruby on Rails:

La página inicial de su aplicación puede crearla generando un controlador con vista, modificando la vista y especificando la ruta:

    rails g controller hogar

Que genera:

Modifique el controlador app/controllers/hogar_controller.rb para indicar que tendrá un vista index:

    class HogarController < ApplicationController
        def index
        end
    end

Cree la vista app/views/hogar/index.html.erb:

    <article>
      <h1>Mi aplicación</h1>
      <para> Manejar <a href="/departamentos">Departamentos</a></para>
    </article>

Y en el archivo de configuración de rutas config/routes.rb añada:

    root "hogar#index"

Al modificar fuentes en general no necesita volver a lanzar el servidor de rails, pero si modifica config/routes.rb o cualquier archivo fuera del directorio app debe reiniciar el servicio.

Examine desde un navegador http://127.0.0.1:3000/. Verá lo que escribió en app/views/hogar/index.html.erb en el ambiente HTML que tenga diseñado en app/views/layouts/application.html.erb.

Puede examinar la tabla creada e interactuar con la base de datos con la interfaz texto de SQLite como se ejemplifica a continuación:

    $ rails dbconsole
    sqlite> .schema
    CREATE TABLE "departamentos" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "nombre"
    varchar(500), "latitud" float, "longitud" float, "created_at" datetime, "updated_at" datetime);
    CREATE TABLE "schema_migrations" ("version" varchar(255) NOT NULL);
    CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version"
    );

Se recomienda emplear UTF8 como codificación de PostgreSQL (si emplea otra codificación convierta sacando un respaldo eliminando la base, volviéndola a crear con -E UTF8 y restaurando los datos).

        cd ..
        rails new prueba1 --database=postgresql

         doas su - _postgresql
        $ createuser -Upostgres -h/var/www/tmp prueba
        Shall the new role be a superuser? (y/n) n
        Shall the new role be allowed to create databases? (y/n) y
        Shall the new role be allowed to create more new roles? (y/n) n
        $ psql -h/var/www/tmp -Upostgres psql (9.3.6) Type "help" for help.
        postgres=# ALTER USER prueba1 WITH password 'miclave'; ALTER ROLE postgres=# $ exit

        rails dbconsole

        ActiveRecord::Base.pluralize_table_names=false

       config.active_record.schema_format=:sql

        rake db:structure:dump

        rails generate model mitabla --migration=false --timestamp=false

    doas gem install annotate

y ejecute:

        annotate

    rake db:schema:dump

y ejecute

    scaffold

para ver las instrucciones que debe dar a rails para generar modelos, controladores y vistas para las tablas de la base de datos.

RoR tiene sus propias convenciones respecto a SQL, nombres de tablas y demás, en ocasiones puede ser mejor intercambiar datos JSON con una aplicación ya existente que interactúe con la base de datos. Sin embargo si desea emplear RoR tanto como pueda para interactuar con la base de datos, tenga en cuenta:

    rails g migration addTiempoToIntervalo created_at:datetime
    updated_at:datetime

tras lo cual debe editar la migración creada para asegurar que queda
bien (por ejemplo pasando a singular la tabla si ese es su caso).

        create_table "usuario", id: false, force: true do |t|
          t.string "id", limit: 15, null: false
          t.string "nombre", limit: 50 ...
          t.datetime "created_at"
          t.datetime "updated_at"
        end
        add_index "usuario", ["id"], name: "index_usuario_on_id",
        unique: true, using: :btree

Y en el modelo `app/models/usuario.rb` debe quedar:

        class Usuario < ActiveRecord::Base
          ...
          self.primary_key=:id
        end

        connection = ActiveRecord::Base.connection()
        connection.execute("INSERT INTO mitabla(id, nombre) VALUES ('id1', 'nom1')")

Si su público objetivo habla principalmente español puede:

       doas gem install rails-i18n

        bundle update

        config.time_zone = 'America/Bogota'
        config.i18n.default_locale = :es

        ActiveSupport::Inflector.inflections do |inflect|
          inflect.irregular 'pais', 'paises'
        end