- Where am I? — Ever need to find the name of the method you are currently within? Here’s a
this_method method! The magic is in the REGEX, of course.
caller =~ /`([^']*)'/ and $1
- One project wanted to test a very ActiveRecord-specific Module in an isolated, generic way. After spending time researching techniques of mocking and stubbing the many, many ActiveRecord methods that would be touched, they decided to just dynamically create an ActiveRecord and a DB Table for it on the fly! They even used single table inheritance (STI)
describe "MyMagicModule Mixin" do
:force => true do |t|
t.integer "some_model_b_id", :limit => 11
class SomeBaseModel < ActiveRecord::Base;end
class SomeModelA < SomeBaseModel
class SomeModelB < SomeBaseModel
it 'should use special belongs_to stuff from MyMagicModule' do
model_a = SomeModelA.create!(
:name=> "Model A",
:some_model_be => SomeModelB.create!(:name => "Model B"))
# test the functionality from MyMagicModule
- Rake migrations check if a migrations table is in sync with migration file and it does not really check what the state of the data in database.
Ask for Help
“Can we use migrations to load static data into an application”
People usually create a separate rake task to bootstap. Mixing it with migration was not working well before.
A developer accidentally committed to an SVN external. Switching the SVN user to have read-only access to the external.
Casebook’s ccrb + Funkytown + JsUnit build opens parallels on development boxes. The issue is probably with the Funkytown configuration.
Adam Keyes is coming in to talk to us during lunch today.
Casebook is moving to Git.
“All your brunch is belong to us” – Damon McCormick
NYC Ruby Tomorrow
Erector 0.4.200 was released. New features include:
The Widget#join method, which joins an Array of text/widgets, with a separator which is text or a widget. This translates the standard idiom, without needing calls to raw.
join [ “People”, “Projects” ], ” | “
Added a Pretty Printer which can be enabled by Erector::Doc.prettyprint_default = true (for example in development.rb)
JsUnit runs very slowly on the CI box on OSX and eventually times out, unless we open a VNC window to the machine. We tried upgrading to a more recent JsUnit, but couldn’t get that to work at all.
Nanite looks really cool.
One interesting thing this morning:
The RailsEnvy blog had a segment talking about a team of engineers building a series of social network plugins using the Pivotal Lab’s technology: Dessert.
Those of us used to Desert (one ‘s’) were wondering what Dessert might be, leading to this quip from Adam:
“Dessert is Desert with a lot of syntactic sugar.”
Ask For Help
Once again, a project is asking for everyone’s favorite IE 6 .PNG alpha transparency fixes — more rounded corners! Examples include the CSS Behavior code, using .PNGs or .GIFs with on/off transparency, regulating IE 6 to the square Web 1.0 world, and even using on/off transparency and just knocking a pixel or two off of corners for a “good enough” rounded look.
What are your favorite IE 6 rounded-corner and/or alpha-transparency fixes?
Ask for Help
One of our clients is looking for high-quality third-party chat services/libraries.
10.5.5 and screen sharing
The Mac screen sharing application includes a host of interesting power features. Unfortunately, upgrading to Mac 10.5.5 causes these features to go away. Workarounds at this point are to store off the application and re-install it. Or to pay $300 for the official solution. Whichever.
Additional routing-related helper methods
It can be useful to create helper methods designed to extend the routing helpers offered by routes.rb.. power “_path” and “_url” methods. While the easy solution is to define these methods in your view helper layer (the most common client of these methods), a more complete solution is to use a pattern like this:
ActionController::Routing::Routes.draw do |map|
... normal routes ...
Any methods added to ActionController::Routing::Helpers will be available in all of the same places that named routes are defined – controllers, views, and ActionController::UrlWriter includers.
Testing Flash in Selenium
Most Flash applications render an inline image in addition to the Flash itself. This image updates as the Flash updates, and appears to be used for caching purposes.
When you’re test-driving, you can make assertions about when this inline image updates to test Flash behavior. The image is binary, so it’s hard to make assertions about exactly what has changed.. but it’s a start.
When you specify a gem from a custom source, and it has dependencies on a separate source, you need to list both sources in geminstaller.yml.
This comes up when you are installing a gem from github and that gem depends on other gems from rubyforge. You can specify multiple sources by adding more –source attributes.
Ask for Help
When using a namespaced controller, it’s hard to get url_for to work with it. Why is that?
The controller option for url_for attempts to apply the namespace of whatever controller context it’s inside. So if you have an Admin::MyController class, here’s what you would need to do for url_fors to this controller:
Most of us now avoid using url_for-style hashes for our links and URL references. Named routes are a lot more dependable.
It is possible to generate a namespaced URL from a model reference, if you are careful.
- This approach assumes that your controller class names correspond to your model class names.
If your model is @model, and your controller is Admin::ModelsController, you can use a helper like the following:
form_for [:admin, @model] do |f| ... end
This approach can limit your design, if you rely too heavily on this convention.
How to read your class’s name
While working with the UltraSphinx plugin, Davis and Brandon learned that Class.name didn’t always give them the right results. Some of their classes had a class method override what Class.name returned.
Class.class_name came closer, but returns the base class for STI (single table inheritance) classes.
Class.to_s was their most reliable option.
Testing your app on both MySQL and PostGRES
David S. is working on a plugin that allows you to test your environment on multiple databases. Since we’re starting to have more projects using PostGRES, we’re uncovering situations where some of our common code makes too many assumptions about running on MySQL.
A couple of projects ran into mysterious issues where some of their namespaced controller classes would not load when run from rake.
The culprit was that their namespace module names were the same name as their app models. The lesson – never have a module with the same name as one of your other unrelated classes. (No, I’m not talking about inner classes, which can be fine).
A prime example of this is an Admin::* namespace coexisting with an Admin model. This will cause strange problems depending on what order the classes are loaded. One recommendation is to pluralize your namespaces. In this case, your namespace would be Admins::*.
Another suggestion would be to use an extended noun form for your namespace (Administration::*). Whatever convention you use, stick to it and avoid name collisions.
Ask for Help
David and Jonathan are having trouble with testing namespaced controllers using RSpec. They have two controllers, Admin::MyController and SuperUser::MyController, and the RSpec tests appear to be finding the wrong controller.
Their short-term solution is to put a manual require in the spec that was getting confused.
UPDATE – The issue turns out to be a naming conflict. The app has a model named SuperUser, and the existence of this model can cause class loading to be confused for SuperUser::* controllers. In Socialitis, our standard is to use plural names for controller namespace names, to prevent this sort of confusion.
Steve has learned that, in general, it’s a good idea to avoid using offsets when manipulating large quantities of data in MySQL. Luckily, some of MySQL’s quirks help with this:
- MySQL sorts indexes. The primary key is the main index that it sorts.
- Any select without an explicit order clause will pick an index, then return data in sorted order by that index. Again, usually you’ll see the primary key first.
You can take advantage of this behavior to paginate through a large dataset where the order doesn’t really matter. The following statements perform better than your typical LIMIT/OFFSET clause:
SELECT * FROM big_table WHERE id > 1 LIMIT 1000
SELECT * FROM big_table WHERE id > 1000 LIMIT 1000
SELECT * FROM big_table WHERE id > 2000 LIMIT 1000
acts_as_solr uses this technique for reindexing.
- Also, inserting a record in the middle of an id ‘hole’ is not a very good idea in MySQL, because the database then puts a great deal of work into reordering all of the later records.
Here’s a link to a related blog post: