With administrate_me, we’re able to build a production-ready backend in a couple of minutes. It simplifies almost any management task you need to build for a rails app, this way you can focus and put all your efforts into application’s frontend.

We’re almost done with administrate_me 2.0 version (I believe its release will be on or about December 18th), you can watch plugin’s progress on github (even you can push some patches).

For those who can’t wait til December 18th, here you have a little snapshot of administrate_me’s backend new look

We’re definately there! yay!

Two bugs prevent it to run smoothly, first it depends on tar and gzip commands, which are not always available on that platform. Even though there are some native implementations, I’ve never found a tar one that I could actually use, most of them just fail at archiving big files. I’ve fixed this using the minitar gem to generate a tar.gz file from the sql dump.

On the other hand, there is an aws-s3 bug that prevents files to be directly passed to the store() method to upload the files. Fixing this was just a matter to read the file using ‘rb’ parameters for File.open().

You can see this and this commit with the changes, a pull request has already been sent.

A great solution for this problem is the delayed_job plugin by Tobias Lütke. This plugin is very easy to install, is very well documented, and provides you with everything you’ll need to execute task in background. I had the oportunity to try it out on burdastyle.com, and it worked just fine. So, congratulations Tobi for this great work and thanks for sharing.

So, let’s try delayed_job plugin out.

First thing we need to do after we install this plugin is to generate a migration to add delayed_jobs table into our database. This migration should look like this:

class CreateDelayedJobs < ActiveRecord::Migration
  def self.up
    create_table :delayed_jobs, :force => true do |table|
      table.integer  :priority, :default => 0
      table.integer  :attempts, :default => 0
      table.text     :handler
      table.string   :last_error
      table.datetime :run_at
      table.datetime :locked_at
      table.datetime :failed_at
      table.string   :locked_by
      table.timestamps
    end
  end

  def self.down
  end
end

Then, we’ll need to define our jobs. A job is just a ruby class with a method called perform. Let’s say we need to send a very simple email notification to our entire users database. We can use this little class:

class NotificationJob < Struct.new(:message)
  def perform
    total = User.count
    limit = 100
    (0..total-1).step(limit) do |offset|
       User.find(:all, :limit => limit, :offset => offset).each do |u|
         Notifier.deliver_message_to_user(u, message)
       end
    end
  end
end

Now, every time you need to send these notifications out, you just enqueue your job like this:

Delayed::Job.enqueue NotificationJob.new("hello world!")

Finally, delayed_job plugin provides you with a set of rake tasks to put enqueue jobs to work:

rake jobs:work

And that’s all folks! Have fun with delayed_job.

Happy hacking!

We wanted to use it too, but most of our projects include administrate_me, so the best thing we could have done is to keep ourselves DRY and fork BORT to create a version including an installed and bootstraped administrate_me by default.

You can check out here our BORT version. The same setup instructions apply as if it were a regular BORT app.

As a plus, this includes an updated version of rspec-on-rails-matchers plugin, which is something that is also catching on on all of out projects lately.

Feel free to clone it, fork it and send all kind of patches and pull requests.

So, the news are that in a few hacking sessions we managed to create some rpsec shared behaviours and matchers to help you test your controllers that use administrate_me.

On this files you can see the actual code of the specs, but most important, clear examples about how to use them:

administrate_me Shared Behaviours: You can use them to check that your controllers are fully functional. It comes in two flavors: ‘basic administrate_me’ and ‘basic administrate_me with parent’ to test child controllers.

administrate_me Matchers: For now you have just two matchers to check for the order set and the fields on which the search is allowed. There are more matchers to come.

Now you dont have excuse for not testing your controllers!

What does it do ?

It’s a ruby wrapper for the Weather XML Data Feed from weather.com.

It currently has two features, searching locations to get their location_id and getting the weather current conditions for a given location.

Getting the code and Installing

The rweather code is of course available at github and is released with a MIT license.

To install it just do the usual:
sudo gem install ckozus-rweather --source http://gems.github.com

How to Use It

This is a simple script using rweather taken from the README. It gets a list of matching locations and shows the current temperature and what it feels like.

The problem presents when I want to search saved articles, i don’t have a centralized place to keep my favorites since they’re distributed between delicious and Google Reader.

Know I said: “Stop! It’s time to keep my bookmarks in sync!” So I came up with a script to automatically post my Google Shared Items to my delicious account.

Requirements

Install this gems

• feed-normalizer: It will be used to read and parse the shared items atom feed.
• json: This will parse the JSON returned by the Yahoo Term Extraction API. If you’re on Windows install json_pure.
• mirrored: It’s a gem to interact with delicious and ma.gnolia bookmark sites. So yes, this script will also work if you’re using magnolia to keep your bookmarks. Currently this gem does not allow to check if an invalid authentication has ocurred, but i’ve already cloned it on github to provide a patch for this problem.

The script

The script it’s pretty straightforward, it will fetch your google reader items, iterate through each of them and post them to delicious if they’re not already there. As a plus, it will use the Yahoo Term Extraction API to get a list of tags for your bookmark.