ugrás a tartalomhoz

Ruby on Rails

Bártházi András · 2005. Aug. 2. (K), 22.00
Ruby on Rails
Webes alkalmazásfejlesztés nagyságrendekkel gyorsabban, kompromisszumok nélkül - szólhatna egy hirdetés a Ruby on Railsről. A Ruby on Rails egy éppen egy éves, Ruby nyelvű webes keretrendszer, mely már ma elérhető, használható, s valóban rendelkezik ezekkel a hangzatos tulajdonságokkal. Most biztosan csóválják páran a fejüket, hogy minek nekünk még egy keretrendszer, de azt kell mondjam, rosszul dönt, aki nem ismerkedik meg ezzel a rendkívül hatékony fejlesztést lehetővé tevő programmal.

Kapcsolódó oldal: Magyar nyelvű Ruby on Rails oldal, webloggal, levelezőlistával

Hogy hogyan lehetséges ez? A Rails sokat köszönhet a Ruby programozási nyelvnek, mely hatékony nyelvi eszközeivel az egyik legmodernebb mai scriptnyelv és fejlesztőjének, David Heinemeier Hanssonnak, aki igen komoly rendszerismereteit a Railsben testesítette meg. A Rails filozófiája igen egyszerű: minél kevesebbet gépeljünk, s hagyatkozzunk az egységes elnevezésekre, alapértelmezésekre hosszú konfigurációs állományok írása helyett.

Ruby, egy új generációs nyelv

A Ruby kétségkívül egy vadonatúj programozási nyelv, bár számos meglévő nyelv szolgál alapjául. Interpreteres, rendelkezik a script nyelvek (mint a PHP, Perl, Python, stb.) ismérveivel, sebessége (a többi script nyelvhez képest) nem hagy kívánnivalót maga után, ráadásként pedig barátságos objektum orientált programozást tesz lehetővé. Általános nyelv, mely mind parancssori, mind webes használatra jó választás lehet - ez utóbbihoz megfelelő támogatással is bír (például FastCGI-ként is futtatható alkalmazásokat készíthetünk segítségével, de Apache modul, vagy Ruby-ban írt webszerver is szolgálhat alapul számára).

Számos operációs rendszerre elérhető, MacOSX alatt alapból telepített, Linux alatt valószínűleg disztribúciónk keretében csomagként hozzáférhető, Windows alatt színes-szagos telepítőt tölthetünk le hozzá.

Gyorstalpaló

A Ruby szintakszisát illetően alapvetően nem különbözik nagyon más nyelvektől, ha nem ijedünk meg egy kis tanulástól, nem lesz nehéz dolgunk az ismerkedéssel. Mind a ciklusokat, mind a változókat, mind az objektumok kezelését ha nem is hagyományos szintakszissal, de többé-kevésbé hagyományos módon oldja meg. A forráskódot olvasgatva főként az objektumok öröklését, s a változók használatát furcsáltam benne, de ezt is gyorsan meg lehet szokni. Bár ez a kiemelés teljesen önkényes, íme egy-két mondat ezekről, talán segítek vele az olvasónak.

A Rubyban minden változó egyben objektum is (hasonlóképpen a Pythonhoz). A sortörés új utasítást jelöl, így nem kell (de lehet) pontosvesszőt használnunk, az egyes blokkhatárokat pedig szavakkal jelöli a nyelv (pl. if ... else ... end).

A változónevek elé nem kell semmilyen karaktert sem kitennünk (ebből a szempontból pedig például a JavaScriptre hasonlít). Nincs szükség a változók deklarálására, ehelyett jelölnünk kell, hogy egy változót milyen látótérrel szeretnénk használni: a globális változók elé egy dollárjelet ($valtozo), az egyedváltozók elé kukacot (@valtozo) kell tenni, a helyi változók elé pedig nem kell semmit sem (ez Perl programozóknak egy kicsit furcsa lehet elsőre). Az osztályok, modulok, konstansok nevének első karaktere nagybetűs, a többi változó pedig kisbetűvel irandó.

Létezik egy speciális, ámde rendkívül egyszerű nyelvi elem, a szimbólum, ami nem más, mint a karakterkonstans. Jelölése egy kettősponttal történik (a :szimbolum - majdnem - ugyanaz, mint a "szimbolum"); egyik alkalmazási lehetősége a hash-ek (asszociatív tömbök) kulcsának jelölése.

