jamesmacaulay-asset_cloud 0.5.1 → 0.5.2

data/CHANGELOG

@@ -1,7 +1,14 @@
+July 2009:
+
+* Added ActiveRecordBucket
+
 June 2009:
 
+* Buckets can be versioned
+* Transactional writes with BucketChains
+* Asset callbacks
 * Use different Asset subclasses for each bucket in a cloud (james)
 * AssetCloud::Base#find now calls asset_at but will raise errors if the asset doesn't exist (james)
 * original AssetCloud::Base#find renamed to #asset_at (james)
 * Added simple bucket multiplexing with AssetCloud::Bucket.chain (james)
-* extraction from Shopify
+* extraction from Shopify (tobi)

data/VERSION

@@ -1 +1 @@
-0.5.1
+0.5.2

data/asset_cloud.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{asset_cloud}
-  s.version = "0.5.1"
+  s.version = "0.5.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Shopify"]
-  s.date = %q{2009-06-17}
+  s.date = %q{2009-07-03}
   s.description = %q{An abstraction layer around arbitrary and diverse asset stores.}
   s.email = %q{developers@shopify.com}
   s.extra_rdoc_files = [
@@ -27,44 +27,54 @@ Gem::Specification.new do |s|
      "lib/asset_cloud.rb",
      "lib/asset_cloud/asset.rb",
      "lib/asset_cloud/base.rb",
-     "lib/asset_cloud/blackhole_bucket.rb",
      "lib/asset_cloud/bucket.rb",
+     "lib/asset_cloud/buckets/active_record_bucket.rb",
+     "lib/asset_cloud/buckets/blackhole_bucket.rb",
+     "lib/asset_cloud/buckets/bucket_chain.rb",
+     "lib/asset_cloud/buckets/file_system_bucket.rb",
+     "lib/asset_cloud/buckets/invalid_bucket.rb",
+     "lib/asset_cloud/buckets/memory_bucket.rb",
+     "lib/asset_cloud/buckets/versioned_memory_bucket.rb",
      "lib/asset_cloud/callbacks.rb",
-     "lib/asset_cloud/file_system_bucket.rb",
      "lib/asset_cloud/free_key_locator.rb",
-     "lib/asset_cloud/invalid_bucket.rb",
-     "lib/asset_cloud/memory_bucket.rb",
      "lib/asset_cloud/metadata.rb",
+     "lib/asset_cloud/validations.rb",
+     "spec/active_record_bucket_spec.rb",
      "spec/asset_spec.rb",
      "spec/base_spec.rb",
      "spec/blackhole_bucket_spec.rb",
-     "spec/bucket_spec.rb",
+     "spec/bucket_chain_spec.rb",
      "spec/callbacks_spec.rb",
      "spec/file_system_spec.rb",
      "spec/files/products/key.txt",
+     "spec/files/versioned_stuff/foo",
      "spec/find_free_key_spec.rb",
      "spec/memory_bucket_spec.rb",
      "spec/regexp_spec.rb",
      "spec/spec.opts",
-     "spec/spec_helper.rb"
+     "spec/spec_helper.rb",
+     "spec/validations_spec.rb",
+     "spec/versioned_memory_bucket_spec.rb"
   ]
