Hvad er Ruby on rails, og hvorfor er det så populært?

Skinner dette er et web-framework, til gengæld er et framework et sæt applikationer og forskellige værktøjer til at skabe en webapplikation.
Rammerne er rammerne for en webapplikation, med et stort udvalg af indstillinger og med det mål at gøre udviklingen så bekvem og behagelig som muligt for udvikleren.

Du er som en skaber, skab hvad du vil. Det vigtigste i udviklingen er trods alt at sætte mål og nå dem, samtidig med at du ved, at den vej, du går for at nå, er den bedste!
Så hvad er skinner, og hvad gør det så fantastisk?

7 søjler af rubin på skinner fremragende

For det første er Ruby On Rails Ruby
Ruby on Rails er en ramme skrevet i det bedste programmeringssprog, Ruby.
Skønheden og bekvemmeligheden ved programmering kan simpelthen ikke beskrives med ord. Ruby on Rails supplerer dette perfekte sprog med nye metoder og klasser til interaktion mellem objekter og klasser.

Alle aspekter af interaktion mellem rammesystemet er meget gennemtænkte og strukturerede.
Ruby on Rails har en masse ting, som andre frameworks ikke har, Ruby on Rails udvikler sig med stormskridt, og andre web-frameworks følger næsten ikke med.

For det andet bruger Ruby on Rails MVC

MVC er en arkitektonisk skabelon (mønster), der giver mulighed for opdeling af applikationskode i tre dele: Model (model), View (view) og Controller (controller).

Model indeholder applikationens matematiske logik, associative forbindelser mellem modeller, forskellige tilbagekald og hovedapplikationskoden er angivet her.
Repræsentation bruges til at vise information til brugeren, er en visning, GUI applikation eller webgrænseflade for en webapplikation. Her er forskellige html-formularer, css stilarter og javascript.
Controller beskæftiger sig med at binde modellen til visningen og behandle ansøgningens brugeranmodning. Her bruger du ruter til at konfigurere routing af din applikation.
Brug af MVC giver dig mulighed for at skrive renere og mere struktureret kode, hvilket markant fremskynder udviklingen og samtidig gør applikationen nemmere at vedligeholde.

For det tredje bruger Ruby on Rails CoC
CoC - Convention over Configuration - hele ideen er, at rammen som standard allerede er perfekt konfigureret. Ruby on Rails kommer med et sæt ekstremt praktiske konventioner, der giver dig mulighed for at begynde at udvikle din applikation umiddelbart efter installation af Ruby on Rails og oprettelse af et nyt projekt. Om nødvendigt kan du ændre standardindstillingerne (de kaldes en aftale) og bruge dine egne, men dette er som regel ikke kun unødvendigt, men også ofte skadeligt.

Den fjerde hval, TØR
DRY - Don't Repeat Yourself (Gentag ikke dig selv!) er et andet udviklingsprincip, der ligger til grund for Ruby on Rails-webframeworket og selve ruby-sproget. Dette princip instruerer udvikleren til at identificere gentagne fragmenter i koden og flytte dem til separate metoder, klasser eller moduler, afhængigt af situationen. I Ruby on Rails optræder dette princip mange steder, hvilket giver dig mulighed for at skrive mindre kode, mindre test og lettere at vedligeholde udviklet kode. For eksempel i en visning er forskellige partialer tilgængelige til brug - det er mønstre til gentagelse af kode, der blot kaldes i koden, for eksempel for Forms. Dette forbedrer ikke kun kodens læsbarhed, men tilføjer også fleksibilitet til at ændre eller tilføje nye oplysninger.

Den femte søjle er CRUD

CRUD - opret, læs, opdater, slet - "oprettelse, læs, opdater, slet") metode, der bruges til at oprette controllere. Brug af en standard, med hvilken du klart kan definere controllerhandlinger til fuldstændig manipulation af ethvert objekt. Du kan også tilføje dine egne handlinger uden problemer.
Også skinner bruger ikke kun POST og FÅ anmodning, og såsom PUT og DELETE. Giver dig mere kontrol over data

Den sjette søjle i ORM

ORM (object-relational mapping) er en programmeringsteknologi, der hjælper med at arbejde med en database i et programmeringssprog uden at bruge forskellige SQL-sprog til at manipulere databasen. Den bruger objektorienteret programmering i rubin.
Hele ideen er, at en tabel er en klasse, dens rækker er objekter, dens kolonner er egenskaber ved objekter.
Klassemetoder udfører operationer på tabeller.
Objektmetoder udfører operationer på individuelle strenge.

Den syvende hval af haml sass/mindre
Ideen er at bruge forenklet og mere funktionelle sprog såsom haml og sass/less. Som øger kodens læsbarhed, gør udviklingen mere bekvem og tolkes automatisk til deres forældres html og css.

Og der er også mange flere fordele, for eksempel at installere forskellige ekstra biblioteker (perler) i én kommando Fremragende gratis Heroku, som giver dig mulighed for at overvåge ydeevnen af ​​din lokale applikation i produktionen på en fjernsky Forskellige færdige løsninger fra Ruby on Rails-dokumentationen. Og evnen til at generere kode for mere hurtig indsættelse webapplikationer.

Målet var at præsentere hovedtrækkene i Ruby on Rails-rammen. Jeg håber du er interesseret, og en anden sej rubinist dukker snart op i webverdenen!

Denne vejledning dækker installation og kørsel af Ruby on Rails.

Efter at have læst det, vil du lære:

• Sådan installerer du Rails, opretter en ny Rails-applikation og vedhæfter din applikation til en database.
• Den generelle struktur af en Rails-applikation.
• Grundlæggende MVC principper(Model, Se controller- "Model-View-Controller") og RESTful baseret design.
• Hvordan man hurtigt genererer indledende kode til en Rails-applikation.

Forudsætninger i denne manual

Denne tutorial er rettet mod begyndere, der ønsker at starte en Rails-applikation fra bunden. Det forudsætter ikke, at du har arbejdet med Rails før.

Rails er en webudviklingsramme skrevet i Ruby-programmeringssproget. Hvis du ikke har erfaring med Ruby, kan du finde det svært at springe direkte ind i at lære Rails. Der er flere gode engelsksprogede ressourcer dedikeret til lære Ruby, For eksempel:

Bemærk venligst, at nogle af ressourcerne, selvom de stadig er gode, stadig dækker ældre versioner af Ruby, såsom 1.6 og især 1.8, og inkluderer ikke noget af den syntaks, du vil se i daglig Rails-udvikling.

Hvad er Rails?

Rails er en webudviklingsramme skrevet i Ruby-programmeringssproget. Det er designet til at gøre programmering af webapplikationer lettere ved at gøre en række antagelser om, hvad hver udvikler har brug for for at skabe et nyt projekt. Det giver dig mulighed for at skrive mindre kode under programmering sammenlignet med andre sprog og rammer. Professionelle Rails-udviklere bemærker også, at det gør det sjovere at udvikle webapplikationer =)

Rails er egenrådige software. Den antager, at der er en "bedre" måde at gøre noget på, og den er designet på en sådan måde, at den opmuntrer på den måde - og i nogle tilfælde endda fraråder alternativer. Hvis du lærer "The Rails Way", vil du muligvis opdage en betydelig stigning i din produktivitet. Hvis du fortsætter med at bringe gamle vaner fra andre sprog ind i Rails-udviklingen og prøver at bruge mønstre, du har lært andre steder, vil du få en mindre glad udviklingsoplevelse.

Rails-filosofien omfatter to vigtige vejledende principper:

• Gentag ikke dig selv: DRY er et softwareudviklingsprincip, der siger, at "Hvert stykke information skal have en enkelt, ikke-redundant, autoritativ repræsentation i systemet." Skriv ikke den samme information igen og igen, koden vil være nemmere at vedligeholde og vil være mere udvidelsesbar og mindre buggy.
• Konvention over konfiguration: Rails har meninger om de bedste måder at gøre en masse ting på i en webapplikation, og standard til disse konventioner i stedet for at tvinge dig til at pille ved adskillige konfigurationsfiler.

Oprettelse af et nyt skinneprojekt

Den bedste måde at bruge denne guide på er at gennemgå den trin for trin. Alle trin er afgørende for at køre eksempelapplikationen, og der kræves ingen yderligere kode eller trin.

Ved at følge denne vejledning vil du oprette et Rails-projekt kaldet blog, en meget simpel webblog. Før vi begynder at oprette en applikation, skal vi sikre os, at Rails selv er installeret.