A Ruby programokban - révén objektum orientált nyelv -, gyakran láthatunk osztály definíciókat. Ezeknél - ha van - a szülő osztályt az új osztály neve után, egy < karakterrel elválasztva írhatjuk.
Ennek a cikknek keretében nem célom bemutatni a Ruby összes lehetőségét, teljes szintakszisát, de talán az itt olvasható keretes anyag segíthet jobban megérteni azokat a kódokat, melyekkel találkozhat az ember az ismerkedés során. Ha ennél csak egy kicsit is részletesebben vagyunk kiváncsiak rá, hogy miket tud, megtekinthetünk egy felsorolást a Ruby oldalán, vagy pedig ingyenesen elolvashatjuk a Programming Ruby könyv első kiadását (illetve megvehetjük a legfrissebb verziót belőle PDF, vagy papír verzióban). Ezeken a forrásokon kívül is számos egyéb kiváló anyag áll rendelkezésünkre, ezeknek egyik forrása a RubyDoc weblap.

A cikk azonban nem a Ruby bemutatásának kapcsán született meg, hanem a hozzá készült keretrendszer, a Ruby on Rails miatt. Fontos, hogy bár az első lépések megtételéhez nem szükséges megismerkedni a nyelvvel, készüljünk fel rá, hogy ha odáig jutunk, meg kell majd tanulnunk - a programozás már csak ilyen. De lássuk, mi az, ami olyan egyedivé teszi ezt a keretrendszert!

Ruby on Rails, sínen vagyunk hát

A Ruby on Railst (továbbiakban RoR, vagy Rails) a bevezetőben említett rövid kódok, konvenciókra épülő felépítés jellemzi. Egy rövidebb kód gyorsabban leírható, jobban átlátható, megérthető, könnyebb hibát keresni benne (s nyilván kevesebb hiba is tud benne előfordulni), s könnyebb fejleszteni is.

A Rails a konfigurálást is minimálisra csökkenti, sem rövidebb-hosszabb sztring értékadások, sem XML fájlok nem fordulnak elő benne. A lényeget Ruby kódként tudjuk leírni, illetve az adatbázis és egyéb helyek alapján alapértelemezett beállítások születnek. Talán egyetlen egy dolgot kell csak beállítani: az adatbázis kapcsolat paramétereit. A Rails nem csak a kivitelezésben, de a tesztelésben, logolásban, továbbá az alkalmazás üzembe helyezésében, skálázásában is segít.

A RoR egy keretrendszer, azaz nem egy konkrét alkalmazást valósít meg, hanem azt teszi egyszerűen és nagyszerűen lehetővé, hogy mi készítsünk el webes alkalmazásokat segítségével. Amellett, hogy a rendelkezésre álló objektumrendszer segítségével segíti munkánkat, kódgenerálásra is képes. Nem bonyolult kódra kell gondolnunk azonban, az automatizmusok nem abból állnak a RoR esetén, hogy helyettünk készít összetett kódot (nem szükségesek összetett kódok), hanem a viszonylag összetettebb kódok az objektumokban vannak, melyek ha nem ássuk mélyebben bele magunkat a Rails működésébe, transzparensek.

