Composer, un administrador de dependencias para PHP

Composer es un administrador de dependencias para PHP que rastrea las dependencias locales de sus proyectos y bibliotecas. Para quienes usan Java, Composer vendría siendo algo como Maven o como CPAN para los programadores Perl.

Se usa en los principales frameworks web modernos para PHP (como Laravel, Symfony, etc.). Para descargarlo debemos ir a este sitio: https://getcomposer.org/download/

También existe una imagen Docker de Composer:

$ docker pull composer/composer
$ docker run --rm -it -v "$(pwd):/app" composer/composer install

Pero, antes de hacer nada, ¿Para qué sirve Composer?

Como desarrolladores PHP, nos ayuda a:

• Resolver las dependencias para paquetes PHP.
• Cargar automáticamente paquetes de PHP.
• Mantener todos los paquetes actualizados.

Una vez instalado, verificamos:

$ composer --version

Si todo va bien, mostrará versión instalada.

A continuación una pequeña lista de comandos más usados de Composer

Comandos más usados de Composer

Obtener ayuda:

$ composer --help

Listar comandos disponibles:

$ composer list

Obtener información de Composer:

$ composer about

Inicializa un nuevo proyecto con un archivo composer.json :

$ composer init

Instala un paquete y lo añade a composer.json :

$ composer require [paquete]

Ejemplo:

$ composer require monolog/monolog

Instala todas las dependencias listadas en composer.json :

$ composer install

Actualiza las dependencias a sus versiones más recientes compatibles :

$ composer update

Desinstala un paquete y lo elimina de composer.json :

$ composer remove [paquete]

Ejemplo:

$ composer remove monolog/monolog

Regenera el archivo de autoloading (vendor/autoload.php):

$ composer dump-autoload

Diagnosticar el sistema para identificar errores comunes:

$ composer diagnose

También es usado para crear proyectos. Veamos un ejemplo de como crear un proyecto Symfony:

$ composer create-project symfony/skeleton:"7.3.x-dev" miproyecto

Esto nos creará un proyecto Symfony, para ejecutar la aplicación debemos ejecutar este comando:

$ symfony server:start

Abrimos el navegador en la dirección: http://localhost:8000/

Continuaremos con esta serie sobre PHP y sus herramientas.

Enlaces:

https://getcomposer.org
https://www.codementor.io/@jadjoubran/php-tutorial-getting-started-with-composer-8sbn6fb6t

Un framework web ligero para PHP: CodeIgniter

Según el sitio oficial:

CodeIgniter es un potente framework PHP de tamaño muy reducido, creado para desarrolladores que necesitan un conjunto de herramientas simple y elegante para crear aplicaciones web con todas las funciones.

Características:

• Ligero: footprint pequeño (~2MB). 
• MVC: soporta el patrón Modelo-Vista-Controlador. 
• Fácil configuración: mínima configuración inicial. 
• Rendimiento: optimizado para alta velocidad. 
• Seguridad: incluye herramientas para proteger contra CSRF, XSS, y validación de datos. 
•  Documentación clara: guías detalladas y comunidad activa. 
•  Flexibilidad: no impone estructuras rígidas, compatible con PHP 7.4+.

Como ya es habitual en este blog crearemos un sencillo ejemplo usando ahora este micro framework.

Usaremos Composer para crear el proyecto.

Creando un proyecto con CodeIgniter(y Composer)

Creamos el proyecto:

$ composer create-project codeigniter4/appstarter hola-mundo

Nos ubicamos en el directorio creado:

$ cd hola-mundo

Copiamos el archivo env a .env

$ cp env .env

Editamos el archivo .env y descomentamos y ajustamos la variable app.baseURL para que quede de la siguiente manera:

app.baseURL = 'http://localhost:8080'

Ejecutamos la aplicación:

$ php spark serve

Abrimos el navegador en la dirección:

http://localhost:8080

¡Hemos creado nuestra primera aplicación usando CodeIgniter y Compose!

En algunos casos deberás editar el archivo php.ini y descomentar extension=intl (quitando el ;) :

