Ruby on Rails Samouczek
Rozpoczęcie pracy z Ruby on Rails

Uwagi

Wersje

Tworzenie aplikacji Ruby on Rails

W tym przykładzie założono, że Ruby i Ruby on Rails zostały już poprawnie zainstalowane. Jeśli nie, możesz dowiedzieć się, jak to zrobić tutaj .

Otwórz wiersz poleceń lub terminal. Aby wygenerować nową aplikację Railsową, użyj polecenia Rails new, a następnie nazwy aplikacji:

$ rails new my_app

Jeśli chcesz utworzyć aplikację Rails z określoną wersją Rails, możesz ją określić podczas generowania aplikacji. Aby to zrobić, użyj rails _version_ new a następnie nazwy aplikacji:

$ rails _4.2.0_ new my_app 

Spowoduje to utworzenie aplikacji Rails nazwie MyApp w my_app katalogu i zainstalować zależności szlachetnych, które są już wymienione w Gemfile użyciu bundle install .

Aby przełączyć się do katalogu nowo utworzonej aplikacji, użyj polecenia cd , oznaczającego change directory .

$ cd my_app

Katalog my_app zawiera wiele automatycznie generowanych plików i folderów, które tworzą strukturę aplikacji Railsowej. Poniżej znajduje się lista plików i folderów, które są tworzone domyślnie:

Teraz musisz utworzyć bazę danych z pliku database.yml :

rake db:create
# OR
rails db:create

rake db:create

Po utworzeniu bazy danych musimy uruchomić migracje, aby skonfigurować tabele:

rake db:migrate
# OR
rails db:migrate

rake db:migrate

Aby uruchomić aplikację, musimy uruchomić serwer:

$ rails server
# OR
$ rails s

Domyślnie, szyny uruchomią aplikację na porcie 3000. Aby uruchomić aplikację z innym numerem portu, musimy uruchomić serwer jak:

$ rails s -p 3010

Jeśli przejdziesz do http: // localhost: 3000 w przeglądarce, zobaczysz stronę powitalną Rails, pokazującą, że twoja aplikacja jest teraz uruchomiona.

Jeśli zgłosi błąd, może być kilka możliwych problemów:

• Wystąpił problem z config/database.yml
• W twoim Gemfile masz zależności, które nie zostały zainstalowane.
• Masz oczekujące migracje. Uruchom rails db:migrate
• W przypadku przejścia do poprzedniej wersji rails db:rollback migracyjnych rails db:rollback

Jeśli nadal powoduje to błąd, powinieneś sprawdzić config/database.yml

Utwórz nową aplikację Rails z wybraną bazą danych i narzędziem testowym RSpec

Railsy używają sqlite3 jako domyślnej bazy danych, ale możesz wygenerować nową aplikację railsową z wybraną bazą danych. Wystarczy dodać opcję -d , a następnie nazwę bazy danych.

$ rails new MyApp -T -d postgresql

To jest (niewyczerpująca) lista dostępnych opcji bazy danych:

• mysql
• wyrocznia
• postgresql
• sqlite3
• frontbase
• ibm_db
• sqlserver
• jdbcmysql
• jdbcsqlite3
• jdbcpostgresql
• jdbc

Komenda -T wskazuje, aby pominąć instalację programu minitest. Aby zainstalować alternatywny pakiet testowy, taki jak RSpec , edytuj plik Gemfile i dodaj

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

Następnie uruchom następujące polecenie z konsoli:

rails generate rspec:install

Generowanie kontrolera

Aby wygenerować kontroler (na przykład Posts ), przejdź do katalogu projektu z wiersza polecenia lub terminala i uruchom:

$ rails generate controller Posts

Możesz skrócić ten kod, zastępując generate g , na przykład:

$ rails g controller Posts

Jeśli otworzysz nowo wygenerowaną aplikację / controllers / posts_controller.rb , zobaczysz kontroler bez żadnych działań:

