For Ruby 1.9.2, I followed the instructions at http://beginrescueend.com/packages/openssl/ , and changed the path to /opt/local since I’m using MacPorts.

https://gist.github.com/1352391

It has the added advantage that you can specify which tests (the names of test blocks / test methods) you want to run inside a `push`ed test file.

Cheers!

* Redefine its entire configuration (OpenStruct object) and fill in what you want.

* Open up another terminal, run `testr-master` and tell it (see its man page for details: `testr-master –help`) exactly which files to run. This is very similar to spin, but it operates on STDIN rather than a UNIX socket.

And I still don’t want to pay the price of waiting for the Rails environment to load.

Sometimes heuristics are great. But there are other times you just want to tell the computer what to do.

The testr(1) bin script provides a simple command-line UI that lets you (among other things) re-run all currently failing tests, all currently passing tests, or just everything. So that’s taken care of too. :-)

Does TestR support this?

(I am also a fan of automatically running tests with a watcher such as guard, but when the test suite is big and slow I fall back to on-demand testing.)

btw: The default for the date delimiter string seems to be undefined.

Your code worked for me if I put it directly in the action where it was needed. However the around_filter didnt work for me, the Time.zone seems to fall out of scope in the yield which surprised me.

‘CST’ is not one of the names Rails uses for time zones. You can see the full list by looking in the activesupport gem in lib/active_support/values/time_zone.rb.

The Rails name for CST is “Central Time (US & Canada)”.

One easy way to see this file is:
$ gem install gemedit
$ gem edit activesupport

This opens activesupport in your editor (whatever EDITOR is set to). Then navigate to the file.

Thanks for posting your detailed notes.

Installation of openssl — requires a new install of rails (failures with Unsupported digest algorithm (sha256)):
1) Validate rvm and any existing copies of rails are gone. If no rvm is installed, skip this bit
a) rvm list
b) rvm remove 1.9.2 (should remove all copies that you have installed with rvm)
2) Download and install homebrew –
a) ruby -e “$(curl -fsSL https://gist.github.com/raw/323731/install_homebrew.rb)”
3) Install OpenSSL
a) brew install openssl
–> note which directory it has installed to (should be something like /usr/local/Cellar/openssl/0.9.8o)
4) install rvm — followed https://rvm.beginrescueend.com/rvm/install/ for single user install which should overwrite system installs of rvm/ruby/rails
a) bash < > ~/.bash_profile
c) . ~/.bash_profile
d) type rvm | head -1 # should return ‘rvm is a function’
5) install ruby
a) rvm install 1.9.2 –with-openssl-dir=/usr/local/Cellar/openssl/0.9.8o
b) rvm use 1.9.2
c) rvm use 1.9.2 –default
d) ruby –version should return this:
ruby 1.9.2p180 (2011-02-18 revision 30909) [i386-darwin9.8.0]
6) install rails & gems
a) gem install rails –version =3.0.3
b) env ARCHFLAGS=”-arch i386″ gem install mysql — –with-mysql-config=/usr/local/mysql/bin/mysql_config
c) bundle install
7) validate
a) ruby -ropenssl -e ‘p OpenSSL::Digest::Digest.new(“sha256″)’ # should not error
b) ruby -e “puts require(‘openssl’)” # should return true
c) rails console and enter this:
OpenSSL::Digest::Digest.new(“sha256″)
–> should not error and should return something like this:
#

https://rvm.beginrescueend.com/packages/openssl/

and it worked!

I’m still trying to promote Rails internally while pursuing my own projects as well. Here’s to its continued growth.

Seriously though, I’m really excited for you, and I can’t wait to see how things go with your startup.

Ha! thanks…

But for those to whom the rationale still doesn’t make sense, I think there’s nothing wrong with a good memory crutch once in a while.

https://github.com/lifo/docrails/commit/3a29bfae2cbb956e469942ed1d4ea8c702085a1a

It turns out to make just a doc change you don’t need to submit a patch. You just check out the docrails project directly, make your change, and push it back to GitHub.