extension=intl

Ejecutar este comando e iniciar de nuevo el server:

$ compose install
$ php spark serve

Enlaces:

https://www.codeigniter.com/

Conociendo Laravel: un framework para PHP

Laravel es un framework de PHP para desarrollar aplicaciones web, conocido por su sintaxis elegante, herramientas integradas y enfoque en la simplicidad y robustez. Facilita tareas como autenticación, enrutamiento, sesiones y más.

Si ya contamos con PHP y Composer instalados podemos crear un proyecto de la siguiente forma:

$ composer global require laravel/installer

Creamos un directorio y nos ubicamos en este:

$ mkdir proyecto
$ cd proyecto

Verificamos instalación:

$ laravel  --version

Creamos el proyecto:

$ laravel  new generador

Esto nos mostrará un prompt, elegiremos todo por default. Si todo va bien, se generará nuestro proyecto.

Nos ubicamos en el directorio creado (generador):

$ cd generador

Instalamos las dependencias y ejecutamos la aplicación:

$ npm install && npm run build
$ composer run dev

Si todo va bien, abriremos el navegador en la dirección:

http://localhost:5173/

¡Hemos creado nuestra primera aplicación con Laravel!

Enlaces:

https://laravel.com/

Slim framework: un micro framework para PHP

Slim es un micro framework PHP que le ayuda a escribir rápidamente aplicaciones web y API simples pero potentes.

Requisitos:

• Si no se tiene PHP instalado, instalarlo. 
• Si no se tiene Composer, instalarlo.

PHP:

https://www.php.net/downloads.php

Composer:

https://getcomposer.org/download/

Nota: Durante la instalación se te pedirá un proxy. Si no lo tienes, omite el paso y continua. También requerirás reiniciar tu máquina.

Instalando Slim Framework

Comprobamos la instalación de PHP y Composer:

$ php --version

$ composer --version

Creamos un directorio, nos posicionamos sobre este y generamos el proyecto:

$ mkdir proyecto-slim
$ cd proyecto-slim
$ composer create-project slim/slim-skeleton generator

Una vez generado, nos ubicamos en el directorio creado:

$ cd generator

index.php

Ejecutamos el proyecto:

$ php -S localhost:8081 -t public

¡Hemos creado nuestro primer proyecto con Slim Framework!

Hay otra forma de instalar y crear un proyecto. Debemos crear un directorio y ubicarnos en el.

$ mkdir proyecto
$ cd proyecto

Instalamos lo necesario para trabajar con Slim Framework:

$ composer require slim/slim
$ composer require slim/psr7

Se creará un directorio vendor y dos archivos (composer.json y composer.lock).

Verificamos el archivo JSON (vendor/composer.json):

{
    "require": {
        "slim/slim": "^4.0",
        "slim/psr7": "^1.0"
    }
}

Creamos un archivo index.php

<?php
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\Factory\AppFactory;

require __DIR__ . '/vendor/autoload.php';

$app = AppFactory::create();

$app->get('/', function (Request $request, Response $response, array $args) {
    $response->getBody()->write("¡Hola, Slim Framework!");
    return $response;
});

$app->run();

Ejecutamos la aplicación:

$ php -S localhost:8081

Tendremos ejecutandose nuestra aplicación en la dirección:

http://localhost:8081/

Algunas impresiones:

• Para ser un "micro" framework se genera todo un proyecto con muchos directorios y archivos "innecesarios". 
• Habrá que realizar un escudriñamiento más a fondo para ver cuales son sus puntos fuertes y de donde flaquea.

Enlaces:

https://www.slimframework.com/
https://getcomposer.org/download/

Un vistazo a Apache Struts Framework

Apache Struts es un framework MVC gratuito y de código abierto para crear aplicaciones web Java elegantes y modernas.

Prioriza las convenciones sobre la configuración, es extensible mediante una arquitectura de plugins e incluye plugins compatibles con REST, AJAX y JSON.

Es utilizado para desarrollar aplicaciones web basadas en la arquitectura MVC (Modelo-Vista-Controlador).