class PostsController < ApplicationController
    # empty
end

Możliwe jest utworzenie domyślnych metod dla kontrolera poprzez przekazanie argumentów nazwy kontrolera.

$ rails g controller ControllerName method1 method2

Aby utworzyć kontroler w module, podaj nazwę kontrolera jako ścieżkę, taką jak parent_module/controller_name . Na przykład:

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

Spowoduje to wygenerowanie następujących plików:

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

Kontroler to po prostu klasa, która jest zdefiniowana do dziedziczenia z ApplicationController .

W tej klasie zdefiniujesz metody, które staną się akcjami dla tego kontrolera.

Wygeneruj zasób za pomocą rusztowań

From guide.rubyonrails.org:

Zamiast generować model bezpośrednio. . . stwórzmy rusztowanie. Rusztowanie w Railsach to pełny zestaw modelu, migracja bazy danych dla tego modelu, kontroler do manipulowania nim, widoki do przeglądania i manipulowania danymi oraz zestaw testowy dla każdego z powyższych.

Oto przykład rusztowania zasobu o nazwie Task z nazwą ciągu i opisem tekstowym:

rails generate scaffold Task name:string description:text

Spowoduje to wygenerowanie następujących plików:

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

przykład usuwania plików generowanych przez rusztowanie dla zasobu o nazwie Task

rails destroy scaffold Task

Utwórz nową aplikację Rails z niestandardowym adapterem bazy danych

Railsy są domyślnie dostarczane z ActiveRecord , ORM (Object Relational Mapping) pochodzącym ze wzoru o tej samej nazwie .

Jako ORM, jest on zbudowany do obsługi mapowania relacyjnego, a dokładniej poprzez obsługę żądań SQL dla ciebie, stąd ograniczenie tylko do baz danych SQL.

Jednak nadal możesz utworzyć aplikację Rails z innym systemem zarządzania bazą danych:

1. po prostu stwórz swoją aplikację bez aktywnego zapisu

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

2. dodaj własny system zarządzania bazą danych w Gemfile

gem 'mongoid', '~> 5.0'

3. bundle install i postępuj zgodnie z instrukcjami instalacji z żądanej bazy danych.

W tym przykładzie mongoid jest odwzorowaniem obiektów dla MongoDB i - jak wiele innych klejnotów bazy danych zbudowanych dla szyn - dziedziczy również z ActiveModel taki sam sposób, jak ActiveRecord , który zapewnia wspólny interfejs dla wielu funkcji, takich jak sprawdzanie poprawności, wywołania zwrotne, tłumaczenia itp. .

Inne adaptery baz danych obejmują między innymi:

• datamapper

• kolejki

Tworzenie interfejsów API Railsów w JSON

W tym przykładzie założono, że masz doświadczenie w tworzeniu aplikacji Railsowych.

Aby utworzyć aplikację tylko API w Railsach 5, uruchom

rails new name-of-app --api

Dodaj active_model_serializers w Gemfile

gem 'active_model_serializers'

zainstaluj pakiet w terminalu

bundle install

Ustaw adapter ActiveModelSerializer na :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 )

Wygeneruj nowe rusztowanie dla swojego zasobu

rails generate scaffold Task name:string description:text

Spowoduje to wygenerowanie następujących plików:

Kontroler: aplikacja / kontrolery / zadania_kontroler.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

Instalowanie szyn

Instalowanie Railsów na Ubuntu

Na czystym ubuntu instalacja Railsów powinna być prosta

Aktualizacja pakietów ubuntu

sudo apt-get update
sudo apt-get upgrade

Zainstaluj zależności Ruby i Rails

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

Instalowanie menedżera wersji Ruby. W tym przypadku najłatwiejszym jest użycie rbenv

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

Instalowanie 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

Uruchom ponownie Shell

exec $SHELL

Zainstaluj ruby

rbenv install 2.3.1
rbenv global 2.3.1
rbenv rehash

Instalowanie szyn

gem install rails

Instalowanie Railsów w systemie Windows

Krok 1: Instalacja Ruby

Potrzebujemy zainstalowanego języka programowania Ruby. Możemy użyć wstępnie skompilowanej wersji Ruby o nazwie RubyInstaller.

• Pobierz i uruchom instalator Ruby z rubyinstaller.org .
• Uruchom instalatora. Zaznacz „Dodaj pliki wykonywalne Ruby do ŚCIEŻKI”, a następnie zainstaluj.
• Aby uzyskać dostęp do Ruby, przejdź do menu Windows, kliknij Wszystkie programy, przewiń w dół do Ruby i kliknij „Uruchom wiersz polecenia za pomocą Ruby”. Terminal wiersza polecenia zostanie otwarty. Jeśli wpiszesz ruby -v i naciśniesz Enter, powinieneś zobaczyć zainstalowany numer wersji Ruby.

Krok 2: Zestaw rozwojowy Ruby

Po zainstalowaniu Ruby możemy spróbować zainstalować Railsy. Ale niektóre biblioteki Rails zależą od potrzeby kompilacji narzędzi do kompilacji, a Windows domyślnie nie ma tych narzędzi. Możesz to zidentyfikować, jeśli zobaczysz błąd podczas próby zainstalowania Rails Gem::InstallError: The '[gem name]' native gem requires installed build tools. Aby to naprawić, musimy zainstalować Ruby Development Kit.

• Pobierz DevKit
• Uruchom instalatora.
• Musimy określić folder, w którym zamierzamy na stałe zainstalować DevKit. Zalecam zainstalowanie go w katalogu głównym dysku twardego, w C:\RubyDevKit . (Nie używaj spacji w nazwie katalogu).

Teraz musimy udostępnić narzędzia DevKit dla Ruby.

• W wierszu polecenia przejdź do katalogu DevKit. cd C:\RubyDevKit lub cd C:\RubyDevKit katalog, w którym został zainstalowany.
• Musimy uruchomić skrypt Ruby, aby zainicjować konfigurację DevKit. Wpisz ruby dk.rb init . Teraz powiemy ten sam skrypt, aby dodać DevKit do naszej instalacji Ruby. Wpisz ruby dk.rb install .

Zestaw DevKit powinien być teraz dostępny dla narzędzi Ruby do użycia podczas instalowania nowych bibliotek.

Krok 3: Szyny

Teraz możemy zainstalować Railsy. Railsy są klejnotem Ruby. W wierszu polecenia wpisz:

gem install rails

Po naciśnięciu klawisza Enter program gem pobierze i zainstaluje tę wersję klejnotu Rails wraz ze wszystkimi innymi klejnotami, od których zależy Rails.

Krok 4: Node.js

Niektóre biblioteki, od których zależy Railsy, wymagają zainstalowania środowiska wykonawczego JavaScript. Zainstalujmy Node.js, aby te biblioteki działały poprawnie.

• Pobierz instalator Node.js stąd .
• Po zakończeniu pobierania otwórz folder pobierania i uruchom instalator node-v4.4.7.pkg .
• Przeczytaj pełną umowę licencyjną, zaakceptuj warunki i kliknij Dalej w dalszej części kreatora, pozostawiając wszystko na domyślnym poziomie.
• Może pojawić się okno z pytaniem, czy chcesz zezwolić aplikacji na wprowadzanie zmian na komputerze. Kliknij „Tak”.
• Po zakończeniu instalacji musisz ponownie uruchomić komputer, aby Railsy mogły uzyskać dostęp do Node.js.

Po ponownym uruchomieniu komputera nie zapomnij przejść do menu Windows, kliknij „Wszystkie programy”, przewiń w dół do Ruby i kliknij „Uruchom wiersz polecenia za pomocą Ruby”.