jamesmacaulay-asset_cloud 0.5.0

data/lib/asset_cloud/file_system_bucket.rb

@@ -0,0 +1,79 @@
+module AssetCloud
+   
+  class FileSystemBucket < Bucket
+
+    def ls(key = nil)
+      objects = []
+      base_path = File.join(path_for(key), '*')
+
+      Dir.glob(base_path).each do |f| 
+        next unless File.file?(f)
+        objects.push Asset.at(cloud, relative_path_for(f) )
+      end                                  
+      objects
+    end
+
+    def read(key)                  
+      File.read(path_for(key))
+    rescue Errno::ENOENT => e
+      raise AssetCloud::AssetNotFoundError, key
+    end          
+    
+    def delete(key)      
+      File.delete(path_for(key))
+    rescue Errno::ENOENT
+    end          
+
+    def write(key, data)            
+      full_path = path_for(key)   
+      
+      retried = false            
+
+      begin   
+        File.open(full_path, "wb+") { |fp| fp << data }      
+        true
+      rescue Errno::ENOENT => e 
+        if retried == false 
+          directory = File.dirname(full_path)
+          FileUtils.mkdir_p(File.dirname(full_path))                  
+          retried = true
+          retry 
+        else
+          raise
+        end 
+        false
+      end
+    end
+
+    def stat(key)           
+      begin 
+        stat = File.stat(path_for(key))
+        Metadata.new(true, stat.size, stat.ctime, stat.mtime)
+      rescue Errno::ENOENT => e   
+        Metadata.new(false)
+      end
+    end 
+
+    protected
+    
+    def path_for(key)
+      cloud.path_for(key)
+    end                 
+    
+    def path
+      cloud.path
+    end
+    
+    private
+
+    def remove_full_path_regexp
+      @regexp ||= /^#{path}\//
+    end
+
+    def relative_path_for(f)  
+      f.sub(remove_full_path_regexp, '')
+    end
+  end
+  
+  
+end

data/lib/asset_cloud/free_key_locator.rb

@@ -0,0 +1,39 @@
+module AssetCloud    
+   
+  module FreeKeyLocator
+     
+    def find_free_key_like(key, options = {})                                                            
+      # Check weather the suggested key name is free. If so we
+      # simply return it.                 
+      
+      if not exist?(key)
+        key
+      else                                       
+                                                                      
+        ext         = File.extname(key)
+        dirname     = File.dirname(key)
+        base        = dirname == '.' ? File.basename(key, ext) : File.join(File.dirname(key), File.basename(key, ext))
+        count       = base.scan(/\d+$/).flatten.first.to_i
+        base        = base.gsub(/([\-\_]?)\d+$/,'')  
+        separator   = $1 || '_'
+        
+
+        # increase the count until you find a unused key
+        10.times do                              
+          count += 1
+          key = "#{base}#{separator}#{count}#{ext}"
+          return key unless exist?(key)
+        end
+
+        # Ok we have to go random here...
+        100.times do                              
+          count += rand(9999999)
+          key = "#{base}#{separator}#{count}#{ext}"
+          return key unless exist?(key)
+        end
+
+        raise StandardError, 'Filesystem out of free filenames' 
+      end
+    end
+  end
+end

data/lib/asset_cloud/invalid_bucket.rb

@@ -0,0 +1,28 @@
+module AssetCloud
+  class InvalidBucketError < StandardError
+  end
+  
+  class InvalidBucket < Bucket  
+    Error = "No such namespace: %s".freeze
+    
+    def ls(namespace)     
+      raise InvalidBucketError, Error % key
+    end                               
+
+    def read(key)  
+      raise InvalidBucketError, Error % key
+    end          
+
+    def write(key, data)       
+      raise InvalidBucketError, Error % key
+    end   
+
+    def delete(key)
+      raise InvalidBucketError, Error % key
+    end           
+    
+    def stat(key)
+      raise InvalidBucketError, Error % key
+    end
+  end
+end

data/lib/asset_cloud/memory_bucket.rb

@@ -0,0 +1,40 @@
+module AssetCloud
+   
+  class MemoryBucket < Bucket
+    
+    def initialize(*args)
+      super
+      @memory = {}
+    end
+
+    def ls(key = nil)
+      @memory.find_all do |key, value|
+        key.left(key.size) == namespace
+      end
+    end
+
+    def read(key)  
+      raise AssetCloud::AssetNotFoundError, key unless @memory.has_key?(key)
+      @memory[key]
+    end          
+    
+    def delete(key)
+      @memory.delete(key)
+    end          
+
+    def write(key, data)    
+      @memory[key] = data
+
+      true
+    end
+
+    def stat(key)
+      return Metadata.non_existing unless @memory.has_key?(key)
+          
+      Metadata.new(true, @memory[key].size)
+    end 
+
+  end
+  
+  
+end

