Ruby on Rails Handledning
Komma igång med Ruby on Rails

Anmärkningar

versioner

Skapa en Ruby on Rails-applikation

Detta exempel antar att Ruby och Ruby on Rails redan har installerats korrekt. Om inte kan du hitta hur du gör det här .

Öppna en kommandorad eller terminal. För att skapa en ny rails-applikation, använd rails nytt kommando följt av namnet på din applikation:

$ rails new my_app

Om du vill skapa din Rails-applikation med en specifik Rails-version kan du ange den vid tidpunkten för att generera applikationen. För att göra det, använd rails _version_ new följt av applikationsnamnet:

$ rails _4.2.0_ new my_app 

Detta kommer att skapa en Rails program som heter MyApp i en my_app katalog och installera pärla beroenden som redan nämns i Gemfile använda bundle install .

Om du vill växla till den nyskapade appens katalog använder du cd kommandot, som står för change directory .

$ cd my_app

my_app katalogen har ett antal auto-genererade filer och mappar som utgör strukturen för en Rails-applikation. Följande är en lista över filer och mappar som skapas som standard:

Nu måste du skapa en databas från din database.yml fil:

rake db:create
# OR
rails db:create

rake db:create

Nu när vi har skapat databasen måste vi köra migreringar för att ställa in tabellerna:

rake db:migrate
# OR
rails db:migrate

rake db:migrate

För att starta applikationen måste vi avbryta servern:

$ rails server
# OR
$ rails s

Som standard kommer rails att starta applikationen i port 3000. För att starta applikationen med olika portnummer måste vi avbryta servern som,

$ rails s -p 3010

Om du navigerar till http: // localhost: 3000 i din webbläsare ser du en välkomstsida för Rails som visar att din applikation nu körs.

Om det kastar ett fel kan det finnas flera möjliga problem:

• Det finns ett problem med config/database.yml
• Du har beroenden i din Gemfile som inte har installerats.
• Du har väntade migrationer. Kör rails db:migrate
• Om du flyttar till de tidigare migreringsskenorna rails db:rollback

Om det fortfarande kastar ett fel, bör du kontrollera config/database.yml

Skapa en ny Rails-app med ditt val av databas och inklusive RSpec Testing Tool

Rails använder sqlite3 som standarddatabas, men du kan generera en ny railsapplikation med en valfri databas. Lägg bara till alternativet -d följt av databasens namn.

$ rails new MyApp -T -d postgresql

Detta är en (icke uttömmande) lista över tillgängliga databasalternativ:

• mysql
• orakel
• postgresql
• sqlite3
• frontbase
• ibm_db
• SQLServer
• jdbcmysql
• jdbcsqlite3
• jdbcpostgresql
• jdbc

Kommandot -T indikerar att hoppa över installationen av minitest. För att installera en alternativ testsvit som RSpec , redigera Gemfile och lägg till

group :development, :test do
  gem 'rspec-rails', 
end

Starta sedan följande kommando från konsolen:

rails generate rspec:install

Generera en kontroller

För att generera en styrenhet (till exempel Posts ), navigerar du till din projektkatalog från en kommandorad eller terminal och kör:

$ rails generate controller Posts

Du kan förkorta den här koden genom att ersätta generate med g , till exempel:

$ rails g controller Posts

Om du öppnar upp den nyligen genererade appen / controllers / posts_controller.rb ser du en controller utan åtgärder:

class PostsController < ApplicationController
    # empty
end

Det är möjligt att skapa standardmetoder för styrenheten genom att mata in kontrollerens namnargument.

$ rails g controller ControllerName method1 method2

Om du vill skapa en styrenhet i en modul anger du styrenhetens namn som en sökväg som parent_module/controller_name . Till exempel:

$ rails generate controller CreditCards open debit credit close
# OR
$ rails g controller CreditCards open debit credit close

Detta genererar följande filer:

Controller: app/controllers/credit_cards_controller.rb
Test:       test/controllers/credit_cards_controller_test.rb
Views:      app/views/credit_cards/debit.html.erb [...etc]
Helper:     app/helpers/credit_cards_helper.rb