Følgende eksempler bruger $ til at angive en terminalinputlinje på UNIX-lignende operativsystemer, selvom den kan være konfigureret anderledes. Hvis du bruger Windows, vil linjen ligne c:\kildekode>

3.1. Montering af skinner

Før du installerer Rails, skal du sikre dig, at de nødvendige forudafhængigheder er installeret på dit system. Disse omfatter Ruby og SQLite3.

Åbn kommandolinjeapplikationer. På macOS, åbn Terminal.app, på Windows, vælg "Kør" fra startmenuen og skriv "cmd.exe". Alle kommandoer, der starter med et dollartegn $, skal køres på kommandolinjen. Sørg for, at du har installeret Nuværende version Rubin:

$ ruby ​​-v ruby ​​2.5.0

Rails kræver, at Ruby version 2.4.1 eller nyere er installeret. Hvis versionsnummeret er mindre end dette, skal du installere nyt eksemplar Rubin.

For hurtigt at installere Ruby og Ruby on Rails på et system, kan Windows-brugere bruge Rails Installer. Yderligere metoder installationer til de fleste operativsystemer kan ses på ruby-lang.org.

Hvis du arbejder på Windows, skal du installere Ruby Installer Development Kit.

Du skal også have en SQLite3-databaseinstallation.

Mange populære UNIX-lignende OS'er leveres med en rimelig version af SQLite3. På Windows, hvis du installerede Rails ved hjælp af Rails Installer, har du allerede SQLite installeret. Andre brugere kan henvise til SQLite3-webstedet for installationsinstruktioner. Kontroller, at den er installeret korrekt og er indeholdt i din PATH:

$sqlite3 --version

Programmet skal rapportere sin version.

For at installere Rails, brug gem installeringskommandoen leveret af RubyGems:

$ perle installere skinner

For at kontrollere, at alt er installeret korrekt, skal du gøre følgende:

$rails --version

Hvis der står noget som "Rails 5.1.1", kan du fortsætte.

3.2. Oprettelse af en blogapplikation

Rails kommer med en række scripts, kaldet generatorer, designet til at gøre en udviklers liv lettere ved at generere alt det nødvendige for at komme i gang med en specifik opgave. En af dem er New Application Generator, som giver dig rammerne for en Rails-applikation, så du ikke selv skal skrive den.

For at bruge denne generator skal du åbne en terminal, gå til en mappe, hvor du har tilladelse til at oprette filer og skrive:

$rails ny blog

Dette vil oprette en Rails-applikation ved navn Blog i blogbiblioteket og installere de ædelstene, hvis afhængigheder er nævnt i Gemfilen, når du bruger bundleinstallation.

Når du bruger Windows Subsystem til Linux, er der nogle begrænsninger på filsystemmeddelelser, der betyder, at du skal deaktivere fjeder- og lytte-perlerne, hvilket kan gøres ved at køre rails new blog --skip-spring --skip-listen .

Du kan se alle de mulige kommandolinjeindstillinger, som Rails-applikationsbyggeren accepterer, ved at køre rails new -h .

Når du har oprettet blogapplikationen, skal du gå til dens mappe:

Blogbiblioteket indeholder flere automatisk genererede filer og mapper, der definerer strukturen af ​​en Rails-applikation. Det meste af arbejdet i denne øvelse vil ske i app-mappen, men lad os nu gennemgå funktionerne i hver mappe, som Rails som standard opretter i en ny applikation:

Fil og mappe	Formål
app/	Indeholder controllere, modeller, visninger, hjælpere, mailere, kanaler, jobs og aktiver i din applikation. Vi vil se nærmere på denne mappe næste gang.
beholder/	Indeholder Rails-scripts, der starter din applikation, og mappen kan også indeholde andre scripts, som du bruger til at konfigurere, opdatere, implementere eller køre.
config/	Rutekonfigurationer, din applikationsdatabase osv. Dette er dækket mere detaljeret i Konfiguration af skinneapplikationer
config.ru	Rack-konfiguration for de Rack-baserede servere, der bruges til at køre applikationen. For mere information om Rack, besøg Rack hjemmeside.
db/	Indeholder dit nuværende databaseskema samt databasemigreringer.
Gemfile Gemfile.lås	Disse filer giver dig mulighed for at angive, hvilke ædelstensafhængigheder din Rails-applikation har brug for. Disse filer bruges af Bundler-perlen. For mere information om Bundler, besøg Bundlers hjemmeside.
lib/	Eksterne moduler til din ansøgning.
log/	Applikationslogfiler.
package.json	Denne fil giver dig mulighed for at angive, hvilke npm-afhængigheder der kræves til din Rails-applikation. Denne fil bruges af Yarn. For mere information om Garn, besøg Garn hjemmesiden.
offentlig/	Den eneste mappe, der er tilgængelig udefra, som den er. Indeholder statiske filer og kompilerede aktiver.
Rakefile	Denne fil finder og indlæser opgaver, der kan køres på kommandolinjen. En specifik opgave er tilgængelig i alle Rails-komponenter. I stedet for at ændre Rakefilen, kan du tilføje dine egne opgaver ved at tilføje filer til programmets lib/tasks-mappe.
README.md	Dette er en introduktionsvejledning til din ansøgning. Den skal redigeres for at fortælle andre, hvad din applikation gør, hvordan den konfigureres osv.
opbevaring/	Active Storage-filer til Disk-tjenesten. Dette er dækket af Active Storage Overview guide.
prøve/	Enhedsprøver, inventar og andre testapparater. Dette er dækket af Testing Rails Applications guide.
tmp/	Midlertidige filer (såsom cache- og pid-filer)
sælger/	Plads til tredjepartskode. I en typisk Rails-applikation inkluderer den eksterne ædelstene.
.gitignore	Denne fil fortæller git hvilke filer (eksplicit eller ved design) den skal ignorere. For mere information om at ignorere filer, se GitHub - Ignorer filer.
.ruby-version	Denne fil indeholder standardversionen af ​​Ruby.

Hej Rails!

Lad os først vise noget tekst på skærmen. Til dette har du brug for kørende server af din Rails-applikation.

4.1. Start af webserveren

Faktisk har du allerede en funktionel Rails-applikation. For at være sikker skal du køre en webserver på din maskine. Dette kan gøres ved at køre følgende kommando fra blog-mappen:

$ bin/rails server

Hvis du bruger Windows, bør du sende scripts fra bin-mappen direkte til Ruby-fortolkeren, dvs. ruby ​​bin\rails-serveren.

At kompilere CoffeeScript og komprimere JavaScript-aktiver kræver et miljø JavaScript udførelse på dit system, og dets fravær vil resultere i en execjs-fejl under aktivkompilering. Typisk leveres macOS og Windows med en JavaScript-runtime installeret. Rails tilføjer mini_racer-perlen til den nye applikations genererede Gem-fil i en kommenteret linje; du kan fjerne kommentarer, hvis det er nødvendigt. therubyrhino er den anbefalede kørselstid for JRuby-brugere og tilføjes til Gem-filen, hvis applikationen er genereret under JRuby. Du kan lære alt om de understøttede kørselstider i ExecJS

Dette vil starte Puma, en webserver distribueret med Rails som standard. For at se programmet i aktion skal du åbne et browservindue og gå til http://localhost:3000. Du bør se standard Rails infoside:

For at stoppe webserveren skal du trykke på Ctrl+C i terminalen, hvor den kører. For at bekræfte, at serveren er blevet stoppet, bør du se kommandolinjemarkøren igen. På de fleste UNIX-lignende systemer, inklusive macOS, vil dette være dollartegnet $. I udviklingstilstand kræver Rails generelt ikke, at serveren skal stoppes; alle ændringer, du foretager i filer, opfanges automatisk af serveren.

Velkommen ombord-siden er en slags test for en ny Rails-applikation: den viser, at dine programmer er konfigureret korrekt nok til at vise siden.

4.2. Sig hej til Rails

For at Rails kan sige "Hej", skal du i det mindste oprette controller Og udsigt(ydeevne).

Formålet med den registeransvarlige er at modtage specifikke anmodninger til applikationen. Routing bestemmer, hvilken registeransvarlig der skal modtage hvilke anmodninger. Der er ofte mere end én rute til hver controller, og forskellige ruter kan håndteres forskelligt handling. Formålet med hver handling er at indsamle oplysninger for at give dem til visningen.

