Vienkārša Ruby lietojumprogramma no nulles ar Active Record

Man patīk strādāt ar Sliedes jo varu viegli un ātri izveidot lietojumprogrammu, kas darbojas, un parādīt to pasaulei vai tikai saviem draugiem. Tomēr ir lietojumprogrammu veidi, kuriem nav nepieciešama tik liela sistēma, kā, piemēram. Sliedes un visas tās funkcijas.

Var gadīties, ka mūsu lietojumprogrammai no visa MVC modeļa ir nepieciešams tikai M (modelis). Modelis-kontrolieris. Vai ir vērts sākt projekts vietnē Sliedes ja mēs zinām, ka V-C (View-Controller) daļa nebūs nepieciešama?

Ir labi zināt, ka Aktīvais ieraksts , Active Model, Action Pack un Action View, kas ir atbildīgi par MVC, var izmantot neatkarīgi ārpus MVC. Sliedes. Tas ļauj mums lai izveidotu vienkāršu Rubīns pieteikums kurai ir datubāzes savienojums, un izstrādāt to bez nevajadzīgas kods un bibliotēkas, ko mēs saņemtu paketē, izpildot komandu rails new.

Esmu soli pa solim aprakstījis, kā to panākt, un visu kodu varat atrast GitHub. Saite ir šī raksta apakšā. 

Struktūra

Lai sāktu mūsu projektu, mums nav nepieciešams daudz. Sāksim, izveidojot Dārgakmens fails kur mēs pievienojam dārgakmeņus, kas mums ir nepieciešami, lai strādātu ar lietojumprogrammu, kopā ar versiju Rubīns mēs izmantosim.

 cat Gemfile

# frozen_string_literal: true

avots 'https://rubygems.org'

ruby '2.7.2'

Pēc izvēles README.md faila mērķis ir aprakstīt, kā darbojas mūsu lietojumprogramma un kā turpināt darbu pie tās gan mums pašiem, gan citiem izstrādātājiem, kuri nākotnē vēlēsies attīstīt projektu kopā ar mums.

cat README.md

# Pieteikums

DARĪT: Izdzēst šo un iepriekšējo tekstu un aprakstīt savu lietojumprogrammu.

lietotne direktoriju ar application.rb failu, kas būs atbildīgs par konfigurāciju un bibliotēku un failu ielādi, kurus mēs pievienosim mūsu lietojumprogrammā. Neaizmirstiet palaist instalēt paketi lai ģenerētu Gemfile.lock. Mūsu pieteikuma struktūrai šajā posmā vajadzētu izskatīties šādi:

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

Datubāze

Kad šāda struktūra ir sagatavota, varam apsvērt, kuru datubāzes dzinēju izvēlēties un konfigurēt. Šajā rakstā es izvēlējos PostgresQL, ar kuru man ir vislielākā pieredze. To var arī MySQL vai SQlite3, vai jebkuru citu dzinēju, kas darbojas ar Aktīvais ieraksts. Izvēloties tehnoloģiju, ir labi vadīties pēc lietojumprogrammas mērķa, kam tā tiks izmantota un kāds būs tās mērķis. 

Lai ātri un vienkārši konfigurētu datu bāzi, es izmantoju docker un docker-compose. Es nevēlos sīkāk iztirzāt šo rīku konfigurāciju, to plusus un mīnusus, bet, ja jūs nekad iepriekš neesat izmantojuši docker, tad es jūs vērsīšu pie oficiālās dokumentācijas par Docker un Docker Compose papildu informācijai.

# docker-compose.yml

versija: '3.7'
pakalpojumi:
  postgresql:
    : image: postgres:12.0-alpine
    porti:
- 5432:5432
    vide:
- PGDATA=/postgresql
- POSTGRESPASSWORD=postgres
- POSTGRESUSER=postgres
    sējumi:
- db-volume:/postgresql
volumes:
  db-volume::

Mums būs nepieciešams arī pievienot mūsu Dārgakmens fails

 gem 'pg'

un mūsu application.rb fails

# app/application.rb

require 'pg'

modulis Application

  klase Error < StandardError; end

# Jūsu kods ir šeit...

beigas

Atsevišķas migrācijas, Rake

Nākamais mūsu lietojumprogrammas konfigurēšanas solis ir pievienot standalone_migrations un grābeklis dārgakmeņi, kas ļaus mums pārvaldīt mūsu migrāciju tāpat kā Rails un iegūt piekļuvi rake db: komandām. 

