Jednoduchá aplikace Ruby od nuly s Active Record

Rád pracuji s Rails protože mohu snadno a rychle vytvořit fungující aplikaci a ukázat ji světu nebo jen svým přátelům. Existují však typy aplikací, které nepotřebují tak rozsáhlý framework, jako je např. Rails a všechny jeho funkce.

Může se stát, že naše aplikace potřebuje z celého vzoru MVC pouze M (Model). Model-Controller. Stojí za to začít projekt na adrese Rails pokud víme, že část V-C (View-Controller) nebude potřeba?

Je dobré vědět, že Aktivní záznam , Active Model, Action Pack a Action View, které jsou zodpovědné za MVC, mohou být použity nezávisle na sobě. Rails. To umožňuje nás vytvořit jednoduchý Ruby aplikace který má připojení k databázi, a vytvořit jej bez zbytečných kód a knihovny, které bychom získali v balíčku spuštěním příkazu rails new.

Krok za krokem jsem popsal, jak toho dosáhnout, a celý kód najdete na GitHubu. Odkaz je na konci tohoto článku. 

Struktura

K zahájení našeho projektu nepotřebujeme mnoho. Začneme vytvořením Gemfile kam přidáme drahokamy, které potřebujeme k práci s aplikací, spolu s verzí systému. Ruby budeme používat.

 cat Gemfile

# frozen_string_literal: true

source 'https://rubygems.org'

ruby '2.7.2'

Volitelný README.md Soubor má popsat, jak naše aplikace funguje a jak na ní dále pracovat, a to jak pro nás, tak pro další vývojáře, kteří s námi budou chtít projekt v budoucnu rozvíjet.

cat README.md

Aplikace #

TO DO: Vymažte tento a výše uvedený text a popište svou aplikaci.

aplikace adresář s application.rb který bude zodpovědný za konfiguraci a načítání knihoven a souborů, které budeme přidávat do naší aplikace. Nezapomeňte spustit instalace svazku generovat Gemfile.lock. Struktura naší aplikace by v této fázi měla vypadat takto:

 strom
 .
 ├── Gemfile
 ├── Gemfile.lock
 ├── README.md
 └──── app
     └──── application.rb

Databáze

S takto připravenou strukturou můžeme zvážit, jaký databázový stroj zvolit a nakonfigurovat. Pro tento článek jsem zvolil PostgresQL, se kterým mám největší zkušenosti. Může to být také MySQL nebo SQlite3, nebo jakýkoli jiný engine pracující s Aktivní záznam. Při výběru technologie je dobré řídit se účelem aplikace, k čemu bude sloužit a jaký bude její účel. 

Pro rychlou a jednoduchou konfiguraci databáze jsem použil docker a docker-compose. Nechci se podrobně zabývat konfigurací těchto nástrojů, jejich výhodami a nevýhodami, ale pokud jste nikdy předtím nepoužívali docker, pak bych vás odkázal na oficiální dokumentaci k těmto nástrojům. Docker a Docker Compose další informace.

# docker-compose.yml

verze: '3.7'
services:
  Postgresql:
    image: postgres:12.0-alpine
    porty: Poststral.cz: port:
- 5432:5432
    prostředí:
- Postgresql: PGDATA=/postgresql
- POSTGRESPASSWORD=postgres
- POSTGRESUSER=postgres
    svazky:
- db-volume:/postgresql
volumes:
  db-volume:

Budeme také muset přidat do našeho Gemfile

 gem 'pg'

a na naše application.rb soubor

# app/application.rb

require 'pg'

modul Application

  class Error < StandardError; end

# Váš kód patří sem...

end

Samostatné migrace, Rake

Dalším krokem při konfiguraci naší aplikace je přidání příkazu standalone_migrations a hrábě gems, které nám umožní spravovat naše migrace stejně jako v Rails a získat přístup k příkazům rake db:. 

1. Aktualizace Gemfile s potřebnými drahokamy a proveďte instalace svazku

drahokam # používaný v jiných než railových a nerubyových aplikacích

gem 'standalone_migrations'

# standalone_migrations potřebuje rake, aby mohl vytvářet migrace a spouštět je, stejně jako v Rails