https://github.com/lifo/docrails

This workaround worked for me too. It’s hacky but now I have 1.9.2 again!

The discussion is here:
http://groups.google.com/group/rubyversionmanager/browse_thread/thread/9ecd3fee7fe848cd

01-29-11 20:13:28 ~ ()ruby-1.9.2-p136
->rvm package install readline
Fetching readline-5.2.tar.gz to /Users/macajueli/.rvm/archives
Extracting readline-5.2.tar.gz to /Users/macajueli/.rvm/src
Applying patch ‘/Users/macajueli/.rvm/patches/readline-5.2/shobj-conf.patch’…
Configuring readline in /Users/macajueli/.rvm/src/readline-5.2.
Compiling readline in /Users/macajueli/.rvm/src/readline-5.2.
Installing readline to /Users/macajueli/.rvm/usr
Fetching readline-6.0.tar.gz to /Users/macajueli/.rvm/archives
Extracting readline-6.0.tar.gz to /Users/macajueli/.rvm/src
Configuring readline in /Users/macajueli/.rvm/src/readline-6.0.
Compiling readline in /Users/macajueli/.rvm/src/readline-6.0.
Installing readline to /Users/macajueli/.rvm/usr
->rvm uninstall 1.9.2
Removing /Users/macajueli/.rvm/rubies/ruby-1.9.2-p136…
01-29-11 20:13:51 ~ ()
->rvm install 1.9.2 –with-readline-dir=$rvm_path/usr
/Users/macajueli/.rvm/rubies/ruby-1.9.2-p136, this may take a while depending on your cpu(s)…

ruby-1.9.2-p136 – #fetching
ruby-1.9.2-p136 – #extracted to /Users/macajueli/.rvm/src/ruby-1.9.2-p136 (already extracted)
ruby-1.9.2-p136 – #configuring
ruby-1.9.2-p136 – #compiling
ruby-1.9.2-p136 – #installing
ruby-1.9.2-p136 – updating #rubygems for /Users/macajueli/.rvm/gems/ruby-1.9.2-p136@global
ruby-1.9.2-p136 – updating #rubygems for /Users/macajueli/.rvm/gems/ruby-1.9.2-p136
ruby-1.9.2-p136 – adjusting #shebangs for (gem).
ruby-1.9.2-p136 – #importing default gemsets (/Users/macajueli/.rvm/gemsets/)
Install of ruby-1.9.2-p136 – #complete
01-29-11 20:18:50 ~ ()ruby-1.9.2-p136
->rvm 1.9.2
01-29-11 20:39:44 ~ ()ruby-1.9.2-p136
->ruby -v
ruby 1.9.2p136 (2010-12-25 revision 30365) [x86_64-darwin10.6.0]

How funny that your son likes printing “I love cheese” in a loop–and that your little game language is called Pie–because after my daughter learned the “puts” method (but before learning that strings have to be quoted) she tried this:

puts I like pie

I bet once she learns loops she’ll be making infinite tributes to pie.

The Pie language looks like fun. I like that you’ve made it possible to do mobile as well as desktop.

I heard about your Kids’ Track at RubyConf when you announced it. Very cool.

He wanted to create a game with graphics, so I made a little language for web-based games. It’s not done yet, but it still seems fun. You can read about it here: http://www.ultrasaurus.com/sarahblog/2010/11/pie-game-development-for-kids/

Good luck and definitely keep writing about your experience teaching!

Sarah

I have that book! I thought it was good, too. I’m sure you’ll have fun with Rosey as she learns to make computers do what she tells them to do!

This summer I found out how poorly prepared my 14 year old daughter was for the impending zombie apocalypse; when asked who she would want with her in case of a zombie virus outbreak she said Michael Jackson. Everyone knows he’s the one most likely to BE a zombie.

I’ve updated the Rails 3 section above to mention this.

1. You said the action doesn’t reveal what will happen when the request arrives. I agree that this is a problem. Having to trace through a bunch of html would be a pain. There are alternatives like using query_trace or New Relic but I get your point–nothing would be clearer than just seeing it right there in the controller and knowing what queries will be run for a given action.