Struts fue muy popular antes de la llegada de Spring Framework y sobre todo de Spring Boot. Sin embargo, debido a su gran rendimiento aún es usado en muchas empresas.

Requerimientos:

• JDK 8 o superior. 
• Apache Maven 3.8.6 o superior. 
• Tener nociones de Java y JSP.
• Se puede usar un IDE como Eclipse, Visual Studio Code o cualquier otro.
• Sirve de mucho conocer algo de Spring Boot.

Nosotros usaremos la terminal para crear y ejecutar el proyecto.

Creando nuestra primera aplicación con Apache Struts2

Vamos a crear una sencilla aplicación de "Hola, mundo".

Creamos el proyecto Apache Struts2 con Maven y nos ubicamos en el directorio creado:

$ mvn archetype:generate -B 
  -DgroupId=org.cursomaven 
  -DartifactId=auditor -DarchetypeGroupId=org.apache.struts  
  -DarchetypeArtifactId=struts2-archetype-blank 
  -DinteractiveMode=false
$ cd auditor 

Abrimos el proyecto. Tendrá más o menos está estructura de carpetas:

auditor/ 
   pom.xml
   src/
     main/
       webapp/
          index.html
          WEB-INF/
           example/
           web.xml 
       resources/
          example.xml
          log4j2.xml
          struts.xml
       java/

Debemos eliminar los archivos innecesarios como: Login.java, HelloWorld.java, ExampleSupport.java. Esto para que solo quede una nueva clase llamada HolaMundo.java. Esto en la carpeta de java/org/cursomaven/example:

package org.cursomaven.example;


import com.opensymphony.xwork2.ActionSupport;


public class HolaMundo extends ActionSupport{

    public String execute() throws Exception {
        setMessage(getText(MESSAGE));
        return SUCCESS;
    }

    public static final String MESSAGE = "HolaMundo.message";
    
   
    private String message;

   
    public String getMessage() {
        return message;
    }

  
    public void setMessage(String message) {
        this.message = message;
    }
}

Tambien eliminaremos las páginas JSP del directorio webapp/WEB-INF/example. Esto para que solo quede una página JSP llamada HolaMundo.jsp

<%@ page contentType="text/html; charset=UTF-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
    <title><s:text name="HolaMundo.message"/></title>
</head>

<body>
<h2><s:property value="message"/></h2>

</body>
</html>

Editamos los archivos: package.properties y example.xml. Los cuales se encuentran en los directorios src/main/resources y src/main/resources/org/cursomaven/example

package.properties

server.port= 8081
HolaMundo.message =Bienvenido a ApacheStruts2.

example.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
        "http://struts.apache.org/dtds/struts-2.5.dtd">
<!-- 
  - This file is included by the struts.xml file as an example
  - of how to break up the configuration file into multiple files.
-->
<struts>
    <package name="example" namespace="/example" extends="struts-default">

        <default-action-ref name="HolaMundo" />

        <action name="HolaMundo" class="org.cursomaven.example.HolaMundo">
            <result>/WEB-INF/example/HolaMundo.jsp</result>
        </action>


        <!-- Add additional "example" package actions here. -->

    </package>
</struts>

Tambien editamos el archivo XML struts.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
        "http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
    <constant name="struts.enable.DynamicMethodInvocation" value="false"/>
    <constant name="struts.devMode" value="true"/>

    <include file="example.xml"/>

    <package name="default" namespace="/" extends="struts-default">

        <default-action-ref name="index"/>

        <action name="index">
            <result type="redirectAction">
                <param name="actionName">HolaMundo</param>
                <param name="namespace">/example</param>
            </result>
        </action>

    </package>

    <!-- Add addition packages and configuration here. -->
</struts>

Construimos con Maven:

$ mvn clean install -X

Ejecutamos con el servidor emembido Jetty:

$ mvn jetty:run -Djetty.port=8081

Abrimos el navegador en la dirección:

http://localhost:8081/auditor/example/HolaMundo

¡Hemos creado nuestra primera aplicación con Apache Struts2!

