Delicatable treats for the rubies.

Been a long time. shouldn’t of left ya without a dope plugin to step to. meh. But for reals, I’ve been working way too much. Here’s a tasty sampler of some new and revived github projects:

• ActiveRecord Dumper
• Asset Tag Extensions
• Ruby Prof Request Filters
• Google Base4r extensions

ActiveRecord Dumper

script/plugin install http://github.com/blythedunham/ar_dumper

Dumper. I barely know her! I wrote this ages ago back in the Rails 1 dot 0h(mg) daze, but still works like a charm.

Easily export records to csv, yaml, or xml using the :find options, or (new) specify an array of activerecords with the :records option. AR Dumper dumps to strings or files with a paginated option, and it supports full customization of displayed headers and content with options such as  nly, :export, :procs, :methods

Book.dumper :yml, :find => {:conditions => ['author_name like ?', 'snowgiraffe'] }

Book.dumper :csv,   nly => [:author_name, :title], :records => @my_books

Asset Tag Extensions

script/plugin install git://github.com/blythedunham/javascript_tag_extensions

Your high performance web site client loading slowly? In addition to combining asset files, one of the best ways to improve client load speed is to move the javascript files and inline script tags to the bottom of the page. Even better, execute inline javascript after the document loads.  To load files at the bottom of the page use the

include_javascript_tag 'myjsfile', :defer => true

Similarly, replacing calls to javascript_tag with Asset Tag Extension’s inline_javascript renders the script at the bottom of the page. Use the n_load => true functionality use JQuery OnLoad functionality.

  <%  inline_javascript   n_load => true do %>
    alert("I love grapes");
  <% end %>

Ruby Prof Request Filters

script/plugin install http://github.com/blythedunham/ruby_prof_request_filters

Need to instantly profile a page? Output ruby prof results to your browser by adding the following params to the url: ruby_prof=true Flat graphs, html graph, whatever you need, this little tool comes in handy when your solving big problems.

Google Base: Base4r

I did some work on Dan Dukeson’s Google Base API For Ruby. Add, modify and delete items from Google Base (formerly Froogle) with Ruby.

Thus was born, ar_test_runner, a convenient plugin with a rake task to run the ActiveRecord test suites with your  code/gem/plugin load. You even can choose the ActiveRecord version and database.

Install

  gem sources -a http://gems.github.com
  sudo gem install blythedunham-ar_test_runner

Run ar_test_runner

Run all plugins and lib files against sqlite for app version

ar_test_runner DB=sqlite

Test 2.2.2 with rails_devs_for_data_integrity plugin loaded on mysql

ar_test_runner PLUGIN=rails_devs_for_data_integrity AR_DIR=/Library/Ruby/Gems/1.8/gems/activerecord-2.2.2

Rake Tasks

ar_test_runner works as a rake task, if installed as a plugin or by adding require “ar_test_runner” to the application’s Rakefile. The following example tests the applications default version of ActiveRecord with the files RAILS_ROOT/lib/my_file.rb and RAILS_ROOT/lib/my_other_file.rb loaded

rake test:activerecord:mysql FILE=lib/my_file.rb,lib/my_other_file.rb

Customize

To specify (or skip)  gems, files, dirs, and plugins ot load or build custom runs see the documentation at ar_test_runner .

script/plugin install git://github.com/zdennis/ar-extensions.git
gem install ar-extensions

While the original functionality of database agnostic ar-extensions is to import (bulk insert) many records quickly, my favorite new features for 0.9.1 are the new find and save options which allow developers to quickly customize queries without writing SQL for the MySQL database.

Find

For instance, suppose the wrong index is used to perform your favorite query. This use to mean that the developer had to dig through the logs, find the generated query, and rewrite the entire query with the correct index in SQL and execute it with ActiveRecord::Base.find_by_sql. With ar-extensions, its just another parameter to the find method. Similarly, leveraging MySQL functionality such as SQL_CACHE, HIGH PRIORITY, and LOCK IN SHARED MODE is just as easy.

Beer.find :all, :index_hint => 'USE INDEX (uk_beer_name)'
#SQL: SELECT * from `beers` USE INDEX (uk_beer_name)

Beer.find :all, :keywords => ' SQL_CACHE HIGH_PRIORITY'
#SQL: SELECT SQL_CACHE HIGH_PRIORITY * from `beers`  

Beer.find :all, :post_sql => ' FOR UPDATE', :pre_sql => '/* My little comment*/'
#SQL: /* My little comment*/ SELECT * from `beers` FOR UPDATE 