gem 'rake'

# Gem potřebný k načtení proměnných prostředí

gem 'dotenv'

2. Přidejme Soubor Rakefile do našeho projektu v kořenovém adresáři, kde načteme dotenv a standalone_migrations které jsme přidali dříve 

# frozen_string_literal: true

require 'dotenv'

Dotenv.load

require 'standalone_migrations'

StandaloneMigrations::Tasks.load_tasks

S Soubor Rakefile Takto nakonfigurovaní můžeme zkontrolovat, zda naše hrábě funguje pomocí rake -T který by měl vrátit seznam dostupných příkazů v naší aplikaci.

3. Před rake db:create, musíme mít v našem projektu ještě konfigurační soubor pro připojení k instanci Postgres. K tomu potřebujeme vytvořit adresář db spolu s adresářem config.yml soubor, který by měl vypadat jako ten níže:

# db/config.yml

výchozí: &default

  adaptér: postgresql

  kódování: unicode

  pool: 

  databáze: 

  uživatelské jméno: 

  password: 

  hostitel: 

  port: 

development:

  <<: *default

test:

  <<: *default

staging:

  <<: *default

production:

  <<: *přednastaveno

Jak vidíte, použil jsem proměnné prostředí ke konfiguraci připojení k našemu Postgresu, kde budeme uchovávat citlivé údaje. data které by v úložišti neměly být. K tomu jsem použil dříve přidaný gem dotenv, který byl rovněž přidán do Soubor Rakefile spolu s standalone_migrations. Pokud ke správě verzí naší aplikace používáme systém Git, nezapomeňme přidat příkaz .gitignore kde zakážeme možnost sledovat .env z našeho projektu.

 # .gitignore
.env*
!.env.example

a přidat.env soubor obsahující správně nakonfigurovaný ENV

# .env

DATABASE_NAME="development"

DATABASE_USER="postgres"

DATABASE_PASSWORD="postgres"

DATABASE_HOST="localhost"

DATABASE_PORT="5432"

4. V této fázi bychom měli být schopni spustit rake db:create příkaz, který vytvoří databázi

   

5. Zkusme přidat novou migraci prostřednictvím rake db:new_migration name=, kde vytvoříme příspěvky stůl s :title sloupec

   

# frozen_string_literal: true

třída CreatePosts < ActiveRecord::Migration[6.0]

  def change

    create_table :posts do |t|

      t.string :title

    end

  end

end

Měli byste si všimnout, že db/migrate adresář byl automaticky přidán a schema.rb byl vytvořen po úspěšné migraci. V současné době vypadá struktura našeho projektu následovně:

 strom
.
├── Gemfile
├── Gemfile.lock
├── README.md
├── Rakefile
├── .gitignore
├── .env.example
├── app
│ └──── application.rb
├── db
│ ├──── config.yml
│ ├── migrate
│ │ └── 20210504135128_create_posts.rb
│ └── schema.rb
└── docker-compose.yml

Aktivní záznam

V neposlední řadě je dalším krokem při vytváření naší aplikace přidání activerecord a jeho konfiguraci. Za tímto účelem budeme muset aktualizovat náš Gemfile o další 3 drahokamy:

gem 'activerecord'
gem 'erb'
gem 'yaml'

Proč přidáváme erb a ymal je vysvětleno níže v komentářích. Celý active_record konfigurace bude v app/application.rb soubor.

Projděme si postupně, co se zde děje:

# frozen_string_literal: true

# Pokud chceme mít možnost spustit aplikaci v různých prostředích,
# např. testovací nebo produkční, je dobré nastavit hodnotu ENVIRONMENT
# na začátku, která se přebírá z proměnné prostředí
# nebo `development` ve výchozím nastavení.

ENV['ENVIRONMENT'] ||= 'development'

# Abychom mohli přidané drahokamy používat, musíme je načíst pomocí metody Kernel#require,
# která načte soubor nebo knihovnu předanou jako parametr

require 'pg'
require 'active_record'
require 'dotenv'
require 'yaml'
require 'erb'

# Ve výchozím nastavení Dotenv.load pro načítání proměnných prostředí dosahuje hodnot
# do souboru `.env`, takže pokud chceme používat jiná prostředí, vyplatí se
# rozšířit tuto metodu na níže uvedenou, která bude nejprve pro vývoj sady
# prostředí hledat soubor končící na `.env.development.local`,
# pak `.env.development` a nakonec `.env`.

Dotenv.load(".env.#{ENV.fetch('ENVIRONMENT')}.local", ".env.#{ENV.fetch('ENVIRONMENT')}", '.env')

# Metoda potřebná pro načtení nastavení databáze
def db_configuration
  # Níže uvedená metoda vrací cestu k souboru s naší konfigurací.
  db_configuration_file_path = File.join(File.expand_path('..', __dir__), 'db', 'config.yml')

  # Když máme cestu k souboru, můžeme načíst jeho hodnoty. Protože soubor config.yml
  # soubor obsahuje proměnné prostředí a, jak jste si možná všimli,
  # syntaxi erb , musíme také použít gem erb. Bez toho,
  # hodnoty proměnných nebudou správně načteny a záznam activerecord
  # nebude možné se připojit k postgresu. následující metoda vrátí hodnotu
  # konfiguraci jako řetězec

  db_configuration_result = ERB.new(File.read(db_configuration_file_path)).result

  # Pomocí dříve přidaného drahokamu `yaml` můžeme bezpečně načíst naši konfiguraci

  YAML.safe_load(db_configuration_result, aliases: true)
konec

# Nakonec musíme vytvořit spojení mezi activerecord a postgres
# pomocí metody `establish_connection`.
ActiveRecord::Base.establish_connection(db_configuration[ENV['ENVIRONMENT']])

modul Application
  class Error < StandardError; end
  # Váš kód patří sem...
end

Konfigurace již máme, takže můžeme přidat model Post v našem rubín aplikace. 

`├──── app`

`│ └── modely`

`│ └── post.rb`

app/models/post.rb
# frozen_string_literal: true

class Post < ActiveRecord::Base;end

a nezapomeňte soubor načíst do application.rb

require 'app/models/post'

Nezapomeňte také přidat require 'app/runner' na app/application.rb

Chceme-li do aplikace přidat nové soubory, služby, další modely, musíme je načíst do aplikace application.rb.

SHRNUTÍ

V současné době je naše rubínová aplikace připravena pokračovat. Nakonfigurovali jsme:

• připojení k databázi,
• Aktivní záznam,
• Samostatné migrace pomocí nástroje rake

Jak vidíte, není vždy nutné používat kolejnice nové. Tímto způsobem se vyhneme zbytečnému kódu v naší aplikaci, který se nepoužívá. Máme větší kontrolu nad vývojem naší aplikace. Postupem času můžeme přidávat další knihovny a obchodní logiku. Pomocí takto nakonfigurované aplikace můžeme vytvořit crawler nebo scraper, připojit se k externím API ze kterých budeme získávat informace a ukládat je do vlastní databáze nebo načítat soubory a získávat z nich zajímavé informace. Přeji vám hodně štěstí při dalším vývoji vlastních aplikací!

BONUS

Naše aplikace musí být také nějak spuštěna. Můžeme to udělat několika způsoby, například z terminálu. Můžeme vytvořit exe/app který načte naši aplikační logiku ze souboru 'app/application' a spustit naši aplikaci prostřednictvím Runner služba přidána do adresáře aplikace.

#!/usr/bin/env ruby
# frozen_string_literal: true

require 'bundler/setup'

$LOAD_PATH.unshift File.expand_path('..', __dir__)
require 'app/application'

Runner.start

# frozen_string_literal: true

třída Runner
  def self.start
    puts 'Start'
  end
end

Nezapomeňte také přidat require 'app/runner' na app/application.rb

Kód najdete na GitHubu:

- https://github.com/dwatek/simplerubínaplikace

Přečtěte si více

GraphQL Ruby. Jak je to s výkonem?

Kolejnice a další dopravní prostředky

Vývoj Rails pomocí TMUX, Vim, Fzf + Ripgrep