Formålet med visningen er at vise disse oplysninger i et format, der kan læses af mennesker. En vigtig forskel at bemærke er, at det sted, hvor oplysningerne indsamles, er controller, ikke en udsigt. Visningen skal kun vise disse oplysninger. Som standard er visningsskabeloner skrevet på et sprog kaldet eRuby (Embedded Ruby), som konverteres af en Rails-anmodningsløkke, før de sendes til brugeren.

For at oprette en ny controller skal du køre "controller"-generatoren og fortælle den, at du vil have en controller kaldet "Velkommen" med en handling kaldet "indeks", som denne:

$ bin/rails genererer controller Velkommen indeks

Rails vil oprette flere filer og en rute.

Opret app/controllere/welcome_controller.rb rute få "welcome/index" invoke erb create app/views/welcome create app/views/welcome/index.html.erb invoke test_unit create test/controllers/welcome_controller_test.rb invoke helper create app/ helpers/welcome_helper.rb invoke test_unit påkalde aktiver påkald kaffe create app/assets/javascripts/welcome.coffee invoke scss create app/assets/stylesheets/welcome.scss

De vigtigste af dem er selvfølgelig controlleren, der er placeret i app/controllers/welcome_controller.rb, og visningen, der er placeret i app/views/welcome/index.html.erb.

Åbn filen app/views/welcome/index.html.erb i en teksteditor. Fjern al eksisterende kode i filen og erstat den med følgende kodelinje:

Hvis du indsender formularen igen, vil du se noget i stil med følgende:

"Første artikel!", "text"=>"Dette er min første artikel.") tilladt: false>

Nu viser denne handling parametrene for artiklen, der kom fra formularen. Det er dog stadig ubrugeligt. Ja, du ser parametrene, men du gør faktisk ikke noget med dem.

5.4. Oprettelse af en artikelmodel

Modeller i Rails bruger et entalsnavn, og deres tilsvarende tabel i databasen bruger et flertalsnavn. Rails leverer en modelgenerator, som de fleste Rails-udviklere bruger til at skabe nye modeller. For at oprette en ny model skal du køre denne kommando i din terminal:

$ bin/rails generere model Artikeltitel:streng tekst:tekst

Med denne kommando fortæller vi Rails, at vi ønsker en artikelmodel med attributten titel strengtype og attribut tekst teksttype. Disse attributter vil automatisk blive tilføjet til artikeltabellen og bundet til artikelmodellen.

Rails vil reagere ved at oprette en række filer. Nu er vi kun interesserede i app/models/article.rb og db/migrate/20140120191729_create_articles.rb (dit navn kan være lidt anderledes). Sidstnævnte er ansvarlig for at skabe databasestrukturen, så den vil vi se på næste gang.

Active Record er smart nok til automatisk at forbinde kolonnenavne med modelattributter, hvilket betyder, at der inde i Rails-modeller ikke er behov for at deklarere attributter, Active Record vil gøre det automatisk.

5.5. Starter en migration

Som du allerede har set, genererer bin/rails-modellen filen database migration i mappen db/migrer. Migrations er en Ruby-klasse designet til at gøre det nemt at oprette og ændre databasetabeller. Rails bruger rake-kommandoer til at køre migreringer, og det er muligt at fortryde en migrering, efter at den er blevet anvendt på din database. Navnet på migreringsfilen indeholder et tidsstempel for at sikre, at de udføres i den rækkefølge, de blev oprettet i.

Hvis du kigger i filen db/migrate/YYYYMMDDHHMMSS_create_articles.rb (husk, din fil har et lidt andet navn), er dette hvad du finder der:

Klasse Opret artikler< ActiveRecord::Migration def change create_table:articles do |t| t.string:title t.text:text t.timestamps end end end

Denne migrering opretter en ændringsmetode, der kaldes, når denne migrering kører. De handlinger, der er defineret i denne migrering, er også reversible, hvilket betyder, at Rails ved, hvordan man fortryder de ændringer, der er foretaget af denne migrering, hvis du beslutter dig for at fortryde dem senere. Når du kører denne migrering, vil den oprette en artikeltabel med en strengkolonne og en tekstkolonne. Det vil også oprette to tidsstempelfelter for at spore, hvornår artiklen blev oprettet og opdateret.

Nu skal vi bruge bin/rails-kommandoen til at starte migreringen:

$ bin/rails db:migrate

Rails vil køre denne migreringskommando og rapportere, at den har oprettet tabellen Artikler.

Opret artikler: migrering ================================================ === -- create_table(:articles) -> 0,0019s == CreateArticles: migreret (0,0020s) =========================== ===============

Da du kører i udviklingsmiljøet som standard, vil denne kommando blive anvendt på databasen defineret i udviklingssektionen af ​​din config/database.yml fil. Hvis du vil udføre migreringer i et andet miljø, såsom produktion, skal du udtrykkeligt videregive det, når du kalder kommandoen: bin/rails db:migrate RAILS_ENV=produktion .

5.6. Lagring af data i controlleren

Tilbage til ArticlesController, vi skal ændre oprettelseshandlingen for at bruge den nye artikelmodel til at gemme data i databasen. Åbn app/controllers/articles_controller.rb, og skift oprettelseshandlingen til at se sådan ud:

Def create @article = Article.new(params[:article]) @article.save redirect_to @article end

Her er, hvad der sker her: Hver Rails-model kan initialiseres med de relevante attributter, som automatisk bliver bundet til de tilsvarende databasekolonner. I den første linje gør vi netop det (husk at params[:article] indeholder de attributter, vi er interesserede i). @article.save er derefter ansvarlig for at gemme modellen i databasen. Til sidst omdirigerer vi brugeren til showhandlingen, som vi definerer senere.

Du undrer dig måske over, hvorfor A i Article.new er med stort, når alle de andre artikellinks i denne vejledning er med stort. I denne sammenhæng refererer vi til en klasse kaldet Artikel, som er defineret i app/models/article.rb. Klassenavne i Ruby skal begynde med stort bogstav.

Nu hvor der er valideringer, vil kalde @article.save på en ugyldig artikel returnere falsk . Hvis du åbner app/controllers/articles_controller.rb igen, vil du se, at vi ikke tjekker resultatet af @article.save-kaldet i oprettelseshandlingen. Hvis @article.save mislykkes i denne situation, skal vi vise formularen til brugeren igen. For at gøre dette skal du erstatte det nye og oprette handlinger i app/controllers/articles_controller.rb med disse:

Def new @article = Article.new end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end private def article_params params.require(:article).permit(:title) , :tekst) ende

Den nye handling opretter nu en ny instansvariabel kaldet @article , og du vil se hvorfor i et par afsnit.

Bemærk, at vi i oprettelseshandlingen brugte render i stedet for redirect_to, når save returnerer falsk. Gengivelsesmetoden bruges til at sikre, at @article-objektet sendes tilbage til den nye skabelon, når det gengives. Denne gengivelse udføres inden for samme anmodning som formularindsendelsen, mens redirect_to fortæller browseren om at lave en anden anmodning.

5.11. Artikelopdateringer

Vi har dækket "CR"-delen af ​​CRUD. Lad os nu fokusere på "U"-delen, opdatering af artikler.

Det første trin er at tilføje en redigeringshandling til ArticlesController, typisk mellem de nye og oprette handlinger, som vist.

Def new @article = Article.new end def edit @article = Article.find(params[:id]) end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end ende

Visningen vil indeholde en formular, der ligner den, vi brugte, da vi oprettede nye artikler. Opret en fil kaldet app/views/articles/edit.html.erb og tilføj følgende til den:

Redigering af artikel

<%= form_with(model: @article, local: true) do |form| %> <% if @article.errors.any? %> <% end %>

<%= form.label:title %>
<%= form.text_field:title %>

<%= form.label:text %>
<%= form.text_area:text %>

<%= form.submit %>

<% end %> <%= link_to "Back", articles_path %>

Lige nu peger vi formularen på en opdateringshandling, som ikke er defineret endnu, men det gør vi snart.

Ved at videregive artikelobjektet til metoden indstilles URL-adressen til indsendelse af den redigerede artikelformular automatisk. Denne mulighed fortæller Rails, at vi ønsker, at denne formular skal indsendes ved hjælp af PATCH, en HTTP-metode, der forventes at blive brugt til opdateringer ressourcer i overensstemmelse med REST-protokollen.