Finder SQL Exposed

And if that’s not enough to take advantage of MySQL query options, finder_sql_to_string will send the query string back and you can gsub your heart out before execution. It’s also a great to use for debugging purposes.

sql = Beer.send :finder_sql_to_string, :conditions => ['flavor like ?', 'delicious']
Beer.find_by_sql sql.gsub('WHERE', 'where /* I heart lowercase */')

Save and Create

As for save and create, the new options provide more control over database inserts and updates, especially when unique keys are involved.

Animal.create!({:name => 'Jerry Giraffe'},   n_duplicate_key_update => [:password])
#INSERT INTO animals (`name`, `fav_beer`, `password`) VALUES('Jerry Giraffe', 'Pabst', NULL) ON DUPLICATE KEY UPDATE `animals`.`password`=VALUES(`password`)

animal.save(:keywords => 'LOW_PRIORITY', :ignore => true,
            :pre_sql => "/* Now I know where this query is coming from within my Rails code!*/")
#/* Now I know where this query is coming from within my Rails code!*/ UPDATE LOW_PRIORITY IGNORE `animals` SET `fav_beer` = 'Pabst', `password` = 'frenchfry', `name` = 'Party Giraffe' WHERE `id` = 1

In addition to these spiffy new features, ar-extensions provides support for all of these:

• (new) create and save options rdoc
• (new) find options rdoc
• (new) insert_select from one table to another rdoc
• (new) find and count unions rdoc
• (new) delete options rdoc
• import (bulk insert) with synchronization rdoc
• csv export rdoc
• better finder hash support rdoc
• disabling foreign keys rdoc
• fulltext search support rdoc
• temporary table manipulation rdoc

That’s a lot of rope! If you do by chance hang yourself, please send bugs, comments and even patches to the new github issue tracker.

# Insert one copy of each book into the shopping cart. 
  CartItem.insert_select(:from => :book,
                         :select => ['books.id, ?, ?, ?, now()', @cart.to_param, 1, Time.now],
                         :into => [:book_id, :shopping_cart_id, :copies, :updated_at, :created_at]})

# GENERATED SQL example (MySQL):
# INSERT INTO `cart_items` ( `book_id`, `shopping_cart_id`, `copies`, `updated_at`, `created_at` )
# SELECT books.id, '134', 1, '2009-03-02 18:28:25', now() FROM `books`

Using the :keywords, :pre_sql, and :post_sql the  insert_select options, support all mysql options available to insert and select statements including

• IGNORE
• ON DUPLICATE KEY UPDATE
• LOW_PRIORITY
• SQL_CACHE
• DELAY

before and after comments and anything you can imagine you want to customize.

To install:

script/plugin install git://github.com/zdennis/ar-extensions.git

For more documentation, refer to  insert_select rdocs and main rdocs.

Customize your primary keys. Pic by Kerri on flickr.

Although the standard MySQL type for id columns is an unsigned int, Rails has no support for them and uses regular signed int(11) as the default for primary keys. In addition, most of my tables are less than 16 million rows (max rows for an unsigned mediumint) and so it saves space to use smaller sized numeric types such as smallint or mediumint to save space.

Inspired by Rob Anderton’s patch which was dismissed as an uncommon requirement, I built yet another plugin to allow customization of primary keys, support unsigned integers and allow users to specify column width for numeric types.

script/plugin install http://github.com/blythedunham/mysql_migration_optimizer/tree/master

Rails ignores signs! pic by alex suarez flikr

Specifying Column Width and Unsigned Integers

The MySQL connection adapter was ignoring the :precision and :scale options and so I just loaded em up to allow unsigned numeric types and allow column width to be specified which was supported on postgresql but not MySQL.

add_column :giraffe, :beer_count, :integer, :limit => 2, :precision => :unsigned, :scale => 4
#SQL: ALTER TABLE `giraffe` ADD `beer_count` smallint(4) UNSIGNED

• :limit determines the numeric type. Rails introduced smart integer columns in 2.1 which more or less translates to the number of bytes needed for storage. Here’s a little map taken from the adapter code. Do be careful, however, as some versions of Rails (2.1) break foreign keys.
  

  :limit	Numeric Type	Column Size
  1	tinyint	1 byte
  2	smallint	2 bytes
  3	mediumint	3 bytes
  nil, 4, 11	int(11)	4 bytes
  5 to 8	bigint	8 bytes