A RoR filozófiájának egyik legfontosabb eleme a "DRY" (Don't Repeat Yourself), azaz úgy lett kialakítva, hogy ne kelljen ismételnünk magunkat. Mit jelent ez? Sokmindent, de főként azt, hogy ha egyszer leírunk valamit, azt sehol se kelljen még egyszer megtennünk. Ilyen például, hogy ha létrehozunk egy adatbázistáblát, akkor automatikusan készíthetünk hozzá webes felületet, amivel létrehozhatunk, olvashatunk, módosíthatunk és törölhetünk elemeket belőle (CRUD: create, read, update, delete). Ehhez az ActiveRecord nevű keretrendszere biztosít lehetőséget, mely az adatbázistáblákat objektumokként teszi elérhetővé.

Konfigurálni szinte semmit sem kell, minden névkonvenciók alapján, automatikusan kapcsolódik egymáshoz (például egy eseményt lekezelő kódrészlet és a hozzá tartozó HTML sablon a nevük alapján), mely persze ha valamiért úgy szükséges, megkerülhető. Hogy - angolul - jobban olvasható legyen a kód, egy érdekes megoldást alkalmaz: az egyes elemeket egyes számmal, a gyűjtőket pedig többes számmal jelöli.

Filozófiájának másik eleme, hogy a programozáshoz elegendő ismerni a Ruby nyelvet, másikat, mint például a JavaScript, vagy mint egy sablonrendszer nyelve nem kell megismernünk (kivéve nyilván a HTML és CSS leíró nyelveket - s kivéve, ha a rendelkezésre álló lehetőségeken kívül mást is szeretnénk). A JavaScript rutinokat automatikusan tudja generálni, akár AJAX-os programokat is létrehozva, a sablonrendszer nyelve pedig maga a Ruby (a sablonrendszer megoldásában nagyon hasonlít a PHP szintakszisra, azaz be tudunk ágyazni kódot, filozófiájában azonban teljesen másról van szó).

Telepítés

A cikkben szeretném elkerülni a RoR részletes telepítési leírását, mivel az nagyon egyszerű és jól dokumentált, ezért csak pár szóban térnék ki rá. Ha cikkem kedvező fogadtatásra talál, s mutatkozik rá igény, nem rajtunk fog múlni egy részletes magyar nyelvű leírás.

Ha magunk szeretnénk kipróbálni a lehetőségeket, mindenekelőtt szükségünk lesz egy Ruby telepítésre, ha van, akkor annak esetleges frissítésére. Ezután a Ruby "csomagkezelője" segítségével (RubyGems, ha ez nincs, akkor ezt fel kell értelemszerűen tenni) feltelepíthetjük a RoR-t, illetve a hozzá szükséges modulokat. Ha ezzel is megvagyunk, gyakorlatilag készen állunk, illetve ajánlott még egy MySQL telepítése, hogy a RoR adatbázis képességeit is tesztelni tudjuk (lehetőség van más adatbázisok, mint PostgreSQL, SQLite használatára is). Bővebben a RubyOnRails wiki-ben, a Howtos Installation oldalon olvashatjuk a különböző rendszerekre történő telepítés menetét.

A következőkben ismertetett példaprogram reményeim szerint telepített környezet nélkül is érthető lesz, azonban mindenképpen javaslom a rendszer telepítését és kipróbálását - megéri megtenni!

Mi lesz a cél?

Hogy tudjuk, hova tartunk, tűzzünk ki egy célt magunk elé! Hozzunk létre egy egyszerű tennivalók listáját tartalmazó weblapot, ahol új bejegyzéseket tudunk létrehozni, régieket törölni.

Indulás

A RoR, mint a korábbiakban említettem, kódgenerálással segíti munkánkat. Induláskor az első lépés mindig az alap keretrendszer telepítése. Ehhez adjuk ki a következő parancsot:
rails konytvar/a/programhoz/kodnev
Windows esetében elé kell írnunk a Ruby értelmező nevét is (pl. ruby.exe - ha ilyen platformon próbálkozunk, ezt tegyük meg a következőkben is). Esetünkben én a fejlesztési könyvtárba álltam, s kiadtam a következőt:
rails todo
A megadott könyvtárban ezáltal létrejön a webalkalmazás váza, a következőt fogjuk látni:

parancssor> rails todo
      create
      create  app/apis
      create  app/controllers
      create  app/helpers
      create  app/models
      create  app/views/layouts
      create  config/environments
      create  components
      create  db
      create  doc
      create  lib
      create  log
      create  public/images
      create  public/javascripts
      create  public/stylesheets
      create  script
      create  test/fixtures
      create  test/functional
      create  test/mocks/development
      create  test/mocks/test
      create  test/unit
      create  vendor
      create  Rakefile
      create  README
      create  CHANGELOG
      create  app/controllers/application.rb
      create  app/helpers/application_helper.rb
      create  test/test_helper.rb
      create  config/database.yml
      create  config/routes.rb
      create  public/.htaccess
      create  config/environment.rb
      create  config/environments/production.rb
      create  config/environments/development.rb
      create  config/environments/test.rb
      create  script/console
      create  script/destroy
      create  script/generate
      create  script/server
      create  script/runner
      create  script/benchmarker
      create  script/profiler
      create  script/breakpointer
      create  public/dispatch.rb
      create  public/dispatch.cgi
      create  public/dispatch.fcgi
      create  public/404.html
      create  public/500.html
      create  public/index.html
      create  public/favicon.ico
      create  public/javascripts/prototype.js
      create  public/javascripts/effects.js
      create  public/javascripts/dragdrop.js
      create  public/javascripts/controls.js
      create  doc/README_FOR_APP
      create  log/server.log
      create  log/production.log
      create  log/development.log
      create  log/test.log
Lépjünk bele az újonnan létrejött todo könyvtárba (és maradjunk is ott)!

A könyvtárban levő program jelenleg közel nulla funkcionalitással bír, de könnyen kiegészíthető lesz újakkal. Az egyetlen dolog, amit jelen pillanatban tud, az egy üdvözlő üzenet. Ezt legegyszerűbben a fenti paranccsal létrejött Webrick alapú webszerver elindításával tehetjük meg, ehhez indítsuk is az el! A Webrick egy Ruby-ban írt, jól használható, de éles környezethez már többnyire lassú webszerver (könyvtárgyűjtemény). A fejlesztés után célszerű Apache+FastCGI alapokon üzemeltetni a kész alkalmazást.

A Webrick elindításához a következő parancsot kell kiadnunk:

script/server
Szerverünk a 3000-es porton el fog indulni:

parancssor> script/server
=> Rails application started on http://0.0.0.0:3000
=> Ctrl-C to shutdown server; call with --help for options
[2005-07-31 18:35:57] INFO  WEBrick 1.3.1
[2005-07-31 18:35:57] INFO  ruby 1.8.2 (2004-12-25) [i386-linux]
[2005-07-31 18:35:58] INFO  WEBrick::HTTPServer#start: pid=4764 port=3000
Ha kedvenc böngészőnkkel meglátogatjuk a http://localhost:3000 webcímet, akkor - remélhetőleg - a következőkkel fogunk találkozni:

Ruby on Rails üdvözlő szöveg


A szöveg keretében pár megfontolandó tanácsot kapunk a biztonságos induláshoz, illetve pár tippet a továbbiakhoz. A szervert hagyjuk futni a háttérben - ennek segítségével fogjuk tudni mindig megnézni az éppen aktuális helyzetet.

A következő lépés egy controller létrehozása lesz (a következőkben angol nevükön fogok hivatkozni a kontrollerre, modellre és nézetre - controller, model és view néven). Az MVC (model-view-controller) architektúráról, melyet a RoR is alkalmaz, lásd rövid összefoglalónkat:

Az MVC modellről (forrás: Hodicska Gergely)

Az MVC rövidítés a model, view, controller szavakból származik. Egyike a legjobban kipróbált, legrégebb óta használtaknak. Az MVC pattern alapján felépített rendszer esetén az őt alkotó osztályokat három csoportba sorolhatjuk, a model részben szereplők felelősek az üzleti logikáért, a view részben lévők feladata a megjelenítés, míg a controller részben lévők a program menetének lefolyását szabályozzák.

Model

Mint említettük a model részben valósítjuk meg az üzleti logikát. A model feladata definiálni a program által használt adatstruktúrákat, illetve azokat a szabályokat, amely alapján hozzáférünk ezekhez, illetve módosíthatjuk őket. Előfordulhat az is, hogy a modelt akár többféle applikáció (vállalati rendszer egy részét elérhetővé teszik webes felületen) is használhatja, a megvalósítása történhet például JavaBean-ben, COM objektumokban, illetve a manapság egyre divatosabb és elterjedtebb webservice-ek által. Ha adatbázist is használunk, akkor a model tervezése során célszerű szem előtt tartani, hogy minden egyes táblához tartozzon egy külön osztály, és azokat csak ezeken keresztül használjuk. Így az adatbázis szerkezetét érintő apróbb változások szerencsés esetben csak ezeket az osztályokat érintik. Ráadásul az így elkészített osztályok egy része nem alkalmazás specifikus, újrafelhasználható lesz.

View

A view-k feladata a model tartalmának bemutatása, a program kimenetének generálása. Az adatokhoz csak a model objektumain keresztül férhetnek hozzá. Könnyen előfordulhat, hogy rendszerünket többféle interfészen keresztül (böngésző, mobil telefon, webszolgáltatás, stb.) használják, így többféle kimenetre (HTML, WML, XML) lehet szükség. Itt jelentkezik az MVC használatának előnye, ha egy új interfész típust kell támogatnunk, akkor csak egy új view-t kell készítenünk, ami a már meglévő modelt használja. A view részhez tartozik minden egyéb osztály is, ami a megjelenítéssel kapcsolatos, például egy tömb alapján táblázatot generáló osztály.

Ezen kívül általában a view-k tartalmazzák (generálják) a felhasználói interakciók lehetőségét megvalósító eszközöket (link, gomb, beviteli mező, stb.).

Controller

Ez az alkalmazás lelke. Ez köti össze a modelt és a view-kat. A felhasználó által eszközölt akciót (form elküldése, kattintás egy linkre, stb.) lefordítja egy a model által végrehajtandó akcióra. Ezután szintén a controller dolga, hogy az akció lefutásának eredményétől függően megjelenítse a szükséges view-t.

MVC pattern előnyei

  • Üzleti logika és a prezentációs logika szétválasztása.
  • Központosított kontroll.
  • A program különálló részei egymástól jól elkülönülő, egymással meghatározott módon összefüggő részekből állnak. Ennek eredményeképpen nő az egyes elemek újrafelhasználhatósága, valamint csökken a kód duplikáció.
  • Az előző ponttal összefüggésben több programozó esetén mindenki a saját szakterületének megfelelő program egységek írására koncentrálhat.

MVC pattern hátránya

  • Egy kicsit több tervezést igényel. Olyan új osztályok megteremtésére van szükség, melyek megvalósítják az egyes részek elkülönülését. Viszont cserébe a konkrét alkalmazás tervezése során ez az időráfordítás megtérül, illetve ezeket az osztályokat csak egyszer kell megvalósítani, ezután minden alkalmazásunk során használhatjuk azokat.


Kis alkalmazásunk központi része a todo nevű controller lesz, hozzuk létre:

parancssor> script/generate controller Todo
Figyelem, a controllernek adjunk mindig nagy betűvel kezdődő nevet - a RoR ezt az elnevezési logikát alkalmazza! A következőt fogjuk látni:

parancssor> script/generate controller Todo
      exists  app/controllers/
      exists  app/helpers/
      create  app/views/todo
      exists  test/functional/
      create  app/controllers/todo_controller.rb
      create  test/functional/todo_controller_test.rb
      create  app/helpers/todo_helper.rb
Négy fájl jött létre, ebből jelenleg számunkra a todo_controller.rb lesz az érdekes. Ennek tartalma jelenleg:

class ApplicationController < ActionController::Base
end
Egy osztálydefiníciót láthatunk, ez fogja leírni a működést. Az osztály egy "ActionController::Base" osztálytól öröklődik. A kód jelenleg üres, azaz működése megegyezik a szülő működésével.

Új controllerünket a http://localhost:3000/todo címen érhetjük el. Ekkor az "Unknown action / No action responded to index" hibaüzenetet fogjuk kapni, ami azt jelenti, hogy bár a controllerünk megvan, de még nem tud semmit, az index actionre nem reagál.

Az egyes feladatokat a controller ún. action-ökre osztja. A tennivalóink listájához történő hozzáadás például add néven fog szerepelni, a törlésnek del lesz a neve. Minden egyes ilyen action-t egy-egy metódus ír le egy rövid kóddal.

A hibaüzeneten gyorsan továbbléphetünk, írjunk a class és az end kulcsszó közé pár sort, hogy a következőt kapjuk:

class ApplicationController < ActionController::Base
  def index
    render :text => "A Ruby on Rails üdvözöl!"
  end
end
Ha megnézzük a weblapot, a válasz nem marad el: kapunk egy barátságos üdvözlőt. Mi történt? Definiáltuk az index metódust, s azon belül pedig megadtuk, hogy készüljön el egy oldal, aminek a szövege az üdvözlet. A render egy függvény, mely paraméteréül egy text=>"A Ruby on Rails üdövözöl" kulcs-érték párt kapott, amit megfelelően értelmezni képes. A Rails kódja ilyen okos függvényekből épül fel.

A következő lépés egy adatbázis létrehozása lesz, mely tárolni fogja tennivalóinkat. Ezt a legegyszerűbben a MySQL parancssori alkalmazásából hozhatjuk létre (a jogosultságok beállítását most mellőzzük):

parancssor> mysql -u root -p
Enter password: ********
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 4 to server version: 4.1.12

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> create database todo;
Query OK, 1 row affected (0.08 sec)

mysql> use todo;
Database changed
mysql> create table entries (id int auto_increment primary key, title varchar(128), txt text);
Query OK, 0 rows affected (0.01 sec)
mysql> quit
Bye
Ezzel létrehoztunk egy adatbázist, s benne egy táblázatot, melyben a tennivalóinkat fogjuk tárolni. A tábla neve entries lett, mely kifejezés többes számban van, hiszen több bejegyzést tárol. Hozzuk létre az adatbázishoz tartozó modelt is (azaz azt az osztályt, ami kódból, SQL utasítások nélkül elérhetővé teszi számunkra az adatbázist), melyet majd a controllerben fogunk használni. Ehhez adjuk ki a következő parancsot (a todo gyökérkönyvtárban):

script/generate model Entry
Ez legenerálja nekünk a kívánt model vázát:

parancssor> script/generate model Entry
      exists  app/models/
      exists  test/unit/
      exists  test/fixtures/
      create  app/models/entry.rb
      create  test/unit/entry_test.rb
      create  test/fixtures/entries.yml
Mint láthatjuk, az Entry-t itt már egyes számban használtuk, a model-ek neve esetén így kell tennünk - egy-egy objektum ugyanis egy-egy elemet fog jellemzően jelölni.

A Rails-szel még tudatnunk kell azt is, hogy hogyan érheti el az adatbázisunkat. Ehhez a config/database.yml fájlt kell szerkesztenünk, a development részhez írjuk be a megfelelő értékeket, például:

development:
  adapter: mysql
  database: todo
  host: localhost
  username: root
  password: ********
Az adatbáziselérés megváltoztatásakor újra kell indítanunk a webszervert, ez akkor is igaz, ha "csak" a Webricket használjuk. Állítsuk le (Ctrl-C), majd indítsuk el megint.

Végül és utoljára, módosítsuk a controllerünket a következőkre:

class ApplicationController < ActionController::Base
  scaffold :entry
end
A scaffold függvény automatikusan létrehoz (futásidőben) pár metódust, melyeket meghagyhatunk úgy, ahogy elkészültek, de akár felül is tudjuk definiálni.

Ha most megnézzük a http://localhost:3000/todo címet, egy üres listát fogunk kapni, illetve alatta egy linket New Entry felirattal:

Üres lista


Kattintsuk erre rá! A táblázat szerkezete alapján egy felviteli formot fogunk kapni az adatbázis mező típusának megfelelően. Esetünkben egy input mezőt kapunk a title mező szerkesztéséhez, s egy textarea-t a txt mező szerkesztéséhez:

Új elem felvitele


Próbáljuk ki - mint látni fogjuk, tudunk új elemeket felvinni, ezek megjelennek a listában, s tudjuk szerkeszteni és törölni is bármelyiket. A scaffold függvény egy teljes felületet készített számunkra ezekhez a műveletekhez! A felület "élő", azaz ha módosul az adatbázis szerkezete, akkor a weblap is idomul ehhez.

Ezzel a kitűzött célt teljesítettük is, de ne érjük be ennyivel! Először is, adjunk a tennivalókhoz egy új mezőt, mely legyen egy dátum mező! Ehhez a következőket kell tennünk:

C:\>mysql -u root -p todo
Enter password: ********
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 15 to server version: 4.1.12a-nt

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> alter table entries add deadline datetime default "2010/12/31 23:59:59" after title;
Query OK, 2 rows affected (0.02 sec)
Records: 2  Duplicates: 0  Warnings: 0

mysql> quit
Bye
Ha megnézzük a weboldalt, egyből látható lesz, hogy select elemek segítségével dátum-idő mezőt is szerkeszteni tudunk.

Az új elemmel kibővült felviteli mezők


Rövid ténykedés után a következőket láthatjuk:

Már nem is üres a listánk


Következő lépés legyen az alkalmazás megjelenésének megváltoztatása. Ehhez a view-kat kell szerkesztenünk, jelenleg ugyanis a scaffold alapértelmezett megjelenéseit látjuk. A megjelenésért felelős HTML fájlokat az app/views könyvtárba, azon belül esetünkben a todo könyvtárba tehetjük. A fájl neve az adott action neve legyen. Ezek most: list, new, show és edit. Szerkesszük most a listázót, ehhez a views könyvtárban hozzunk létre egy list.rhtml fájlt a következő tartalommal:

<h1>Tennivalóim</h1>
<%= link_to 'Új elem', :action => 'new' %>

<% for entry in @entries %>
<hr />
<h2><%=h entry.title %></h2>
<p><%h entry.deadline %></p>
<p>
  <%= link_to 'Szerkeszt', :action => 'edit', :id => entry %>
  <%= link_to 'Töröl', {:action => 'destroy', :id => entry}, :confirm => 'Biztosan?' %>
</p>
<% end %>
Ha most megnézzük az alkalmazást, láthatjuk, hogy egészen másként néz ki, mint előtte.

Másként néz ki


A többi action megjelenést is hasonlóan szerkeszthetjük.

Hogy egy áttekintést kaphassunk a lehetőségekről, érdemes legeneráltatni a scaffold által készített kimenetet, hogy az fizikailag is belekerüljön a kódunkba, s láthassuk, mi történik, s hogyan. A következő parancs mind a kódot, mind a view-k fájlait elkészíti. A kérdésekre válaszoljunk Yes-szel, fogadjuk el, hogy felülírja az általunk módosított állományokat:

parancssor> script/generate scaffold entry todo

Összefoglalás

Ebben a nagyon rövid ízelítőben nem került sor sem az Ajax integrációval történő megismerkedésre, sem a pontos működés hogyanjára, illetve számos lehetőség áll még rendelkezésre, amit nem is érintettünk. Kedvcsinálóul annyit tudnék még mondani, hogy ezen (akár elég összetett) funkciók legtöbbjét pár sorral lehet megvalósítani. Amit látható volt talán, s bízom benne, hogy az olvasó is így fogja gondolni és kedvet is kap az ismerkedéshez: hogy a RoR segítségével kevés kódolással, csak a funkcióra koncentrálva, gyorsan és hatékonyan tudunk felületeket létrehozni.

A következőkben még pár linket mutatnék be, melyeken főként vagy egy-egy kis szeletét lehet megtekinteni a Railsnek, vagy pedig általános ismerkedési lehetőséget szolgáltatnak. Külön kiemelném a ma nappal útjára indult magyar Ruby on Rails weblapot, illetve a hozzá kapcsolódó levelezőlistát.

Angol nyelvű weblap (a videókat érdemes először szemügyre venni):
http://www.rubyonrails.org

Egy friss videó a legújabb verzióról, immáron hanggal:
http://www.rubyonrails.org/media/video/rails_take2_with_sound.mov

A Rails AJAX lehetőségeit bemutató referenciaoldal:
http://rails.rubyonrails.com/classes/ActionView/Helpers/JavaScriptHelper.html

Egy (jelenleg terv) RoR alapú CMS rendszerről:
http://www.railfrog.com/

Egy (már működő) webes levelező:
http://mailr.org/

Egy bemutató cikk az OnLampen:
http://www.onlamp.com/pub/a/onlamp/2005/06/09/rails_ajax.html

Szintén egy cikk a LinuxJournaltól:
http://www.linuxjournal.com/article/8217

Egy friss kiegészítő:
http://nubyonrails.topfunky.com/articles/2005/08/01/sparklines-now-gem-i-fied

Jó szórakozást!
 ■
Bártházi András arcképe
Bártházi András
Az Emarsys-nál dolgozik vezető fejlesztőként, és az API-ért, integrációkért felelős termékmenedzserként. Szeret profi csapatban profit alkotni.
1

hozzányúlás után automatizmus?

Jano · 2005. Aug. 3. (Sze), 12.27
Érdekes, figyelemfelkeltő írás! Ami felmerült bennem közben, hogy nagyon jó, hogy automatikusan generálgat nekünk ürlapokat meg kimenetet de gyakorlatban jellemzőbb,hogy több táblába adataira van egyszerre szükség. Ehhez is tud segítséget nyújtani?

A másik: hogy ha egyszer hozzányultunk a kodhóz akkor az autmoatizmusról lemondhatunk. Tehát csak az első, alap kódgenerálást tudja megcsinálni.
2

Működik

Bártházi András · 2005. Aug. 3. (Sze), 13.28
Az eddigi tapasztalatok szerint nincsenek hiányosságai komolyabb esetekben sem.

A több összekapcsolódó táblát tudja kezelni, mind az 1:1, mind az 1:sok, mind a sok:sok kapcsolatot ismeri. Ezt le kell írni neki persze.

A kódgenerálás cselesen működik. Ugye egy kontroller, az egy osztály a kódban. Alapvetően ez nem tud semmit, az egyes actionöket vagy te írod meg kézzel, vagy pedig használod a scaffold-ot. Ez utóbbi esetben futási időben jönnek létre az action-ök (mikor a scaffold függvény lefut), azokat felül tudod definiálni, ha a kódban a scaffold hívása előbb volt, mint a definíciód. Le tudod a scaffold által beszúrt kódot is gyártatni a rendszerrel, s akkor látható is lesz.

Ez a kód különben baromi egyszerű:

class TesztController < ApplicationController
  def index
    list
    render :action => 'list'
  end

  def list
    @teszt_pages, @teszts = paginate :teszt, :per_page => 10
  end

  def show
    @teszt = Teszt.find(params[:id])
  end

  def new
    @teszt = Teszt.new
  end

  def create
    @teszt = Teszt.new(params[:teszt])
    if @teszt.save
      flash[:notice] = 'Teszt was successfully created.'
      redirect_to :action => 'list'
    else
      render :action => 'new'
    end
  end

  def edit
    @teszt = Teszt.find(params[:id])
  end

  def update
    @teszt = Teszt.find(params[:id])
    if @teszt.update_attributes(params[:teszt])
      flash[:notice] = 'Teszt was successfully updated.'
      redirect_to :action => 'show', :id => @teszt
    else
      render :action => 'edit'
    end
  end

  def destroy
    Teszt.find(params[:id]).destroy
    redirect_to :action => 'list'
  end
end
A formot is át tudod úgy formázni, hogy dinamikus legyen, s az adatbázisból jöjjön a tartalma. Nyilván, hogy ha teljesen te írod, akkor utána már nem fogja tudni követni, de ez sem olyan nagy érvágás.

-boogie-
3

nem, nem, nem!

Anonymous · 2005. Aug. 3. (Sze), 19.54
nem, nem, nem! a scaffoldingal létrehozott template-ek egyenként saját ütemedben lecserélhetők. Más táblákkal való összekapcsolás, fastruktúrának megfelelő szerkezet munkára bírása sem nehéz. Egyedüli baj, hogy csak angolul ért. Az eszközök táblát nem tudod scaffolni de az Items igen. Még van pár dolog de az I18N nem az erőssége(sajnos). Írhatnék még de inkább itt vannak a kedvenc ruby linkjeim:
4

Köszönet!

Jano · 2005. Aug. 4. (Cs), 10.58
Köszönöm a sok linket! Tegnap már nézelődtem én is mindenfelé, de haladóbb példákat, tutorialokat nehezebb találni. Kész script is nagyságrendekkel kevesebb van amiből lehetne ellesni gyakorlati megvalósítást.

(Nem akarsz regisztrálni? Igy nem tudom melyik anonymousnak mondok köszönetet vagy tudok én segíteni legközelebb viszont.)
5

<Nincs cím>

Anonymous · 2005. Aug. 5. (P), 19.59
Szia

Ruby scripteket itt találsz: forge

(Regisztrálni nem akarok. Nekem nem jön be a site hangvétele.)
6

"csak" keretrendszer vagy több?

Hojtsy Gábor · 2005. Aug. 6. (Szo), 11.46
Elolvasva a cikket bennem az a kérdés merült fel, hogy a Rails valójában "csak" egy keretrendszer, azaz mondjuk Perlben ugyanezt a kényelmet meg lehetne teremteni egy hasonló filozófiával készült rendszerrel, vagy annál több. Ha több, akkor miben?
7

CakePHP: rapid development framework

Anonymous · 2005. Aug. 6. (Szo), 17.17
Ez egy keretrendszer. A magy hype-ot a rubynak köszönheti ami amellett, hogy extrém könnyen tanulható nyelv, nagyon jól sikerült biztonsági és oop-s szempontból egyaránt. Van már php-s próbálkozás is ami egész jól alakul: cake
8

szvsz több

Bártházi András · 2005. Aug. 6. (Szo), 17.49
Maga a Rails "csak" egy keretrendszer, de a Ruby mellett szerintem ma nincsen olyan nyelv, amivel ennyire jól meg lehetne csinálni. Funkcionálisan - természetesen - meg lehet valósítani ugyanazokat a szolgáltatásokat, de nem minden esetben olyan tömören, mint ahogy Rubyval. Talán majd a Perl 6 ilyen lesz. A Ruby OO-ja, a szintaktikája, a tömörsége, s egyéb nyelvi lehetőségei (ha hiányzik egy metódus, akkor egy default metódust hívunk, stb.) jól sikerültek. Perl 5-ben létezik hasonlóan jól használható, részben önálló, nem csak a Rails alapján készült keretrendszer, ez a Catalyst, de szerintem - a Perl miatt - nem ilyen jó a szintatktikája. A RoR-ban tényleg olyan, mintha angol mondatokat írna az ember :), míg a Catalystben (ahogy a PHPben is), ha egy metódust hívsz, akkor nyilazni kell (apró különbség, de nálam számít).

-boogie-
9

Érdekes...

Mara · 2005. Aug. 13. (Szo), 07.32
Sziasztok!

Még csak kezdő vagyok a témában, de nagyon érdekel. Eddig php-t tanulok, de ez kifejezetten felkeltette az érdeklődésemet....

Köszönöm szépen srácok!

:D
10

A List Apart

Anonymous · 2005. Aug. 24. (Sze), 07.17
http://www.alistapart.com
Azt hiszem nem rossz kis referencia ez a Ruby-nak!
- BonD
11

lol

Anonymous · 2006. Okt. 29. (V), 20.02
1. a webrick nem adatbazisszerver

2. egy tabla boviteset nem igy kell csinalni hanem
ruby script/generate migration valami
12

re: lol

Bártházi András · 2006. Okt. 30. (H), 15.02
1) Valóban. Ahogy ez előző mondatban is írtam, egy webszerver (illetve egy rutinkönyvtár, melyre egy webszerver van építve). Köszönöm a jelzést, javítva.

2) Sokféleképpen lehet csinálni. Sem a cikk születésekor nem voltam, sem most nem vagyok profi Rails tudor. Viszont nem lehet mindjárt mindennel kezdeni, illetve emlékeim szerint anno minden video, tutorial, stb. az egyszerű tábla manipulációt javasolta. Rég született ám ez a cikk. :) Azóta ott a hiperszuper Capistrano és még sokminden más is, melyek akkor még talán ha a fejekben megszülettek.
13