En styrenhet är helt enkelt en klass som är definierad att ärva från ApplicationController .

Det är inne i den här klassen som du definierar metoder som kommer att bli åtgärderna för den här kontrollern.

Skapa en resurs med byggnadsställningar

Från guides.rubyonrails.org:

Istället för att generera en modell direkt. . . låt oss ställa in ett byggnadsställning. Ett ställning i Rails är en fullständig uppsättning av modeller, databasmigrering för den modellen, styrenhet för att manipulera den, vyer för att visa och manipulera data och en testsvit för var och en av ovanstående.

Här är ett exempel på ställning av en resurs som heter Task med ett strängnamn och en textbeskrivning:

rails generate scaffold Task name:string description:text

Detta genererar följande filer:

Controller: app/controllers/tasks_controller.rb
Test:       test/models/task_test.rb
            test/controllers/tasks_controller_test.rb
Routes:     resources :tasks added in routes.rb
Views:      app/views/tasks
            app/views/tasks/index.html.erb
            app/views/tasks/edit.html.erb
            app/views/tasks/show.html.erb
            app/views/tasks/new.html.erb
            app/views/tasks/_form.html.erb
Helper:     app/helpers/tasks_helper.rb
JS:         app/assets/javascripts/tasks.coffee 
CSS:        app/assets/stylesheets/tasks.scss
            app/assets/stylesheets/scaffolds.scss

exempel för att radera filer som genererats av ställning för resursen som heter Task

rails destroy scaffold Task

Skapa en ny Rails-app med en icke-standardiserad databasadapter

Rails levereras som standard med ActiveRecord , en ORM (Object Relational Mapping) härrörande från mönstret med samma namn .

Som en ORM är den byggd för att hantera relationskartläggning, och mer exakt genom att hantera SQL-förfrågningar för dig, därmed begränsningen till endast SQL-databaser.

Du kan dock fortfarande skapa en Rails-app med ett annat databashanteringssystem:

1. Skapa helt enkelt din app utan aktiv post

$ rails app new MyApp --skip-active-record

2. lägg till ditt eget databashanteringssystem i Gemfile

gem 'mongoid', '~> 5.0'

3. bundle install och följ installationsstegen från önskad databas.

I det här exemplet är mongoid en objektskartläggning för MongoDB och - som många andra databas-ädelstenar byggda för räls - ärver den också från ActiveModel på samma sätt som ActiveRecord , som ger ett gemensamt gränssnitt för många funktioner som valideringar, återuppringningar, översättningar, etc. .

Andra databasadaptrar inkluderar, men är inte begränsade till:

• datamapper

• uppföljaren-skenor

Skapa Rails API: er i JSON

Detta exempel antar att du har erfarenhet av att skapa Rails-applikationer.

Kör för att skapa en API-enbart app i Rails 5

rails new name-of-app --api

Lägg till active_model_serializers i Gemfile

gem 'active_model_serializers'

installera bunt i terminalen

bundle install

Ställ in ActiveModelSerializer adaptern så att den använder :json_api

# config/initializers/active_model_serializer.rb
ActiveModelSerializers.config.adapter = :json_api
Mime::Type.register "application/json", :json, %w( text/x-json application/jsonrequest application/vnd.api+json )

Generera ett nytt ställning för din resurs

rails generate scaffold Task name:string description:text

Detta genererar följande filer:

Controller: app / controllers / task_controller.rb

Test:       test/models/task_test.rb
            test/controllers/tasks_controller_test.rb
Routes:     resources :tasks added in routes.rb
Migration:  db/migrate/_create_tasks.rb
Model:      app/models/task.rb
Serializer: app/serializers/task_serializer.rb
Controller: app/controllers/tasks_controller.rb

Installera skenor

Installera Rails på Ubuntu

På en ren ubuntu bör installationen av Rails vara rakt fram

Uppgradering av ubuntu-paket

