Ruby on RailsRozpoczęcie pracy z Ruby on Rails


Uwagi

logo

Ruby on Rails (RoR) lub Rails to popularna platforma aplikacji internetowych typu open source. Railsy używają Ruby, HTML, CSS i JavaScript do stworzenia aplikacji internetowej działającej na serwerze WWW. Railsy używają wzorca model-view-controller (MVC) i zapewniają pełen zestaw bibliotek z bazy danych aż do widoku.

Wersje

Wersja Data wydania
5.1.2 26.06.2017
5.0 30.06.2016
4.2 2014-12-19
4.1 08.04.2014
4.0 2013-06-25
3.2 2012-01-20
3.1 31.08.2011
3.0 29.08.2010
2.3 16.03.2009
2.0 2007-12-07
1.2 19.01.2007
1.1 2006-03-28
1.0 2005-12-13

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
 
  1. dodaj własny system zarządzania bazą danych w Gemfile
gem 'mongoid', '~> 5.0'
 
  1. 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

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
 

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:

Folder plików Cel, powód
aplikacja / Zawiera kontrolery, modele, widoki, pomocników, mailery i zasoby dla twojej aplikacji.
kosz/ Zawiera skrypt railsowy, który uruchamia twoją aplikację i może zawierać inne skrypty używane do konfigurowania, aktualizowania, wdrażania lub uruchamiania aplikacji.
config / Skonfiguruj trasy aplikacji, bazę danych i wiele innych.
config.ru Konfiguracja szafy dla serwerów opartych na szafie służących do uruchamiania aplikacji.
db / Zawiera bieżący schemat bazy danych, a także migracje bazy danych.
Gemfile Gemfile.lock Pliki te pozwalają określić, jakie zależności klejnotów są potrzebne dla twojej aplikacji Rails. Pliki te są używane przez klejnot Bundlera.
lib / Rozszerzone moduły dla twojej aplikacji.
log/ Pliki dziennika aplikacji.
publiczny/ Jedyny folder widziany przez świat w obecnym stanie. Zawiera pliki statyczne i skompilowane zasoby.
Rakefile Ten plik lokalizuje i ładuje zadania, które można uruchomić z wiersza poleceń. Definicje zadań są zdefiniowane w komponentach Rails.
README.md To jest krótka instrukcja obsługi dla twojej aplikacji. Powinieneś edytować ten plik, aby powiedzieć innym, co robi twoja aplikacja, jak ją skonfigurować itp
test/ Testy jednostkowe, osprzęt i inna aparatura testowa.
temp / Pliki tymczasowe (takie jak pamięć podręczna i pliki pid).
sprzedawca/ Miejsce na cały kod innej firmy. W typowej aplikacji Railsowej obejmuje to klejnoty sprzedawane.

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

5.0
rake db:create
# OR
rails db:create
 
5.0
rake db:create
 

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

5.0
rake db:migrate
# OR
rails db:migrate
 
5.0
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

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
 

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
 

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.

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”.