data/lib/asset_cloud/metadata.rb

@@ -0,0 +1,30 @@
+module AssetCloud
+
+  class Metadata
+    attr_accessor :exist, :size, :created_at, :updated_at
+    
+    def new?
+      !self.exist
+    end                 
+    
+    def exist?
+      self.exist
+    end
+    
+    def initialize(exist, size = nil, created_at = nil, updated_at = nil)
+      self.exist, self.size, self.created_at, self.updated_at = exist, size, created_at, updated_at
+    end                 
+    
+    def self.existing
+      self.new(true)
+    end
+
+    def self.non_existing
+      self.new false
+    end    
+    
+    def inspect
+      "#<#{self.class.name}: exist:#{exist} size:#{size.inspect} bytes>"
+    end  
+  end
+end

data/lib/asset_cloud.rb

@@ -0,0 +1,23 @@
+require 'active_support'
+
+# Core
+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'   
+
+
+# Extensions
+require File.dirname(__FILE__) + '/asset_cloud/free_key_locator'
+require File.dirname(__FILE__) + '/asset_cloud/callbacks'
+
+
+AssetCloud::Base.class_eval do
+  include AssetCloud::FreeKeyLocator                                
+  include AssetCloud::Callbacks                                
+end
+

data/spec/asset_spec.rb

@@ -0,0 +1,135 @@
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Asset" do
+  include AssetCloud
+  
+  before do
+    @cloud = mock('Bucket')
+  end               
+  
+  describe "when first created (without a value)" do    
+    before do
+      @asset = AssetCloud::Asset.new(@cloud, "products/key.txt")
+    end            
+    
+    it "should be return new_asset? => true" do
+      @asset.new_asset?.should == true
+    end
+
+    it "should have a key" do
+      @asset.key.should == 'products/key.txt'    
+    end                                     
+
+    it "should have a value of nil" do   
+
+      @asset.value.should == nil
+    end                                     
+
+    it "should have a basename" do    
+      @asset.basename.should == 'key.txt'
+    end
+
+    it "should have a basename without ext (if required)" do    
+      @asset.basename_without_ext.should == 'key'
+    end
+
+    it "should have an ext" do
+      @asset.extname.should == '.txt'
+    end                                   
+   
+    
+    it "should store data to the bucket" do
+      @cloud.should_receive(:write).with("products/key.txt", 'value')
+                              
+      @asset.value = 'value'
+      @asset.store
+    end
+
+    it "should not try to store data when it's value is nil" do
+      @cloud.should_receive(:write).never
+
+      @asset.store
+    end
+
+    it "should not try to read data from bucket if its a new_asset" do
+      @cloud.should_receive(:read).never
+
+      @asset.value.should == nil
+    end                 
+    
+    it "should simply ignore calls to delete" do
+      @cloud.should_receive(:delete).never
+      
+      @asset.delete
+    end
+    
+  end
+  
+  describe "when first created with value" do    
+    before do
+      @asset = AssetCloud::Asset.new(@cloud, "products/key.txt", 'value')
+    end           
+    
+    it "should be return new_asset? => true" do
+      @asset.new_asset?.should == true
+    end
+     
+    
+    it "should have a value of 'value'" do   
+      @asset.value.should == 'value'
+    end              
+    
+    it "should return false when asked if it exists because its still a new_asset" do
+      @asset.exist?.should == false
+    end
+
+
+    it "should not try to read data from bucket if its a new_asset" do
+      @cloud.should_receive(:read).never
+
+      @asset.value.should == 'value'
+    end
+    
+    it "should write data to the bucket" do
+      @cloud.should_receive(:write).with("products/key.txt", 'value')                              
+      @asset.store      
+    end
+    
+  end                 
+  
+  describe "when fetched from the bucket" do
+    before do
+      @asset = AssetCloud::Asset.at(@cloud, "products/key.txt", 'value', AssetCloud::Metadata.new(true, 'value'.size, Time.now, Time.now))
+    end                   
+    
+    it "should be return new_asset? => false" do
+      @asset.new_asset?.should == false
+    end
+                             
+    it "should indicate that it exists" do
+      
+      @asset.exist?.should == true
+    end
+    
+    
+    it "should read the value from the bucket" do      
+      @asset.value.should == 'value'
+    end     
+    
+    
+    it "should simply ignore calls to delete" do
+      @cloud.should_receive(:delete).and_return(true)
+      
+      @asset.delete
+    end         
+    
+    it "should ask the bucket to create a full url" do
+      @cloud.should_receive(:url_for).with('products/key.txt').and_return('http://assets/products/key.txt')
+      
+      @asset.url.should == 'http://assets/products/key.txt'
+    end
+  end
+   
+  
+end

