ones zeros majors and minors

I Love Labels

2010-08-11T00:00:00-07:00

I really love when checkbox labels are done properly.

To see what I mean click on this checkbox's text label ("Click Me!"):

Click Me!

<input type="checkbox"> Click Me!

Nothing happened, right? Right.

Now click on this checkbox's text label:

Click Me!

<label><input type="checkbox"> Click Me!</label>

Yep, awesome. Here's another way to do it (in case your <label> and <input> tags are far apart):

Click Me!

<input type="checkbox" id="ckbx"> <label for=ckbx">Click Me!</label>

do it like rake

2010-07-22T00:00:00-07:00

If you must require RubyGems in your Ruby library, do it like Rake:

begin
  require 'rake'
rescue LoadError
  require 'rubygems'
  require 'rake'
end

Everyone wins.

Managing Expectations

2010-07-21T00:00:00-07:00

If you look on Cultured Code's Arrivals page, you'll see something like this:

This is a very tempting thing for small companies to do. You want your customers to know that you're working on something they want.

But ultimately, it's a bad idea. When Cloud Sync launches, I'll think, "Finally." If I didn't know they were working on it, I'd think, "Oh, Cloud Sync! Finally! Sweet!"

That is, when it's released my thoughts will focus on how long it's been on their Arrivals board. I won't think about all the awesome stuff they released in the meantime, some of which may have been more valuable than Cloud Sync.

Under promise, over deliver.

Slightly Obtrusive JavaScript

2010-05-31T00:00:00-07:00

There are good things and bad things about "Unobtrustive JavaScript." One bad thing: it's hard to tell what JavaScript is touching an element.

Idea: Only ever use classes and ids prefix with js- when touching the DOM with JavaScript.

For example:

<a href="#prices class="js-open-tab">Prices</a>

Now we know to look for any JavaScript touching .js-open-tab, which should only be a simple search away.

And hey, now JavaScript and CSS won't share selectors. Since we're separating our content and presentation, we might as well separate our behavior all the way too.

We could also use FireQuery, though it only works with one JavaScript library in one browser, and not with $.fn.live(). Though I do love it.

Higher Order Mustache

2010-04-27T00:00:00-07:00

On the GitHub East Coast tour a few weeks ago Tom Preston-Werner and I were trying to figure out a solution to what I saw as the Final Mustache Problem: caching.

In ERB you might do this:

<% cache "user:#{current_user.id}" do %>
  Some expensive stuff.
<% end %>

At GitHub we do a fair amount of HTML caching this way. Without this feature, we couldn't start porting the site to Mustache. Solving this problem would probably let us implement syntax highlighting and other similar concepts in Mustache, too.

Here's what we got: Higher Order Sections.

How? If the value of cache_by_user_id is a lambda or function, Mustache will pass the unrendered block of text to it. The block can then do whatever it wants and its return value replaces the block.

Here's how we might do caching in Ruby:

class MyView < Mustache
  def cache_by_user_id
    lambda do |text|
      cache_key = "user:#{current_user.id}"

      if value = $cache.get(cache_key)
        value
      else
        rendered = render(text)
        $cache.set(cache_key, rendered)
        rendered
      end
    end
  end
end

The lambda is passed the raw template text. If we find something in the cache, we return that and it replaces the block. If we don't find anything in the cache we render the block, store it in the cache, then return it.

Examples

I opened sourced the mustache-syntax-highlighter recently, and also created a Gist of a Markdown helper we're using. Both are Higher Order Sections in action.

Bonus: both mustache.rb and mustache.js already support this feature.

JavaScript Style

2010-04-01T00:00:00-07:00

I know that when you write Ruby or Python, you use under_scored method names and CamelCase class names. But JavaScript isn't Ruby or Python.

Consider:

In browsers, all methods are camelCase.
In node.js's standard library, all methods are camelCase.
In commonjs, all methods are camelCase.
In jQuery, all methods are camelCase.
In MooTools, all methods are camelCase.
In Prototype, all method are camelCase.
In YUI, all method are camelCase.
In JavaScript: The Good Parts, all methods are camelCase.