-  s.has_rdoc = true
   s.homepage = %q{http://github.com/Shopify/asset_cloud}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.2}
+  s.rubygems_version = %q{1.3.4}
   s.summary = %q{An abstraction layer around arbitrary and diverse asset stores.}
   s.test_files = [
-    "spec/asset_spec.rb",
+    "spec/active_record_bucket_spec.rb",
+     "spec/asset_spec.rb",
      "spec/base_spec.rb",
      "spec/blackhole_bucket_spec.rb",
-     "spec/bucket_spec.rb",
+     "spec/bucket_chain_spec.rb",
      "spec/callbacks_spec.rb",
      "spec/file_system_spec.rb",
      "spec/find_free_key_spec.rb",
      "spec/memory_bucket_spec.rb",
      "spec/regexp_spec.rb",
-     "spec/spec_helper.rb"
+     "spec/spec_helper.rb",
+     "spec/validations_spec.rb",
+     "spec/versioned_memory_bucket_spec.rb"
   ]
 
   if s.respond_to? :specification_version then

data/lib/asset_cloud.rb

@@ -4,20 +4,32 @@ require 'active_support'
 require File.dirname(__FILE__) + '/asset_cloud/asset'
 require File.dirname(__FILE__) + '/asset_cloud/metadata'
 require File.dirname(__FILE__) + '/asset_cloud/bucket'
-require File.dirname(__FILE__) + '/asset_cloud/invalid_bucket'
-require File.dirname(__FILE__) + '/asset_cloud/blackhole_bucket'
-require File.dirname(__FILE__) + '/asset_cloud/memory_bucket'
-require File.dirname(__FILE__) + '/asset_cloud/file_system_bucket'
-require File.dirname(__FILE__) + '/asset_cloud/base'   
+require File.dirname(__FILE__) + '/asset_cloud/buckets/active_record_bucket'
+require File.dirname(__FILE__) + '/asset_cloud/buckets/blackhole_bucket'
+require File.dirname(__FILE__) + '/asset_cloud/buckets/bucket_chain'
+require File.dirname(__FILE__) + '/asset_cloud/buckets/file_system_bucket'
+require File.dirname(__FILE__) + '/asset_cloud/buckets/invalid_bucket'
+require File.dirname(__FILE__) + '/asset_cloud/buckets/memory_bucket'
+require File.dirname(__FILE__) + '/asset_cloud/buckets/versioned_memory_bucket'
+require File.dirname(__FILE__) + '/asset_cloud/base'
 
 
 # Extensions
 require File.dirname(__FILE__) + '/asset_cloud/free_key_locator'
 require File.dirname(__FILE__) + '/asset_cloud/callbacks'
+require File.dirname(__FILE__) + '/asset_cloud/validations'
 
 
 AssetCloud::Base.class_eval do
-  include AssetCloud::FreeKeyLocator                                
-  include AssetCloud::Callbacks                                
+  include AssetCloud::FreeKeyLocator
+  include AssetCloud::Callbacks
+  callback_methods :write, :delete
+end
+
+AssetCloud::Asset.class_eval do
+  include AssetCloud::Callbacks
+  callback_methods :store, :delete
+  
+  include AssetCloud::Validations
 end
 

data/lib/asset_cloud/asset.rb

@@ -6,7 +6,7 @@ module AssetCloud
   class AssetNotSaved < AssetError
   end
 
-  class Asset    
+  class Asset
     include Comparable
     attr_accessor :key, :value, :cloud, :metadata
     attr_accessor :new_asset
@@ -65,6 +65,10 @@ module AssetCloud
     
     def created_at
       metadata.created_at
+    end
+    
+    def updated_at
+      metadata.updated_at
     end    
             
     def delete
@@ -110,10 +114,24 @@ module AssetCloud
     def url    
       cloud.url_for key
     end                   
-      
+    
+    def bucket_name
+      @key.split('/').first
+    end
   
     def inspect
       "#<#{self.class.name}: #{key}>"
     end  
+    
+    # versioning
+    
+    def rollback(version)
+      self.value = cloud.read_version(key, version)
+      self
+    end
+    
+    def versions
+      cloud.versions(key)
+    end
   end
 end

data/lib/asset_cloud/base.rb

@@ -5,7 +5,7 @@ module AssetCloud
   end
 
   class Base    
-    cattr_accessor :logger       
+    cattr_accessor :logger
     
     VALID_PATHS = /^[a-z0-9][a-z0-9_\-\/]+([a-z0-9][\w\-\ \.]*\.\w{2,6})?$/i
   
@@ -73,10 +73,10 @@ module AssetCloud
       end
     end
     
-    def asset_at(key)
-      check_key_for_errors(key)
+    def asset_at(*args)
+      check_key_for_errors(args.first)
       
-      asset_class_for(key).at(self, key)        
+      asset_class_for(args.first).at(self, *args)        
     end            
   
     def move(source, destination)
@@ -145,12 +145,26 @@ module AssetCloud
     end
                       
     def []=(key, value)
-      write(key, value)
+      asset = self[key]
+      asset.value = value
+      asset.store
     end
 
     def [](key)
       asset_at(key)
     end
+    
+    # versioning
+    
+    def read_version(key, version)
+      logger.info { "  [#{self.class.name}] Reading from #{key} at version #{version}" } if logger      
+      bucket_for(key).read_version(key, version)
+    end
+    
+    def versions(key)
+      logger.info { "  [#{self.class.name}] Getting all versions for #{key}" } if logger      
+      bucket_for(key).versions(key)
+    end
        
     protected
     

data/lib/asset_cloud/bucket.rb

@@ -1,8 +1,8 @@
                                                                                            
 module AssetCloud
   class AssetNotFoundError < StandardError
-    def initialize(key_or_message, message=false)
-      super(message ? key_or_message : "Could not find asset #{key_or_message.to_s.inspect}")
+    def initialize(key, version=nil)
+      super(version ? "Could not find version #{version} of asset #{key}" : "Could not find asset #{key}")
     end
   end
   
@@ -10,30 +10,6 @@ module AssetCloud
     attr_reader :name
     attr_accessor :cloud
     
-    # returns a new Bucket class which writes to each given Bucket
-    # but only uses the first one for reading
-    def self.chain(*klasses)
-      Class.new(self) do
-        attr_reader :chained_buckets
-        define_method 'initialize' do |cloud, name|
-          super
-          @chained_buckets = klasses.map {|klass| klass.new(cloud,name)}
-        end
-        def ls(key=nil)
-          @chained_buckets.first.ls(key)
-        end
-        def read(key)
-          @chained_buckets.first.read(key)
-        end
-        def write(key, data)
-          @chained_buckets.each { |b| b.write(key, data)}
-        end
-        def delete(key)
-          @chained_buckets.each { |b| b.delete(key)}
-        end
-      end
-    end
-    
     def initialize(cloud, name)
       @cloud, @name = cloud, name
     end
@@ -53,5 +29,15 @@ module AssetCloud
     def delete(key)
       raise NotImplementedError
     end
+    
+    # versioning
+    
+    def read_version(key, version)
+      raise NotImplementedError
+    end
+    
+    def versions(key)
+      raise NotImplementedError
+    end
   end
 end

data/lib/asset_cloud/buckets/active_record_bucket.rb

@@ -0,0 +1,57 @@
+module AssetCloud
+  class ActiveRecordBucket < AssetCloud::Bucket
+    class_inheritable_accessor :key_attribute, :value_attribute
+    self.key_attribute = 'key'
+    self.value_attribute = 'value'
+  
+    def ls(key=name)
+      col = records.connection.quote_column_name(self.key_attribute)
+      records.all(:conditions => ["#{col} LIKE ?", "#{key}%"]).map do |r|
+        cloud[r.send(self.key_attribute)]
+      end
+    end
+  
+    def read(key)
+      find_record!(key).send(self.value_attribute)
+    end
+  
+    def write(key, value)
+      record = records.send("find_or_initialize_by_#{self.key_attribute}", key.to_s)
+      record.send("#{self.value_attribute}=", value)
+      record.save!
+    end
+  
+    def delete(key)
+      if record = find_record(key)
+        record.destroy
+      end
+    end
+  
+    def stat(key)
+      if record = find_record(key)
+        AssetCloud::Metadata.new(true, record.send(self.value_attribute).size, record.created_at, record.updated_at)
+      else
+        AssetCloud::Metadata.new(false)
+      end
+    end
+  
+    protected
+  
+    # override to return @cloud.user.assets or some other ActiveRecord Enumerable
+    # which responds to .connection, .find, etc.
+    # 
+    # model must have columns for this class's key_attribute and value_attribute,
+    # plus created_at and updated_at.
+    def records
+      raise NotImplementedError
+    end
+  
+    def find_record(key)
+      records.first(:conditions => {self.key_attribute => key.to_s})
+    end
+  
+    def find_record!(key)
+      find_record(key) or raise(AssetCloud::AssetNotFoundError, key)
+    end
+  end
+end

data/lib/asset_cloud/buckets/bucket_chain.rb

@@ -0,0 +1,84 @@
+module AssetCloud
+  class BucketChain < Bucket
+    # returns a new Bucket class which writes to each given Bucket
+    # but only uses the first one for reading
+    def self.chain(*klasses)
+      Class.new(self) do
+        attr_reader :chained_buckets
+        define_method 'initialize' do |cloud, name|
+          super
+          @chained_buckets = klasses.map {|klass| klass.new(cloud,name)}
+        end
+      end
+    end
+    
+    
+    def ls(key=nil)
+      first_possible_bucket {|b| b.ls(key)}
+    end
+    def read(key)
+      first_possible_bucket {|b| b.read(key)}
+    end
+    def stat(key=nil)
+      first_possible_bucket {|b| b.stat(key)}
+    end
+    def read_version(key, version)
+      first_possible_bucket {|b| b.read_version(key, version)}
+    end
+    def versions(key)
+      first_possible_bucket {|b| b.versions(key)}
+    end
+    
+    
+    def write(key, data)
+      every_bucket_with_transaction_on_key(key) {|b| b.write(key, data)}
+    end
+    def delete(key)
+      every_bucket_with_transaction_on_key(key) {|b| b.delete(key)}
+    end
+    
+    def respond_to?(sym)
+      @chained_buckets.any? {|b| b.respond_to?(sym)}
+    end
+    def method_missing(sym, *args)
+      first_possible_bucket {|b| b.send(sym, *args)}
+    end
+    
+    private
+    
+    def first_possible_bucket(&block)
+      @chained_buckets.each do |bucket|
+        begin
+          return yield(bucket)
+        rescue NoMethodError, NotImplementedError => e
+          nil
+        end
+      end
+    end
+    
+    def every_bucket_with_transaction_on_key(key, i=0, &block)
+      return unless bucket = @chained_buckets[i]
+      
+      old_value = begin
+        bucket.read(key)
+      rescue AssetCloud::AssetNotFoundError
+        nil
+      end
+      result = yield(bucket)
+      
+      begin
+        every_bucket_with_transaction_on_key(key, i+1, &block)
+        return result
+      rescue StandardError => e
+        if old_value
+          bucket.write(key, old_value)
+        else
+          bucket.delete(key)
+        end
+        raise e
+      end
+    end
+    
+  end
+  
+end

data/lib/asset_cloud/{file_system_bucket.rb → buckets/file_system_bucket.rb}

@@ -8,7 +8,7 @@ module AssetCloud
 
       Dir.glob(base_path).each do |f| 
         next unless File.file?(f)
-        objects.push Asset.at(cloud, relative_path_for(f) )
+        objects.push cloud[relative_path_for(f)]
       end                                  
       objects
     end

data/lib/asset_cloud/{memory_bucket.rb → buckets/memory_bucket.rb}

@@ -6,11 +6,13 @@ module AssetCloud
       super
       @memory = {}
     end
-
-    def ls(key = nil)
-      @memory.find_all do |key, value|
-        key.left(key.size) == namespace
+    
+    def ls(prefix=nil)
+      results = []
+      @memory.each do |k,v|
+        results.push(cloud[k]) if prefix.nil? || k.starts_with?(prefix)
       end
+      results
     end
 
     def read(key)  
@@ -31,7 +33,7 @@ module AssetCloud
     def stat(key)
       return Metadata.non_existing unless @memory.has_key?(key)
           
-      Metadata.new(true, @memory[key].size)
+      Metadata.new(true, read(key).size)
     end 
 
   end

data/lib/asset_cloud/buckets/versioned_memory_bucket.rb

@@ -0,0 +1,33 @@
+module AssetCloud
+   
+  class VersionedMemoryBucket < MemoryBucket
+    
+    def read(key)
+      raise AssetCloud::AssetNotFoundError, key unless @memory.has_key?(key)
+      read_version(key, latest_version(key))
+    end
+
+    def write(key, data)    
+      @memory[key] ||= []
+      @memory[key] << data
+      true
+    end
+    
+    def read_version(key, version)
+      @memory[key][version - 1]
+    end
+    
+    def versions(key)
+      (1..latest_version(key)).to_a
+    end
+    
+    private
+    
+    def latest_version(key)
+      @memory[key].size
+    end
+
+  end
+  
+  
+end

data/lib/asset_cloud/callbacks.rb

@@ -2,37 +2,40 @@ module AssetCloud
   
   module Callbacks
     
-    CALLBACKS = [:delete, :write]
-    
     def self.included(base)
-           
-      CALLBACKS.each do |method|
-         code = <<-"end_eval"
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+      def callback_methods(*symbols)
+        symbols.each do |method|
+          code = <<-"end_eval"
         
-         def self.before_#{method}(*callbacks, &block)
-           callbacks << block if block_given?
-           write_inheritable_array(:before_#{method}, callbacks)
-         end          
+           def self.before_#{method}(*callbacks, &block)
+             callbacks << block if block_given?
+             write_inheritable_array(:before_#{method}, callbacks)
+           end          
         
-         def self.after_#{method}(*callbacks, &block)
-           callbacks << block if block_given?
-           write_inheritable_array(:after_#{method}, callbacks)
-         end          
+           def self.after_#{method}(*callbacks, &block)
+             callbacks << block if block_given?
+             write_inheritable_array(:after_#{method}, callbacks)
+           end          
         
          
-         def #{method}_with_callbacks(*args)
-           if execute_callbacks(:before_#{method}, args)
-             result = #{method}_without_callbacks(*args)
-             execute_callbacks(:after_#{method}, args)         
-           end
-           result
-         end    
+           def #{method}_with_callbacks(*args)
+             if execute_callbacks(:before_#{method}, args)
+               result = #{method}_without_callbacks(*args)
+               execute_callbacks(:after_#{method}, args)         
+             end
+             result
+           end    
 
-         alias_method_chain :#{method}, 'callbacks'         
-        end_eval
+           alias_method_chain :#{method}, 'callbacks'         
+          end_eval
                         
-        base.class_eval code, __FILE__, __LINE__        
-      end      
+          self.class_eval code, __FILE__, __LINE__        
+        end      
+      end
     end
     
     def execute_callbacks(symbol, args)

data/lib/asset_cloud/validations.rb

@@ -0,0 +1,43 @@
+module AssetCloud
+  module Validations
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+        include AssetCloud::Callbacks
+        
+        alias_method_chain :store, :validation
+      end
+    end
+    
+    module ClassMethods
+      def validate(*validations, &block)
+        validations << block if block_given?
+        write_inheritable_array(:validate, validations)
+      end
+    end
+    
+    def store_with_validation
+      validate
+      errors.empty? ? store_without_validation : false
+    end
+    
+    def errors
+      @errors ||= []
+    end
+    
+    def valid?
+      validate
+      errors.empty?
+    end
+    
+    def add_error(msg)
+      errors << msg
+      errors.uniq!
+    end
+    
+    def validate
+      errors.clear
+      execute_callbacks(:validate, [])
+    end
+  end
+end

data/spec/active_record_bucket_spec.rb

@@ -0,0 +1,95 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+MockRecords = Object.new
+
+class MockActiveRecordBucket < AssetCloud::ActiveRecordBucket
+  self.key_attribute = 'name'
+  self.value_attribute = 'body'
+  protected
+  def records
+    MockRecords
+  end
+end
+
+class RecordCloud < AssetCloud::Base
+  bucket :stuff, MockActiveRecordBucket
+end
+
+describe AssetCloud::ActiveRecordBucket do    
+  directory = File.dirname(__FILE__) + '/files'
+  
+  before do
+    @cloud = RecordCloud.new(directory , 'http://assets/files' )
+    @bucket = @cloud.buckets[:stuff]
+  end
+  
+  describe '#ls' do
+    before do
+      MockRecords.should_receive(:connection).and_return(@mock_connection = mock("connection"))
+      @mock_connection.should_receive(:quote_column_name).with('name').and_return("`name`")
+      (@mock_record = mock("record")).should_receive(:name).and_return('stuff/a1')
+    end
+    
+    it "should return a list of assets which start with the given prefix" do
+      MockRecords.should_receive(:all).with(:conditions => ["`name` LIKE ?", "stuff/a%"]).and_return([@mock_record])
+      
+      @bucket.ls('stuff/a').size.should == 1
+    end
+    
+    it "should return a list of all assets when a prefix is not given" do
+      MockRecords.should_receive(:all).with(:conditions => ["`name` LIKE ?", "stuff%"]).and_return([@mock_record])
+      
+      @bucket.ls.size.should == 1
+    end
+  end
+  
+  describe '#read' do
+    it "should return the value of a key when it exists" do
+      (@mock_record = mock("record")).should_receive(:body).and_return('foo')
+      MockRecords.should_receive(:first).with(:conditions => {'name' => 'stuff/a1'}).and_return(@mock_record)
+      
+      @bucket.read('stuff/a1')
+    end
+    it "should raise AssetNotFoundError when nothing is there" do
+      MockRecords.should_receive(:first).with(:conditions => {'name' => 'stuff/a1'}).and_return(nil)
+      
+      lambda {@bucket.read('stuff/a1')}.should raise_error(AssetCloud::AssetNotFoundError)
+    end
+  end
+  
+  describe '#write' do
+    it "should write to the DB" do
+      (@mock_record = mock("record")).should_receive(:body=).with('foo').and_return('foo')
+      @mock_record.should_receive(:save!).and_return(true)
+      MockRecords.should_receive(:find_or_initialize_by_name).with('stuff/a1').and_return(@mock_record)
+      
+      @bucket.write('stuff/a1', 'foo')
+    end
+  end
+  
+  describe '#delete' do
+    it "should destroy records" do
+      (@mock_record = mock("record")).should_receive(:destroy).and_return(true)
+      MockRecords.should_receive(:first).with(:conditions => {'name' => 'stuff/a1'}).and_return(@mock_record)
+      
+      @bucket.delete('stuff/a1')
+    end
+  end
+  
+  describe '#stat' do
+    it "should return appropriate metadata" do
+      (@mock_record = mock("record")).should_receive(:created_at).and_return(1982)
+      @mock_record.should_receive(:updated_at).and_return(2002)
+      @mock_record.should_receive(:body).and_return('foo')
+      MockRecords.should_receive(:first).with(:conditions => {'name' => 'stuff/a1'}).and_return(@mock_record)
+      
+      metadata = @bucket.stat('stuff/a1')
+      metadata.created_at.should == 1982
+      metadata.updated_at.should == 2002
+      metadata.size.should == 3
+    end
+  end
+  
+
+
+end

data/spec/asset_spec.rb

@@ -37,6 +37,10 @@ describe "Asset" do
     it "should have an ext" do
       @asset.extname.should == '.txt'
     end                                   
+    
+    it "should have a bucket_name" do    
+      @asset.bucket_name.should == 'products'
+    end
    
     
     it "should store data to the bucket" do

data/spec/base_spec.rb

@@ -64,6 +64,27 @@ describe BasicCloud do
     end
   end
   
+  describe "#[]" do
+    it "should return the appropriate asset when one exists" do
+      asset = @fs['products/key.txt']
+      asset.key.should == 'products/key.txt'
+      asset.value.should == 'value'
+    end
+    it "should not raise any errors when the asset doesn't exist" do
+      lambda { @fs['products/not-there.txt'] }.should_not raise_error
+    end
+  end
+  
+  describe "#[]=" do
+    it "should write through the Asset object (and thus run any callbacks on the asset)" do
+      special_asset = mock(:special_asset)
+      special_asset.should_receive(:value=).with('fancy fancy!')
+      special_asset.should_receive(:store)
+      SpecialAsset.should_receive(:at).and_return(special_asset)
+      @fs['special/fancy.txt'] = 'fancy fancy!'
+    end
+  end
+  
   describe "#bucket" do
     it "should allow specifying a class to use for assets in this bucket" do
       @fs['assets/rails_logo.gif'].should be_instance_of(AssetCloud::Asset)

data/spec/bucket_chain_spec.rb

@@ -0,0 +1,158 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class ChainedCloud < AssetCloud::Base
+  bucket :stuff, AssetCloud::BucketChain.chain( AssetCloud::MemoryBucket,
+                                                AssetCloud::MemoryBucket,
+                                                AssetCloud::FileSystemBucket )
+  
+  bucket :versioned_stuff, AssetCloud::BucketChain.chain( AssetCloud::FileSystemBucket,
+                                                          AssetCloud::VersionedMemoryBucket,
+                                                          AssetCloud::MemoryBucket )
+end
+
+describe AssetCloud::BucketChain do    
+  directory = File.dirname(__FILE__) + '/files'
+  
+  before(:each) do
+    @cloud = ChainedCloud.new(directory , 'http://assets/files' )
+    @bucket_chain = @cloud.buckets[:stuff]
+    @chained_buckets = @bucket_chain.chained_buckets
+    @chained_buckets.each {|b| b.ls('stuff').each {|asset| asset.delete}}
+    
+    @versioned_stuff = @cloud.buckets[:versioned_stuff]
+  end
+  
+  describe ".chain" do
+    it 'should take multiple Bucket classes and return a new Bucket class' do
+      @bucket_chain.should be_a_kind_of(AssetCloud::BucketChain)
+    end
+  end
+  
+  describe "#write" do
+    it 'should write to each sub-bucket when everything is kosher and return the result of the first write' do
+      @chained_buckets.each do |bucket|
+        bucket.should_receive(:write).with('stuff/foo', 'successful creation').and_return('successful creation')
+      end
+      
+      @bucket_chain.write('stuff/foo', 'successful creation').should == 'successful creation'
+    end
+    it 'should roll back creation-writes and re-raise an error when a bucket raises one' do
+      @chained_buckets.last.should_receive(:write).with('stuff/foo', 'unsuccessful creation').and_raise('hell')
+      @chained_buckets[0..-2].each do |bucket|
+        bucket.should_receive(:write).with('stuff/foo', 'unsuccessful creation').and_return(true)
+        bucket.should_receive(:delete).with('stuff/foo').and_return(true)
+      end
+      
+      lambda { @bucket_chain.write('stuff/foo', 'unsuccessful creation') }.should raise_error(RuntimeError)
+    end
+    it 'should roll back update-writes and re-raise an error when a bucket raises one' do
+      @bucket_chain.write('stuff/foo', "original value")
+      
+      @chained_buckets.last.should_receive(:write).with('stuff/foo', 'new value').and_raise('hell')
+      
+      lambda { @bucket_chain.write('stuff/foo', 'new value') }.should raise_error(RuntimeError)
+      @chained_buckets.each do |bucket|
+        bucket.read('stuff/foo').should == 'original value'
+      end
+    end
+  end
+  
+  describe "#delete" do
+    it 'should delete from each sub-bucket when everything is kosher' do
+      @bucket_chain.write('stuff/foo', "successful deletion comin' up")
+      
+      @chained_buckets.each do |bucket|
+        bucket.should_receive(:delete).with('stuff/foo').and_return(true)
+      end
+      
+      @bucket_chain.delete('stuff/foo')
+    end
+    it 'should roll back deletions and re-raise an error when a bucket raises one' do
+      @bucket_chain.write('stuff/foo', "this deletion will fail")
+      
+      @chained_buckets.last.should_receive(:delete).with('stuff/foo').and_raise('hell')
+      @chained_buckets[0..-2].each do |bucket|
+        bucket.should_receive(:delete).with('stuff/foo').and_return(true)
+        bucket.should_receive(:write).with('stuff/foo', 'this deletion will fail').and_return(true)
+      end
+      
+      lambda { @bucket_chain.delete('stuff/foo') }.should raise_error(RuntimeError)
+    end
+  end
+    
+  describe "#read" do
+    it 'should read from only the first available sub-bucket' do
+      @chained_buckets[0].should_receive(:read).with('stuff/foo').and_raise(NotImplementedError)
+      @chained_buckets[0].should_receive(:ls).with(nil).and_raise(NoMethodError)
+      @chained_buckets[0].should_receive(:stat).and_return(:metadata)
+      
+      @chained_buckets[1].should_receive(:read).with('stuff/foo').and_return('bar')
+      @chained_buckets[1].should_receive(:ls).with(nil).and_return(:some_assets)
+      @chained_buckets[1].should_not_receive(:stat)
+      
+      @chained_buckets[2..-1].each do |bucket|
+        bucket.should_not_receive(:read)
+        bucket.should_not_receive(:ls)
+        bucket.should_not_receive(:stat)
+      end
+      
+      @bucket_chain.read('stuff/foo').should == 'bar'
+      @bucket_chain.ls.should == :some_assets
+      @bucket_chain.stat.should == :metadata
+    end
+  end
+  
+    
+  describe "#read_version" do
+    it 'should read from only the first available sub-bucket' do
+      buckets = @versioned_stuff.chained_buckets
+      
+      buckets[1].should_receive(:read_version).with('stuff/foo',3).and_return('bar')
+      buckets.last.should_not_receive(:read_version)
+      
+      @versioned_stuff.read_version('stuff/foo', 3).should == 'bar'
+    end
+  end
+  
+  describe "#versions" do
+    it 'should read from only the first available sub-bucket' do
+      buckets = @versioned_stuff.chained_buckets
+      
+      buckets[1].should_receive(:versions).with('versioned_stuff/foo').and_return([1,2,3])
+      buckets.last.should_not_receive(:versions)
+      
+      @versioned_stuff.versions('versioned_stuff/foo').should == [1,2,3]
+    end
+  end
+  
+  describe "with versioned buckets" do
+    it 'should store and retrieve versions seamlessly' do
+      %w{one two three}.each do |content|
+        @cloud['versioned_stuff/foo'] = content
+      end
+      asset = @cloud['versioned_stuff/foo']
+      asset.value.should == 'three'
+      asset.rollback(1).value.should == 'one'
+      asset.versions.should == [1,2,3]
+      asset.value = 'four'
+      asset.store
+      asset.versions.should == [1,2,3,4]
+    end
+  end
+  
+  describe '#respond_to?' do
+    it 'should return true if any chained buckets respond to the given method' do
+      @bucket_chain.respond_to?(:foo).should == false
+      @chained_buckets[1].should_receive(:respond_to?).with(:bar).and_return(true)
+      @bucket_chain.respond_to?(:bar).should == true
+    end
+  end
+  
+  describe '#method_missing' do
+    it 'should try each bucket' do
+      @chained_buckets[1].should_receive(:buzz).and_return(true)
+      @chained_buckets[2].should_not_receive(:buzz)
+      @bucket_chain.buzz.should == true
+    end
+  end
+end

data/spec/callbacks_spec.rb

@@ -1,9 +1,17 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
+class CallbackAsset < AssetCloud::Asset
+  before_store :callback_before_store
+  after_delete :callback_after_delete
+end
+
+class BasicCloud < AssetCloud::Base
+  bucket :callback_assets, AssetCloud::MemoryBucket, :asset_class => CallbackAsset
+end
+
 class CallbackCloud < AssetCloud::Base
   bucket :tmp, AssetCloud::MemoryBucket
   
-
   after_delete :callback_after_delete
   before_delete :callback_before_delete
    
@@ -75,4 +83,26 @@ describe MethodRecordingCloud do
     @fs['tmp/file.txt'] = 'random data'
     @fs.run_callbacks.should == [:callback_before_write, :callback_before_write]
   end
+end
+
+describe CallbackAsset do
+  before(:each) do
+    @fs = BasicCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/')
+    @fs.write('callback_assets/foo', 'bar')
+    @asset = @fs.asset_at('callback_assets/foo')
+  end
+  
+  it "should run its before_store callback before store is called" do
+    @asset.should_receive(:callback_before_store).and_return(true)
+    @asset.should_not_receive(:callback_after_delete)
+    
+    @asset.store
+  end
+  
+  it "should run its after_delete callback after delete is called" do
+    @asset.should_not_receive(:callback_before_store)
+    @asset.should_receive(:callback_after_delete).and_return(true)
+    
+    @asset.delete
+  end
 end

data/spec/files/versioned_stuff/foo

@@ -0,0 +1 @@
+four

data/spec/memory_bucket_spec.rb

@@ -25,6 +25,22 @@ describe AssetCloud::MemoryBucket do
     
   end
   
+  describe '#ls' do
+    before do
+      %w{a b}.each do |letter|
+        2.times {|number| @fs.write("memory/#{letter}#{number}",'.')}
+      end
+    end
+    
+    it "should return a list of assets which start with the given prefix" do
+      @fs.buckets[:memory].ls('memory/a').size.should == 2
+    end
+    
+    it "should return a list of all assets when a prefix is not given" do
+      @fs.buckets[:memory].ls.size.should == 4
+    end
+  end
+  
 
 
 end

data/spec/validations_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class ValidatedAsset < AssetCloud::Asset
+  validate :no_cats
+  
+  private
+  def no_cats
+    add_error('no cats allowed!') if value =~ /cat/i
+  end
+end
+
+class BasicCloud < AssetCloud::Base
+  bucket :dog_pound, AssetCloud::MemoryBucket, :asset_class => ValidatedAsset
+end
+
+describe ValidatedAsset do
+  before(:each) do
+    @cloud = BasicCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/')
+    @cat = @cloud.build('dog_pound/fido', 'cat')
+    @dog = @cloud.build('dog_pound/fido', 'dog')
+  end
+  
+  describe "#store" do
+    it "should not store the asset unless validations pass" do
+      @cloud.should_receive(:write).with('dog_pound/fido', 'dog').and_return(true)
+      
+      @cat.store
+      @cat.store.should == false
+      @cat.errors.should == ['no cats allowed!']
+      @dog.store.should == true
+    end
+  end
+  
+  describe "#valid?" do
+    it "should clear errors, run validations, and return validity" do
+      @cat.store
+      @cat.errors.should == ['no cats allowed!']
+      @cat.valid?.should == false
+      @cat.errors.should == ['no cats allowed!']
+      @cat.value = 'disguised feline'
+      @cat.valid?.should == true
+      @cat.errors.should be_empty
+    end
+  end
+end

data/spec/versioned_memory_bucket_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/spec_helper'
+                                                    
+class VersionedMemoryCloud < AssetCloud::Base
+  bucket :memory, AssetCloud::VersionedMemoryBucket
+end
+
+describe AssetCloud::VersionedMemoryBucket do    
+  directory = File.dirname(__FILE__) + '/files'
+                    
+  before do
+    @fs = VersionedMemoryCloud.new(directory , 'http://assets/files' )
+    %w{one two three}.each do |content|
+      @fs.write("memory/foo", content)
+    end
+  end
+  
+  describe '#read_version' do
+    it "should return the appropriate data when given a key and version" do
+      @fs.read_version('memory/foo', 1).should == 'one'
+      @fs.read_version('memory/foo', 3).should == 'three'
+    end
+  end
+  
+  describe '#versions' do
+    it "should return a list of available version identifiers for the given key" do
+      @fs.versions('memory/foo').should == [1,2,3]
+    end
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jamesmacaulay-asset_cloud
 version: !ruby/object:Gem::Version 
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors: 
 - Shopify
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-17 00:00:00 -07:00
+date: 2009-07-03 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -36,27 +36,35 @@ files:
 - lib/asset_cloud.rb
 - lib/asset_cloud/asset.rb
 - lib/asset_cloud/base.rb
-- lib/asset_cloud/blackhole_bucket.rb
 - lib/asset_cloud/bucket.rb
+- lib/asset_cloud/buckets/active_record_bucket.rb
+- lib/asset_cloud/buckets/blackhole_bucket.rb
+- lib/asset_cloud/buckets/bucket_chain.rb
+- lib/asset_cloud/buckets/file_system_bucket.rb
+- lib/asset_cloud/buckets/invalid_bucket.rb
+- lib/asset_cloud/buckets/memory_bucket.rb
+- lib/asset_cloud/buckets/versioned_memory_bucket.rb
 - lib/asset_cloud/callbacks.rb
-- lib/asset_cloud/file_system_bucket.rb
 - lib/asset_cloud/free_key_locator.rb
-- lib/asset_cloud/invalid_bucket.rb
-- lib/asset_cloud/memory_bucket.rb
 - lib/asset_cloud/metadata.rb
+- lib/asset_cloud/validations.rb
+- spec/active_record_bucket_spec.rb
 - spec/asset_spec.rb
 - spec/base_spec.rb
 - spec/blackhole_bucket_spec.rb
-- spec/bucket_spec.rb
+- spec/bucket_chain_spec.rb
 - spec/callbacks_spec.rb
 - spec/file_system_spec.rb
 - spec/files/products/key.txt
+- spec/files/versioned_stuff/foo
 - spec/find_free_key_spec.rb
 - spec/memory_bucket_spec.rb
 - spec/regexp_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
-has_rdoc: true
+- spec/validations_spec.rb
+- spec/versioned_memory_bucket_spec.rb
+has_rdoc: false
 homepage: http://github.com/Shopify/asset_cloud
 post_install_message: 
 rdoc_options: 
@@ -83,13 +91,16 @@ signing_key:
 specification_version: 3
 summary: An abstraction layer around arbitrary and diverse asset stores.
 test_files: 
+- spec/active_record_bucket_spec.rb
 - spec/asset_spec.rb
 - spec/base_spec.rb
 - spec/blackhole_bucket_spec.rb
-- spec/bucket_spec.rb
+- spec/bucket_chain_spec.rb
 - spec/callbacks_spec.rb
 - spec/file_system_spec.rb
 - spec/find_free_key_spec.rb
 - spec/memory_bucket_spec.rb
 - spec/regexp_spec.rb
 - spec/spec_helper.rb
+- spec/validations_spec.rb
+- spec/versioned_memory_bucket_spec.rb

data/spec/bucket_spec.rb

@@ -1,41 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-class ChainedCloud < AssetCloud::Base
-  bucket :stuff, AssetCloud::Bucket.chain(AssetCloud::MemoryBucket, AssetCloud::BlackholeBucket)
-end
-
-describe AssetCloud::Bucket do    
-  directory = File.dirname(__FILE__) + '/files'
-  
-  before(:each) do
-    @cloud = ChainedCloud.new(directory , 'http://assets/files' )
-    @bucket_chain = @cloud.buckets[:stuff]
-    @memory_bucket, @blackhole_bucket = @bucket_chain.chained_buckets
-  end
-  
-  describe "#chain" do
-    it 'should take multiple Bucket classes and return a new Bucket class' do
-      @bucket_chain.should be_a_kind_of(AssetCloud::Bucket)
-    end
-    
-    it 'should return a Bucket which writes to each sub-bucket' do
-      @bucket_chain.chained_buckets.each do |bucket|
-        bucket.should_receive(:write).with('stuff/foo', 'bar').and_return(true)
-        bucket.should_receive(:delete).with('stuff/foo').and_return(true)
-      end
-      
-      @bucket_chain.write('stuff/foo', 'bar')
-      @bucket_chain.delete('stuff/foo')
-    end
-    
-    it 'should return a Bucket which reads from only the first sub-bucket' do
-      @memory_bucket.should_receive(:read).with('stuff/foo').and_return('bar')
-      @memory_bucket.should_receive(:ls).with(nil).and_return(:some_assets)
-      @blackhole_bucket.should_not_receive(:read)
-      @blackhole_bucket.should_not_receive(:ls)
-      
-      @bucket_chain.read('stuff/foo').should == 'bar'
-      @bucket_chain.ls.should == :some_assets
-    end
-  end
-end