data/spec/base_spec.rb

@@ -0,0 +1,77 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class SpecialAsset < AssetCloud::Asset
+end
+
+class BasicCloud < AssetCloud::Base
+  bucket :special, AssetCloud::MemoryBucket, :asset_class => SpecialAsset
+end
+
+
+describe BasicCloud do    
+  directory = File.dirname(__FILE__) + '/files'
+                    
+  before do
+    @fs = BasicCloud.new(directory , 'http://assets/files' )
+  end                          
+    
+  it "should raise invalid bucket if none is given" do
+    @fs['image.jpg'].exist?.should == false
+  end
+
+  
+  it "should be backed by a file system bucket" do     
+    @fs['products/key.txt'].exist?.should == true    
+  end
+  
+  it "should raise when listing non existing buckets" do
+    @fs.ls('products').should == [AssetCloud::Asset.new(@fs, 'products/key.txt')]
+  end
+                
+ 
+  it "should allow you to create new assets" do
+    obj = @fs.build('new_file.test')
+    obj.should be_an_instance_of(AssetCloud::Asset)
+    obj.cloud.should be_an_instance_of(BasicCloud)
+  end                  
+  
+  it "should raise error when using with minus relative or absolute paths" do    
+    lambda { @fs['../test']  }.should raise_error(AssetCloud::IllegalPath)
+    lambda { @fs['/test']    }.should raise_error(AssetCloud::IllegalPath)
+    lambda { @fs['.../test'] }.should raise_error(AssetCloud::IllegalPath)
+    lambda { @fs['./test']   }.should raise_error(AssetCloud::IllegalPath)
+  end                                                                         
+  
+  it "should allow sensible relative filenames" do
+    @fs['assets/rails_logo.gif']
+    @fs['assets/rails-2.gif']
+    @fs['assets/223434.gif']
+    @fs['files/1.JPG']
+  end
+  
+  it "should compute complete urls to assets" do    
+    @fs.url_for('products/key.txt').should == 'http://assets/files/products/key.txt'    
+  end                                               
+  
+  describe "#find" do
+    it "should return the appropriate asset when one exists" do
+      asset = @fs.find('products/key.txt')
+      asset.key.should == 'products/key.txt'
+      asset.value.should == 'value'
+    end
+    it "should raise AssetNotFoundError when the asset doesn't exist" do
+      lambda { @fs.find('products/not-there.txt') }.should raise_error(AssetCloud::AssetNotFoundError)
+    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)
+      @fs['special/fancy.txt'].should be_instance_of(SpecialAsset)
+      
+      @fs.build('assets/foo').should be_instance_of(AssetCloud::Asset)
+      @fs.build('special/foo').should be_instance_of(SpecialAsset)
+    end
+  end
+                
+end

data/spec/blackhole_bucket_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/spec_helper'
+                                                    
+class BlackholeCloud < AssetCloud::Base     
+  bucket AssetCloud::BlackholeBucket
+end
+
+describe BlackholeCloud do    
+  directory = File.dirname(__FILE__) + '/files'
+                    
+  before do
+    @fs = BlackholeCloud.new(directory , 'http://assets/files' )
+  end                        
+   
+  it "should allow access to files using the [] operator" do
+    @fs['tmp/image.jpg']
+  end
+                
+  it "should return nil for non existent files" do
+    @fs['tmp/image.jpg'].exist?.should == false
+  end
+
+  it "should still return nil, even if you wrote something there" do
+    @fs['tmp/image.jpg'] = 'test'
+    @fs['tmp/image.jpg'].exist?.should == false
+  end
+  
+  describe "when using a sub path" do
+    it "should allow access to files using the [] operator" do
+      @fs['tmp/image.jpg']
+    end
+
+    it "should return nil for non existent files" do
+      @fs['tmp/image.jpg'].exist?.should == false
+    end
+
+    it "should still return nil, even if you wrote something there" do
+      @fs['tmp/image.jpg'] = 'test'
+      @fs['tmp/image.jpg'].exist?.should == false
+    end    
+  end
+end

data/spec/bucket_spec.rb

@@ -0,0 +1,41 @@
+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

