Konfigurace prostředí a databáze, základy Ruby - MujMAC.cz - Apple, Mac OS X, Apple iPod

Navigace:  » Úvodní stránka  » Rubriky  » Software  

6. listopadu 2006, 00.00 | Druhý díl seriálu o Ruby on Rails – konfigurace a základy jazyka Ruby.

Konfigurace

Pokud budete RoR provozovat na produkčním serveru, pravděpodobně na něm budete pracovat s databází MySQL nebo PostgreSQL; framework ale poskytuje plnohodnotné rozhraní i pro kompaktní databázi SQLite (a SQLite3), kterou vám mohu s čistým svědomím doporučit nejen pro vývojové prostředí. Konfiguraci pro kteroukoliv variantu najdete v souboru config/database.yaml, do kterého vepište něco na tento způsob:

development:
  adapter: sqlite3
  database: db/devel.db

test:
  adapter: sqlite3
  database: db/test.db

production:
  adapter: sqlite3
  database: db/prod.db
    

Databázové soubory tvořit nemusíte, to za vás udělá migrační utilita, až budete potřebovat vytvořit tabulky. Databáze pro prostředí development a production můžete nastavit na stejný soubor, ale databázi test ne – je smazána a znovu vygenerována při každém spuštění igrační utility a chyba by vás tedy mohla stát veškerá data.

Jak již většina z vás jistě pochopila, RoR aplikace může běžet ve dvou režimech; režim produkční se používá při ostrém provozu a serveru, zatímco režim vývojářský (development) pro vývoj. Výhod takového řešení je hned několik: jednak je možné aplikaci přepnout do vývojářského režimu a provést na ní úpravy, aniž bychom riskovali ztrátu dat v produkční databázi a jednak je v tomto režimu zapnutá řada voleb, která vám usnadní vývoj a debugování programu. Volby pro oba režimy (a navíc pro speciální režim test) najdete ve složce config/environments, ale upravovat je nemusíte. V souboru config/environment.rb najdete dvě důležité předvolby: hned první volbou v souboru je volba prostředí, kterou můžete zatím ponechat svému osudu; druhou volbou je RAILS_GEM_VERSION, což je verze RoR, kterou bude vaše aplikace (velmi hlasitě) požadovat, když se ji pokusíte spustit. Pokud vám tedy spuštění některého z programů dělá problémy, ověřte, zda se hodnota v tomto souboru shoduje s nainstalovanou verzí RoR.

Jazyk Ruby

Nuže, řekli jsme si již, jak si na svůj stroj nainstalovat Ruby on Rails, jak za pomoci řečeného frameworku vytvořit šablonu aplikace a jak onu aplikaci zkonfirugovat a spustit. V téhle fázi bychom se měli pustit do vývoje prvního programu, ale ještě před tím, než se dostaneme právě k tomu, je důležité porozumět jazyku, se kterým se chystáme pracovat. Následující rychlokurs jazyka Ruby rozhodně není vyčerpávající a už vůbec není určen někomu, kdo s programováním ještě nepřišel do styku. Pokud nejste seznámeni s koncepty objektově orientovaného programování, raději se seznamte alespoň s jeho základy, než se pustíte do RoR.

Co je tedy Ruby za jazyk? Máme-li jej zařadit do kategorií a polepit nálepkami, můžeme říct, že se jedná o jazyk:

1. interpretovaný
2. objektový
3. s dynamickým typováním

Co to vše znamená? Inu, ke spuštění programu napsaného v Ruby je zapotřebí tzv. interpreteru, tedy programu, který přečte náš zdrojový kód a provede, co je v něm zapsáno. Do stejné rodiny jazyků (ie. interpretovaných) patří kupříkladu Python, PHP nebo Java. V současné době si můžeme vybrat ze dvou interpreterů Ruby, a to (překvapení) ruby a Jruby, který je, co do funkcí, identický, ale místo integrace s jazykem C nabízí integraci s Javou. Dynamické typování pak říká, že u proměnných není třeba před použitím deklarovat datový typ, protože ten je jim přidělen podle hodnoty. Systém, který Ruby používá, se nazývá Duck Typing, podle zvířete, které vypadá, chodí i kváká jako kachna a je tedy rozumné s ním zacházet jako s kachnou; proměnná v Ruby je ve skutečnosti objekt, který umí reagovat na zprávy jako +, - nebo = a podle nich upravovat svou hodnotu. Pokud třeba třídě String dodefinujeme operátor *, bude se umět násobit a z pohledu programu se bude chovat jako číslo.

Hello, World!

První jazyk, který programátor napíše v každém novém jazyce, je Hello, World!. V Ruby vypadá takhle:

print "Hello, World!"
    

Řekli jsme si, že Ruby je plně objektový jazyk. To se ale tvrdí o celé řadě jazyků, ale jen málokdy je to pravda. Kód, který jsme právě zapsali, se navíc za moc objektový považovat nedá. Inu, pojďme se podívat, co se tedy vlastně stane, když spustíme prostý program, bez jakéhokoliv objektového balastu okolo:

print self
print "\n"
print self.class
    