Så skal du oprette en opdateringshandling i app/controllers/articles_controller.rb . Tilføj det mellem oprettelseshandlingen og den private metode:

Def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end def update @article = Article.find(params[:id]) if @article.update(article_params) redirect_to @article else render "edit" end end private def article_params params.require(:article).permit(:title, :text) end

Den nye metode, update , bruges, når du vil opdatere en post, der allerede eksisterer, og den tager en hash, der indeholder de attributter, du vil opdatere. Som før, hvis der er en fejl under opdatering af artiklen, vil vi gerne vise formularen til brugeren igen.

Vi genbrugte artikel_params-metoden, som vi definerede tidligere til oprettelseshandlingen.

Det er ikke nødvendigt at videregive alle attributter for at opdatere. For eksempel, hvis @article.update(title: "En ny titel") blev kaldt, vil Rails kun opdatere title-attributten, hvilket efterlader alle andre attributter uberørte.

<% @articles.each do |article| %> <% end %>

Titel	Tekst
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>

Og vi tilføjer også app/views/articles/show.html.erb til skabelonen, så linket "Rediger" også er på artikelsiden. Tilføj følgende i slutningen af ​​skabelonen:

... <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Og sådan ser vores applikation ud nu:

5.12. Brug af partialer til at rydde op i gentagelser i visninger

Vores redigeringsside minder meget om den nye side, faktisk bruger de den samme kode til at vise formularen. Lad os fjerne denne duplikering ved at bruge en delvis visning. Ved konvention begynder delvise filer med en understregning.

Opret en ny fil app/views/articles/_form.html.erb med følgende indhold:

<%= form_with model: @article, local: true do |form| %> <% if @article.errors.any? %>

<% end %>

<%= form.label:title %>
<%= form.text_field:title %>

<%= form.label:text %>
<%= form.text_area:text %>

<%= form.submit %>

<% end %>

Lad os nu opdatere app/views/articles/new.html.erb-visningen for at bruge denne nye del ved at omskrive den fuldstændigt:

Ny artikel

<%= render "form" %> <%= link_to "Back", articles_path %>

Og det samme for view-appen/views/articles/edit.html.erb:

Rediger artikel

<%= render "form" %> <%= link_to "Back", articles_path %>

5.13. Sletning af artikler

Nu er vi klar til at dække del "D" af CRUD, slette fra databasen. I overensstemmelse med REST-konventionen er ruten til at fjerne artikler i bin/skinne-ruternes output som følger:

SLET /artikler/:id(.:format) artikler#destroy

Slet-routingmetoden skal bruges til ruter, der ødelægger ressourcer. Hvis det blev efterladt som en normal get-rute, ville det være muligt at oprette følgende ondsindede URL'er:

se lige denne kat!

Vi bruger slettemetoden til at ødelægge ressourcer, og denne rute er forbundet med ødelæggelseshandlingen i app/controllere/articles_controller.rb, som endnu ikke eksisterer. Destruktionsmetoden er normalt den sidste CRUD-handling i en controller, og ligesom andre offentlige CRUD-handlinger skal den placeres før alle private eller beskyttede metoder. Lad os tilføje det:

Def destroy @article = Article.find(params[:id]) @article.destroy redirect_to articles_path end

Hele ArticlesController i filen app/controllers/articles_controller.rb skulle nu se sådan ud:

Klasseartikler Controller< ApplicationController def index @articles = Article.all end def show @article = Article.find(params[:id]) end def new @article = Article.new end def edit @article = Article.find(params[:id]) end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end def update @article = Article.find(params[:id]) if @article.update(article_params) redirect_to @article else render "edit" end end def destroy @article = Article.find(params[:id]) @article.destroy redirect_to articles_path end private def article_params params.require(:article).permit(:title, :text) end end

Du kan kalde destroy på Active Record-objekter, når du vil fjerne dem fra databasen. Bemærk, at vi ikke behøver at tilføje en visning for denne handling, da vi omdirigerer til indekshandlingen.

Listeartikler

<%= link_to "New article", new_article_path %> <% @articles.each do |article| %> <% end %>

Titel	Tekst
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>	<%= link_to "Destroy", article_path(article), method: :delete, data: { confirm: "Are you sure?" } %>

Her bruger vi link_to på en anden måde. Vi videregiver den navngivne rute som det andet argument og mulighederne som et andet argument. Metoden: :delete og data: (bekræft: "Er du sikker?" ) muligheder bruges som html5-attributter, så når der klikkes på et link, vil Rails først vise brugeren en bekræftelsesdialog og derefter sende linket ved hjælp af slettemetoden . Dette gøres ved hjælp af rails-ujs JavaScript-filen, som automatisk inkluderes i applikationslayoutet (app/views/layouts/application.html.erb), når applikationen genereres. Uden denne fil vil bekræftelsesdialogen ikke blive vist.

Tillykke, du kan nu oprette, se alle og individuelt, opdatere og ødelægge artikler.

Tilføjelse af en anden model

Det er tid til at tilføje en anden model til applikationen. Den anden model vil behandle kommentarer til artikler.

6.1. Generering af modellen

Vi agter at bruge den samme generator, som vi brugte tidligere, da vi oprettede artikelmodellen. Denne gang vil vi oprette en kommentarmodel, der indeholder et link til artiklen. Kør følgende kommando i en terminal:

$ bin/rails generere model Kommentar commenter:string body:text article:references

Denne kommando genererer fire filer:

Lad os først tage et kig på app/models/comment.rb:

Klassekommentar< ApplicationRecord belongs_to:article end

Dette minder meget om artikelmodellen, vi så tidligere. Forskellen er i belongs_to:article line, som sætter forbindelse Aktiv rekord. Du lærer om forbindelser i næste afsnit af vejledningen.

Søgeord (:referencer) brugt i bash kommando, dette er en speciel datatype for modeller. Den opretter en ny kolonne i din database med navnet på den repræsenterede model med tilføjet _id, som kan indeholde numeriske værdier. For bedre at forstå, analyser filen db/schema.rb efter at have udført migreringen.

Ud over modellen foretog Rails også en migrering for at oprette den tilsvarende databasetabel:

Klasse Opret kommentarer< ActiveRecord::Migration def change create_table:comments do |t| t.string:commenter t.text:body t.references:article, foreign_key: true t.timestamps end end end

t.references-linjen opretter en numerisk kolonne kaldet artikel_id, et indeks på den og en fremmednøgle-begrænsning, der peger på id-kolonnen i artiklertabellen. Dernæst starter vi migreringen:

$ bin/rails db:migrate

Rails er smart nok til kun at køre migreringer, der ikke allerede er blevet kørt på den aktuelle database, i vores tilfælde vil du se:

Opret kommentarer: migrering ================================================= == -- create_table(:comments) -> 0,0115s == CreateComments: migreret (0,0119s) ============================ =============

6.2. Tilsluttede modeller

Active Record-relationer giver dig mulighed for nemt at erklære relationer mellem to modeller. I tilfælde af kommentarer og artikler kan du beskrive forholdet som følger:

• Hver kommentar hører til én artikel.
• En artikel kan have mange kommentarer.

Faktisk er det meget tæt på den syntaks, som Rails bruger til at erklære denne forbindelse. Du har allerede set kodelinjen i kommentarmodellen (app/models/comment.rb), der får hver kommentar til at høre til en artikel:

Klassekommentar< ApplicationRecord belongs_to:article end

Du skal redigere app/models/article.rb for at tilføje den anden side af linket:

Klasse artikel< ApplicationRecord has_many:comments validates:title, presence: true, length: { minimum: 5 } [...] end

Disse to annoncer bliver automatisk tilgængelige et stort antal af muligheder. For eksempel, hvis du har en @article-instansvariabel, der indeholder en artikel, kan du få alle kommentarer, der hører til den pågældende artikel, i et array ved at kalde @article.comments .

6.3. Tilføjelse af en rute for kommentarer

Som med velkomstcontrolleren skal vi tilføje en rute, så Rails ved, hvilken adresse vi vil gå til for at se kommentarerne. Åbn filen config/routes.rb igen, og rediger den som følger:

Ressourcer:artikler gør ressourcer:kommentarer slutter

Dette vil skabe kommentarer som indlejret ressource i artikler. Dette er den anden side af at fange de hierarkiske forhold, der eksisterer mellem artikler og kommentarer.

6.4. Generering af en controller

