Paprasta "Ruby" programa nuo nulio su "Active Record

Man patinka dirbti su Bėgiai nes galiu lengvai ir greitai sukurti veikiančią programą ir parodyti ją pasauliui arba tik savo draugams. Tačiau yra tokių tipų programų, kurioms nereikia tokios didelės struktūros, kaip Bėgiai ir visas jos funkcijas.

Gali atsitikti taip, kad mūsų programai iš viso MVC modelio reikia tik M (modelio). Modelis-valdiklis. Ar verta pradėti projektas svetainėje Bėgiai jei žinome, kad V-C (View-Controller) dalis nebus reikalinga?

Gera žinoti, kad Aktyvus įrašas , Active Model, Action Pack ir Action View, kurie yra atsakingi už MVC, gali būti naudojami atskirai už Bėgiai. Tai leidžia mus sukurti paprastą Ruby paraiška kuris turi duomenų bazės ryšį, ir sukurti jį be nereikalingų kodas ir bibliotekas, kurias gautume pakete, paleidę komandą rails new.

Aprašiau, kaip tai padaryti žingsnis po žingsnio, ir visą kodą galite rasti "GitHub". Nuoroda yra šio straipsnio apačioje. 

Struktūra

Norint pradėti projektą, mums daug ko nereikia. Pradėkime nuo to, kad sukursime Gemfile kur pridedame brangakmenius, reikalingus programai veikti, ir programos versiją. Ruby mes naudosime.

 cat Gemfile

# frozen_string_literal: true

source 'https://rubygems.org'

ruby '2.7.2'

Neprivalomas README.md failo paskirtis - aprašyti, kaip veikia mūsų programa ir kaip toliau su ja dirbti - tiek mums patiems, tiek kitiems kūrėjams, kurie ateityje norės plėtoti projektą kartu su mumis.

cat README.md

# taikymas

ATLIKTI: Ištrinkite šį ir aukščiau esantį tekstą ir aprašykite savo programą

programa katalogas su application.rb failą, kuris bus atsakingas už konfigūravimą ir bibliotekų bei failų, kuriuos pridėsime į savo programą, įkėlimą. Nepamirškite paleisti įdiegti paketą generuoti Gemfile.lock. Šiame etape mūsų programos struktūra turėtų atrodyti taip:

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

Duomenų bazė

Parengę tokią struktūrą, galime svarstyti, kokį duomenų bazės variklį pasirinkti ir sukonfigūruoti. Šiame straipsnyje pasirinkau "PostgresQL", su kuria turiu daugiausia patirties. Ji taip pat gali būti "MySQL" arba SQlite3, arba bet kuris kitas variklis, veikiantis su Aktyvus įrašas. Renkantis technologiją verta vadovautis programos paskirtimi, kam ji bus naudojama ir kokia bus jos paskirtis. 

Norėdamas greitai ir paprastai konfigūruoti duomenų bazę, naudojau "docker" ir docker-compose. Nenoriu išsamiai aprašyti šių įrankių konfigūracijos, jų privalumų ir trūkumų, bet jei niekada anksčiau nenaudojote "docker", norėčiau nukreipti jus į oficialią dokumentaciją, skirtą "Docker" ir "Docker Compose daugiau informacijos.

# docker-compose.yml

versija: '3.7'
paslaugos:
  Postgresql:
    Atvaizdas: postgres:12.0-alpine
    portai:
- 5432:5432
    aplinka:
- PGDATA=/postgresql
- POSTGRESPASSWORD=postgres
- POSTGRESUSER=postgres
    tomai:
- php postgresql: db-volume:/postgresql
tomai:
  db-volume::

Taip pat turėsime pridėti prie savo Gemfile

 gem 'pg'

ir į mūsų application.rb failas

# app/application.rb

require 'pg'

modulis Application

  klasė Error < StandardError; end

# Jūsų kodas eina čia...

pabaiga

Atskiras perkėlimas, Rake

Kitas mūsų programos konfigūravimo žingsnis - pridėti standalone_migrations ir grėblys brangakmenių, kurie leis mums valdyti migracijas kaip ir Rails sistemoje ir gauti prieigą prie rake db: komandų. 

1. Atnaujinti Gemfile su reikalingais brangakmeniais ir atlikite įdiegti paketą

# brangakmenis, naudojamas ne 'rail' ir ne 'Ruby' programose

gem 'standalone_migrations'

# standalone_migrations reikia rake, kad būtų galima kurti migracijas ir jas paleisti, kaip Rails sistemoje

gem 'rake'

# Gem reikalingas aplinkos kintamiesiems įkelti

gem 'dotenv'

2. Pridėkime Rakefile į mūsų projekto šakninį katalogą, į kurį įkeliame dotenv ir standalone_migrations kurį pridėjome anksčiau 

# frozen_string_literal: true

reikalauti 'dotenv'

Dotenv.load

require 'standalone_migrations'

StandaloneMigrations::Tasks.load_tasks

Su Rakefile Taip sukonfigūruoti galime patikrinti, ar mūsų grėblys veikia naudojant grėblys -T komandą, kuri turėtų grąžinti mūsų programoje esančių komandų sąrašą.

3. Prieš rake db:create, vis dar turime turėti projekto konfigūracijos failą, kad galėtume prisijungti prie "Postgres" egzemplioriaus. Norėdami tai padaryti, turime sukurti db katalogą kartu su config.yml failą, kuris turėtų atrodyti taip, kaip toliau:

# db/config.yml

numatytasis: &default

  adapteris: postgresql

  kodavimas: unicode

  baseinas: 

  duomenų bazė: 

  vartotojo vardas: 

  slaptažodis: 

  host: 

  prievadas: 

development:

  <<: *default

testas:

  <<: *default

Staging:

  <<: *default

gamyba:

  <<: *default

Kaip matote, naudodamas aplinkos kintamuosius sukonfigūravau ryšį su mūsų "Postgres", kuriame laikysime jautrius duomenys kurių neturėtų būti saugykloje. Tam naudojau anksčiau pridėtą gem dotenv, kuri taip pat buvo įtraukta į Rakefile kartu su standalone_migrations. Jei naudojame "Git" programos versijų valdymui, nepamirškime pridėti .gitignore failą, kuriame išjungsime galimybę sekti .env failą iš mūsų projekto.

 # .gitignore
.env*
!.env.example

ir pridėkite.env failą, kuriame yra teisingai sukonfigūruotas ENV

# .env

DATABAZĖS_NAME="development"

DATABAZĖS VARTOTOJAS="postgres"

DATABASE_PASSWORD="postgres"

DATABASE_HOST="localhost"

DATABASE_PORT="5432"

4. Šiame etape turėtume galėti paleisti rake db:create komanda, kuri sukurs duomenų bazę

   

5. Pabandykime pridėti naują migraciją per rake db:new_migration name=, kur sukuriame pranešimai lentelę su :title stulpelis

   

# frozen_string_literal: true

klasė CreatePosts < ActiveRecord::Migration[6.0]

  def change

    create_table :posts do |t|

      t.string :title

    end

  end

pabaiga

Turėtumėte pastebėti, kad db/migruoti katalogas buvo automatiškai pridėtas ir schema.rb buvo sukurtas po sėkmingo perkėlimo. Šiuo metu mūsų projekto struktūra atrodo taip:

 medis
.
├──── 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

Aktyvus įrašas

Paskutinis, bet ne mažiau svarbus žingsnis kuriant mūsų programą yra pridėti aktyvus įrašas ir jo konfigūraciją. Tam mums reikės atnaujinti savo brangakmenių failą dar 3 brangakmeniais:

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

Kodėl mes pridedame erb ir ymal paaiškinta toliau komentaruose. Visas active_record konfigūracija bus app/application.rb failas.

Panagrinėkime, kas čia vyksta, vieną po kito:

# frozen_string_literal: true

# Jei norime, kad programą būtų galima paleisti skirtingose aplinkose,
# pvz., bandomąją ar gamybinę, verta nustatyti ENVIRONMENT reikšmę
# pradžioje, kuri paimama iš aplinkos kintamojo
# arba `development` pagal numatytuosius nustatymus.

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

# Norėdami naudoti pridėtus brangakmenius, turime juos įkelti naudodami metodą Kernel#require,
#, kuris įkelia failą arba biblioteką, perduotą kaip parametras

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

# Pagal numatytuosius nustatymus Dotenv.load aplinkos kintamiesiems įkelti pasiekia
# į `.env` failą, todėl, jei norime naudoti kitas aplinkas, verta
# išplėsti šį metodą iki toliau pateikto, kuris pirmiausia už rinkinio plėtrą
# aplinka ieško failo, kuris baigiasi `.env.development.local`,
# tada `.env.development` ir galiausiai `.env`.

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

# Metodas, reikalingas duomenų bazės nustatymams įkelti
def db_configuration
  # Toliau pateiktas metodas grąžina kelią iki failo su mūsų konfigūracija
  db_configuration_file_path = File.join(File.expand_path('..', __dir__), 'db', 'config.yml')

  # Turėdami kelią iki failo, galime perskaityti jo reikšmes. Kadangi config.yml
  # faile yra aplinkos kintamųjų ir, kaip galbūt pastebėjote,
  # erb  sintaksę, mums taip pat reikia naudoti erb brangakmenį. Be jo,
  # kintamųjų reikšmės nebus perskaitytos teisingai ir activerecord
  # negalės prisijungti prie postgres.
  # konfigūraciją kaip eilutę

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

  # Naudodamiesi anksčiau pridėtu `yaml` brangakmeniu, galime saugiai įkelti savo konfigūraciją

  YAML.safe_load(db_configuration_result, aliases: true)
pabaiga

# Galiausiai turime sukurti ryšį tarp activerecord ir postgres
# naudodami `establish_connection` metodą
ActiveRecord::Base.establish_connection(db_configuration[ENV['ENVIRONMENT']])

modulis Application
  klasė Error < StandardError; end
  # Jūsų kodas eina čia...
pabaiga

Jau turime konfigūracijas, todėl galime pridėti "Post" modelį į savo rubinas programa. 

`├── app`

`│ └── modeliai`

`│ └── └── post.rb`

app/models/post.rb
# frozen_string_literal: true

klasė Post < ActiveRecord::Base;end

ir nepamirškite įkelti failo į application.rb

reikalauti 'app/models/post'

Taip pat nepamirškite pridėti require 'app/runner' į app/application.rb

Jei norime į savo programą pridėti naujų failų, paslaugų, daugiau modelių, turime juos įkelti į application.rb.

SUMMARY

Šiuo metu mūsų "Ruby" programa yra parengta tęsti darbą. Mes sukonfigūravome:

• duomenų bazės ryšys,
• Aktyvus įrašas,
• Autonominiai perkėlimai su rake

Kaip matote, ne visada būtina naudoti bėgiai nauji. Taip išvengsime nereikalingo ir nenaudojamo kodo savo programoje. Galime labiau kontroliuoti savo programos kūrimą. Laikui bėgant galime pridėti daugiau bibliotekų ir verslo logikos. Tokią sukonfigūruotą programą galime naudoti norėdami sukurti "crawler" arba "scraper", prisijungti prie išorinių API iš kurių gausime informaciją ir ją saugosime savo duomenų bazėje arba įkeliame failus ir iš jų išgausime įdomią informaciją. Linkiu jums sėkmės toliau kuriant savo programas!

BONUSAS

Mūsų programą taip pat reikia kažkaip paleisti. Tai galime padaryti keliais būdais, pavyzdžiui, iš terminalo. Galime sukurti exe/app failą, į kurį bus įkelta mūsų taikomosios programos logika iš 'app/application' failą ir paleisti mūsų programą per Bėgikas paslauga pridėta į programų katalogą.

#!/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

klasė Runner
  def self.start
    puts 'Start'
  pabaiga
end

Taip pat nepamirškite pridėti reikalauti 'app/runner' į app/application.rb

Kodą galima rasti "GitHub" svetainėje:

- https://github.com/dwatek/simplerubinasprograma

Skaityti daugiau

"GraphQL Ruby". O kaip dėl našumo?

Bėgiai ir kitos transporto priemonės

"Rails" kūrimas naudojant TMUX, "Vim", Fzf + Ripgrep