Néha szükség van egy osztály, vagy model változóinak egyenkénti ellenőrzésére. Ebben a példában azt ellenőrizzük, hogy a változók tömbök-e, vagy sem.
te_modeled.instance_variables.each do |i| if te_modeled.instance_variable_get(i).instance_of?(Array) then #a te kódod ide jön, a te_modeled.instance_variable_get(i)-t használhatod, ami egy érték end end
Enniy az egész!
Az angol nyelvű fordítás megtalálható: each loop for class or model instance variables
Ahhosz, hogy megkapjuk a a controller nevet, az action nevet és az id-t Rails3 nézetben, vagy sablonban, egyszerű helpereket fogunk igénybevenni. Például, ha van egy routing szabályunk: "match ':controller(/:action(/:id(.:format)))'" és a kért url: '/users/show/23', akkor:
#controller név: #=> 'users' #action név, a metódus neve: #=> 'show' #az id információ: #=> '23'
Ennyi az egész!
Az angol nyelvű változat megtalálható: How to get requested controller name, action name and id
Ebben a postban pár ajax és javascript trükköt mutatok be.Az első lépés eldönteni, hogy mit is akarunk csinálni és, hogy hogyan. Néha van úgy, hogy jobb megoldások is vannak, mint azt elsőre gondolnánk. Egy ajax metódus meghívásához ezt a kódot a header tagba kell illeszteni (a layoutban): <%= javascript_include_tag :defaults %>
Ha eldöntötted, hogy ajax hívásokat fogsz az oldaladon végezni, szerver oldali programozással, akkor ajánlott egy új ajax controller létrehozása, de nem feltétlenül szükséges. Parancssorban:
rails g controller ajax
Ezután, ha csinálunk egy ajax hívást, definiálnunk kell hozzá egy metódust a app/controllers/ajax_controller.rb fájlban. A következő lépés, hogy a javascript kimenetet írjuk le ajax_controller.rb fájlban a respond_to függvénnyel, és a metódust: (most: empty_cart):
class AjaxController < ApplicationController
respond_to :js
def empty_cart
Cart.where(:session_id => request.session_options[:id]).destroy_all
end
end
Eután már meg tudjuk csinálni a empty_cart.js.erb fájlt az app/views/ajax/ könyvtárban. Ebben a fájlban azt a javascriptet írjuk le, amit az oldalra küldeni szeretnénk. Ez egy javascript sablon, de használhatunk benne ruby-s kifejezéseket is. Természetesen használhatunk prototype függvényeket és script.aculo.us effekteket is. A partial cart.html-t korábban a layout-ok között definiáltuk. Itt, amennyiben a kosár üres, ki kell írnia egy sort: "A kosár üres". A div tagon belüli részt cseréljük ki a partial-lal:
$("cart_div").update("<%= escape_javascript(render("layouts/partials/cart.html.erb")) %>");
new Effect.Highlight("cart_div", {duration: 1.5, startcolor: "#909090"});
Ezután csinálhatunk egy ajax linket a view-ban, most: layouts/partials/cart.html.erb. Itt egy css-ben definiált gombot használunk:
<% if Cart.where(:session_id => request.session_options[:id]).empty? %>
Cart is empty.
<% else %>
..put here your cart html code..
<%=raw form_tag url_for(:action => "empty_cart",
:controller => :ajax ),
{ :method => :post,
:remote => true,
:id => "empty_cart" } %>
<%=raw submit_tag "Empty Cart",
:id => "empty_cart_submit",
:class => "empty_cart_button",
:confirm => "Are you sure?" %>
</form>
<% end %>
Ne felejtsük el a link html ocióban beállítani ezt: :remote => true, hogy ajax metódust hívjunk.
Bármilyen effektet használhatunk a javascript erb sablonunkban, úgy, mint sima javascriptben is. Például egy toggle effekt:
new Effect.toggle("some_div_<%= id %>", "slide", {duration: 0.2});
Ne felejtsd el a ruby-s kifejezéseket <%= %> tagok közé rakni csakúgy,mint a html view-ban.
Rails 2-ben ezek a funkciók még megtalálhatóak voltak, most, rails3-ban már nem. Ehelyett használhatunk Prototype Legacy Helper plugint, vagy, amit javaslok, hogy írjuk meg erre a saját javascript kódunkat, ami gyorsabb, mint az ajax hívás. Tegyük a javascript kódunkat a form view-ba (app/views/controller_name/form.html.erb):
document.observe("dom:loaded", function() {
new Form.Observer("<%= @jsvalidator.form.id %>", 0.3, function(form, value) {
// most megvannak a form értékeink egyetlen url formátumú sorban
// tehát meg kell csinálnunk a mező - érték párokat, ehhez a textArray segít
textArray=unescape(value).split("&");
var i=0;
for(i=0; i<(textArray.length); i++) {
// ezután az összes érték a cikluson belüll esz látható
// a textArray[i] egy mező-érték párt jelent, ezt is felbontjuk
value_line_with_equal_sign=textArray[i];
value_name="";
value_value="";
value_name=value_line_with_equal_sign.split("=",2)[0];
value_value=value_line_with_equal_sign.split("=",2)[1];
// mostmár megvannak az értékek, bármit le tudunk ellenőrizni
// a value_name a mező neve
// a value_value a mező értéke
} } }
A @jsvalidator objektum form adatokat tartalmaz és a form controllerében definiáltuk Több információ: How to generate inline javascript
A cikk angol nyelvű változata megtalálható: Rails3 ajax tricks with javascript.
Ennyi az egész!
ruby-on-rails-tutorials.blogspot.com/2011/08/how-to-create-scriptaculous-ajax.html
Ez nagyon egyszerű. Ha csinálunk egy új gem-et saját locale fájlokkal, elsőkörben a lokális fájlokat kell létrehoznunk a gem lib/locales könyvtárban (en.yml és hu.yml). Ezután az .rb fájlunkban, aminek a lib könyvtárban kell lennie, csinálunk egy új methódust: translate_string.
class Example
require 'rubygems'
require 'active_support'
require 'i18n'
def initialize
path=File.dirname(__FILE__)
I18n.load_path += Dir[ File.join(path, 'locales', '*.{rb,yml}') ]
end
def translate_string(var)
return I18n.t(var, :scope=>[:example, :vars])
end
end
Ezután szerkesszük meg a locale fájlokat, en.yml:
en:
example:
vars:
title: example
És a hu.yml:
hu:
example:
vars:
title: példa
Vigyázzunk, hogy space-eket használjunk tabok helyett. Ezután építsük fel a gem-ünket, majd tegyük be a Gemfile-ba, ami rails3 alkalmazás könyvtárában van. Ne felejtsük el újraindítani az alkalmazásunkat. Ezután már meg tudjuk hívni az új osztályunkat a controllerünkből:
e=Example.new
e.translate_string("title")
Ez pedig ezt adja vissza: "példa". Ennyi az egész!
További angol nyelvű információ az I18n fájlokról és bállításokról: I18n yml files in Rails3
Az eredeti cikk angol verziója megtalálható: ruby-on-rails-tutorials.blogspot.com/2010/10/how-to-load-i18n-locale-files-in-rails3.html
Ebben az útmutatóban leírom, hogy miképpen lehet olyan új osztályt készíteni hash paraméterekből, amelyhez nem szükséges active record. Amennyiben nem használsz adatmázist az object mentésére, ez a leírás neked való! Legelőször csináljunk egy új contact.rb fájlt az "app/models" könyvtárban.
class Contact
include ActiveModel::Serialization
attr_accessor :name, :company_name, :email, :phone, :comment
def initialize(attributes = {})
@name=attributes[:name]
@company_name=attributes[:company_name]
@email=attributes[:email]
@phone=attributes[:phone]
@comment=attributes[:comment]
end
# persisted fontos, hogy ne kapjunk "undefined method `to_key' for" hibaüzenetet
def persisted?
false
end
end
Ezután már új form létrehozására is használhatjuk a modelünket, akárcsak egy ActiveRecord-os model esetében:
@contact=Contact.new
vagy:
@contact=Contact.new(params[:contact])
Ezt az objectet használhatjuk arra, hogy email-ben küldük el az adatokat az értékesítőknek, vagy arra is, hogy egy másik, adatbázist hsználó object-be ágyazzuk json segítségével. Például, ha van egy json_contact nevű text mezőnk a User active_record object-ben, users.rb:
Class User < ActiveRecord::Base before_save :before_save_function def before_save_function self.json_contact=self.json_contact.to_json true end def contact unless self.json_contact.nil? then contact_hash = ActiveSupport::JSON.decode(self.json_contact).symbolize_keys.clone return Contact.new(contact_hash) else return nil end end end
Ezután hozzáadhatjuk a Contact objectet a User.json_contact-hoz úgy, mint:
@user=... # bármi (find, vagy new)
@contact=Contact.new(params[:contact])
@user.json_contact=@contact
@user.save
Ne felejtsd el újraindítani az alkalmazást, ha bármi változás van a modelekben. Mostmár megkaphatjuk az eredeti User.contact-ot, mint egy objectet, és úgy is használható, mint egy Contact model:
contact_name=@user.contact.name
Ennyi az egész!
Az útmutató angol másolata megtalálható: ruby-on-rails-tutorials.blogspot.com/2010/10/create-new-class-in-rails3-with.html
Ebben az útmutatóban megpróbálom leírni, hogyan lehet saját gem-ből egy, a gem-hez tartozó sablon fájlból generálni javascript kódot rails3 alkalmazásban. Ez olyan esetekben lehet hasznos, ha több alkalmazásunk van és egy form hitelesítést mindegyikben alkalmazni szeretnénk, így csak egyszer kell megírni. Más helyen is hasznos lehet, ahol javascriptet szeretnénk dinamikusan generálni. Az útmutató nem tartalmazza a teljes forráskódot, mert az túlságosan széttördelné a gondolatmenetet.
Először meg kell csinálnunk a gem fájlstruktúrát:
- jsvalidator- lib- jsvalidator.js.erb
- jsvalidator.rb- jsvalidator.gemspec
Ezután szerkesszük a jsvalidator.gemspec fájlt, amit a jsvalidator könytárban hoztunk létre.
Gem::Specification.new do |spec| spec.name = 'jsvalidator' spec.version ='0.0.1' spec.files = ["lib/jsvalidator.js.erb", "lib/jsvalidator.rb"] spec.summary = "Javascript form validator for rails3 with javascript." spec.author = 'Programmer' spec.email = 'programmer@yourdomain.com' spec.homepage = 'http://www.yourdomain.com' spec.has_rdoc = false end
Az osztály struktúrát a jsvalidator.rb fájlban hozzuk létre. Az Erubis gem-et a "gem install erubis" paranccsal hozhatjuk létre.
require 'rubygems'
require 'active_support'
require 'erubis'
class Jsvalidator
# form object definiálása
attr_accessor :form
def form
return @form
end
# mi most nem inicializálunk semmit, de ebben a blokkban lehet # a kezdeti paramétereket beállítani
def initialize
end
# csinálunk egy függvényt, hogy a formunkat leírjuk,
# ez most egy másik object lesz valójában, amit később definiálunk
def define_form(attributes={})
f=Form.new(attributes)
@form=f if f
end
# a jsvalidator_helper egy olyan függvény, amit a Jsvalidator osztályból fogunk
# meghívni
def jsvalidator_helper
# __FILE__ az a konstans, ami ezt a file-t jelenti
path=File.dirname(__FILE__)
template_path=File.join(path, 'jsvalidator.js.erb')
# megadhatunk különböző objecteket a sablonnak, mint pl.: @jsvalidator,
# ami jelen esetben self, mivel most csak a Jsvalidator osztállyal dolgozunk
vars={ '@jsvalidator' => self }
# tehát beolvassuk a sablon fájlt
template= File.read(template_path)
# Az Erubis végrehajtja a sablonban lévő ruby kifejezéseket és objecteket
javascript=Erubis::Eruby.new(template).result(vars)
# eután megcsináljuk a visszatérési stringet
javascript="<script type="\text/javascript\">
//<![CDATA[
" + javascript + "
//]]>
</script>"
return javascript
end
# a Jsvalidator osztály vége
end
# ezután írjuk le a Form osztályt
class Form < Jsvalidator
# Bármilyen objectet létre lehet hozni benne, mi most csak a Form.id-t használjuk
attr_accessor :id
def initialize(attributes={})
@id=attributes[:id]
end
end
Ebben a fájlban megcsináhatjuk a modelt és az adatstruktúrát is. Ezután szerkesszük meg a sjvalidator.js.erb fájlt. Ebben a javascriptünket fogjuk leírni, amit majd a view oldalunkba illesztünk be. Ebben a sablonban használhatunk bármilyen ruby-s kifejezést úgy, mintha view-ban tennénk, pl.: <%= @jsvalidator.akarmi %>, de előbb ezeket az objecteket definiálnunk kellett a Form osztályban.
document.observe("dom:loaded", function() {
new Form.Observer("<%= @jsvalidator.form.id %>", 0.3, function(form, value) {
// most megvannak a form értékeink egyetlen url formátumú sorban
// tehát meg kell csinálnunk a mező - érték párokat, ehhez a textArray segít
textArray=unescape(value).split("&");
var i=0;
for(i=0; i<(textArray.length); i++) {
// ezután az összes érték a cikluson belüll esz látható
// a textArray[i] egy mező-érték párt jelent, ezt is felbontjuk
value_line_with_equal_sign=textArray[i];
value_name="";
value_value="";
value_name=value_line_with_equal_sign.split("=",2)[0];
value_value=value_line_with_equal_sign.split("=",2)[1];
// mostmár megvannak az értékek, bármit le tudunk ellenőrizni
// a value_name a mező neve
// a value_value a mező értéke
} } }
Ezután megcsináljuk a gem-et a jsvalidator könytárban, parancsorban:
gem build jsvalidator.gemspec
és installáljuk:
sudo gem install jsvalidator
Ezután módosítsuk a Gemfile fájlt, ami a Rails3 alkalmazásunk könyvátárában van. Illesszük be a következő sort:
gem 'jsvalidator', :path = "/home/user/gems/jsvalidator", :require = "jsvalidator"
Ezután parancssorba gépeljük be:
bundler update
Amennyiben nem akarsz gem-et létrehozni, mert folyamatosan szeretnéd tesztelni a kódot, egyszerűen adjuk hozzá az application_controller.rb fájlhoz ezt a sort a megfelelő elérési úttal:
require '/home/user/gems/jsvalidator/lib/jsvalidator.rb'
Mostmár csak a helpert kell hozzáadninuk a form view fájlunkhoz:
<% @jsvalidator=Jsvalidator.new %> <% @jsvalidator.define_form( :id => "your_form_id" %> <%= raw @jsvalidator.jsvalidator_helper %>
Ennyi az egész.
Az eredeti cikk megtalálható angolul a ruby-on-rails-tutorials.blogspot.com/2010/10/how-to-generate-inline-javascript-by.html linken.