I'm not saying you must write JavaScript a certain way. Do what makes you the most comfortable, write code that is fun to write. But if you're trying to figure out what everyone else is doing, they're doing camelCase.

Mustache 0.9.0

2010-03-26T00:00:00-07:00

I'm very happy to announce Mustache 0.9.0, probably the most major release so far. Sinatra 1.0, new parser, bugfixes, and more!

Grab it:

gem install mustache

Or check http://defunkt.github.com/mustache/ for other implementations.

Sinatra 1.0

The release of Sinatra 1.0 changed the way templates are rendered. As such, previous versions of Mustache use an old API and won't work with it.

If you're upgrading from Mustache 0.7.0 or lower please note that the settings have changed very slightly. This diff is an example of one app I upgraded to Sinatra 1.0 + Mustache 0.9 -- pretty painless, and the settings all have better names (finally).

Anyway, Mustache 0.9.0 works great with Sinatra 1.0 and even provides some big improvements:

Caching

The first time a Mustache template is rendered it is compiled into pure Ruby and cached, even if there's no associated view class. Subsequent calls use the cached version which completely bypasses the parsing and generating stages.

Overriding Content in Layouts

Previously there was no easy way to change the layout from a view class. Take this layout.mustache:

And these views:

class Layout < Mustache
  def title
    "layout"
  end
end

class Index < Layout
  def title
    "index"
  end
end

You'd expect it to work, and you'd hope it would work, but it would not. Now it does. Just make sure your views inherit from your layout and everything will be dandy.

Syntax Errors

More syntax errors are caught and the error messages are much more helpful thanks to the new parser (more on that below).

For example, here's a broken template:

And here's what we get trying to tokenize it:

Or take this broken template:

Again, helpful output:

Tag names are a bit more strict as they more closely resemble allowed Ruby method names, with a few exceptions. If you have a big problem with this please file an issue.

New Parser

Magnus Holm has once again torn Mustache's parser apart and rebuilt it into something beautiful. This time it's an entirely new scanner and generator.

Mustache used to loop through a template looking for regular expressions and building up a compiled Ruby string along the way. As a result we had some obscure bugs in nested sections and whatnot. The new parser uses Ruby's StringScanner to intelligently build an array of tokens from a string template.

Using the mustache command line utility we can see exactly what Mustache::Parser returns for a given template:

Pretty neat. Internally this token stream is handed to Mustache::Generator who compiles it into a Ruby string:

$ mustache -c hi.mustache
"#{if v = ctx[:greet?]
    if v == true
      "Hello #{CGI.escapeHTML(ctx[:name].to_s)}!"
    else
      v = [v] unless v.is_a?(Array) # shortcut when passed non-array
      v.map { |h|
        ctx.push(h)
        r = "Hello #{CGI.escapeHTML(ctx[:name].to_s)}!"
        ctx.pop
        r }.join
    end
  end}"

This compiled string is the actual code run in your app to produce HTML output. Fun to look at but mostly useless unless you're familiar with Mustache's internals.

Bugfixes

Recursive partials, nested sections with names matching outer sections, and other bugs are now fixed. Many bugs were fixed by the new parser.

Speedup

When we started to allow Ruby objects to server as section contexts, the implementation slowed down Mustache dramatically. That's been fixed and things are (when compiled and cached) once again speedy.

Mustache 1.0

This release would be 1.0 but there's no Rails integration. That's next on the list - see you then.

ARGF

2010-03-13T00:00:00-08:00

Today Ruby gave me a birthday present: ARGF. If you write a lot of shell scripts you're gonna love it.

To demonstrate we'll write rcat, a dumbed down version of cat(1), in Ruby. But first let's examine some of cat's basic functionality using one.txt and two.txt.

$ echo 'File one!' > one.txt
$ echo 'File two :(' > two.txt

Printing a single file:

$ cat one.txt
File one!

Printing multiple files:

$ cat one.txt two.txt
File one!
File two :(

Mixing files and streams:

$ cat - two.txt < one.txt
File one!
File two :(

Okay. And rcat?

$ rcat one.txt
File one!

$ rcat one.txt two.txt
File one!
File two :(

$ rcat - two.txt < one.txt
File one!
File two :(

Great! So, how's rcat work?

$ rcat rcat
#!/usr/bin/env ruby
puts ARGF.read

Gorgeous. From the docs:

The global constant ARGF (also accessible as $<) provides an IO-like stream which allows access to all files mentioned on the command line (or STDIN if no files are mentioned). ARGF provides the methods #path and #filename to access the name of the file currently being read.

I've just rewritten mustache(1) to use ARGF. Less code, more functionality - what else could you want for your birthday? Thanks Ruby!

gem man fork

2010-03-11T00:00:00-08:00

Want to install gem-man(1) and forget about it? You can. Add this to your ~/.bash_profile or whatever after installing 0.2.0:

alias man='gem man -s'

Now:

$ man 5 mustache
$ man fork
$ man grep

And, of course:

$ man gem-man

man what

2010-03-08T00:00:00-08:00

Everyone loves having instant access to documentation. This is one of the things Cheat does really well: just type cheat git and you've got a git cheat sheet in your terminal. Or in your editor, whatever. It's cool stuff.

Well, man pages do the same thing. For instance, I've installed node.js via homebrew which means I can type man node at any time to see the docs to the entire node.js standard library. Seriously. Thanks mxcl and ryah.

In Emacs I can hit M-x man to pull up any man page. Vim has a plugin and so does TextMate.

If you're using a tool that came with your OS, you can bet there's a man page for it. Unicorn has a great one, so does ack. And if you've installed cmatrix, which I hope you have, it has one too.

It's the way Unix documents things, and it's already really easy for you to access. man pages are worth understanding.

What's a man page?

Wikipedia says:

Man pages (short for manual pages) are the extensive documentation that comes preinstalled with almost all substantial Unix and Unix-like operating systems. The Unix command used to display them is man. Each page is a self-contained document.

You can see one by going to your terminal and typing:

$ man grep

Or, naturally, man man.

On some systems like Debian, every program is required to come with a man page. I don't know if the same is true for OS X, but all the Mac-specific commands I've used have man pages. For example:

$ man pbcopy

Same for launchctl, say, and more.

Man pages are a great way to learn about a piece of software. Try man grep or check out man strftime. Yes, C functions have man pages too.

What do the sections mean?

man pages are broken into sections:

General commands
System calls
C library functions
Special files (usually devices, those found in /dev) and drivers
File formats and conventions
Games and screensavers
Miscellanea
System administration commands and daemons

This means we can have markdown(1) and markdown(5), two man pages with the same name that live in different sections. One is a man page describing a command, typing markdown in your shell, and one is a man page describing the Markdown file format. Like what you'd read on Gruber's Markdown page.

You can specify which you'd like to view like so:

$ man 1 markdown
$ man 5 markdown

How do you find man pages?

You can use apropos on many systems to search for man pages matching a string:

$ apropos ruby
macruby(1), ruby(1)      - Interpreted object-oriented scripting language
cap(1)                   - Ruby on Rails web applications deployment utility
gem(1)                   - RubyGems program
irb(1), erb(1), ri(1), rdoc(1), testrb(1) - Ruby helper programs
mongrel_rails(1)         - Fast HTTP library and server for Ruby
rake(1)                  - Ruby Make
ruby(1)                  - Interpreted object-oriented scripting
language

There are also at least five iPhone apps dedicated to man pages, all of which cost money:

If you're using Ruby, you can discover man pages that RubyGems you've installed contain by installing gem-man and using --all:

$ gem install gem-man
$ gem man --all
These gems have man pages:

ronn 0.4.1
unicorn 0.97.0
unicorn 0.96.0
gem-man 0.1.3
mustache 0.6.0

And then:

$ gem man 1 mustache

Sweet. There's also Richard Crowley's alias man trick.

How do you write man pages?

man pages are written in a funky macro language as part of a typesetting system called roff, which dates back to around 1973. That is, according to man roff. Anyway, it's nasty - you can look at mustache.1 for an example. You don't wanna write it by hand.

It's much easier to let a computer generate this markup for us, just like how we let Markdown generate HTML. As far as I know there are two excellent tools you can use to author man pages.

AsciiDoc

Git and Unicorn use AsciiDoc. The Passenger guys do, too. It can generate both HTML and man pages from quite readable text files.

In fact, check this out: I grabbed ParseTree's spartan yet extremely readable README.txt and ran it through asciidoc:

Tasty.

You can grab AsciiDoc with:

$ brew install asciidoc

or by any of the methods documented on their Installation page.

It, naturally, has a man page: man asciidoc once you've got it installed.

ronn

Personally, I like to use Ryan Tomayko's ronn. If you have RubyGems:

$ gem install ronn

Now run it on any README.markdown. I'll try it on Resque's:

$ ronn -b5 README.markdown

Gorgeous.

It looks even better when passed something in the Markdown derived ronn(5) format:

Here are some I've published:

Others

Perl has Pod - I can man Apache2::Const and see a different yet familiar face, presumably a man page generated by pod2man, which is neat.

Ruby also has rtfm, a gem for building man pages in Ruby.

Then there's Doxygen, and probably many more.

How do you publish man pages?

For generating them, I use these rake tasks. You might also want to look at Richard Crowley's manskeleton.

For HTML I like to use GitHub Pages. It's pretty easy to write a Rake task or something that generates a man page's HTML and publishes it to your gh-pages branch. I pretty much do it in all my projects - I'm sure many others do the same.

Many packaging systems support files in man/file.section or man/manSECTION/file.SECTION format. For example, manskeleton's man pages or mustache's.

When you install a Debian or homebrew package, any man pages get installed automatically. This means if you package man pages users will magically get them, and everyone wins.

So let's do that.

Manuals of Interest

Finally, some manuals of interest:

man fork
man bash
man zsh
man curl
man httpd
man 5 crontab
man netcat
man gist
man hub
man git-rebase
gem man 7 ronn
gem man unicorn

coffee-mode

2010-03-07T00:00:00-08:00

I've fallen in love with CoffeeScript.

It's the best parts of my three favorite languages (JavaScript, Ruby, and Python) rolled into one. It runs on node.js, compiles to surprisingly readable JavaScript, has great documentation, and is written in itself.

Yes, CoffeeScript is written in CoffeeScript. Check the source code or the beautiful internals documentation.

You can use it on the server with node.js (or, presumably, any CommonJS compatible process), or you can use it in the browser.

Deployment? When you bundle your JavaScript, compile your CoffeeScript and include it. In development mode use something like rack-coffee to have your CoffeeScript automatically compiled and served to the browser - no work on your part.

There's a Vim plugin, a TextMate bundle, and, now, an Emacs mode.

Say hello to coffee-mode.

coffee-mode: An Emacs major mode for CoffeeScript.

It does all the things you want it to.

Syntax Highlighting
imenu support (for ⇧⌘T in textmate.el)
customize-group support
Comment support (alt-; and ⌘; for me)
Indentation using tab-width
"Smart" indentation (e.g. hitting RET after a -> will indent you properly)
Menu Bar with links to the documentation for CoffeeScript and node.js.
Compiles CoffeeScript

A Note on Compilation

If you're using Aquamacs, ⌘r should compile the current coffee-mode buffer and open the resulting JavaScript in a new buffer using js2-mode. You can customize the mode used to open JavaScript by overriding coffee-js-mode and you can override the key combo by adding this to the coffee-mode-hook like so:

(defun coffee-custom ()
  "coffee-mode-hook"

  ;; Emacs key binding
  (define-key coffee-mode-map [(meta r)] 'coffee-compile-buffer))

(add-hook 'coffee-mode-hook '(lambda () (coffee-custom)))

Make sure you have CoffeeScript 0.5.4 or higher, or change your coffee-command and coffee-args-compile variables to whatever you know works.

Why is this worth pointing out? Because it means you can hit a single key and see the compiled JavaScript in your editor, which is just great:

Installation

In your shell:

$ cd ~/.emacs.d/vendor
$ git clone git://github.com/defunkt/coffee-mode.git

In your emacs config:

(add-to-list 'load-path "~/.emacs.d/vendor/coffee-mode")
(require 'coffee-mode)

If coffee-mode is not enabled automatically for any files ending in ".coffee" or named "Cakefile", add this to your emacs config as well:

(add-to-list 'auto-mode-alist '("\\.coffee$" . coffee-mode))
(add-to-list 'auto-mode-alist '("Cakefile" . coffee-mode))

Bugs http://github.com/defunkt/coffee-mode/issues

Source http://github.com/defunkt/coffee-mode

Enjoy.

Code Bloggin' at Gist

2010-03-01T00:00:00-08:00

http://gist.github.com/defunkt, in case you missed it.

gist(1)

2010-02-28T00:00:00-08:00

I just updated the command line gist script with a few patches, cleaner code, a RubyGem, and a man page. The updated version should hit homebrew soon, too.

In a nutshell:

$ gem install gist
$ gist -h
$ gist -m
$ gist script.py
$ echo "puts :hi" | gist -t rb

Enjoy.

Load Paths

2010-02-19T00:00:00-08:00

If your import is failing in Python or your require can't locate a Ruby file, here is how to find the load path in each language:

Python:

$ python
>>> import sys
>>> sys.path
['', '/usr/lib/python2.5', '/usr/lib/python2. ...]

Ruby:

$ irb
>> $LOAD_PATH
=> ["/usr/local/lib/site_ruby/1.8", "/usr/local ...]

These should help you debug load errors, especially if you're new to either language.

hub + zsh

2010-02-17T00:00:00-08:00

hub never seemed to play nicely with git's autocompletion in zshell. Until now.

$ resque git:(master) git log v0.2.0
v0.1.0  [v0.2.0]  v1.0.0  v1.1.0  v1.2.0  v1.2.1  v1.2.2  v1.2.3

How? After installing hub just run this:

$ hub alias -s zsh >> ~/.zshrc

Of course, you can always use hub without aliasing it to git. But what fun is that?

Pystache 0.2.0

2010-02-15T00:00:00-08:00

I just pushed Pystache 0.2.0 to Pypi.

Check the compare view for changes.

I hope to have a language agnostic "Mustache Guide" ready in the next few weeks. Keep an eye out!

hub updater

2010-02-13T00:00:00-08:00

Hub 0.3.1 is out. Grab it with hub-update:

Haml + Mustache

2010-02-12T00:00:00-08:00

Haml and Mustache are friends, not enemies.

See for yourself.

example.yml

example.haml.mustache

This is nothing new. We've covered the mustache command line utility before.

What's new is using Mustache to generate Haml, then generating HTML from that Haml:

$ cat example.yml example.haml.mustache | mustache | haml -s
<div id='content'>
  <div class='left column'>
    <h2>Welcome to our site!</h2>
  </div>
  <div class='right column'>
    <div id='users'>
      <p>chris</p>
      <p>bob</p>
      <p>jones</p>
    </div>
  </div>
</div>

Hamstache.

Resque 1.4.0

2010-02-11T00:00:00-08:00

From the HISTORY:

Fallback when unable to bind QUIT and USR1 for Windows and JRuby.
Fallback when no Kernel.fork is provided (for IronRuby).
Web: Rounded corners in Firefox
Cut down system calls in Worker#prune_dead_workers
Enable switching DB in a Redis server from config
Support USR2 and CONT to stop and start job processing.
Web: Add example failing job
Bugfix: Worker#unregister_worker shouldn't call done_working
Bugfix: Example god config now restarts Resque properly.
Multiple failure backends now permitted.

Check the compare view, too.

Upgrade:

$ gem install resque

Find Resque on Gemcutter and GitHub.

Gem Popularity

2010-02-11T00:00:00-08:00

Ever wonder how popular a RubyGem is? Gemcutter has the answer.

Rails: 323,229 downloads
rspec: 82,260 downloads
god: 13,577 downloads
shoulda: 12,726 downloads
mustache: 2,690 downloads
machinist: 4,730 downloads
delayed_job: 5,787 downloads
memcache-client: 31,851 downloads
rdiscount: 8,441 downloads
rack: 326,053 downloads
sinatra: 33,722 downloads
thin: 22,707 downloads

Jumpcut

2010-01-27T00:00:00-08:00

I can't really imagine what life was like before Jumpcut. If you're not using clipboard history, try it - it's basically one key command that will change the way you work.

Even better: Launchbar has a clipboard manager, too (which I currently use).

Hotkey Bookmarks

2010-01-27T00:00:00-08:00

Since switching to Chrome the thing I've missed most is the ⌘# hotkeys for bookmarks.

In Safari you can hit ⌘1 to open the first bookmark in your bookmark bar, ⌘2 to open the second, etc. This means you can keep your bookmark bar closed and jump to any site whose number you know pretty quickly. No clicking or extra UI required!

In Chrome, ⌘N quickly switches you to the corresponding tab in the active window. Some people love this. That's great, and they're not wrong - it's a cool feature. What's wrong is having to pick sides.

Spark is a great piece of OS X software which lets you bind key combinations to anything - Applications, AppleScript, etc.

I've bound F1, F2, F3, and F4 to AppleScripts which open the sites I want.

Here's an example:

do shell script "open https://mail.google.com/a/ozmm.org/"

No more relying on the browser of the month for this functionality. Sweetness.

Chrome Error Pages

2009-12-18T00:00:00-08:00

Why so many different styles?

2009 Open Source Top Ten

2009-12-17T00:00:00-08:00

This was an amazing year for open source software. In alphabetical order, here are my favorite releases of 2009.

BERT

Beyond playing a massive role in making GitHub fast, BERT is a textbook example of how to do open source correctly. Three well documented and tested libraries double as reference implementations for those who would implement the spec in other languages.

ClickToFlash

In only a few months it became the canonical example of distributed version control gone right: a simple Safari plugin posted on GitHub got dozens of contributors and was kept surprisingly sane and useful under the guidance of one Rentzsch.

Gemcutter

Ruby's gem ecosystem had been in a funk for a while. qrush cured it. Packed with useful features, Gemcutter actually makes it fun to publish gems again.

homebrew

It seems so obvious in retrospect: a packaging system with packages stored in git, so anyone can easily add (or maintain) a package with the same tools they use to develop software. With almost 200 contributors and nearly 400 packages as of writing, it has certainly proven the viability of this idea. It also helps that it's simple to use and works great - no longer do we dread installing or updating software on our Macs. Now it's fun.

Unicorn

The long awaited silver bullet: a Ruby web-app server that relies on proven Unix technologies to do the hard stuff and do it well. It doesn't hurt that the author is extremely responsive and a great maintainer, either.

nginx http push module

Like Unicorn, it leaves the heavy lifting of a hard problem to a proven champion: nginx's famous concurrency. The idea is so simple it's beautiful but, more importantly, the module asks an important and inevitable question: what if persistent connections to the browser were so easy that anyone with a commodity VPS could implement sites with them?

What does a Web with cheap persistent connections look like? We're going to find out soon.

node.js

node is what we were all waiting for: fast, simple, server side JavaScript. Ryan Dahl has shown us what V8 can really do. While the year of Desktop Linux may never arrive, 2010 will certainly be the Year of JavaScript thanks in no small part to node.

Redis

Redis has set the standard for open source databases: simple, sensible, and well commented default configuration file; fantastic documentation; cheat-sheet style command reference; extremely useful command line utility; easy installation; great performance; and a very attentive maintainer. Bonus points for being easy to explain and easy to use.

Underscore.js

The missing link, the "tie to go along with jQuery's tux." Even better: it's DOM free and can be used on the server side. The noConflict pattern jQuery pioneered is put to great use here and something I'd love to see more of in the future. Underscore is a good idea well executed.

yajl-ruby

JSON is the serialization format of the web. yajl-ruby makes it fast and, more importantly, streams it: yajl-ruby works great with EventMachine and even includes example code so you can quickly get started. Almost every Ruby project I touch uses JSON, and in all of them I now use yajl-ruby.

Thanks to the authors for sharing their creations with us. Now go out there and build something with them!

return early

2009-12-15T00:00:00-08:00

I often see code like this:

def logger
  unless @logger
    @logger = Logger.new(STDOUT)
    @logger.level = Logger::WARN
  end
  @logger
end

What you really want to do is return the instance variable if it's already set. So why not do that?

def logger
  return @logger if defined? @logger
  @logger = Logger.new(STDOUT)
  @logger.level = Logger::WARN
  @logger
end

Or you could cache bang it.

Cache Bang

2009-12-14T00:00:00-08:00

My favorite caching idiom:

def rankings
  # return cached data or call `rankings!`
  cache(:rankings!)
end

def rankings!
  # compute expensive rankings
end

Smoke 'em if you got 'em.

URLs in Ruby

2009-12-14T00:00:00-08:00

Last year I showed you how to turn Ruby into Java.

This year I want to show you how to write URLs in Ruby. Let's have them return their body, shall we?

For example:

>> http://github.com/defunkt.json
=> #<URLDSL::Request http://github.com/defunkt.json/>
>> puts http://github.com/defunkt.json
[{"repository":{"url":"http://github.com/defunkt/repl",
... etc ...
=> nil

Yes, amazing.

>> puts http://github.com/api/v2/yaml/repos/show/schacon/grit
---
repository:
  :url: http://github.com/schacon/grit
  :description: Grit is a Ruby library for extracting information
                from a git repository in an object oriented manner
                - this fork tries to intergrate as much pure-ruby
                functionality as possible
  :homepage: http://grit.rubyforge.org/
  :fork: true
  :open_issues: 0
  :private: false
  :name: grit
  :owner: schacon
  :watchers: 81
  :forks: 11
=> nil

Obligatory Twitter URL:

>> require 'json'
=> true
>> url = http://twitter.com/statuses/show/6592721580.json
=> #<URLDSL::Request http://twitter.com/statuses/show/6592721580.json/>
>> JSON.parse(url.to_s)['text']
=> "He nose the truth."

That's about as far as we can take it, but that's far enough.

The code: gist 255948

Enjoy.

repl

2009-12-12T00:00:00-08:00

I've been playing with redis-cli a lot this year and at one point thought, "This would be great as a simple little shell."

So, repl. It turns any basic, non-interactive program into an interactive one.

In other words, this:

$ redis-cli set name chris
OK
$ redis-cli get name
chris

Becomes this:

$ repl redis-cli
>> set name chris
OK
>> get name
chris

If you have rlwrap installed you even get the full benefits of readline: history, reverse searches, etc.

What's more, the contents of any file in ~/.repl matching the name of the command you're running will be used as a completion list. See the repl-completion project (still in its infancy) for more info.

Check out the README, manual, or just install it as a gem:

$ gem install repl -s http://gemcutter.org/

Enjoy.

CakePHP on GitHub

2009-12-10T00:00:00-08:00

CakePHP is now on GitHub. This tickles me because I created and published my first open source project on Sourceforge, Spyc in an attempt to get it included in CakePHP.

Spyc got me my first big job, which got me my first Rails job, which is where I met PJ Hyett, an eventual GitHub co-founder.

So, thanks CakePHP. And welcome.

:nth-child

2009-11-30T00:00:00-08:00

For my new projects page, I wanted the background color of each box to change into one of six pre-selected colors on hover. I also wanted an arbitrary number of boxes, so the colors needed to repeat.

I could easily do this using a template language by giving each li a unique class then styling thoses classes, but that's lame. Instead I used CSS3's :nth-child, which works in current versions of Chrome, Safari, and Firefox.

The CSS for the first two boxes is as follows:

.row > a:nth-child(6n+1):hover {
  background-color: #FFFF00;
}

.row > a:nth-child(6n+2):hover {
  background-color: #FF0000;
}

The 6n+1 means "the first instance and every sixth instance thereafter." So 6n+2 is the second a which is a child of .row and every sixth a after that.

In this manner we also define 6n+3 through 6n+6.

If there were only four boxes, I'd have 4n+1 through 4n+4. In fact, to achieve the step-like effect with the boxes I style every first and third box differently using 4n+1 and 4n+3:

.row > a:nth-child(4n+1) {
  margin-top: 40px;
}

.row > a:nth-child(4n+3) {
  margin-top: 0;
}

Finally, I give the first a some extra padding:

.row > a:first-child {
  padding-left: 20px;
}

Which I could have written as:

.row > a:nth-child(1) {
  padding-left: 20px;
}

For more (somewhat obtuse) information, see Sitepoint's Understanding :nth-child Pseudo-class Expressions documentation.