Here’s how you can make the change, on the fly, inside of your rake task:

task :swimming_pool => :environment do
  ActiveRecord::Base.connection_pool.instance_variable_set('@size', 15)
  ActiveRecord::Base.connection_pool.instance_variable_set('@timeout', 10)
  # Do awesome threaded stuff here
end

The first line of the rake task increases your pool size and the second line changes your timeout when waiting for a connection from the pool. You can adjust those values to whatever you need. That just happened to be what I need for this particular task.

The only real “feature” is that it will now handle full names just fine. Otherwise, the rest of the stuff was mostly performance related.  Here it is:

class String
  # Extension of the string class to properly handle camel names
  def nameize
    if self.match(/ /)
      # If the name has a space in it, we gotta run the parts through the nameizer.
      name = self.split(' ').each { |part| part.nameize! }.join(' ')
      return name
    elsif self.match(/^[A-Z]/)
      # If they took the time to capitalize their name then let's just jump out.
      return self
    else
      # If there are no spaces and there is no prior
      # capitalization then let's downcase the whole thing.
      name = self.downcase
    end
    # Let's now assume that they were lazy...
    return case
    when name.match(/^mac/)
      name.gsub(/^mac/, "").capitalize.insert(0, "Mac")
    when name.match(/^mc/)
      name.gsub(/^mc/, "").capitalize.insert(0, "Mc")
    when name.match(/^o\'/)
      name.split("'").each{ |piece| piece.capitalize! }.join("'")
    else
      name.capitalize # name is a first name or it's not Irish then capitalize it.
    end
  end

  def nameize!
    replace nameize # BANG!
  end

end

As always – question, comments, suggestions – shoot me an email, leave a comment, or hit me on Twitter (@PatrickTulskie).

Yeah it’s great, except this Friday it didn’t happen.  Thanksgiving weekend happened instead so we pushed it to Monday.  Being the silly goose I am, I decided to get a new Macbook on Black Friday.  I restored my stuff from Time Machine, installed my Ruby Gems, and thought all was well.  Monday morning, my turn to present code came up and there was a problem with screen sharing.  Crap.  All of my code is in a git branch that is not pushed to a server yet and the time it would have taken to get to a state where we could present it from another machine would have been too much so we postponed my review until my screen sharing would work.  This was most displeasing to me.

How To Handle It Next Time.

As of late, there has been a lot of talk about bonjour in the ruby world.  There are a lot of really awesome applications that use the technology.  Take for example, gitjour.  It takes an existing git repository and makes it available to machines on the local network through bonjour.  All they would need is the gem and to type “gitjour list” in a terminal window to see what’s available.  That’s badass.

So if we had to rewind to Monday morning, what we should have done is take a functioning machine on the local network and had that person do a clone of my repository to a new working directory and then we could have screen shared that.  It would have taken a fraction of the time that it would have taken to push it to the server with my own local branch, tell someone to get a copy of my branch from the server and what branch to take.  Gitjour would have cut out all of the steps and it would have been quicker since it’s on the local network.

This thought alone makes me want to dive deeper into bonjour and figure out how to use it for various things.  If you have any good resources, post them in the comments or hit me up on Twitter. (http://twitter.com/patricktulskie)

What Was The Screen Sharing Problem?

Turns out iChat 4.0.5 doesn’t know how to view the screen of someone with iChat 4.0.6.  The new Macbook comes with 4.0.6 by default and there is no easy way to upgrade to it.  I downgraded to 4.0.2 from my Blackbook and now all is well.

WARNING: You’re using the Ruby-based MySQL library that ships with Rails. This library is not suited for production. Please install the C-based MySQL library instead (gem install mysql).

Normally I don’t care, but I figured since I was doing some cleanup today and getting things ready to move on to a longer term it might be good to have a properly working MySQL gem.  I like to run with a system that is close to what we run production.  The closer you get, the less surprises you have when you push it live.

More Fixing.  Less Talking.

Damn you’re so pushy sometimes.  Anyhow.  I did a sudo gem install mysql and got another damn error.

Building native extensions.  This could take a while...
ERROR:  Error installing mysql:
ERROR: Failed to build gem native extension.

/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby extconf.rb install mysql
checking for mysql_query() in -lmysqlclient... no
checking for main() in -lm... yes
checking for mysql_query() in -lmysqlclient... no
checking for main() in -lz... yes
checking for mysql_query() in -lmysqlclient... no
checking for main() in -lsocket... no
checking for mysql_query() in -lmysqlclient... no
checking for main() in -lnsl... no
checking for mysql_query() in -lmysqlclient... no
*** extconf.rb failed ***
Could not create Makefile due to some reason, probably lack of
necessary libraries and/or headers.  Check the mkmf.log file for more
details.  You may need configuration options.

Oh good.  Another error.  Perfect.  I searched around the interwebs and someone suggested using “–with-mysql-lib=/usr/local/mysql/lib” in the options since that’s where the libraries are located.  It still barfed on me with that.

A Solution Please.

A few more minutes of hunting and pecking and I found the golden command:

sudo gem install mysql -- --with-mysql-config
Building native extensions.  This could take a while...
Successfully installed mysql-2.7
1 gem installed

Now I don’t have any errors when starting my rails applications that use MySQL and I’m closer to what I have in production.

class String
  # Extension of the string class to properly handle camel names
  # Should be used on pieces of names, not full names.
  def nameize
    # If they took the time to capitalize their name then let's just jump out
    if self.match(/\A[A-Z]/)
      return self
    else
      name = self.downcase
    end
    # Let's now assume that they were lazy...
    return case
    when name.match(/^mac/)
      name.capitalize.gsub(/Mac/, "").capitalize.insert(0, "Mac")
    when name.match(/^mc/)
      name.capitalize.gsub(/Mc/, "").capitalize.insert(0, "Mc")
    when name.match(/^o\'/)
      name.split("'").each{ |piece| piece.capitalize! }.join("'")
    else
      name.capitalize
    end
  end
end

I know it’s not perfect, but it should handle most oddly capitalized names.  Let me know what you think in the comments or on Twitter or whatever and definitely give me any changes you think should be in there.

…

So what if I started off my post with a pun?  Look you’re just going to have to deal with it.  Let’s move on.  No stop it with the face, it’s my blog and I can do what I want.

Anyhow – REST is one of those things I hear a lot of people talk about as if it is this big mystery.  Then, when you finally find someone to explain it, it turns out they have never actually used it and only understand the theory.  It’s so frustrating to the beginning Ruby on Rails developer because not everyone has a mini David Hansson in their pocket and it really is one of those things you need to see to understand.

Ok Patrick.  I’ll bite.  Let’s hear more about this.

It’s a really simple concept that I will explain abstractly at first and then I want you to forget what I said until I compare it to what you’ve probably already seen.  REST stands for Representational State Transfer.  Technically speaking, REST should be RST but since Roy Fielding coined the term in the year 2000 and he’s kind of a big deal, people tend to stick with his acronym.

The theory behind it is that your destination |object| is nothing more than a representation of that object at the time you are viewing it.  This plays extremely well into a MVC framework like Ruby on Rails since your controllers and models handle the object and the view is just how you see the object at a given point in time.  Then in the URL, you would just be using nouns to describe what you’re getting.  Sorta like this:

http://yourdomain.com/noun1/…/your_object_name

That makes no sense.

I know.  Look, it’s actually really simple.

Ok so say I have a web application that you would like to pull data from in order to handle however you’d like with a separate application you are creating.  An example might be a news site – they provide for you an RSS feed that.  The data is all the same server side but how your web browser sees it is different from how your RSS feed reader sees it so the object (the data) needs to change its form to be readable to the current application.  With me so far?

If I wrote my web application to be RESTful then your application could request the data in RSS or XML or whatever form you prefer to parse, all while maintaining a normal user’s view in their web browser.  Ah ha!  So we’re no longer web page builders – we’re data providers.  You’re now actually building page templates and writing more code to handle your data.

I’m still a little unsure about this Patrick.

I was too, so I sat down and tried it.

On my side project – www.Twexaminer.com – I made sure that my controller was pulling data from twitter and storing it into objects instead of just “building a page.”  From there I created 2 views.  One is the default HTML view that you see when you view the page from a web browser and the other is a special .xml request that gives you the output of all of the data that the application has collected.

Ex:
http://www.twexaminer.com/examiner/result/patricktulskie
-vs-
http://www.twexaminer.com/examiner/result/patricktulskie.xml

Basically I’m going to my examiner and saying “hey, give me a result” and then clarifying that it should be PatrickTulskie.  In the second example there I tell the examiner to give me the result of PatrickTulskie in XML format.

I could further expand this to make more views or representations for the same data, but for the time being I just have the 2.  In this way, I am now passing on the content using standard looking URLs that a common person can understand.  In addition, if you want to parse the data easily, there is a very intuitive way to get the data without the formatting fluff.  I am effectively passing data to your app, without the use of SOAP or any special hacks, in a format it understands just with a simple GET.  Ah ha!  Simple!

Ok now if I wanted to get fancier then I could add something to my examiner controller to handle updating of a cached result so it would look something like this… in pseudo code…

pt_object = new RestResource(http://www.twexaminer.com/examiner/result/patricktulskie)
pt_object.update

…and then pull off data from that.  This would all be handled through HTTP requests though without needing any additional layers to handle transferring XML to and from client and server.  RestResource is a hypothetical object that one could create that has a simple XML parser to make an easy to use hash out of the data.  XML parsing and generation is easy in Ruby so this just makes sense.

Ah so this is pretty sweet.

Yeah. I know.  It makes things much simpler when you’re creating something that uses my data now doesn’t it?  Go, play with it in your project and let me know what you think in the comments or on Twitter, or through email, or through facebook… or whatever.  Just make sure I get the “comment” you’re trying to convey through some medium.

The Problem – Why You Should Care

Other sites that you pull content from are not always going to be reliable.  They could be down, running slow, or some other possible problem.  If you are using something like twitter to display your status on your site but you have a lot of other content you want people to see then it would be wise to use client-side scripting to get the content.  You might be saying in your head “Oh but I have this sweet PHP script that does that for me.” but you should tell that voice in your head to shut up and just listen.

The Solution…

When you use server-side scripting then the server that is dishing out your website needs to go to the other (possibly) slow website.  If it’s waiting for this content then your user is waiting for your site to finish being generated server side and then sent to their browser.  This was a problem when twitter was doing its thing with the “fail whale” on a regular basis and was generally taking forever to display tweets.  This in turn was making my site very slow.  Realizing the problem, I took out the PHP widget that I had and replaced it with my own little creation that utilizes javascript and a tiny bit of PHP.

Let’s take a look at how to do that…

First thing you’re going to want to do is make a little div with some static text in it that gets killed when your stuff finishes loading.  You can make it kinda like this:

<div id=”twit_text”>
<ul id=”twitter_update_list”><li>Waiting for Twitter.com to reply.  Please hold.</li></ul>
</div>

The ul in there will be replaced by the script which actually sits right on twitter’s servers.  This is pretty simple and basic stuff.  It is advisable to put some static content in there so that users know that something else is going to happen and you don’t have a blank spot on the page.  There is one other piece of magic that actually uses a little bit of PHP but not for the same purpose the other scripts use it for…

<?
$currURL = currPageURL();

if (($currURL == “http://www.patricktulskie.com/”) || ($currURL == “http://patricktulskie.com/”))
{
echo “<script type=\”text/javascript\” src=\”http://twitter.com/javascripts/blogger.js\”></script>”;
echo “<script type=\”text/javascript\” src=\”http://twitter.com/statuses/user_timeline/PatrickTulskie.json?callback=twitterCallback2&count=1\”></script>”;
}
?>

This goes in the footer of the page to only load the javascript if the page you’re looking at is the index page.  You can modify the PHP to load on different pages but for my purposes I only want you to see the status on the index.  You can’t easily do this with a plugin because plugins are loaded entirely as the page loads.  The PHP above is in the very footer of the page and it only kicks off the javascript IF we’re on the index of the site AND after everything else on the page has already loaded.

One Other Thing…

I use this function to get the URL of the page.  You can put it in your wordpress theme’s functions or you can put it wherever you need it on your site.  It’s fairly reusable too.

function currPageURL()
{
$pageURL = ‘http’;
if ($_SERVER["HTTPS"] == “on”) {$pageURL .= “s”;}
$pageURL .= “://”;
if ($_SERVER["SERVER_PORT"] != “80″)
{
$pageURL .= $_SERVER["SERVER_NAME"].”:”.$_SERVER["SERVER_PORT"].$_SERVER["REQUEST_URI"];
}
else
{
$pageURL .= $_SERVER["SERVER_NAME"].$_SERVER["REQUEST_URI"];
}
return $pageURL;
}

I Hate Twitter

Well thats fine.  I’m sure it doesn’t like you much either.  Regardless, this is a really basic usability concept that many people don’t seem to grasp or even think about when creating a website.  Say you want to pull news feeds from a Digg category using an RSS parser on your page.  You have other stuff on the page but this Digg box is in your sidebar.  If you don’t think about where the script is going to execute in relation to your page loading, then you’re going to have problems when Digg is running slow or is down.  For those of you who don’t want to get into a full blown ajax setup, or simply don’t know how to then this is a great work around that uses really minimal coding.

Today we’re going to beat up on certain gallery pages that use images of the format “imageName.sized.jpg”.  What I mean by this is – we’re going to take the page (which is usually filled with junk) and replace everything with just the full size image and the caption.

Let’s get some assumptions out of the way:
You know SOME Java Script, the site you’re visiting also has the non-sized images in the same directory as the sized images, and you don’t care what else is on the web page.  We’re also assuming there is only one caption with no “id” and we only have a style class to work with.

Ok?  Ok.  Let’s go.

Once you’ve installed GreaseMonkey, set it up, and got it going then you’ll want to make a new user script.  The namespace isn’t terribly important right now so just make it the URL for your website or something like that and continue on.  Once you’ve specified your edittor of choice, it will open up and you’ll basically have a blank canvas to work with.  The code you enter here will be run when the page is completed.  First thing we’re going to do is get the caption with this code:

function getCaption()
{
var all = document.all ? document.all :
document.getElementsByTagName(’p');
var theCaption;
for (var e = 0; e < all.length; e++)
{
if (all[e].className == “pcaption”)
{
theCaption = all[e];
}
}
return theCaption;
}

What we’re doing there is grabbing all of the elements of the document that are paragraphs (p tags) and then looping through until we find that “pcaption” class.  You might need to look at the gallery you’re visiting to get the exact names but that’s the basic gist of it.  Now let’s grab the image and replace the page with it and our caption:

var theImage, unSizedImage, unSizedPath;
theImage = document.getElementById(’galleryImage’);
theCaption = getCaption();

if (theImage)
{
unSizedPath = theImage.src.replace(/.sized/,”");
unSizedImage = document.createElement(’img’);
unSizedImage.src = unSizedPath;
document.body.innerHTML = “<center>” + theCaption.innerHTML + “<br /><img src=\”" + unSizedImage.src + “\” /></center>”;
}

First we just create some variables and get our caption from before.  Once we have that all setup we say if you find an image with the id of “galleryImage” then we’re gonna do some work.   We grab the src for the image, strip out the .sized portion, and then assign that source to a new blank set of image tags.  Lastly we take the body’s innerHTML and assign it our caption’s innerHTML and our newly grabbed image.

In this little exercise we learned how to totally modify the contents of a page with a new image from “somewhere else.”  We also learned how to get a set of tags using the class for instances where we don’t have an id.  We also did some very basic string replacing and innerHTML utilization and manipulation.  Pretty cool huh?

Now you can toy with it anyway you want.  There’s a lot of fun stuff in there.  For more Grease Monkey tutorials and guides you can visit http://diveintogreasemonkey.org/  Have something you’re looking to accomplish?  Well, just comment to this post with a suggestion.

Note: Wordpress is really awesome at stripping out whitespace from stuff.  Sorry about the poor code formatting as a result.  I will be looking into a better way to display this stuff so it doesn’t happen in the future.