1. Atjaunināt Dārgakmens fails ar nepieciešamajiem dārgakmeņiem un veiciet instalēt paketi

# dārgakmens, ko izmanto lietojumprogrammās, kas nav saistītas ar sliedēm un nav saistītas ar rubīnu

gem 'standalone_migrations'

# standalone_migrations ir nepieciešams rake, lai varētu izveidot migrācijas un palaist tās, kā tas ir Rails sistēmā

gem 'rake'

# Gem nepieciešams, lai ielādētu vides mainīgos

gem 'dotenv'

2. Pievienosim Rakefile uz mūsu projektu saknes direktorijā, kur mēs ielādēsim dotenv un standalone_migrations ko pievienojām iepriekš 

# frozen_string_literal: true

require 'dotenv'

Dotenv.load

require 'standalone_migrations'

StandaloneMigrations::Tasks.load_tasks

Ar Rakefile Šādi konfigurēti, mēs varam pārbaudīt, vai mūsu grābeklis darbojas, izmantojot grābeklis -T komandu, kurai jāatgriež mūsu lietojumprogrammā pieejamo komandu saraksts.

3. Pirms rake db:create, mums projektā joprojām ir nepieciešams konfigurācijas fails, lai izveidotu savienojumu ar Postgres gadījumu. Lai to izdarītu, mums ir jāizveido db direktorija kopā ar config.yml failam, kam vajadzētu izskatīties kā zemāk redzamajam:

# db/config.yml

noklusējuma: &default

  adapter: postgresql

  kodēšana: unicode

  baseins: { 5 }: 

  datu bāze: 

  lietotājvārds: 

  parole: 

  host: 

  port: 

attīstība:

  <<: *default

testēt:

  <<: *default

staging:

  <<: *default

ražošana:

  <<: *default

Kā redzat, es izmantoju vides mainīgos, lai konfigurētu savienojumu ar mūsu Postgres, kur mēs saglabāsim sensitīvu dati kam nevajadzētu būt repozitorijā. Šim nolūkam es izmantoju iepriekš pievienoto gem dotenv, kas arī tika pievienots Rakefile kopā ar standalone_migrations. Ja lietojumprogrammas versiju kontrolei izmantojam Git, atcerēsimies pievienot a .gitignore failu, kurā mēs atslēgsim iespēju izsekot .env failu no mūsu projekta.

 # .gitignore
.env*
!.env.example

un pievienojiet.env failu, kurā ir pareizi konfigurēts ENV

# .env

DATABASE_NAME="development"

DATABASE_USER="postgres"

DATABASE_PASSWORD="postgres"

DATABASE_HOST="localhost"

DATABASE_PORT="5432"

4. Šajā posmā mums vajadzētu spēt palaist rake db:create komanda, kas izveidos datubāzi

   

5. Mēģināsim pievienot jaunu migrāciju, izmantojot rake db:new_migration name=, kur mēs izveidojam ziņojumi galds ar :title sleja

   

# frozen_string_literal: true

klase CreatePosts < ActiveRecord::Migration[6.0]

  def change

    create_table :posts do |t|

      t.string :title

    end

  beigas

beigas

Jums vajadzētu pamanīt, ka db/migrēt katalogs tika automātiski pievienots un schema.rb tika izveidots pēc veiksmīgas migrācijas. Pašlaik mūsu projekta struktūra izskatās šādi:

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

Aktīvais ieraksts

Pēdējais, bet ne mazāk svarīgais, solis mūsu lietojumprogrammas izveidē ir pievienot activerecord un tā konfigurāciju. Šim nolūkam mums būs jāatjaunina mūsu dārgakmeņu fails ar vēl 3 dārgakmeņiem:

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

Kāpēc mēs pievienojam erb un ymal ir paskaidrots tālāk komentāros. Viss active_record konfigurācija būs app/application.rb failu.

Apskatīsim, kas šeit notiek, pa kārtai:

# frozen_string_literal: true

# Ja vēlamies, lai lietojumprogrammu varētu palaist dažādās vidēs,
# piemēram, testa vai ražošanas, ir labi iestatīt ENVIRONMENT vērtību
# sākumā, kas tiek ņemta no vides mainīgā
# vai `development` pēc noklusējuma.

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

# Lai izmantotu pievienotos dārgakmeņus, mums tie jāielādē, izmantojot metodi Kernel#require,
#, kas ielādē failu vai bibliotēku, kas nodota kā parametrs

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

# Pēc noklusējuma Dotenv.load vides mainīgo ielādei sasniedz
# uz `.env` failu, tāpēc, ja vēlamies izmantot citas vides, ir vērts
# paplašināt šo metodi līdz turpmāk minētajai, kas vispirms kopumam izstrādes
# vide meklēs failu, kas beidzas ar `.env.development.local`,
# tad `.env.development` un visbeidzot `.env`.

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

# Datu bāzes iestatījumu ielādēšanai nepieciešamā metode
def db_configuration
  # Tālāk minētā metode atgriež ceļu līdz datnei ar mūsu konfigurāciju.
  db_configuration_file_path = File.join(File.expand_path('..', __dir__), 'db', 'config.yml')

  # Kad mums ir ceļš līdz datnei, mēs varam nolasīt tās vērtības. Tā kā config.yml
  # failā ir vides mainīgie un, kā jūs, iespējams, pamanījāt,
  # erb  sintaksi, mums arī jāizmanto erb gem. Bez tā,
  # mainīgo vērtības netiks nolasītas pareizi, un activerecord
  # nevarēs izveidot savienojumu ar postgres.
  # konfigurāciju kā virkni

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

  # Izmantojot iepriekš pievienoto `yaml` gem, mēs varam droši ielādēt mūsu konfigurāciju

  YAML.safe_load(db_configuration_result, aliases: true)
beigas

# Visbeidzot, mums ir jāizveido savienojums starp activerecord un postgres
#, izmantojot `establish_connection` metodi
ActiveRecord::Base.establish_connection(db_configuration[ENV['ENV['ENVIRONMENT']])

modulis Application
  klase Error < StandardError; end
  # Jūsu kods ir šeit...
beigas

Mums jau ir konfigurācijas, tāpēc varam pievienot Post modeli mūsu rubīns lietotne. 

`├──── app``

`│ └── modeļi`

`│ └──── post.rb`

app/models/post.rb
# frozen_string_literal: true

klase Post < ActiveRecord::Base;end

un neaizmirstiet ielādēt failu application.rb

pieprasīt 'app/models/post'

Neaizmirstiet arī pievienot require 'app/runner' uz app/application.rb

Ja mēs vēlamies pievienot jaunus failus savā lietojumprogrammā, pakalpojumus, vairāk modeļu, mums tie ir jāielādē programmā. application.rb.

KOPSAVILKUMS

Pašlaik mūsu rubīna lietojumprogramma ir gatava turpināšanai. Mēs esam konfigurējuši:

• datubāzes savienojums,
• Aktīvais ieraksts,
• Atsevišķas migrācijas ar rake

Kā redzat, ne vienmēr ir nepieciešams izmantot jaunas sliedes. Šādā veidā mēs izvairāmies no nevajadzīga koda, kas netiek izmantots. Mums ir lielāka kontrole pār lietojumprogrammas izstrādi. Laika gaitā mēs varam pievienot vairāk bibliotēku un biznesa loģiku. Mēs varam izmantot šādi konfigurētu lietojumprogrammu, lai izveidotu pārlūku vai skrāpi, izveidotu savienojumu ar ārējiem API no kuriem mēs iegūsim informāciju un saglabāsim to savā datubāzē vai ielādēsim failus un izvilksim no tiem interesējošo informāciju. Novēlu jums veiksmi turpmākajā savu lietojumprogrammu izstrādē!

BONUSS

Arī mūsu lietojumprogramma ir kaut kādā veidā jāsāk izmantot. To var izdarīt vairākos veidos, piemēram, no termināļa. Mēs varam izveidot exe/app failu, kas ielādēs mūsu lietojumprogrammas loģiku no 'app/application' failu un palaist mūsu lietojumprogrammu, izmantojot Skrējējs pakalpojums, kas pievienots lietotņu direktorijā.

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

klase Runner
  def self.start
    puts 'Start'
  end
end

Neaizmirstiet arī pievienot pieprasīt 'app/runner' uz app/application.rb

Kods ir atrodams GitHub:

- https://github.com/dwatek/simplerubīnslietotne

Lasīt vairāk

GraphQL Ruby. Kā ir ar veiktspēju?

Sliedes un citi transporta līdzekļi

Rails attīstība ar TMUX, Vim, Fzf + Ripgrep