undefined method `require_gem' for main:Object

me parece que é algo com a versão nova do RubyGens, eu to rodando a versão 1.1.1 e o rails 1.1.2, se por acaso voçê também tenha que usar essa versão e encontrar esse tipo de erro, ele pode ser corrigido fazendo uma pequena mudança no arquivo boot.rb que está dentro do diretório config do seu projeto, então faça o seguinte:

em projetc_name/config/boot.rb procure pela linha:

require_gem "rails", "=#{version}"

e mude para

gem "rails", "=#{version}"

Pronto, somente isso.

Partial Updates

Unfortunately, one of the things I've been looking forward to completely falls flat in my book... Partial Updates (to some extent: Dirty Objects).  

When I first read the paragraph-blurb about this addition I was pretty impressed and was looking forward to seeing how it was implemented.  I was much less impressed when I got my head under the hood.  Relying totally on use of ActiveRecord setter methods is a pretty big fail in my book.  Tracking down every place that a field is edited "in place" to specially flag it (xyz_will_change) is completely unreasonable and maintaining that rule going forward is an annoyance that I just don't need.

I played with several ways of attempting to set flags when changes were "likely" (ex: when getters were used) or always flagging "likely to be edited in place" attributes (ex: serialized fields) but just was ending up with lots of additional complexity, reduced reliability, and basically voiding out any gained efficiency.

Having this enabled by default (apparently the plan) is just plain confusing:  Seems much more reasonable to enabled this when you know it's going to benefit you.  I also don't like that it adds another question for a new developer to ask (or get tripped up on) when joining a project.  I really don't want to have to read every line of the new guys code for the first three months to make sure that he's sticking to the rules (and setting up tests to verify it explicitly).

XML handling

Null values are now flagged as such instead of just being blank, like they would look if they were... uh... blank.  This is a good thing - it also tripped me up for a bit.

Eager Loading

It seems eager loading has been changed a bit.  Statements that used to result in :include items being joined right into a single large query now (may) result in several smaller statements.  

Does it make queries more efficient?  Probably.

Does it increase db traffic?  Probably.

Is it a bad thing?  Probably Not (overall).

Is it a bad thing that stuff that worked before doesn't?  Yeah, that's annoying.

My specific problem is on an association defined with a :select => "distinct labels.*".  I played around a bit with potential changes down in the AR guts but in the end (unfortunately) I ended up basically tricking it into running it as a single statement.  It's not at all difficult to make it happen but it's also not at all straightforward - and I hate it when the framework makes me write a big comment.

For me, I added an :order to my find that would make it order by something in a different table, which scares the thing into running a single statement.  Ideally, I'd like to have something explicit (maybe on the association but more likely on the find itself) that would allow an optional param to say "run this as one statement".  That would let someone reading the code clearly see what's going on - instead of wondering (or more likely: not noticing) that I'm ordering by some pointless field.

Overall

Not nearly as bad as I had expected.  Felt good to get some deprecated stuff fixed and get some of my old TODOs out of there in the process.  Also good to have it (almost) over with and to, at least temporarily,have caught up with the Joneses.

cd /usr/lib/ruby/gems/1.8/gems/sqlite3-ruby-1.2.2/lib/sqlite3
sudo chmod +r *

Today I got this error when using 'rake db:migrate':

sqlite3_api.so: undefined symbol: RSTRING_PTR

The answer is at http://d.hatena.ne.jp/GARAPON/20080602/1212387419, the ruby version in RHEL5 is 1.8.5, so workaround is:

Put the following lines in file '/usr/lib/ruby/1.8/i386-linux/ruby.h':
#define RSTRING_PTR(s) (RSTRING(s)->ptr)
#define RSTRING_LEN(s) (RSTRING(s)->len)

gem uninstall sqlite3-ruby
gem install sqlite3-ruby
rake db:migrate

Then do the above 'sudo chmod +r *' AGAIN to get rid of the 'no such file to load' error message.

[root@wpprdwf ~]# gem install mysql -- --with-mysql-lib=/usr/lib/mysql
Building native extensions.  This could take a while...
Successfully installed mysql-2.7
1 gem installed

Para resolver esse pequeno problema você simplesmente tem que adicionar um require no seguinte arquivo: /usr/bin/gem

Então faça:

sudo gedit /usr/bin/gem

e logo abaixo de :

require 'rubygems'

add isso:

require 'rubygems/gem_runner'


Feche o arquivo e pronto podera usar o RubyGem sem nenhum problema.


Mike Bowler (GargoyleSoftware.com) returns armed with a fist full of meta-programming as he looks at “Diving into meta-programming with Date.once”

Kristan ‘Krispy’ Uccello will examine the architecture and design of the Domainer.com platform as he investigates, “Web Development Demons: Why it can be hard to do something simple”.

We regret that Leila Boujnane, co-founder and CEO of Idée Inc. (idéeinc.com), was called out of town. However, Leila will join us at our next event, May 13^th, to discuss and demonstrate her company’s highly successful image search APIs.

We thank you all for your ongoing support and interest – as always, if you would like to get involved as a presenter please email corina.newby@tsotinc.com or call (416) 908-6082.

See you tomorrow night!

def in? collection
collection.include? self
end

end[/sourcecode]
And now I can sleep again at night.

Dacă vom folosi: http://localhost:3000/admin/mycontroller/myaction,
se va trece prin controller-ul de mai sus, apoi o redirectare va fi făcută către controller-ul "mycontroller" şi către acţiunea "myaction" aferentă acestuia.
Spor la treaba.

irb(main):001:0> "abc"[1]
=> "b"

but in ruby 1.8:

irb(main):001:0> "abc"[1..1]
=> "b"

There is an easier way, for 1.8, to do that?

www.gleisarbeiter.de

Der Wordpress-Blog selbst wird von mir nicht mehr aktualisiert. Schaut bitte jetzt unter dem neuen Link nach Neuigkeiten.

Viel Spaß!

Ferret und ActsAsFerret bietet eine einfach zu konfigurierende Unterstützung für dieses Stemming:

Eine Datei

stemming_analyzer.rb

im lib/-Verzeichnis anlegen:

require 'rubygems'
require 'ferret'

class StemmingAnalyzer < Ferret::Analysis::Analyzer
  include Ferret::Analysis
  def initialize(stop_words = FULL_GERMAN_STOP_WORDS)
    @stop_words = stop_words
  end
  def token_stream(field, str)
    StemFilter.new(StopFilter.new(LowerCaseFilter.new(StandardTokenizer.new(str)),@stop_words), 'de')
  end
end

Im zu durchsuchenden Model dann folgendes:

acts_as_ferret :fields => {
  :bandname => {}, :firstName_if_public => {},
  :tag_list => {}, :comment_list => {}
}, :ferret => {
    :analyzer => StemmingAnalyzer.new, :remote => true}

Dabei ist darauf zu achten, dass, wenn ihr den DrB-Server verwenden wollt, :remote => true innerhalb des :ferret-Attributs sein muss. Bei uns war dieses ausserhalb, woraufhin bei einem Aufruf von XYZ.rebuild_index nur nil zurückgeliefert wurde und Stemming nicht funktionierte.

Über script/console kann dann schön getestet werden. Wenn man nebenbei noch die log/ferret_server.log anschaut, kann man sehen, dass jetzt automatisch Suchwörter wie "und" in XYZ.find_by_contents("Gitarren und Geigen") entfernt werden. Ausserdem kann man sehen, dass z.B. "Geigen" auf "Geig" reduziert wird, womit sich dann auch Wörter wir Geige finden lassen.

Wenn er da ist, dann sitzt er genau hier, mir gegenüber, und wie man schon an seinen Stuhl-Armlehnen sehen kann, ist er nicht grad der kleinste :-) Aber ein total Netter. Gestern war der erste Tag und er durfte sich erstmal mit der Installation unseres Projektes ligx.de auf seinem neuen Macbook ausruhen. Heute kann er endlich zeigen was in ihm steckt :-D Aber das wird wohl kein Problem werden, schließlich hat er seine Diplomarbeit in RubyOnRails gemacht.

Also dann, auf eine gute Zusammenarbeit!

store[manager] = Bob Smith
store[location][state] = Wisconsin
store[location][zip] = 53590

And easily process them on the server side with something like:
Store.new(params[:store])

So, why does this:
link_to "Store", :controller => :store, :action => :show, :store => { :manager => "Bob Smith", :location => { :state => "Wisconsin", :zip => 53590 } }

output something stupid like this:
http://localhost:3000/case/1/store/show?store=locationstateWisconsinzip53590managerBob+Smith

when what I'd like is something like:
http://localhost:3000/store/show?store%5Blocation%5D%5Bstate%5D=Wisconsin&store%5Blocation%5D%5Bzip%5D=53590&store%5Bmanager%5D=Bob+Smith

Well, without further ado, I give you the url_for hack to make it happen (note: For a widespread solution this would need to do a bit more... escape things, handle some different object types, handle more than 1 layer of hashed values, etc... but you get the idea)

Putting this in url_for has other benefits since lots of things depend on it. For example, now you can do:

redirect_to :action => :show, :store => { :manager => "Bob Smith", :location => { :state => "Wisconsin", :zip => 53590 } }

This is especially handy if you'd like an action to "hand off" some of the params that it's received via a redirect.

Morgen nachmittag gehts los mit dem ICE zur RailsConfEurope in Berlin. Wirklich interessante Themen und Tutorials stehen an und natürlich BratwurstOnRails morgen abend ;-)

See you at RailsConf!

Wie kann ich meine Goldberg-Tabelleninhalte möglichst einfach in meine Testdatenbank laden?

Eigentlich ganz einfach:

Im Rails_Root

rake goldberg:dump_bootstrap

aufrufen, damit werden die Tabelleninhalte von Goldberg in das Verzeichnis vendor/plugins/goldberg/db gedumpt und zwar im yml-Format.

In den Functionality/Unit-Tests z.B. in der setup Methode einfach den Befehl

GoldbergMigration.load_bootstrap

aufrufen und die Test-Tabellen werden mit den aktuellen Goldbergdaten gefüllt.

Dari sisi pengguna, keunggulan RoR adalah:

1. RoR dapat menggunakan 100% open source software, sehingga biaya pembelian lisensi dapat ditekan sampai 0.
2. RoR tidak membutuhkan perangkat keras yang mahal
3. RoR dapat menggunakan model bisnis persewaan (SaaS, software as a service) dengan biaya awal yang kecil

OK, semua poin di atas berlaku juga untuk open source web development platform yang lainnya, seperti PHP, Perl dan lain-lain, nah keunggulan utama RoR dibandingkan dengan platform lain adalah:

1. RoR sangat mendukung "software engineering best practices" yang sering diabaikan oleh pengguna platform lainnya, sehingga produk aplikasi RoR cenderung lebih berkualitas dan lebih sedikit cacatnya (bug).
2. RoR memiliki waktu pengembangan yang paling singkat, sehingga biaya pengadaan aplikasi pun tentunya dapat ditekan
3. RoR memiliki tingkat keluwesan yang tinggi (high agility) sehingga lebih mudah beradaptasi dengan business process yang sering berubah-ubah
4. RoR lebih mudah dipelihara karena keringkasannya. Bukan hanya pengembangan aplikasi yang berbanding lurus (bahkan berbanding exponensial) dengan banyaknya source code (kode sumber), pemeliharaan pun biasanya seperti itu juga.
5. Hampir semua UKM tentunya berkeinginan untuk tumbuh pesat dan "lulus" dari UKM. Nah dengan sifat RoR yang database independent, maka transisi menuju database yang lebih canggih (misalnya Oracle atau DB2) akan lebih mulus, tidak banyak (atau bahkan tidak ada sama sekali) yang harus diubah dari sisi aplikasi ketika bisnis kita menuntut penggunaan database yang lebih canggih.

Nah, bukankan sudah saatnya kita mengkampanyekan penggunaan RoR sebagai teknologi pilihan untuk UKM?

Besok saya akan membahas keunggulan RoR bagi UKM sebagai produsen software, ya, para software house kecil dan menengah.

The Positives

MVC, MVP, ABC easy as 123...

Under the covers, MonoRail is a full MVC compliant framework essentially comprising a front controller sitting over the ASP.NET infrastructure intercepting specially formed URI's. The HTML ends up in the browser via your choice of view engine, with NVelocity (a fork of the Jakarta Velocity port) the default and most accessible, Brail being the Boo dynamic language and most performant option and of course a cruddy web forms engine too which nobody should use. :) I've been comfortably using NVelocity for a while now, and provide testament that its not difficult to pick up.

The controller code orchestrates the flow of logic through the application and rails URI's map nicely to actions on the controller which are ultimately public methods on the controller class itself. All nice and easy. Actions exposed on controllers derived from the magical SmartDispatcherController can translate posted form values into domain model objects for you by simply adding the DataBind attribute to your action's argument list:

public void Save([DataBind("publisher")] Publisher publisher)

In the above example the publisher argument is passed into the Save action fully constructed via the form or query string values posted! This saves on the usual binding and scraping stuff you normally do in web forms and which almost always ends up sitting in the code behind untested. Note: the databinding stuff is of course very flexible and my example above just touches on the possibilities.

ActiveRecord

The model can be supplied with an ActiveRecord enabled domain model. This of course abstracts away NHibernate behind the scenes. Unfortunately generic collections support doesn't work right now but I believe that work is firmly underway.

Edit: Generic collections are supported, as long as you're running from the trunk.

Domain entities are adorned with the necessary attributes defining how their properties are mapped to your data source. This is a departure from the usual hbm XML mapping files but just as expressive.

ActiveRecord also supplies simple validation in the form of special attributes including email validation, regular expression validation and the like.

UI Components

Reusability of UI components is achieved via ViewComponent. These can support nested sections, parameters etc.

AJAX and client scripting support

Built into MonoRail are a number of helpers which allow you to perform the usual AJAX stuff such as calling remote server side methods and callback support, Scriptaculous and Effects2 client side goodness. In fact the helper extensibility is a nice way of adding extensions and wrapping commonly performed functionality in the view.

Convention over configuration

Like RoR, MonoRail prefers convention over configuration. The project structure skeleton is the same throughout all MonoRail enabled solutions. The MonoRail installer also includes a handy templated solution provider for both VS.NET 2003 and 2005 to create the project skeleton and testing is included. Accustomed MonoRail developers can open any solution and just know where things are going to be.

Testability

One of the sore points of ASP.NET development was the unit testing difficulty. MonoRail overcomes this by enforcing the MVC pattern. Controllers are testable classes sitting outside of the usual ASP.NET cruft. There are a number of framework features within MonoRail which specifically aid testing.

Scaffolding

Like RoR, controllers adorned with the necessary scaffolding attributes can automatically produce the basic markup and logic for CRUD operations on your domain model. Handy for prototyping or creating rough-and-ready data entry capabilities in your applications.

Container support

MonoRail supports IoC via the Windsor container. Controllers and their dependencies/parameters can be injected by the container if necessary.

The negatives

MonoRail does have some negatives, which I will mull over:

No 3rd party or ASP.NET web forms controls support

I don't really see this as an issue but can see that some ASP.NET developers will. Fans of the big UI library packages will complain, but there is this old concept of HTML and it is surprising how flexible it can be ;) Most use of control libraries I have seen has been misguided, by this I mean they're usually added to a screen just because they can.

The web forms control library isn't such an issue as things like calendars, grids and the like are not to difficult to duplicate the MonoRail way.

Learning a whole bunch of new concepts/patterns/practices

Most ASP.NET developers are what can only be described as morts. They're not familiar with design patterns and good practices such as clean separation since they came from either ASP or VB (procedural backgrounds) so this stuff doesn't come naturally. If you've used NHibernate you'll pick up the ActiveRecord stuff in no time. Learning the template syntax for your chosen view engine is of course another consideration.

Summary

In summary, the benefits of using MonoRail over web forms are clear. Clean separation of concerns, testability, reduced complexity and none of the web form cruft and artifacts. MonoRail won't suit everybody, but even if you're happy with web forms it's definitely worth a look. Personally I think its the only way worth programming in the enterprise with ASP.NET today.