First, we got some participation from David Eisinger to help improve testing and some other critical features. Thanks, David! Recently though, we added some new functionality we had lying around in an old plugin called acts_as_amazonable.

The new functionality allows you to load Amazon product attributes into a new or existing model object on your system. You can define which fields are loaded, and which attributes in your model they map to. We are using this functionality on a new double-secret project that we are working on, and it is great. In that project, we are letting our users type in an ISBN code, and we pre-populate a form with all of the Amazon data we want for that product, saving the user from a lot of typing. We also pick up the images, so they don’t even have to load an image to sell their item. Pretty cool!

Here’s how you use aaap’s new functionality:

require 'acts_as_amazon_product'
 
 class LocalBook < ActiveRecord::Base
   acts_as_amazon_product(
     :asin => 'isbn', :name => 'title',
     :access_key => '0123456', :associate_tag => 'assoc-20',
     :auto_load_fields => {
         :title => 'title',
         :isbn => 'asin',
         :publisher_name => 'manufacturer',
         :author => 'author'}
   )
 end

The keys in the auto_load_fields hash are the fields in your object, and the values are their Amazon equivalents. In the true Rails convention over configuration spirit, we have included some of the most popular auto load fields as defaults. If your object contains the following attributes, they will automatically be loaded with their Amazon equivalents:

:auto_load_fields => {
     :title => 'title',
     :isbn => 'asin',
     :publisher_name => 'manufacturer',
     :author => 'author',
     :binding => 'binding',
     :list_price => 'listprice/amount',
     :pages => 'numberofpages',
     :description => 'content',
     :small_image_url => 'smallimage/url',
     :medium_image_url => 'mediumimage/url',
     :large_image_url => 'largeimage/url',
     :detail_url => 'detailpageurl'
}

Don’t worry if your object does not have some or most of these fields; Acts as Amazon Product is smart enough to check to see if the method exists before attempting to load up the Amazon value.

Now, if by some coincidence you have some fields in your local object that have the same name as our auto_load defaults, you can choose to specifically ignore those fields using, you guessed it, :ignore_fields. :ignore_fields is a simple array of fields in your object that you do NOT want to be replaced with the Amazon equivalent. You would specify them like this:

acts_as_amazon_product(
    :asin => 'isbn', :name => 'title',
    :access_key => '0123456', :associate_tag => 'assoc-20',
    :ignore_fields => [:small_image_url, :medium_image_url]
  )

In this instance, the object in question would load Amazon info for any of the default fields that the object has, with the exception of the small_image_url and medium_image_url values.

To load the Amazon values into your object for local storage, you may call the following methods:

load_from_amazon(title_or_asin, by_title = false)
load_from_amazon!(title_or_asin, by_title = false)

The two methods do exactly the same thing, except the first simply returns a new, unsaved object with its Amazon-like fields loaded with their appropriate Amazon values. The second version (load_from_amazon!) goes one step further and saves the object for good measure.

You may pass either an isbn (asin) or a title in. If you are passing a title, you need to specify that you are passing a title by also passing true as the second parameter so we will perform an item_search rather than an item_lookup. Note that passing a title is risky business, since currently the code will take the first result returned and load that into your object. So unless your title is unique, I would recommend sticking with the isbn (asin) value.

Since that is the default, all you need to do would be something like this:

@local_book = LocalBook.load_from_amazon('1590598415')

If your object was similar to the LocalBook object in our example, for instance, you would not need to specify the auto_load_fields in the acts_as call at all. The title, isbn, publisher_name and author methods would automatically be called once you call load_from_amazon, and their values populated appropriately.

It is important to note that if you call load_from_amazon with an invalid asin, you will simply get back an empty object.

Now, calling load_from_amazon still allows you to take advantage of the other Acts as Amazon features, like the dynamic loading of Amazon attributes on the fly by using the various amazon.foo methods as it always has.

def nested_error_messages_for(object)
  if ([Symbol, String].member? object.class)
    object = instance_variable_get("@#{object}")
  end
  unless object.nil? || object.errors.count.zero?
    error_messages = object.errors.to_a.uniq.map do |key, value|
      object2 = object.send(key)
      if object2.is_a?(Array)
        object2.collect {|obj| 
          content_tag(:li, nested_error_messages_for(obj)) 
        }
      elsif object2.is_a?(ActiveRecord::Base)
        content_tag(:li, nested_error_messages_for(object2))
      elsif value.match(/^\^/)
        content_tag(:li, value[1..value.length])
      else
        content_tag(:li, 
           "#{key.underscore.split('_').join(' ').humanize} #{value}")
      end
    end
    content_tag(:div,
      content_tag(:div, 
        "#{object.class} has errors", :class => 'error_field') +
      content_tag(:ul, error_messages), :class => 'error_block')
    else
      ''
    end
end

To use it, just replace your current call to error_messages_for with nested_error_messages_for. There’s nothing extra that needs to be done in the controller as with some recipes. You’ll also want to make it look good with some CSS.