The problem is, that gives a false sense of security. Reading a controller action in Rails doesn’t reveal what will happen when the request arrives. Even when people try to follow the rules and not write queries in views, It’s common to show associations in a view without having joined or included the association in the controller. So the controller doesn’t make it clear that more queries will be run.

It’s pretty easy for these queries to get out of hand. In the worst case I’ve seen, the controller did just one query but by the time the view was rendered, 300 queries were performed–and that was just to build a site’s nav bar (which was shown on every page). A programmer naively crawled the entire category tree in a helper function (in the helpers folder) without realizing each call to .parent or .children ran a db query.

It feels like I’m saying “it’s already bad so it’s ok to make it worse.” Not exactly. If I knew a good fix that made all queries obvious in the controller, I might advocate that. But since I don’t know one, I’m trying to be pragmatic and say given the current landscape, let’s see we we *can* solve some of its problems.

2. You said the name of these helper methods are like any other variable name. In this example “company”. You would prefer “get_company()”. I see what you’re saying but I’m not yet convinced on this one. I was tempted to name the helper methods something like “get_company()” instead of just “company,” but it seemed like it goes too much against the Ruby naming pattern that’s used for all accessors. Once someone has used Ruby for a bit they’re probably going to know that “company” is either a variable or an accessor method, and if they don’t see the variable declaration up above then it must be an accessor method.

But you’re right that a programmer who barely knows the code won’t realize that the accessor method queries the db. As I mentioned above, I worry about that with ActiveRecord in general since it’s not obvious which method calls will run queries.

My answer is: it’s still better than in the normal Rails pattern, where you still query the db to get the company even if you *never* reference “company.”

But hey, if readers want to use this pattern but call the helper method get_company() to make it more obvious, or leave off the parens and call it get_company, go for it. You’ll still get the benefits I described in the post.

Summing up:

The Struts 2 project I work on for my day job uses the helper method approach that I describe in the post above. I waited six months before writing this post about doing it in Rails to make sure it was working out ok. So far we have not had problem #1 or #2 that you mentioned. (Yes, #2 is a potential problem even in Java because we’re using OGNL script to call the accessors. So in the view it looks like “company,” not “getCompany()”.) But admittedly it’s a team of three and we all know the code really well. We’ll have to see what happens when more people join the team.

Thanks a lot for your insights.

Here is why i don’t like this approach:

1. the action doesn’t reveal what will happen when the request arrive.
if you look at the index action in the example you will see that it is empty. you need to read the view in order to understand what queries will be made or services will be called.

this makes it harder to understand the flow and how to optimize or refactor it. you will need to find the view and look for names of methods mixed inside html, and you will also have to look in all the partials that are called. a messy job.

2. the name of these helper methods are like any other variable name. in this example “company”. i would prefer “get_company()”.

i understand company is sweeter, but since ruby doesn’t require you to use bracket, when a programmer who barely knows the code tries to solve a problem and see “company.name” his first thought is that company is an object variable, he doesn’t suspect this might be a call to a method that query the db.

truncated_time = input_time.beginning_of_day

In pure ruby you can do it by going to an array and back:

time_array = input_time.to_a
time_array[0] = 0 #set seconds to zero
time_array[1] = 0 #set minutes to zero
time_array[2] = 0 #set hours to zero
truncated_time = Time.local *time_array

More information: http://stackoverflow.com/questions/912139/truncating-ruby-time-objects-efficiently

The bad news is load_and_authorize just takes you back to the same old problem I was pointing out in the article. It proactively performs a query (in a before_filter) before knowing if the view will actually need the data. Then we’re back to square one.

But your question brings up a great point: even without load_and_authorize_resource, calling authorize! in the controller (as I did in my article) causes a proactive query before knowing if the view will need the data.

