CR should feel very familiar to Rails developers. Its interface is akin to ActiveResource and it borrows heavily from the (very good) ObjectiveResource library for the iPhone.

All basic CRUD operations are supported, and you can perform advanced finds with arbitrary parameters. A brief example of fetching a record, modifying it, and saving it:

var post = [Post find:@"42"];
[post setTitle:@"Why X is Better than Y"];
[post save];

Check out the README on the project’s page on GitHub for more details and usage examples.

Live Demo

I also created a demo application which is a simplified clone of OS X’s Address Book. The demo is live on Heroku. Check it out. The source for the demo is also on GitHub.

If you’re a Rails developer waiting for a good opportunity to try out Cappuccino, there’s no better time than now.

If you’re a Cappuccino developer looking for an easy-to-use, powerful back-end for your applications, Rails might be the answer for you.

CR is a young project, but it drives one of my client applications that is production-ready (albeit not deployed), so I believe it is ready for prime time. Please try it and let me know how it goes.

Fork, report issues, et cetera.

A Problem

I often use WordPress as a CMS and have a couple of sites with many users contributing. I rarely go a week without an email or phone call from a user who needs help posting. When it comes to remote support there is no substitute for seeing what they’re seeing.

However, if you want to login to the site with their user account you have to either ask for their password (tacky & insecure) or reset their password temporarily (amateurish & annoying).

A Solution

Say goodbye to the days of tacky, amateurish, insecure & annoying. The Skeleton Key plugin allows WordPress administrators (level 10 users) to login to the site as any user by authenticating with the user’s login and their own (administrator) password. Once logged in, you are that user. Handy, huh?

***UPDATE***
The plugin has already gotten some TLC and it is now more performant and secure. We are now requiring admins to login with their own login followed by a “+” followed by the user’s login. This will cut down on the chances of people guessing administrative passwords. In a weird, corny way the “+” is your digital skeleton key… so to login as user “joeblow” as an admin I would provide:

username = admin+joeblow
password = [the admin's password]
/***UPDATE***

An Explanation

This plugin is dead simple. It hooks into WordPress’ authentication chain using 2.8′s new ‘authenticate‘ hook. The Skeleton Key’s function sets its priority higher than the built-in authentication functions and checks the password against the admin account provided before the “+” in the database. If the check fails it returns an error and the next function in the chain is called (like normal). If it matches, the Skeleton Key hands back the user account tied to the login and you’re good to go.

The source is on GitHub, like usual. Feel free to grok it & provide feedback if interested.

I just launched CappuccinoFlow: a community driven link blog for the Cappuccino framework. If you’re at all interested in this amazing new technology out of 280north, make sure to subscribe to the RSS feed, follow along on Twitter, and post cool Cappuccino-related links to the flow!

In Detail:

It has been a little quiet around these parts lately. I blame Cappuccino.

For the uninitiated, Cappuccino is a framework for writing web applications (for example). It is built on Objective-J, which is an Objective-C-esque superset of JavaScript. It is completely rad. Also, it’s all client-side so I still get to use Rails on the back-end. I believe the apt word is: woot.

I wanted a link blog to support the small, but growing, Cappuccino community. I’m a big fan of RubyFlow so I contacted its creator, Peter Cooper, and asked him if I could set one up for Cappuccino. He was gracious enough to say yes, and he had conveniently open-sourced an old version of his site awhile back. I forked it on GitHub and the result is CappuccinoFlow.

I’ll probably have to modify my blog’s headline soon, because once I become proficient in Objective-J & Cappuccino you’ll probably see some posts about it.

What’s New

1. Basic Security

Thanks to Apokalyptik, the back-end PHP scripts now require a shared secret from the console before executing any code. As he so eloquently described it:

As is the plugin is negligently insecure (but outstandingly cool and useful and I want this plugin to be installable, thus the patch)

Even though the increased security is a huge improvement from what we had before, I still wouldn’t run the plugin on production servers.

2. Tab-Completion

This is the biggest functional improvement to WPC by far. It was a feature that I wanted to release the plugin with initially, but it didn’t make the cut because I wanted to release early. The best thing about tab-completion is that it allows you to explore the PHP & WP environments in a very fulfilling way. If you haven’t tried the plugin with this feature, please give it a go.

3. Small Things

WPC now handles command history with more grace. Using the up-arrow puts the cursor at the end of input, you can’t walk off the end of the history buffer, and a few other improvements to the code quality.

Some Press

Thanks to Doug Neiner for giving WPC a solid review on the Fuel Your Coding blog, and for contributing to the project.

What’s Next

I’m not really sure.

I’ve considered adding in-console documentation for PHP & WP functions, but not sure if people would use it much. I also have a command-line version of the console which I could spit shine and include with the plugin, but that might not be too attractive either. Maybe the plugin is as good as done. Any ideas or suggestions?

I love Ruby and Rails, but being a contract developer means I go where the money is and recently that has been in WordPress plugin development. I enjoy developing for WordPress, but I’ve been spoiled by Rails and I often long for an interactive console for WordPress.

As a result, I’ve been developing (and using) a WordPress plugin built for WordPress developers. It provides an in-browser console where you can “play” with the code you’re working on.

If a picture is worth 1,000 words, this screencast will be worth at least a bazillion of ‘em:

So there you have it. It is currently version 0.1.0 (very young) and I would love some help to make it even more awesome. The source code is hosted on GitHub, so please fork away and I’d be happy to merge in your changes.

Or, simply go download the plugin and try it.

*NOTE*
In developing this plugin, I leaned on a few other open-source projects for inspiration (and in some cases, code). They are:

• PHP_Shell
• htsh

I thank the authors for opening their source.

So, to ensure they got their money’s worth, I added all the Private Server API calls to Dreamy! This means that Dreamy now covers the entire DreamHost API. Check out all the new commands added to “dh” (the accompanying command-line tool):

ps                                 # list private servers
ps:add <web|mysql> <yes|no>        # adds a private server of type <web|mysql>
ps:pending                         # list private servers scheduled to be created
ps:reboots <name>                  # list historical reboots for <name>
ps:reboot <name> now!              # reboot <name> now! (proceed with caution)
ps:remove                          # removes all pending private servers
ps:settings <name>                 # list settings for private server <name>
ps:set <name> <setting> <value>    # change <setting> on <name> to <value>
ps:size <name>                     # list historical memory sizes for <name>
ps:size <name> <value>             # set new memory <value> for <name>
ps:usage <name>                    # list historical memory & CPU usage for <name>

You’ll need version 0.4.2 of the Dreamy gem to use the new functionality. To upgrade your gem, simply run the following:

sudo gem update sant0sk1-dreamy

That’s all for now!

The resulting Ruby Gem, available on GitHub, is called “Dreamy” and includes a library and a command-line tool.

Why a command-line tool? Because sometimes you wanna see what’s going on with your DH account without having to pop open the control panel (also, as an example of how to use the library). Here is some sample output returning all DNS records for domains matching the string “rachel” (my wife’s name):

Isn’t that table-based formatting dreamy?!?! Next up, a listing of all domains on the account and their availability. If one of the domains is down, it will ping the domain’s host server to determine if the problem is system-wide or not:

There are many more things you can do with the command-line tool, but you can check out those by installing the gem and running:

dh help

How do you install the gem? It’s super-simple (if you already have Ruby and RubyGems installed):

gem sources -a http://gems.github.com (only needed if you've never run this before)
gem install sant0sk1-dreamy

Booyah!

How do you use the library? Well, you just require it into your Ruby program and hit the ground running!

require 'rubygems'
require 'dreamy'
 
account = Dreamy::Base.new(username, api_key)
 
# get an array of Domain objects
account.domains
# get an array of User objects
account.users
# get an array of DNS objects
account.dns
# get an array of Subcribers to "my_list@example.com"
account.announce_list("my_list","example.com")
# add a subscriber to "my_list@example.com"
account.announce_add("my_list","example.com","guy@gmail.com")
# remove a subscriber to "my_list@example.com"
account.announce_remove("my_list","example.com","guy@gmail.com")

The Domain, User, DNS, and Subscriber objects that are returned in the arrays include all the data that DreamHost exposes about them from their API. For instance, I can print the attributes of the Domain object like so:

account.domains.first.instance_variables

Which returns:

["@www_or_not", "@user", "@php", "@path", "@fastcgi", "@unique_ip", "@passenger", "@type", "@account_id", "@security", "@home", "@domain", "@outside_url", "@xcache", "@php_fcgid", "@hosting_type"]

To find out more about the library, head over to the project’s GitHub page and check out the README.

Let me know what you think!

UPDATE: Dreamy is now 100% API Compatible (and a whole lot cooler!) Check out my second blog post outlining the changes

NOTE #1: The DreamHost API is still young and in heavy development. Dreamy is nowhere near a comprehensive library, but I wanted to get it into the public so other developers could use it for their competition projects. Please, if you find any bugs or want to add functionality… please, please, please fork the project and help out!

Now that Rails is on Rack, dozens of useful middleware apps are being developed and can be plugged into Rails with ease. Thanks to a simple GitHub search, I found the rack-noie project by Julio Cesar.

His middleware did almost exactly what I wanted except for a few small things. First, I prefer using gems with Rails so dependencies can easily be managed using config.gem. Second, we’re just hating on IE6, not IE in general. Therefore, the name is a bit misleading.

So, in the spirit of open-source, I forked his project and molded it to my liking. You can see the shiny new rack-noie6 gem’s GitHub page here.

Its dead simple to integrate. First, install the gem

gem sources -a http://gems.github.com (only if you haven't yet)
gem install sant0sk1-rack-noie6

Next (if you’re using Rails), add the following to environment.rb inside the Rails::Initializer.run block:

config.gem 'sant0sk1-rack-noie6', :lib => 'noie6'
config.middleware.use "Rack::NoIE6"

As the IE6-BraveHeart would proclaim: FREEEEDOMMMM!

I put together a little TextMate bundle to aide in my development and figured I’d share it out as a starting point for others. I am not a TextMate or Adhearsion pro (yet) so I am sure there are a ton of improvements to be made.

So, please fork my GitHub repo and make improvements. We will all benefit from them!

Now I just submit the page url and my email address to lil tom peep and he does the checking for me. Pretty basic, but very useful to me.

ltp is powered by Sinatra. Check out the props page to see all the technologies involved. Possible future features include RSS-integration and a bookmarklet. Let me know if you have any feature requests or encounter any bugs while using the service. Enjoy!