I’m pretty sure there’s more that could be done with this, but thought I’d present it here first and try to get some feedback before turning it into a gem. Let me know how it works for you.

User.count(:conditions => ['created_at > ?', 30.days.ago])

Here’s a simple extension I made to ActiveRecord to DRY it up:

module ActiveRecord
  class Base
      def self.count_since(time_ago)
        count(:conditions => ['created_at > ?', time_ago])
      end
  end
end

Put that snippet in a file in your lib directory. I called mine rails_extensions.rb. Then add require ‘rails_extensions’ to the bottom of your environment.rb file.

Now you can just do:

User.count_since(30.days.ago)

That’s a little cleaner, don’t you think?

Autotest.add_hook :run do |autotest|
  autotest.add_exception(/^\.\/vendor/)
  autotest.add_exception(/\.svn/)
end

Thanks Ryan and David for the updates!

I’ve been noticing in my current project that running autotest was constantly consuming about 25-30% of my cpu and causing my macbook pro to run really hot. I did a little googling and found this discussion on the topic.

For me, my problem was definitely the vendor directory (~3500 files in 4 plugins: rspec, rspec_on_rails, restful_open_id_authentication and active_merchant). I tried excluding the entire directory by adding this to my ~/.autotest file:

Autotest.add_hook :initialize do |autotest|
  autotest.exceptions <<
   %r%^\./(?:db|doc|log|public|script|vendor|previous_failures.txt)%
end

However, that didn’t work. After some investigation, I found out that the rspec_on_rails plugin in my vendor directory was subclassing Autotest::Rspec and setting it’s own exceptions string like this:

def initialize
  super
  @exceptions = 
   %r%^\./(?:db|doc|log|public|script|vendor\/rails|previous_failures.txt)%
...

See the problem? It dutifully calls super so AutoTest:initialize can do it’s stuff (including calling my hook) and then wipes out the exception string with it’s own.

So, I browsed the lib/autotest.rb code and found another hook. Adding this to my ~/.autotest now lowers the cpu usage to about 5%. Huzzah!

Autotest.add_hook :run do |autotest|
  autotest.exceptions = Regexp.union(/^\.\/vendor/, autotest.exceptions)
end

All that’s necessary to integrate any of your existing models with Amazon is to add a require line to the top of your model file and then an acts_as_amazon_product line just inside your class definition.

require 'acts_as_amazon_product'
 
class Book < ActiveRecord::Base
  acts_as_amazon_product(
      :asin => 'isbn', :name => 'title', 
      :access_key => '0123456', 
      :associate_tag => 'assoc-20')
end

After this, you can access Amazon data in your controllers or views like this:

@book = Book.new(:title => 'Getting Things Done')
@book.amazon.isbn
@book.amazon.title
@book.amazon.author
@book.amazon.small_image_url
 
@book.amazon.get('itemattributes/foobar')

The code does not require changing any current database tables. It only requires adding one migration for a single new table used to cache responses from Amazon:

ActiveRecord::Base.connection.create_table :amazon_products do |t|
  t.column :asin, :string
  t.column :xml, :text
  t.column :created_at, :datetime
  t.column :amazonable_id, :integer
  t.column :amazonable_type, :string
end

Example:

$ cklog access_log

04-15-2007: 21
04-16-2007: 2134
04-17-2007: 304
04-18-2007: 6960
04-19-2007: 951
04-20-2007: 412

Here’s the script:

require 'date'
 
daily = Hash.new
File.open(ARGV[0] || "access_log", "r") do |file|
  while line = file.gets
    if line =~ /(\d{2}\/\w{3}\/\d{4}).*GET\s([^\?\s]+)/
      date = Date.strptime $1, '%d/%b/%Y'
      daily[date] = 0 if daily[date].nil?
      daily[date] + 1
    end
  end
end
 
daily.sort.each {|d, f| 
  puts "#{d.strftime '%m-%d-%Y'}: #{f}"
}

You can run this as a stand-alone script and just pass in the URL to crawl as an argument.

[ruby]
require ‘net/http’
require ‘uri’

class SiteCrawler
def initialize(url)
@site_uri = URI.parse(url)
@site_uri.path = “/” if @site_uri.path == “”
@visited = Hash.new
@queue = Array.new
addPath(@site_uri.path)
puts “Initialized site crawl for #{@site_uri}”
end

def addPath(path)
@queue.push path
@visited[path] = false
end

def getPage(path)
begin
uri = @site_uri.clone
uri.path = uri.path + path if path != “/”
puts “getting #{uri}”
response = Net::HTTP.get_response(uri)
rescue Exception
puts “Error: #{$!}”
return “”
end
return response.body
end

def queueLocalLinks(html)
html.scan(/ uri = URI.parse("#{w}")
if !@visited.has_key?(uri.path) and
(uri.relative? or uri.host == @site_uri.host)
addPath(uri.path)
end
}
end