asset_cloud 1.0.2

data/lib/asset_cloud/free_key_locator.rb

@@ -0,0 +1,28 @@
+require 'securerandom'
+
+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))
+        base        = base.gsub(/_[\h]{8}-[\h]{4}-4[\h]{3}-[\h]{4}-[\h]{12}/, "")
+
+        # Attach UUID to avoid name collision
+        key = "#{base}_#{SecureRandom.uuid}#{ext}"
+        return key unless exist?(key)
+
+        raise StandardError, 'Filesystem out of free filenames'
+      end
+    end
+  end
+end

data/lib/asset_cloud/metadata.rb

@@ -0,0 +1,29 @@
+module AssetCloud
+  class Metadata
+    attr_accessor :exist, :size, :created_at, :updated_at, :value_hash
+
+    def new?
+      !self.exist
+    end
+
+    def exist?
+      self.exist
+    end
+
+    def initialize(exist, size = nil, created_at = nil, updated_at = nil, value_hash = nil)
+      self.exist, self.size, self.created_at, self.updated_at, self.value_hash = exist, size, created_at, updated_at, value_hash
+    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/validations.rb

@@ -0,0 +1,52 @@
+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 warnings
+      @warnings ||= []
+    end
+
+    def valid?
+      validate
+      errors.empty?
+    end
+
+    def add_error(msg)
+      errors << msg
+      errors.uniq!
+    end
+
+    def add_warning(*msgs)
+      warnings.concat(msgs)
+    end
+
+    def validate
+      errors.clear
+      warnings.clear
+      execute_callbacks(:validate, [])
+    end
+  end
+end

data/spec/active_record_bucket_spec.rb

@@ -0,0 +1,95 @@
+require '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 = double("connection"))
+      @mock_connection.should_receive(:quote_column_name).with('name').and_return("`name`")
+      (@mock_record = double("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 = double("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 = double("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 = double("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 = double("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_extension_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+class NoCatsAsset < AssetCloud::Asset
+  validate :no_cats
+  before_store :asset_callback
+
+  private
+  def no_cats
+    add_error('no cats allowed!') if value =~ /cat/i
+  end
+end
+
+class CssAssetExtension < AssetCloud::AssetExtension
+  applies_to :css
+
+  validate :valid_css
+
+  private
+  def valid_css
+    add_error "not enough curly brackets!" unless asset.value =~ /\{.*\}/
+  end
+end
+
+class XmlAssetExtension < AssetCloud::AssetExtension
+  applies_to :xml
+
+  validate :valid_xml
+  before_store :xml_callback
+
+  def turn_into_xml
+    asset.value = "<xml>#{asset.value}</xml>"
+  end
+
+  private
+  def valid_xml
+    add_error "not enough angle brackets!" unless asset.value =~ /\<.*\>/
+  end
+end
+
+class CatsAndDogsCloud < AssetCloud::Base
+  bucket :dog_pound, AssetCloud::MemoryBucket, :asset_class => NoCatsAsset
+  bucket :cat_pen, AssetCloud::MemoryBucket
+
+  asset_extensions CssAssetExtension, :only => :cat_pen
+  asset_extensions XmlAssetExtension, :except => :cat_pen
+end
+
+describe "AssetExtension" do
+  include AssetCloud
+
+  before do
+    @cloud = CatsAndDogsCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/')
+  end
+
+  describe "applicability" do
+    it "should work" do
+      asset = @cloud['cat_pen/cats.xml']
+      XmlAssetExtension.applies_to_asset?(asset).should == true
+    end
+  end
+
+  describe "validations" do
+    it "should be added to assets in the right bucket with the right extension" do
+      asset = @cloud['cat_pen/cats.css']
+      asset.value = 'foo'
+      asset.store.should == false
+      asset.errors.should == ["not enough curly brackets!"]
+    end
+
+    it "should not squash existing validations on the asset" do
+      asset = @cloud['dog_pound/cats.xml']
+      asset.value = 'cats!'
+      asset.store.should == false
+      asset.errors.should == ['no cats allowed!', "not enough angle brackets!"]
+    end
+
+    it "should not apply to non-matching assets or those in exempted buckets" do
+      asset = @cloud['cat_pen/cats.xml']
+      asset.value = "xml"
+      asset.store.should == true
+    end
+  end
+
+  describe "callbacks" do
+    it "should run alongside the asset's callbacks" do
+      asset = @cloud['dog_pound/dogs.xml']
+      asset.should_receive(:asset_callback)
+      asset.extensions.first.should_receive(:xml_callback)
+      asset.value = '<dogs/>'
+      asset.store.should == true
+    end
+  end
+
+  describe "#method_missing" do
+    it "should try to run method on extensions" do
+      asset = @cloud['dog_pound/dogs.xml']
+      asset.value = 'dogs'
+      asset.turn_into_xml
+      asset.value.should == '<xml>dogs</xml>'
+    end
+  end
+
+end

data/spec/asset_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+describe "Asset" do
+  include AssetCloud
+
+  before do
+    @cloud = double('Cloud', :asset_extension_classes_for_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 have a relative_key_without_ext" do
+      @asset.relative_key_without_ext.should == 'key'
+    end
+
+    it "should have a bucket_name" do
+      @asset.bucket_name.should == 'products'
+    end
+
+    it "should have a bucket" do
+      @cloud.should_receive(:buckets).and_return(:products => :products_bucket)
+      @asset.bucket.should == :products_bucket
+    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 (without a value) with subdirectory" do
+    before do
+      @asset = AssetCloud::Asset.new(@cloud, "products/retail/key.txt")
+    end
+
+    it "should have a relative_key_without_ext" do
+      @asset.relative_key_without_ext.should == 'retail/key'
+    end
+
+    it "should have a relative_key" do
+      @asset.relative_key.should == 'retail/key.txt'
+    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
+
+    it "should ask the bucket whether or not it is versioned" do
+      bucket = double('Bucket')
+      @cloud.should_receive(:buckets).and_return(:products => bucket)
+      bucket.should_receive(:versioned?).and_return(true)
+
+      @asset.versioned?.should == true
+    end
+
+    it "should validate its key" do
+      asset = AssetCloud::Asset.new(@cloud, "products/foo, bar.txt", "data")
+      asset.store.should == false
+      asset.errors.size.should == 1
+      asset.errors.first.should =~ /illegal characters/
+    end
+  end
+
+
+end