Continuaremos con esta serie sobre Frameworks web en próximas entregas.

Enlaces:

https://struts.apache.org/index.html

Dancer2: un framework web para Perl

Dancer2 es el framework web ligero de nueva generación para Perl. Esta herramienta proporciona una interfaz CLI atractiva y fácilmente extensible.

Veremos cómo instalarlo y crear un ejemplo sencillo.

Instalación de Dancer2

Abre una terminal y escribe esto:

$ cpan

Entrarás a CPAN, ahora instalamos Dancer2:

cpan> i Dancer2

Comenzará el proceso de descarga e instalación. Esperamos un poco (pueden ser algunos minutos).

Cuando finalice verificamos la instalación:

$ dancer2 version

Obtener ayuda:

$ dancer2 --help

Para crear un proyecto:

$ dancer2 gen -a MyWeb::App

Esto te creará un proyecto web con Dancer2.

Nos ubicamos en el directorio creado y ejecutamos la aplicación:

$ cd MyWeb-App
$ plackup -r bin/app.psgi

Abrimos un navegador en la siguiente dirección:

https://0.0.0.0:5000

Ahora crearemos un sencillo programa web sin la necesidad de crear un proyecto completo.

Un Hola, mundo con Dancer2

Creamos un sencillo script para el clásico "Hola, mundo".

dancr.pl

#!/usr/bin/env perl
use Dancer2;
get '/' => sub {
    return 'Hola, mundo con Dancer2';
};
start;

Ejecutamos el script:

$ perl dancr.pl

Abrimos un navegador en la dirección:

http://localhost:3000/

¡Hemos creado nuestra primera aplicación con Dancer2!

continuaremos con este tema en próximas entregas.

Enlaces:

https://perldancer.org/
https://medium.com/lets-fill-the-gap/dancer2-introduction-and-installation-8444079355fd

Genie Framework: un framework para Julia

Genie Framework es:

un marco de código abierto con todo lo que necesita para crear rápidamente aplicaciones web centradas en datos y listas para producción con Julia.

En este blog ya hemos escrito sobre Julia:

Un lenguaje de programación enfocado al cálculo, estadística y la matemática en general.

La documentación oficial nos dice:

Genie Framework es un potente framework web integral para el lenguaje de programación Julia, ideal para crear interfaces de usuario interactivas, API y aplicaciones web de producción. Ofrece un enfoque sencillo y de bajo código que facilita el desarrollo web a los usuarios de Julia, incluso a aquellos sin experiencia previa en desarrollo web.

Existen dos versiones:

• Genie Builder, la profesional. 
• Open Source, la de uso libre.

La versión Open Source tiene tres componentes principales:

1. Genie.jl: proporciona herramientas de backend y frontend para que puedas crear aplicaciones web y APIs completas basadas en tu código Julia. 
2.  Stipple.jl: Para una interactividad en tiempo real y una interfaz de usuario completa, como la que se necesita en un panel de control, proporciona una capa de interfaz de usuario reactiva. 
3.  SearchLight.jl: Para la persistencia de la base de datos, el ORM de Genie, que se puede añadir en cualquier momento.

¿Necesito tener Julia Language instalado en mi máquina? Sí, se necesita. Podemos descargarlo desde este enlace:

https://julialang.org/downloads/

Si usas Windows puedes obtenerlo de la Microsoft Store o abrir una terminal y pegar esto:

winget install --name Julia --id 9NJNWW8PVKMN -e -s msstore

Comencemos creando un directorio y posicionarnos sobre el mismo:

1 2	$ mkdir proyecto $ cd proyecto

Crear el proyecto con Julia:

1	$ julia --project

Dentro del REPL de Julia, agregamos el Framework:

1	pkg> add GenieFramework

Este comando instala Genie.jl, Stipple.jl y sus dependencias en su proyecto.

Creamos un archivo ``app.jl``. Escribimos lo siguiente:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

module App using GenieFramework @genietools @app begin @in name = "Genie" end function ui() [ h1("Mi primera aplicacion Genie") input("Introduce tu nombre", :nombre) p("Hola, {{message}}!") ] end @page("/", ui) end