data/spec/callbacks_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class CallbackCloud < AssetCloud::Base
+  bucket :tmp, AssetCloud::MemoryBucket
+  
+
+  after_delete :callback_after_delete
+  before_delete :callback_before_delete
+   
+  after_write :callback_after_write
+  before_write :callback_before_write
+end
+
+class MethodRecordingCloud < AssetCloud::Base
+  attr_accessor :run_callbacks
+  
+  bucket :tmp, AssetCloud::MemoryBucket  
+
+  before_write :callback_before_write
+  after_write :callback_before_write
+
+
+  def method_missing(method, *args)
+    @run_callbacks << method.to_sym
+  end
+end
+
+describe CallbackCloud do
+  before { @fs = CallbackCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/') }
+  
+  it "should invoke callbacks after store" do
+    
+    @fs.should_receive(:callback_before_write).with('tmp/file.txt', 'text').and_return(true)
+    @fs.should_receive(:callback_after_write).with('tmp/file.txt', 'text').and_return(true)
+    
+    
+    @fs.write 'tmp/file.txt', 'text'
+    
+  end
+
+  it "should invoke callbacks after delete" do
+    
+    @fs.should_receive(:callback_before_delete).with('tmp/file.txt').and_return(true)
+    @fs.should_receive(:callback_after_delete).with('tmp/file.txt').and_return(true)
+    
+    
+    @fs.delete 'tmp/file.txt'    
+  end                        
+  
+  it "should invoke callbacks even when constructing a new asset" do
+    @fs.should_receive(:callback_before_write).with('tmp/file.txt', 'hello').and_return(true)
+    @fs.should_receive(:callback_after_write).with('tmp/file.txt', 'hello').and_return(true)
+    
+    
+    asset = @fs.build('tmp/file.txt')
+    asset.value = 'hello'
+    asset.store
+    
+  end
+  
+end
+
+describe MethodRecordingCloud do
+  before do 
+    @fs = MethodRecordingCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/') 
+    @fs.run_callbacks = []
+  end
+   
+  it 'should record event when invoked' do
+    @fs.write('tmp/file.txt', 'random data')        
+    @fs.run_callbacks.should == [:callback_before_write, :callback_before_write]
+  end
+
+  it 'should record event when assignment operator is used' do
+    @fs['tmp/file.txt'] = 'random data'
+    @fs.run_callbacks.should == [:callback_before_write, :callback_before_write]
+  end
+end

data/spec/file_system_spec.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/spec_helper'
+                                                    
+class FileSystemCloud < AssetCloud::Base 
+  bucket AssetCloud::InvalidBucket
+  bucket :products, AssetCloud::FileSystemBucket
+  bucket :tmp,      AssetCloud::FileSystemBucket
+end
+
+
+describe FileSystemCloud do    
+  directory = File.dirname(__FILE__) + '/files'
+                    
+  before do
+    @fs = FileSystemCloud.new(directory , 'http://assets/files' )
+    FileUtils.mkdir_p(directory + '/tmp')
+  end                        
+  
+  after do
+    FileUtils.rm_rf(directory + '/tmp')
+  end
+  
+  it "should use invalid bucket for random directories" do
+    @fs.bucket_for('does-not-exist/file.txt').should be_an_instance_of(AssetCloud::InvalidBucket)
+  end
+
+  it "should use filesystem bucekt for products/ and tmp/  directories" do
+    @fs.bucket_for('products/file.txt').should be_an_instance_of(AssetCloud::FileSystemBucket)
+    @fs.bucket_for('tmp/file.txt').should be_an_instance_of(AssetCloud::FileSystemBucket)
+  end
+
+  it "should return Asset for existing files" do
+    @fs['products/key.txt'].exist?.should == true
+    @fs['products/key.txt'].should be_an_instance_of(AssetCloud::Asset)
+  end           
+  
+  it "should be able to test if a file exists or not" do
+    @fs.stat('products/key.txt').exist?.should == true
+    @fs.stat('products/key2.txt').exist?.should == false
+  end
+
+  it "should be able to list files" do
+    @fs.ls('products').collect(&:key).should == ['products/key.txt']
+  end
+    
+  describe 'when modifying file system' do 
+
+    it "should call write after storing an asset" do      
+      @fs.buckets[:tmp].should_receive(:write).with('tmp/new_file.test', 'hello world').and_return(true)
+      
+      @fs.build('tmp/new_file.test', 'hello world').store      
+    end                                             
+    
+    it "should be able to create new files" do
+      @fs.build('tmp/new_file.test', 'hello world').store
+      
+      @fs.stat('tmp/new_file.test').exist.should == true
+    end
+    
+    it "should be able to create new files with simple assignment" do
+      @fs['tmp/new_file.test'] = 'hello world'
+      
+      @fs.stat('tmp/new_file.test').exist.should == true      
+    end
+    
+    it "should create directories as needed" do            
+      @fs.build('tmp/new_file.test', 'hello world').store
+
+      @fs['tmp/new_file.test'].exist?.should == true
+      @fs['tmp/new_file.test'].value.should == 'hello world'
+    end
+    
+  end
+end

data/spec/files/products/key.txt

@@ -0,0 +1 @@
+value