ruby on rails blog

pepusz · 2008. Júl. 6. (V), 11.36
Indítottam egy blogot a témában. pepusz.hu ruby on rails magyarul
14

magyar nyelvű XD

Xefande · 2010. Feb. 10. (Sze), 12.55
Kapcsolódó: " Magyar nyelvű Ruby on Rails oldal "
hát ez röhej, hol magyar nyelvű ???
ez egy egyoldalas honlap amin van kb 2 magyar mondat, meg úgy 50 db kifelé menő link.

Inkább azt kellett volna írni, hogy .hu végződésű, rubyonrails domain :D
15

Segíts fordítani!

Kevlar · 2010. Jún. 17. (Cs), 11.01
A Rails közösség biztosan nem sértődik meg, ha lefordítod az oldalt magyarra.
16

Ruby oktatás

Viharkelto · 2014. Aug. 14. (Cs), 20.24
Sziasztok!

A következő linken találtam oktatást, ha érdekel valakit:

URL törölve. – Joó Ádám

Más nyelveket is oktatnak!

Szép napot mindenkinek!
17

Egy év múlva a szerkesztőség

Joó Ádám · 2014. Aug. 14. (Cs), 20.41
Egy év múlva a szerkesztőség címén kérheted a felhasználód zárolásának feloldását.