sudo apt-get update
sudo apt-get upgrade

Installera Ruby och Rails-beroende

sudo apt-get install git-core curl zlib1g-dev build-essential libssl-dev libreadline-dev libyaml-dev libsqlite3-dev sqlite3 libxml2-dev libxslt1-dev libcurl4-openssl-dev python-software-properties libffi-dev

Installera rubinversionshanteraren. I detta fall använder den enkla rbenv

git clone https://github.com/rbenv/rbenv.git ~/.rbenv
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc

Installera Ruby Build

git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build
echo 'export PATH="$HOME/.rbenv/plugins/ruby-build/bin:$PATH"' >> ~/.bashrc

Starta om skalet

exec $SHELL

Installera rubin

rbenv install 2.3.1
rbenv global 2.3.1
rbenv rehash

Installera skenor

gem install rails

Installera Rails på Windows

Steg 1: Installera Ruby

Vi behöver Ruby-programmeringsspråk installerat. Vi kan använda en förkompilerad version av Ruby som heter RubyInstaller.

• Ladda ner och kör Ruby Installer från rubyinstaller.org .
• Kör installationsprogrammet. Markera "Lägg till Ruby-körbara filer till din PATH" och installera sedan.
• För att komma åt Ruby, gå till Windows-menyn, klicka på Alla program, bläddra ner till Ruby och klicka på "Start kommandotolken med Ruby". En kommandotolkterminal öppnas. Om du skriver ruby -v och trycker på Enter, bör du se Ruby-versionens nummer som du installerade.

Steg 2: Ruby Development Kit

Efter installation av Ruby kan vi försöka installera Rails. Men vissa av biblioteken Rails beror på behov av några byggverktyg för att kunna sammanställas, och Windows saknar dessa verktyg som standard. Du kan identifiera detta om du ser ett fel när du försöker installera Rails Gem::InstallError: The '[gem name]' native gem requires installed build tools. För att fixa detta måste vi installera Ruby Development Kit.

• Ladda ner DevKit
• Kör installationsprogrammet.
• Vi måste ange en mapp där vi ska installera DevKit permanent. Jag rekommenderar att du installerar den i roten på din hårddisk på C:\RubyDevKit . (Använd inte mellanslag i katalognamnet.)

Nu måste vi göra DevKit-verktygen tillgängliga för Ruby.

• Byt till DevKit-katalogen i kommandotolken. cd C:\RubyDevKit eller vilken katalog du installerade den i.
• Vi måste köra ett Ruby-skript för att initiera DevKit-installationen. Skriv ruby dk.rb init . Nu berättar vi samma skript för att lägga till DevKit till vår Ruby-installation. Skriv ruby dk.rb install .

DevKit ska nu vara tillgängligt för dina Ruby-verktyg att använda när du installerar nya bibliotek.

Steg 3: Rails

Nu kan vi installera Rails. Rails kommer som en Ruby pärla. Skriv din kommandotolk:

gem install rails

När du trycker på Enter kommer gem att ladda ner och installera den versionen av Rails-pärlen, tillsammans med alla andra juveler som Rails beror på.

Steg 4: Node.js

Vissa bibliotek som Rails beror på kräver en JavaScript-runtime för att installeras. Låt oss installera Node.js så att dessa bibliotek fungerar korrekt.

• Ladda ner Node.js-installationsprogrammet härifrån .
• När nedladdningen är klar besöker du din nedladdningsmapp och kör installationsprogrammet node-v4.4.7.pkg .
• Läs hela licensavtalet, acceptera villkoren och klicka på Nästa genom resten av guiden och lämna allt som standard.
• Ett fönster kan dyka upp med frågan om du vill tillåta att appen gör ändringar på din dator. Klicka på "Ja".
• När installationen är klar måste du starta om din dator så att Rails kan komma åt Node.js.

När din dator har startat om, glöm inte att gå till Windows-menyn, klicka på "Alla program", bläddra ner till Ruby och klicka på "Start kommandotolken med Ruby".