Salimos del modo Pkg pulsando la tecla Retroceso. Luego, en el REPL de Julia, cargamos y ejecutamos la aplicación:

1 2 3

using GenieFramework Genie.loadapp() up()

Abrimos el navegador en la ruta:

http://localhost:8000

¡Hemos creado nuestra primera aplicación con Genie Framework!

Enlaces:

https://genieframework.com/
https://codemonkeyjunior.blogspot.com/search?q=julia

LangChain, un marco para desarrollar aplicaciones impulsadas por LLMs

LangChain es un marco diseñado para simplificar la creación de aplicaciones que integran LLMs (grandes modelos de lenguajes). LangChain proporciona todos los componentes básicos de la integración de IA en un único marco. Ofrece una arquitectura modular, flexible y escalable, fácil de mantener.

Pero, ¿Qué es un LLM (Large Language Model)?

Es un tipo de inteligencia artificial que puede comprender y generar texto en lenguaje humano.

Ahora, ¿Qué se necesita saber para aprender LangChain? Aquí una breve lista:

1. Programación en Python. 
2. Conceptos de inteligencia artificial y modelos de lenguaje (Ej. Entender qué son los modelos de lenguaje grandes (LLMs) como GPT, LLaMA o BERT). 
3. Procesamiento de lenguaje natural (NLP). 
4. Bases de datos y almacenamiento. 
5. Conceptos de APIs y servicios en la nube

Herramientas necesarias:

• Es necesario instalar o tener instalado Python en su última versión. 
• Instalar LangChain.

Podemos instalarlo de la siguiente forma:

$ pip install langchain

Un ejemplo sencillo:

holamundo.py

import getpass
import os

if not os.environ.get("OPENAI_API_KEY"):
  os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter API key for OpenAI: ")

from langchain.chat_models import init_chat_model

model = init_chat_model("gpt-4o-mini", model_provider="openai")

model.invoke("Hola, mundo!")

Si queremos profundizar sobre el tema podemos acceder a este enlace:

https://python.langchain.com/docs/introduction/

Continuaremos con este tema en próximas entregas.

Enlaces:

https://www.langchain.com/

GCP: línea de comandos de bigquery

La herramienta de línea de comandos bq es una herramienta de línea de comandos basada en Python para BigQuery.

Nos sirve para ejecutar consultas SQL de BigQuery. Veamos algunos ejemplos de cómo usarlo:

Listar version:

1	$ bq version

Obtener ayuda:

1

$ bq help

Listar datasets, jobs, etc.

1 2 3

$ bq ls $ bq ls --location=US $ bq ls --dataset=mydataset

Mostrar información sobre los dataset, jobs, etc.:

1 2 3

$ bq show mydataset $ bq show mydataset.mytable $ bq show --job=job_id

Eliminar datasets, tablas, etc.:

1 2 3

$ bq rm mydataset $ bq rm mydataset.mytable $ bq rm --job=job_id

Consultar datos de una tabla:

1	$ bq query --nouse_legacy_sql "SELECT name, age FROM mi_dataset.mi_tabla WHERE age > 30 LIMIT 10"

Crear un nuevo dataset:

1	$ bq mk --dataset mi_proyecto:mi_nuevo_dataset

Carga un archivo CSV local a una tabla en BigQuery:

1	$ bq load --source_format=CSV --autodetect mi_dataset.mi_tabla ./datos.csv

Exportar datos a Google Cloud Storage

1	$ bq extract --destination_format=CSV mi_dataset.mi_tabla gs://mi_bucket/salida.csv

Ejecutar un script desde un archivo:

1	$ bq query --nouse_legacy_sql < query.sql

Verificar el estado de un job:

1	$ bq show -j job_id

Para poder usarlo, debes estar autenticado:

1	$ gcloud auth login

Además de haber configurado tu proyecto:

1	$ gcloud config set project mi_proyecto

Aquí un script shell para realizar una consulta:

myshell.sh

1 2 3 4 5 6 7 8 9 10 11 12

#!/bin/bash gcloud config set project myProject bq query --use_legacy_sql=false --destination_table=myDataset.myTable \ 'SELECT word, SUM(word_count) AS count FROM `bigquery-public-data`.samples.shakespeare WHERE word LIKE "%raisin%" GROUP BY word'

Dar permisos:

1	$ sudo chmod 777 myshell.sh

Ejecución:

1	$ sh -x myshell.sh

La herramienta de línea de comandos bq de Google BigQuery es muy útil para interactuar con BigQuery desde la terminal.

En próximas entregas ampliaremos los ejemplos de su uso.

Enlaces:

https://medium.com/data-nuggets/11-basic-bigquery-bq-commands-for-data-interaction-59e0d7cee84c
https://stackoverflow.com/questions/76906880/how-to-run-saved-queries-using-bq-command-line-tool
https://cloud.google.com/bigquery/docs/bq-command-line-tool

Padrino: un framework web creado sobre Sinatra

Padrino es un framework web que está creado sobre la biblioteca web Sinatra.

Como hemos mencionado, Sinatra es un framework web ligero y es semejante a otros como Flask que tiene como base al lenguaje Python.

Instalando Padrino

Para instalarlo debemos teclear:

$ gem install padrino

Listamos para verificar instalación:

$ gem list

Creando un proyecto:

$ padrino g project hola_mundo

Nos ubicamos en el directorio creado:

$ cd hola_mundo

Tecleamos lo siguiente:

$ bundle --binstubs

Advertencia: ¡Este framework es bastante complicado de configurar si usamos una versión de Ruby mayor a la 3.0 !

Debemos modificar el archivo Gemfile

source 'https://rubygems.org'
ruby '3.3.4'
gem 'rake'
gem 'rack', '~> 2.2.0' # Especifica una versión compatible
gem 'padrino', '0.15.3'
gem 'webrick'

Hallar el archivo archivo router.rb en una ruta similar a la de:

C:\Users\HP\.local\share\gem\ruby\3.3.0\gems\padrino-core-0.15.3\lib\padrino-core

Lo editamos en la línea 61, añadiendo y sustityendo la línea por:

#match = Regexp.new("^#{Regexp.quote(path).gsub('/', '/+')}(.*)", nil, 'n')
match = Regexp.new("^#{Regexp.quote(path).gsub('/', '/+')}(.*)", nil)

Debemos ejecutar esto para instalar las dependencias descritas en el Gemfile:

$ bundle install

Editamos el programa app.rb

module HolaMundo

  class HolaMundo::App
    get '/' do
      "Hola, mundo"
    end
  end
end

Ejecutamos la aplicación y abrimos el navegador en la ruta http://localhost:3000/

$ bundle exec padrino start

¡Hemos creado nuestra primera y última aplicación usando este Framework!

Conclusión: No recomiendo este framework, ya que la configuración y la resolución de errores te puede llevar mucho tiempo. Considero que Sinatra es mejor y, aunque no lo he usado, Ruby on Rails también son mejores opciones.

Enlaces:

https://padrinorb.com/
https://sinatrarb.com/

Creando una aplicación web con Sinatra (Calculadora de pulsaciones)

Sinatra es un framework web ligero para el lenguaje Ruby que nos permite crear aplicaciones de una manera más sencilla que usando Ruby on Rails (quizás haremos un post al respecto).

En esta ocasión crearemos una sencilla aplicación que nos permita obtener el número de pulsaciones de una persona teniendo estas fórmulas:

No. pulsaciones masculina = (220 - edad) 
No. pulsaciones femenina = (226 - edad)

Requisitos:

1. Tener instalado Ruby. 
2. Tener nociones de HTML, CSS y Javacript. 
3. Tener nociones de Ruby (obviamente).

Comenzaremos con crear un directorio llamado ``pulse_calculator`` y nos posicionamos sobre este.

$ mkdir pulse_calculator
$ cd pulse_calculator