• :scale: column width explained here by Matt Thommes number in parenthesis (4) .
• :precision : specify :signed or :unsigned. Default will be :unsigned unless you specify set MySqlMigrationOptimizer.default_sign = :signed
  in your enviroment.rb.

Customizing Primary Keys

create_table "animal", :force => true,  :primary_column => {:type=>:integer, :limit => 3, :scale=>5}  do |t| end
#SQL: CREATE TABLE `animal` ( `id` mediumint(5) UNSIGNED NOT NULL auto_increment PRIMARY KEY) ENGINE=InnoDB

If you really want to get crazy you can specify some other type. Here’s the rope, I’ll leave the room if you want to hang yourself.

# Specify a string column as the primary key
create_table "blah", :force => true,
:primary_column => {:type=>:string, :limit=>25, :auto_increment=>false} do |t|#
end

#SQL: CREATE TABLE `blah` (`id` varchar(25) NOT NULL PRIMARY KEY) ENGINE=InnoDB

Do be careful to use the same numeric type for the foreign key columns as the referenced id column.

add_column   ther_table, :blah_id, :integer, :limit => 3, :scale=>5

If you have already generated a lot of tables and do not want to change all the old column types, specify the default to be :signed in config/environment.rb. Any new columns should then specify :precision => :unsigned

MySqlMigrationOptimizer.default_sign = :signed

The schemadumper has been amended to work correctly.

Install

script/plugin install git://github.com/blythedunham/static_record_cache.git

Documentation

class SomeStaticClass < ActiveRecord::Base
  acts_as_static_record
end

#cache hits
SomeStaticClass.find_by_name('blah')
SomeStaticClass.find_by_id(5)
SomeStaticClass.find :all
assoc_class.some_static_class

One can specify the cache key for faster lookups and also customize the finder SQL for the class. More documentation can be found in the rdocs.

Another, simpler method of caching can be used by folks using the active record context plugin by technoweenie. Extending StaticRecordCache will permanently cache data for the class regardless of context. This however, only caches by id.

class TelephoneCarriers < ActiveRecord::Base
  extend StaticActiveRecordContext
end

Be sure to install active_record_cache plugin:

script/plugin install http://svn.techno-weenie.net/projects/plugins/active_record_context/

eload-select plugin to the rescue!

Employee.find :all, :select => 'addresses.city, address.state, employees.*',
                    :include => :address

The advantages of the eload-select plugin:

1. Works with aliases and database functions

Employee.find :first,
  :select => 'now() as current_time, addresses.city, DATE(addresses.created_at) as addresses.created_at, employee.*'
  :include => :address

2. Plays nice with other plugins like ar-extensions
3. Selects columns on the base table (some options force you to select all of the base table)

Employee.find :all, :select => 'addresses.city, employees.name, employees.start_date',
                    :include => :address

script/plugin install git://github.com/blythedunham/eload-select.git

And your off! Recently updated to work with all versions of rails including 2.3.

Be careful of folder babies in buckets! photo by Patrish McLean

Back in the ‘burgh at Carnegie Mellon’s radio station WRCT, a really awesome poster with a baby crawling to its death in a bucket reminded you of how dangerous buckets can really be. Especially when DJing techno.  I can’t work with Amazon S3 without wishing all my baby resources and folders and files would crawl in to an S3 death bucket and vanish. OMG AMAZON!

So anyhoo, to create folders instead of just files (or what appears to be folders in the awesome S3 firefox organizer), do a PUT with:

This bitty rails code demonstrates this using the S3 plugin:

  S3_FOLDER_EXT = '_$folder$'
  def exists_in_S3?(file_name, bucket_name, options ={})
    connect_to_S3 

    file_search_name = file_name.dup
    file_search_name << S3_FOLDER_EXT if options[:folder]

    AWS::S3::Bucket.objects(bucket_name, :prefix => file_search_name).any?

  end

  def create_S3_folder(file_name, bucket_name, options={})
    connect_to_S3
    folder = AWS::S3::S3Object.store(file_name + S3_FOLDER_EXT, '', bucket_name,
      {:access => :public_read,
       :content_type => "binary/octet-stream",
       :cache_control => 'max-age=3600,post-check=900,pre-check=3600' }.update(options))
  end

  def connect_to_S3
    unless AWS::S3::Base.connected?
      AWS::S3::Base.establish_connection!(:access_key_id => 'blah', :secret_access_key => 'giraffe!')
    end
  end

At this point, you should ask yourself why you want to create folders in the first place. Because I want to stick my head in a bucket right now.