Výstup tohoto programu nám odhalí, že ruby si okolo našeho kódu ve skutečnosti domyslelo objekt nazvaný main, který je instancí třídy Object. Kdybychom šli ještě o krok dále, a zkusili zjistit hodnotu self.class.class, dozvěděli bychom se, že třída Object je ve skutečnosti objekt a sama je instancí třídy Class. Třídy v Ruby jsou tedy také objekty. Vlastní třídu si můžeme vytvořit takto:

class Tvor
  def initialize
    print "Ziju! Hura!"
  end
end
    

Název každé třídy (a také všech konstant) musí začínat velkým písmenkem, názvy metod a proměnných zase písmenkem malým; pro rozdělení slov v nazvech konstant a tříd se používají velká písmena (MojeTrida), v ostatních případech podtržítka (moje_metoda). Metoda initialize je jakýsi konstruktor, který se zavolá vždycky, při vytvoření nové instance třídy. Každá metoda implicitně vrací návratovou hodnotu posledně vyhodnoceného příkazu; příkaz return je tedy redundantní, ale doporučuji jej používat ve složitějších konstrukcích, čistě pro přehlednost nebo pro předčasné ukončení běhu metody.

class Tvor
  def initialize(pohlavi = :kluk)
    @pohlavi = pohlavi
  end

  def self.nova_holcicka
    Tvor.new(:holka)
  end

  def self.novy_chlapecek
    Tvor.new :kluk
  end
end
    

V konstruktoru je možné snadno požadovat parametry, jak by člověk čekal v každém jiném jazyce. Rovnítko za názvem argumentu udává výchozí hodnotu, pro případ, že při volání není hodnota zadána (jinak se vyvolá exception). Statické metody třídy lze definovat pomocí proměnné self; ta vždy ukazuje na objekt, ve kterém se právě nacházíme – protože příkaz def není ve skutečnosti příkaz, ale pouze metoda objektu Class, self zde ukazuje právě na objekt, který právě definujeme: na třídu Tvor. Místo definice metody pro instanci této třídy se tedy definuje metoda přímo pro třídu (z instance je pak taková metoda přístupná pomocí self.class.metoda).

Jak vidíte, rozšířili jsme náš konstruktor o volbu pohlaví nového tvora. Onen zavináč před názvem proměnné znamená jednoduše to, že se jedná o proměnnou instance – tedy takovou proměnnou, která se uloží v objektu a je potom přístupná všem jeho metodám (ale ne zvenku). Dvojtečka před hodnotou značí symbol; symboly v Ruby jsou jakési nálepky bez hodnoty, které se inicializují svým první použitím a při každém dalším použití znamenají to samé (používají se pak například místo konstant nebo jako přepínače, čímž se šetří paměť i práce programátora). Poslední věc, které si na tomto příkladu račte povšimnout, je absence závorek okolo parametrů volání metody new v metodě self.novy_chlapecek. Ruby závorky v tomto případě (ani v řadě jiných případů) explicitně nevyžaduje, protože zkrátka nejsou potřeba.

class Tvor
  def initialize(pohlavi = :kluk)
    @pohlavi = pohlavi
  end
end

karel = Tvor.new
print karel.pohlavi
    

Tento kód vrátí chybu, protože proměnná pohlavi je přístupná jen zevnitř našeho objektu. Proto musíme provést něco podobného:

class Tvor
  def initialize(pohlavi = :kluk)
    @pohlavi = pohlavi
  end

  def pohlavi
    @pohlavi
  end

  def pohlavi=(nova_hodnota)
    @pohlavi = nova_hodnota
  end
end

karel = Tvor.new
print karel.pohlavi
karel.pohlavi = :holka
print "\n#{karel.pohlavi}"
    

Jak vidíte, dodefinovali jsme si do našeho objektu metody pohlavi a pohlavi=, které slouží k jednoduchému přístupu do proměnné pohlaví. Do těchto metod můžeme pochopitelně přidat i nějaké ověřování nebo generování hodnot, či si vytvořit kompletně virtuální atribut. Základní formu těchto metod (tu, kterou vidíte v našem příkladu) můžete rovněž přidat do třídy tímto způsobem:

class Tvor
    attr_accessor :pohlavi
    

Pokud chcete atribut pouze pro čtení, nahraďte attr_accessor za attr_reader, případně za attr_writer, pokud chcete jen zápis. Ruby rovněž poskytuje sadu dalších metod, které můžete zavolat z těla třídy, které implementují introspekci a tzv. access control.

class Tvor
    public :metoda1
    protected :metoda2, :metoda3
    private :metoda4
    
    alias :foo :bar
    
    public
    
    def metoda8
        ...
    end
    
    private
    
    def metoda9
        ...
    end
end
    

Public, private a protected fungují, jak by se od nich v každém jazyce čekalo. Pokud jsou jim parametrem předány názvy metod, nastaví přístupnost jim; jsou-li zavolány bez parametru, nastaví výchozí hodnotu pro metody definované v těle třídy po nich. Metoda alias slouží k vytvoření virtuální metody, která je ukazatelem na jinou metodu, což často pomáhá použitelnosti kódu (Kdo si má pamatovat, jestli se metoda jmenuje gender nebo sex? Teď můžete mít obojí v podstatě zadarmo.)

To nám pro dnešek stačí, v příštím díle se podíváme na introspekci, možnosti rozšiřitelnosti, metaprogramování, moduly, namespace, dědění a specifika prostředí RoR. Rovněž se v příkladech začneme konečně přesouvat k RoR samotným.