Når vi har modellen, så lad os vende vores opmærksomhed mod at skabe den passende controller. Vi vil igen bruge den samme generator, som vi brugte før:

$ bin/rails genererer controllerkommentarer

Fem filer og en tom mappe vil blive oprettet:

Som enhver anden blog vil vores læsere oprette deres kommentarer umiddelbart efter at have læst artiklen, og efter at have tilføjet en kommentar, vil de blive dirigeret tilbage til artiklens visningsside og se, at deres kommentar allerede er blevet afspejlet. I denne forbindelse fungerer vores CommentsController som et middel til at oprette kommentarer og fjerne spam, hvis nogen.

Først udvider vi artikelshowskabelonen (app/views/articles/show.html.erb) for at tillade, at der tilføjes en ny kommentar:

Titel: <%= @article.title %>

Tekst: <%= @article.text %>

Tilføj en kommentar:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Dette vil tilføje en formular til artiklens visningsside, der opretter en ny kommentar, når oprettelseshandlingen kaldes på CommentsController. Her bruger form_with-kaldet et array, som vil skabe en indlejret rute såsom /articles/1/comments .

Lad os skrive oprette i app/controllers/comments_controller.rb:

Klassekommentarer Controller< ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end

Det er lidt mere kompliceret end hvad du så i artikelcontrolleren. Dette er en bivirkning af den vedhæftede fil, du opretter. Hver anmodning om en kommentar holder styr på artiklen, som kommentaren er knyttet til, så vi løser først problemet med at hente artiklen ved at ringe til find på artikelmodellen.

Derudover udnytter koden nogle af de tilgængelige metoder til forbindelser. Vi bruger oprettelsesmetoden på @article.comments til at oprette og gemme en kommentar. Dette linker automatisk kommentaren, så den hører til en bestemt artikel.

Når vi har oprettet en ny kommentar, tager vi brugeren tilbage til den oprindelige artikel ved hjælp af article_path(@article)-hjælperen. Som vi allerede har set, kalder det show-handlingen på ArticlesController, som igen gengiver show.html.erb-skabelonen. Det er her, vi ønsker at vise kommentarer, så lad os tilføje følgende til app/views/articles/show.html.erb.

Titel: <%= @article.title %>

Tekst: <%= @article.text %>

Kommentarer

<% @article.comments.each do |comment| %>

Kommentar: <%= comment.commenter %>

Kommentar: <%= comment.body %>

<% end %>

Tilføj en kommentar:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Nu kan du tilføje artikler og kommentarer til din blog og vise dem de rigtige steder.

Refaktorering

Nu hvor vi har fungerende artikler og kommentarer, lad os tage et kig på app/views/articles/show.html.erb skabelonen. Det blev langt og ubehageligt. Lad os bruge partialer til at lindre det.

7.1. Gengivelse af samlinger af partialer

Først laver vi en delvis kommentar, der viser alle kommentarerne til en artikel. Opret en fil app/views/comments/_comment.html.erb og læg følgende i den:

Kommentar: <%= comment.commenter %>

Kommentar: <%= comment.body %>

Så kan du ændre app/views/articles/show.html.erb sådan her:

Titel: <%= @article.title %>

Tekst: <%= @article.text %>

Kommentarer

<%= render @article.comments %>

Tilføj en kommentar:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Dette vil nu gøre appen/views/comments/_comment.html.erb delvist én gang for hver kommentar i @article.comments-samlingen. Da gengivelsesmetoden itererer gennem @article.comments-samlingen, tildeler den hver kommentar til en lokal variabel navngivet som partial, i dette tilfælde kommentar , som er tilgængelig for os i partial til visning.

7.2. Gengivelse af en formular i en delvis

Lad os også flytte den nye kommentarsektion til vores del. Igen, opret en fil app/views/comments/_form.html.erb indeholdende:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %>

Skift derefter app/views/articles/show.html.erb sådan her:

Titel: <%= @article.title %>

Tekst: <%= @article.text %>

Kommentarer

<%= render @article.comments %>

Tilføj en kommentar:

<%= render "comments/form" %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Den anden gengivelse definerer bare den delvise skabelon, vi ønsker at gengive, kommentarer/form . Rails er smart nok til at sætte en understregning på denne linje og forstå, at du ville gengive filen _form.html.erb i mappen app/views/comments.

@article-objektet er tilgængeligt i alle partialer, der gengives i visningen, da vi definerede det som en instansvariabel.

Sletning af kommentarer

Et andet vigtigt træk ved bloggen er muligheden for at fjerne spam. For at gøre dette skal du indsætte et link i visningen og en ødelæggelseshandling i CommentsController.

Kommentar: <%= comment.commenter %>

Kommentar: <%= comment.body %>

<%= link_to "Destroy Comment", , method: :delete, data: { confirm: "Are you sure?" } %>

Tryk på denne nyt link"Destroy Comment" vil køre DELETE /articles/:article_id/comments/:id i vores CommentsController, som derefter vil blive brugt til at finde den kommentar, vi vil slette, så lad os tilføje en ødelæggelseshandling til vores controller (app/controllers/comments_controller .rb):

Klassekommentarer Controller< ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end def destroy @article = Article.find(params[:article_id]) @comment = @article.comments.find(params[:id]) @comment.destroy redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end

Destruktionshandlingen vil finde den artikel, vi ser, finde kommentaren i @article.comments-samlingen og derefter fjerne den fra databasen og returnere os til at se artiklen.

8.1. Sletning af relaterede objekter

Hvis du sletter en artikel, skal kommentarerne tilknyttet den også slettes, ellers fylder de blot i databasen. Rails giver dig mulighed for at bruge den afhængige mulighed på et link for at opnå dette. Rediger artikelmodellen, app/models/article.rb , som følger:

Klasse artikel< ApplicationRecord has_many:comments, dependent: :destroy validates:title, presence: true, length: { minimum: 5 } [...] end

Sikkerhed

9.1. Grundlæggende godkendelse

Hvis du udgiver din blog online, kan enhver tilføje, redigere og slette artikler eller slette kommentarer.

Rails tilbyder et grundlæggende HTTP-godkendelsessystem, der fungerer godt i denne situation.

I ArticlesController har vi brug for en måde at blokere adgang til forskellige handlinger, hvis brugeren ikke er godkendt. Her kan vi bruge Rails http_basic_authenticate_with metoden til at give adgang til de nødvendige handlinger, hvis metoden tillader det.

For at bruge autentificeringssystemet definerer vi det øverst i vores ArticlesController i app/controllere/articles_controller.rb. I vores tilfælde ønsker vi, at brugeren skal godkendes for hver handling undtagen indeks og vis , så vi skriver det sådan her:

Klasseartikler Controller< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", except: [:index, :show] def index @articles = Article.all end # пропущено для краткости

Vi ønsker også kun at tillade godkendte brugere at slette kommentarer, så i CommentsController (app/controllers/comments_controller.rb) skriver vi:

Klassekommentarer Controller< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", only: :destroy def create @article = Article.find(params[:article_id]) # ... end # пропущено для краткости

Hvis du nu prøver at skabe ny artikel, så står over for udfordringen grundlæggende autentificering HTTP:

Andre autentificeringsmetoder er også tilgængelige for Rails-applikationer. To populære tilføjelser til Rails er blandt andre Devise og Authlogic.

9.2. Andre tanker om sikkerhed

Sikkerhed, især i webapplikationer, er et bredt og detaljeret område. Sikkerheden af ​​din Rails-applikation er dækket mere detaljeret i guiden Sikkerhed for Rails-applikationer Den enkleste måde at arbejde med Rails på er at gemme alle eksterne data i UTF-8. Hvis ikke, vil Ruby- og Rails-bibliotekerne ofte være i stand til at konvertere dine oprindelige data til UTF-8, men dette fungerer ikke altid pålideligt, så det er bedst at være sikker på, at alle eksterne data er UTF-8.

Hvis du laver en fejl i dette område, er det mest almindelige symptom en sort diamant med et spørgsmålstegn indeni, der vises i browseren. Et andet almindeligt symptom er symboler som "ü" i stedet for "ü". Rails tager en række interne trin for at afbøde almindelige tilfælde af problemer, der automatisk kan opdages og rettes. Men hvis der er eksterne data, som ikke er gemt i UTF-8, kan dette føre til den slags problemer, som Rails ikke automatisk kan opdage og rette.

De to mest almindelige datakilder, der ikke er i UTF-8, er:

• Din teksteditor: De fleste teksteditorer (såsom TextMate) gemmer filer som UTF-8 som standard. Hvis din teksteditor ikke gør dette, kan det forårsage, at specialtegn, der er indtastet i dine mønstre (såsom é), vises som en diamant med et spørgsmålstegn i browseren. Dette gælder også for dine i18N-oversættelsesfiler. De fleste editorer, der ikke er standard til UTF-8 (såsom nogle versioner af Dreamweaver), tilbyder en måde at ændre standarden til UTF-8. Gør dette.
• Din database: Rails konverterer som standard data fra din database til UTF-8 på kanten. Men hvis din database ikke bruger UTF-8 internt, kan den muligvis ikke gemme alle de tegn, som din bruger vil indtaste. For eksempel, hvis din database bruger Latin-1 internt, og din bruger indtaster russiske, hebraiske eller japanske tegn, vil dataene gå tabt, så snart de kommer ind i databasen. Hvis det er muligt, så brug UTF-8 som internt lager i din database.

I denne artikel vil jeg fortælle dig, hvordan du opretter et simpelt program, der fungerer med en MySQL-database i miljøet Ruby on Rails 3. Du kan tænke på dette materiale som en trin-for-trin guide for begyndere Rails-programmører.

Så til arbejde har vi brug for installerede skinner og rubygems. I går havde jeg et problem med sidstnævnte, så jeg var nødt til at fjerne rubygems1.8-pakken (det er ikke klart, hvordan den endte i systemet) og installere rubygems1.9 Lad mig minde dig om, at jeg udvikler på Ubuntu, dog til Windows Jeg tror, ​​at Rails-konsolkommandoerne vil være de samme. Som udviklingsmiljø bruger jeg NetBeans med et plugin til Ruby on Rails. Min kollega skrev godt om installationen.

Kontrol af links

Du skal sikre dig, at mappen /usr/bin indeholder rails, rake, ruby, bundler-symlinks til filer fra mappen /usr/local/ruby/bin. Brug kommandoen for at se links:

alt efter hvad du vil filtrere.

Oprettelse af en applikation

Jeg oprettede en speciel mappe til mine rubin-applikationer.

mkdir /home/andrey/ruby
cd /home.andrey/ruby

Skinnerne har meget konsolværktøjer, hvilket i høj grad letter arbejdet, især prototyping. For at oprette et program ved hjælp af mysql som en database skal du køre kommandoen:

app er navnet på vores nye applikation. Efter at have udført kommandoen, vil vi se, hvordan rails gjorde os til rammen for den fremtidige applikation.

root@vaio:~/ruby# skinner ny app -d mysql
skab
oprette README
oprette Rakefile
oprette config.ru
create.gitignore
oprette Gemfile
oprette app
oprette app/controllere/application_controller.rb
oprette app/helpers/application_helper.rb
oprette app/mailere
oprette app/modeller
oprette app/views/layouts/application.html.erb
oprette konfiguration
oprette config/routes.rb
oprette config/application.rb
oprette config/environment.rb
oprette konfigurationer/miljøer
oprette config/environments/development.rb
oprette config/environments/production.rb
oprette config/environments/test.rb
oprette config/initializers
oprette config/initializers/backtrace_silencers.rb
oprette config/initializers/inflections.rb
oprette config/initializers/mime_types.rb
oprette config/initializers/secret_token.rb
oprette config/initializers/session_store.rb
oprette config/locales
oprette config/locales/en.yml
opret config/boot.rb
oprette config/database.yml
oprette db
oprette db/frø.rb
oprette dok
opret doc/README_FOR_APP
skabe lib
oprette lib/opgaver
opret lib/tasks/.gitkeep
oprette log
oprette log/server.log
oprette log/production.log
oprette log/development.log
oprette log/test.log
skabe offentlighed
oprette public/404.html
oprette public/422.html
oprette public/500.html
oprette public/favicon.ico
oprette public/index.html
oprette public/robots.txt
skabe offentlige/billeder
oprette public/images/rails.png
oprette offentlige/stylesheets
oprette public/stylesheets/.gitkeep
oprette offentlige/javascripts
oprette public/javascripts/application.js
oprette public/javascripts/controls.js
oprette public/javascripts/dragdrop.js
oprette public/javascripts/effects.js
oprette public/javascripts/prototype.js
oprette public/javascripts/rails.js
oprette script
oprette script/rails
oprette test
lave test/opstillinger
oprette test/funktionel
skabe test/integration
oprette test/performance/browsing_test.rb
oprette test/test_helper.rb
oprette test/enhed
oprette tmp
oprette tmp/sessioner
oprette tmp/sockets
oprette tmp/cache
oprette tmp/pids
oprette leverandør/plugins
oprette leverandør/plugins/.gitkeep

Vi går til mappen med det og installerer de nødvendige ædelstene. Gems er plug-in biblioteker, der kræves til projektet (analogt med PHPs PECL og PEAR).

Efter dette vil konsollen vise noget som dette:

andrey@vaio:~/ruby/app> sudo bundle install
Brug af rive (0.8.7)
Brug af abstrakt (1.0.0)
Brug af activesupport (3.0.0)
Brug af builder (2.1.2)
Bruger i18n (0.4.2)
Brug af activemodel (3.0.0)
Brug af erubis (2.6.6)
Brug af stativ (1.2.1)
Brug af stativmontering (0.6.13)
Brug af rack-test (0.5.6)
Brug af tzinfo (0.3.23)
Brug af actionpack (3.0.0)
Brug af mime-typer (1.16)
Brug af polyglot (0.3.1)
Brug af trætop (1.4.8)
Brug af mail (2.2.9)
Brug af actionmailer (3.0.0)
Brug af arel (1.0.1)
Brug af activerecord (3.0.0)
Brug af activeresource (3.0.0)
Brug af bundler (1.0.3)
Bruger mysql2 (0.2.6)
Brug af thor (0.14.4)
Brug af railties (3.0.0)
Brug af skinner (3.0.0)
Din pakke er færdig! Brug `bundle show ` for at se, hvor en bundt perle er installeret.

Det betyder, at alle ædelstene er installeret og forbundet. Hvis noget mangler, vil bundtet selv downloade dem fra rubygems og installere dem. Det her er til mig i lang tid manglede i php, i det væsentlige viser det sig at være et projektinstallationsprogram. Listen over afhængige ædelstene er placeret i Gem-filen i projektets rod.

Konfiguration

Nu skal vi specificere adgangsoplysningerne til databasen for vores projekt. Åbn projektet i NetBeans: Nyt projekt -> Ruby -> Ruby on Rails-applikation med eksisterende kilde. Vi angiver stien, i mit tilfælde vil det være (/home/andrey/ruby/app) og navnet på projektet (app). Til Ruby-platformen vælger vi den, der er installeret på systemet, i stedet for den, der er indbygget i NetBeans. Klik på Udfør og projektet oprettes. Åbn pseudo-mappen Konfiguration og filen database.yml. Her skal du angive login og adgangskode for at få adgang til databasen, helst for alle tre miljøer på én gang (udvikling, test, produktion). Miljø er det miljø, som vores applikation kører i,

• udvikling - udviklerens computer,
• produktion - industriel drift server,
• test — arbejde i testtilstand på den kontinuerlige integrationsserver eller testerens computer.

skinner generere model Brugernavn:streng hashed_adgangskode:streng salt:streng

Du kan med det samme se, hvad Rails har genereret for os:

påberåbe active_record
oprette db/migrate/20101107054200_create_users.rb
oprette app/modeller/bruger.rb
påkald test_unit
oprette test/unit/bruger_test.rb
oprette test/fixtures/users.yml

Godt, nu skal vi lave en database. For at gøre dette gør vi:

andrey@vaio:~/ruby/app$ rake db:create
(i /home/andrey/ruby/app)
andrey@vaio:~/ruby/app$ rake db:migrate
(i /home/andrey/ruby/app)
== Opret brugere: migrering =============================================== =======
— create_table(:brugere)
-> 0,0061s
== Opret brugere: migreret (0,0063s) ========================================= =============== ==

Konsollen viser de tilføjede data. Vi kigger i phpmyadmin og ser de nye app_development og app_test databaser, samt tabellerne i dem. Nu er det tid til at tilføje rigtige data. For at gøre dette skal du starte rails-konsollen

En konsol er ikke bare en konsol, men en IRB-konsol i forbindelse med din applikation. Lad os som et eksempel oprette to brugere:

andrey@vaio:~/ruby/app$ rails konsol
Indlæser udviklingsmiljø (Rails 3.0.0)
irb(main):001:0> bruger1 = Bruger.ny
=> #
irb(main):002:0> bruger1.navn = "andrey"
=> "andrey"
irb(main):003:0> bruger1.gem
=> sandt
irb(main):004:0> bruger2 = Bruger.ny
=> #
irb(main):005:0> bruger2.navn = "vasiliy"
=> "vasiliy"
irb(main):006:0> bruger2.gem
=> sandt

irb(main):007:0> exit
andrey@vaio:~/ruby/app$

Lad os se på databasen, og vi har faktisk to brugere. Jeg vil gerne bemærke, at Rails selv tilføjede primære nøglekolonner og felterne create_at (creation date) og updated_at (modificeret dato) til modellen.

Vi har en model, og vi har også data. Det er tid til at starte vores applikation.

andrey@vaio:~/ruby/app$ rails server
=> Opstart af WEBrick
=> Rails 3.0.0-applikation, der starter under udvikling på http://0.0.0.0:3000
=> Ring med -d for at frakoble
=> Ctrl-C for at lukke serveren
INFO WEBrick 1.3.1
INFO ruby ​​1.9.2 (2010-08-18)
INFO WEBrick::HTTPServer#start: pid=4193 port=3000

Applikationen kører, åbn browseren på adressen og se testsiden.

Godt, applikationen virker. Men den viser en almindelig HTML-side fra mappen /public/index.html. Og vi vil have dynamik. Åbn det andet konsolvindue (da vi i det første har Ruby-serveren kørende - WebRick), gå til mappen med projektet og skriv følgende kommando der:

andrey@vaio:~/ruby/app$-skinner genererer controllerindeksindeks
opret app/controllere/index_controller.rb
rute få "indeks/indeks"
påberåbe erb
oprette app/visninger/indeks
oprette app/views/index/index.html.erb
påkald test_unit
oprette test/functional/index_controller_test.rb
påkalde hjælper
oprette app/helpers/index_helper.rb
påkald test_unit
opret test/unit/helpers/index_helper_test.rb
andrey@vaio:~/ruby/app$

Med denne lavede vi en Index-controller, i den er der en Index-handling og typen af ​​denne handling er index.html.erb. Vi laver Refresh (F5) i NetBeans og ser på vores filer. Fantastiske. Nu skal vi på en eller anden måde omdirigere ruten for hovedsiden til den controllerhandling, vi oprettede. Åbn rutefilen (Configuration/routes.rb), og fjern kommentaren fra følgende linje der:

# Du kan få roden til dit websted omdirigeret med "root"
# husk blot at slette public/index.html.
root:to => "velkommen#indeks"

Kun i stedet for velkommen skriver vi også indeks. Nå, jeg er vant til Zend Framework, at controlleren og handlingen kaldes index som standard. Glem ikke at slette (eller omdøbe) public/index.html-filen).

root:to => "indeks#indeks"

Vi opdaterer siden i browseren og ser, at vores visning nu vises.

Indeks#indeks

Store. Nu kan vi kode Gå til vores nyoprettede controller (Controllers -> index_controller.rb) og skriv følgende handlingstekst der:

klasse IndexController< ApplicationController
def indeks
@brugere = Bruger.find(:alle)
ende
ende

Åbn nu visningen Views/index/index.html.erb og skriv følgende kode der:

Indeks#indeks

Find mig i app/views/index/index.html.erb

<% for user in @users -%>
<%=user.name%>

<% end %>

Ved at gøre dette beder vi Rails om at gentage rækken af ​​brugere og vise deres navne. Vi opdaterer siden og ser listen over brugere nedenfor.

Indeks#indeks

Find mig i app/views/index/index.html.erb

andrey
vasiliy

Store! Applikationen er oprettet!

Tak skal du have!

Hvis denne artikel hjalp dig, eller du vil støtte min forskning og blog, er her den bedste måde at gøre det på:

God dag!

Forord

Jeg ville engang gerne lære Rails bedre at kende, men vidste ikke, hvor jeg skulle starte, før denne artikel fangede mit øje. Dernæst vil du se oversættelsen blandet med egen erfaring og leksikalske og fraseologiske vendinger, der er karakteristiske for mig. Så lad os gå.

Introduktion

Jeg har meget erfaring med at arbejde med PHP, men nu arbejder jeg som Rails-udvikler. Den største udfordring for de fleste mennesker, der forsøger at lære noget nyt, er selve læringsprocessen. Når du er dygtig til et sprog eller rammer og kender det ud og ind, virker det ikke nødvendigt at skifte til noget nyt.

Det er dog ret nemt at lære Ruby on Rails. Det er en utrolig kraftfuld ramme, der har et enormt fællesskab, der skubber det fremad. Så spørgsmålet, vi har, er: hvad er den bedste måde at lære Rails på? Her er den - lektionsplanen.

Denne artikel er en komplet plan over de nødvendige lektioner for at sætte dig ind i Rails og begynde at arbejde med det på kortest mulig tid. Alt du skal gøre er at følge nedenstående trin, som er listet i rækkefølge.

Punkt 1: arbejde med øvelser i Prøv Ruby

Du tror måske, at lære Ruby er det bedste her vigtigt skridt, men det er ikke sandt. Nogle af dem, der begynder at studere Ruby i detaljer, stopper med at studere og bliver simpelthen ved det nuværende sprog og rammer. Gør det ikke!. Vær ikke bange for at lære dette sprog (eller et hvilket som helst andet). Ruby er et sjovt, fantastisk og let at lære sprog. Plus, glem ikke, at du ikke behøver at studere det 100%. Du skal bare kende det grundlæggende.

Det mest anbefalede værktøj til at dykke ned i Ruby-syntaks er TryRuby-webstedet. Det giver et interaktivt miljø, der giver dig mulighed for at prøve syntaksen i aktion. Hvis du ringer Hjælp, vil du blive inviteret til at se en 15-minutters tutorial, der vil lære dig det grundlæggende. Glem ikke, at manualen har to kapitler, som du kan læse ved at skrive hjælp 2.

Hvis du arbejder hårdt på disse opgaver i nogen tid, vil du udvikle et godt vidensgrundlag. Det eneste, jeg gjorde først, var at studere disse to manualer. Resten lærte jeg i processen med at udvikle sites på Rails, samt ved at google og træne med IRB.

Punkt 2: Installation af Ruby og Ruby på skinner

Hvis du vil lære Rails, så skal du uden tvivl installere det på din computer. Her er flere løsninger baseret på hvilket OS du har. Hvis du har en Mac eller Linux-baseret computer, så anbefaler jeg, at du bruger RVM. Dette er et fantastisk værktøj til at installere Ruby. Her er faktisk instruktionerne til selve installationen. Hvis du har Windows, skal du bruge RubyInstaller.

Det næste trin er at installere Rails selv. For at gøre dette skal du installere RubyGems. Hvis du bruger RVM, så tillykke - du har allerede RubyGems installeret. Hvis du har Windows, så råder jeg dig til at følge med her. For at installere Rails skal du bruge kommandoen perle installere skinner og så er alt gjort!

Punkt 3: Læs Jeffrey Ways introduktion til skinner

I denne 40-minutters screencast leder Jeffrie Way dig igennem, hvad du skal vide for at bruge Rails. I den finder du meget brugbar information, herunder emner som:

• Modeller og generatorer
• Testdrevet udvikling (TDD)
• ActiveRecord
• RSpec og Capybara
• Partialer

og meget mere...

Punkt 4: Tag Rails For Zombies-kurset

Jeg har altid troet, at lære ved eksempel er det mest den bedste måde lære et sprog eller en ramme. Et gratis og utroligt kraftfuldt kursus, du helt sikkert bør tjekke ud, er Rails For Zombies, skabt af gutterne hos EnvyLabs. Dette kursus er interaktivt, hvilket betyder, at du efter at have set hver video vil arbejde med nyttige og interessante øvelser.

Indtil dette tidspunkt fortalte jeg dig om interaktive og gratis værktøjer. Tiden for freebies er forbi! Nu bør du købe en bog kaldet Agile Web Development with Rails. Det er designet til at lære dig, hvordan du bruger Rails ved at bygge et websted fra bunden. Hun passerer grundlæggende grundlæggende, såsom controllere, modeller, stilladser, funktionstest og også lidt AJAX. Køb mindst den seneste udgave.