How do we work around this? By authorizing the resource in the helper method instead of in a before_filter. Try something like this:

  def company
    return @company if defined? @company
    @company = Company.find(params[:id])
    authorize! params[:action].to_sym, @company
    @company
  end

  def companies
    return @companies if defined? @companies
    @companies = Company.all
    authorize! :read, @companies
    @companies
  end

Feel free to DRY up this code.

In which the instance variable (e.g.- @article) will already have been loaded (and authorized for the user) before the ‘show’ method gets called.

In this case, one can simplify the show action even more in your example (i.e. – empty).

I think I agree that even in this case, I’d still use your suggested helper method access in the view. Thanks for the tip.

You can’t use public methods to be accessible to the view because this visibility is reserved to routes (:controller/:action). However, I think it would be nice to have protected methods available in the view.

public => callable methods for routes
protected => available methods for controller, helpers, views
private => only available in controller, like the name suggests

I still think it’s kind of a nice pattern to use even with Arel because it’s more DRY than the typical pattern. I’ve added a brief paragraph about that to the “Does It Work in Rails 3?” section above. But with Arel, the practical benefits of using this pattern might no longer outweigh the benefit of using the patterns every Rails developer is familiar with.

@company = Company.find(params[:id])

you now have it in only one place.

In the “render” statement you would use company/companies instead of @company/@companies:

render company # used to be render @company
render companies # used to be render @companies

This code is already just as DRY as the conventional Rails pattern. More DRY if you count the removal of the duplicate key logic for read_fragment and cache. My preference is just to leave the code as is rather than try to make it a plugin. I don’t think a plugin would really help here.

I realise you’ve implemented it yourself — and commend you on your good taste! — but it existed on your system beforehand (as evidenced by ri) and I was just suggesting why that might be.

There’s been discussion in the distant past about including this method in core Ruby. I’d be a fan of that.

It’s unfortunate that ri doesn’t tell you where it’s defined.

I changed “Test::Unit::TestCase” to “ActiveSupport::TestCase”.

This fixes the error people were talking about in the comments:
./test/unit/../test_helper.rb:42: undefined method `setup’ for Test::Unit::TestCase:Class (NoMethodError)

>> require ‘rubygems’
=> true
>> require ‘json’
=> true
>> JSON.unparse({“a”=>”b”})
=> “{\”a\”:\”b\”}”
>> require ‘active_support’
=> true
>> JSON.unparse({“a”=>”b”})
NoMethodError: undefined method `[]‘ for #
from /var/lib/gems/1.8/gems/activesupport-2.3.4/lib/active_support/json/encoders/hash.rb:45:in `as_json’
from /var/lib/gems/1.8/gems/activesupport-2.3.4/lib/active_support/json/encoders/hash.rb:34:in `to_json’
from /var/lib/gems/1.8/gems/json-1.1.9/lib/json/common.rb:183:in `unparse’
from (irb):5
>>

That looks nice. You’re right, it is more succinct.

And thanks for making me think more about it–I noticed a bug in my code when I read your post, and I think my bug made its way to your reply too. I’ve corrected it in the post above. I was originally using /@(.+)/ as the regular expression but that rewrites URLs that have an @ sign in the middle. I changed it to %r{/@(.+)} (inserted a slash at the front and used %r to avoid having to escape the slash).

I’m guessing the same thing would work in Rack::Rewrite.

Brian, Rack::Rewrite has a development branch that will allow you to do everything that Refraction does more succinctly.

As far as your example above, it’s actually simpler with Rack::Rewrite (http://github.com/jtrupiano/rack-rewrite ):

    config.middleware.insert_before(Rack::Lock, Rack::Rewrite) do
      rewrite /@(.+)/, "/users/$1"
    end

Rails::logger.info “\n\nStarting #{name}\n#{‘-’ * (9 + @name.length)}\n”

Good stuff. Here is the RESTful syntax:

 link_to_seo_remote(event.name, { :update => "#{dom_id(event)}_detail", :url => event_path(event), :method=>:get, :complete => visual_effect(:slide_down, "#{dom_id(event)}_detail") } )

Many thanks.

Did I mention that I love Rails?