Dentro de esta crearemos una carpeta llamada ``views``. Esta nos servirá para crear las vistas de la aplicación web.

Ahora crearemos un archivo llamado ``Gemfile`` (sin ninguna extensión). Abrimos el archivo y colocamos lo siguiente:

source 'https://rubygems.org'

gem 'sinatra'
gem 'sinatra-contrib'

Es necesario ejecutarlo para instalar las dependencias, lo haremos de la siguiente forma:

$ bundle install

Crearemos el programa principal ``app.rb``, el cual contendrá la lógica del cálculo del número de pulsaciones. Se tomará en cuenta la edad y el género (masculino y femenino) para ello.

require 'sinatra'
require 'sinatra/reloader' if development?

# Ruta para el formulario (home)
get '/' do
  erb :index
end

# Ruata para ver el resultado
post '/calculate' do
  @name = params[:name]
  @age = params[:age].to_i
  @gender = params[:gender]

  # Calculo tomando el genero
  @pulse = if @gender == 'Femenino'
             226 - @age
           else
             220 - @age
           end

  erb :result
end

Como se puede observar:

• La ruta será GET "/" para el formulario de ingreso de datos. 
• La ruta POST "/calculate" para la vista de resultados obtenidos.
• Los datos a tomar en cuenta será la edad y género.

Dentro de la carpeta ``views`` crearemos dos archivos que serán las vistas:

• index.erb , para el formulario de entrada de datos. 
• result.erb , para mostrar los resultados.

index.erb

<!DOCTYPE html>
<html>
<head>
  <title>Pulsaciones Calculator</title>
  <style>
    body { font-family: Arial, sans-serif; margin: 50px; }
    .form-container { border: 1px solid black; padding: 20px; width: 300px; }
    label { display: block; margin: 10px 0 5px; }
    input, select, button { width: 100%; padding: 5px; margin-bottom: 10px; }
    button { background-color: #ccc; border: none; cursor: pointer; }
  </style>
</head>
<body>
  <div class="form-container">
    <h2>Pulsaciones Calculator</h2>
    <form action="/calculate" method="post">
      <label>Nombre:</label>
      <input type="text" name="name" required>

      <label>Edad:</label>
      <input type="number" name="age" required>

      <label>Género:</label>
      <select name="gender" required>
        <option value="Masculino">Masculino</option>
        <option value="Femenino">Femenino</option>
      </select>

      <button type="submit">Calcular</button>
    </form>
  </div>
</body>
</html>

result.erb

<!DOCTYPE html>
<html>
<head>
  <title>Resultados</title>
  <style>
    body { font-family: Arial, sans-serif; margin: 50px; }
    .result-container { border: 1px solid black; padding: 20px; width: 300px; }
    .result-box { border: 2px solid purple; padding: 10px; margin-top: 20px; }
    .pulse { color: red; }
  </style>
</head>
<body>
  <div class="result-container">
    <h2>Pulsaciones Calculator</h2>
    <p><strong>Nombre:</strong> <%= @name %></p>
    <p><strong>Edad:</strong> <%= @age %></p>
    <p><strong>Género:</strong> <%= @gender %></p>

    <div class="result-box">
      <h3>Resultados</h3>
      <p>Número de pulsaciones obtenidas: <span class="pulse"><%= @pulse %> pulsaciones</span></p>
    </div>
  </div>
</body>
</html>

Ejecutamos la aplicación web:

$ ruby app.rb

Si todo va bien, se ejcutará la aplicación web. Abrimos un navegador en la dirección:

http://[::1]:4567/

ó

http://localhost:4567/

¡Hemos creado nuestra aplicación para calcular pulsaciones con Sinatra!

Continuaremos con esta serie en fururas entregas.

Enlaces:

https://sinatrarb.com/
https://www.netguru.com/blog/ruby-on-rails-versus-sinatra
https://blog.appsignal.com/2023/05/31/how-to-use-sinatra-to-build-a-ruby-application.html
https://medium.com/simform-engineering/explore-sinatra-and-its-potential-for-building-web-apps-8463a2db0a0b