Punkt 6: Byg en simpel blog

Jeg ved godt det lyder ret kedeligt ( i det mindste for mig), men dette er et godt eksempel, der bruges overalt på grund af det faktum, at det er ret enkelt og hurtigt at skrive. Ved at følge denne vej hjælper du med at konsolidere din viden og færdigheder. Men jeg foreslår, at du ikke copy-paste (du opnår ikke noget ved at gøre dette, undtagen måske 10 minutters spildt elektricitet), men prøv at skrive det gradvist, fra hukommelsen, nogle gange bare kigge på bogen for at se, hvordan denne eller hin metode virker.

Punkt 7: Tilføj nye funktioner til din blog

Fabelagtig! Har du trods alt bygget din? egen blog. Men stadig har den ikke fuld funktionalitet, men kun gaver grundlæggende funktioner iboende i hver blog. Okay, lad os arbejde lidt og tilføje et godkendelsessystem.

Jeg vil egentlig ikke tvinge dig til at gøre noget svært lige nu, for du har allerede arbejdet hårdt. Du kan bruge en færdiglavet perle (omniauth, for eksempel) som et autentificeringssystem. Samtidig vil du finde ud af, hvordan du implementerer ædelstene i dit projekt.

Jeg anbefaler også at se denne screencast fra Ryan Bates, som beskriver at skabe et simpelt autentificeringssystem fra bunden. Efter implementering af systemet bør du tilføje muligheden for at slette/redigere indlæg, hvis du ikke allerede har gjort det. Hvis opgaven allerede er fuldført, så er det tid til at gå videre til næste punkt.

Punkt 8: skabe noget af dit eget

På på dette tidspunkt Det er på tide, at du bliver mere kreativ og tænker på at skabe en form for service (for eksempel fotohosting). Lad være med at designe dit andet websted. Tag noget færdiglavet. For eksempel,

Forfatteren blev tilskyndet til at skrive denne tekst ved at studere en række ting, der findes i Globalt netværk materialer, der godt kunne betegnes under samme overskrift/tag: Hvordan jeg lærte Ruby(eller Ruby on Rails, PHP, JS, C++ osv.) i tre dage.

Eller noget i den stil. Forfatteren huskede til gengæld straks (ukontrollerbare associationer) en række anekdoter, forenet igen af ​​et fælles tema, som består i den evaluerende karakterisering af handlinger, der kan udføres tåbeligt... det russiske sprog er kraftfuldt og utroligt aforistisk, men , desværre synes det ikke muligt at citere disse mesterværker her; Derfor er der ikke andet at gøre end at tilbyde læserens opmærksomhed en personligt skrevet version af dokumentet fra serien Sådan lærer du at arbejde i Ruby on Rails med fornøjelse og relativt hurtigt.

Et fungerende eksempel på koden beskrevet i artiklen, blandt andre Rails Eksempler, kan altid findes i forfatterens testblog på herokuapp.com, velkommen.

Teknikken er enkel, og forfatteren hævder slet ikke laurbærrene af en opdager her: det er nødvendigt, at det er interessant, og resultaterne vil ikke lade dig vente. Det skader ikke at forsøge at spille på dine egne svagheder, for nogle gange kan forfængelighed være gavnlig for sagen; resultaterne af udviklingen skal være sådan, at de med stolthed kan præsenteres for læsere, venner og kolleger på internettet, udrullet et sted på Heroku eller Amazon, også - så vi kan vende tilbage til dem igen og igen, genopbygning og forbedring, fora og StackOwerflow hjælper os alle. Så jeg siger, hvorfor ikke først skrive din blog videre Ruby on Rails?

Jeg foreslår, at man starter fra den fremragende Kom godt i gang med Rails-doketten eller dens russisksprogede tilpasning af Rails for begyndere, også Byg en blog med Ruby on Rails, og materialerne i denne blog, som man nemt kan finde links til i venstre sidebjælke, kan også hjælpe. Og så - det er det, så magi, først er alt lagt ud som ved noter, åbn konsollen - og frem... forfatteren anser det for sin pligt kun at komme med nogle få forklaringer og tekniske anbefalinger designet til at gøre det lettere for dygtigen til at finde og erhverve den lette side af kraften, og ikke mere Togo. Dette er kun din kamp, ​​gå dristigt frem og vend tilbage som sejr.

Så. Trin-for-trin i den første manual er perfekt kalibreret og, jeg håber, det vil ikke volde dig nogen problemer; alt, der kræves af dig, er at være opmærksom, omhyggeligt at gentage de detaljerede trin... og efter en time er din første blog klar, kan du tage en pause og gå videre til den anden, noget mere interessante. Og det er her, måske et par afskedsord kan komme til nytte, som vi nu går videre til.

Lad os starte med udsagnet om, at disse metoder er ganske i stand (som en mulighed) til at se ud som det, der er vist nedenfor, men på ingen måde de samme som i originalen:

app/controllere/posts_controller.rb

# Opdateringshandling opdaterer indlægget med den nye information def update if @post.update_attributes(post_params) flash[:notice] = "Opdateret indlæg med succes!" redirect_to posts_path else flash[:alert] = "Fejl ved opdatering af indlæg!" render:edit end end # Vis handlingen gengiver det individuelle indlæg efter at have hentet id'et def show end # Destruktionshandlingen fjerner indlægget permanent fra databasen def destroy @post = Post.find(params[:id]) if @post . destroy flash[:notice] = "Slettet indlæg med succes!" redirect_to posts_path else flash[:alert] = "Fejl ved opdatering af indlæg!" ende ende

Men prøv det og det, hvorfor ikke. Lad os gå videre.

Anden blog, selvom mere kompleks (tilsat artikeleditor CKEditor Og udtænke, et fleksibelt værktøj til godkendelse i skinneapplikationer), mangler af en eller anden grund muligheden for at efterlade kommentarer i originalen. Du bliver selv nødt til at udfylde denne mangel: fortsæt analogt med beskrivelsen af ​​oprettelse af den første blog, kun meget små ændringer vil være nødvendige: ganske enkelt i stedet for artikel Og artikler du vil have den første blog stolpe Og indlæg i den anden blog er det dybest set forskellen. Vær forsigtig, og alt vil løse sig.

Recaptcha Du skal også selv linke til kommentarer: ja, ja, dette er ikke Joomla for dig, væn dig til det. Titanisk indsats er dog ikke påkrævet; forbindelsesprocessen Recaptcha er beskrevet detaljeret i artiklen Connecting Recaptcha in Rails application. Dernæst er det ikke overflødigt at justere udtænke på en sådan måde, at bloggen fungerer (i hvert fald i første omgang!) i enkeltbrugertilstand, hvilket tillader adskillige af dens læsere LÆSEKUN tilstand, med andre ord vil vi forbyde registrering af nye brugere til at begynde med. Der er en del forskellige opskrifter på internettet på, hvordan man gør dette, men efter min mening er det mest kompetente hack af denne art i Wiki devise, i materialet kaldet How To: Set up devise as a single user system. Nemlig: vi opretter en ny controller:

app/controllere/registrations_controller.rb:

Klasseregistreringskontrol< Devise::RegistrationsController before_action:one_admin_registered?, only: [:new, :create] protected def one_admin_registered? if ((Admin.count == 1) & (admin_signed_in?)) redirect_to root_path elsif Admin.count == 1 redirect_to new_admin_session_path end end end

så tilsidesætter vi det i routes.rb, og det er det:

#devise_for:admins devise_for:admins, controllers: (registreringer: "registreringer")

CKEDITOR.editorConfig = function(config) ( // config.enterMode = 2; //disabled

Fuldstændig config.enterMode = CKEDITOR.ENTER_BR // ved at trykke på ENTER-tasten
config.shiftEnterMode = CKEDITOR.ENTER_P; //tryk på SHIFT + ENTER-tasterne

Config.autoParagraph = falsk; // stopper automatisk indsættelse af

På fokus);

Måske, til at begynde med, er dette virkelig alt... fanden, jeg glemte næsten det vigtigste. Hvis du vil implementere din nye blog til Heroku- føje disse tre linjer til

config/application.rb

Config.assets.precompile += Ckeditor.assets config.assets.precompile += %w(ckeditor/*) config.autoload_paths += %W(#(config.root)/app/models/ckeditor)

Ellers CKEditor vil nægte at arbejde for dig på dit nye sted.