jamesmacaulay-asset_cloud 0.5.0

data/.document

@@ -0,0 +1,3 @@
+README.rdoc
+lib/**/*.rb
+LICENSE

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+*.orig
+.dotest

data/CHANGELOG

@@ -0,0 +1,7 @@
+June 2009:
+
+* 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

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2009 Tobias Lütke & Jaded Pixel, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,17 @@
+= AssetCloud
+
+An abstraction layer around arbitrary and diverse asset stores.
+
+== Installation
+
+=== as a Gem
+
+    gem install Shopify-asset_cloud -s http://gems.github.com
+
+=== as a Rails plugin
+
+    script/plugin install git://github.com/Shopify/asset_cloud.git
+
+== Copyright
+
+Copyright (c) 2008-2009 Tobias Lütke & Jaded Pixel, Inc. Released under the MIT license (see LICENSE for details).

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+desc 'Default: run unit tests.'
+task :default => [:spec]
+
+desc "Run all spec examples"
+Spec::Rake::SpecTask.new do |t|
+  t.libs << "spec"
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = ['--options', %\"#{File.dirname(__FILE__)}/spec/spec.opts"\]
+end
+
+desc 'Generate documentation for the asset_cloud plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'AssetCloud'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "asset_cloud"
+    gemspec.summary = "An abstraction layer around arbitrary and diverse asset stores."
+    gemspec.email = "developers@shopify.com"
+    gemspec.homepage = "http://github.com/Shopify/asset_cloud"
+    gemspec.description = "An abstraction layer around arbitrary and diverse asset stores."
+    gemspec.authors = ["Shopify"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION

@@ -0,0 +1 @@
+0.5.1

data/asset_cloud.gemspec

@@ -0,0 +1,79 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{asset_cloud}
+  s.version = "0.5.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Shopify"]
+  s.date = %q{2009-06-16}
+  s.description = %q{An abstraction layer around arbitrary and diverse asset stores.}
+  s.email = %q{developers@shopify.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "CHANGELOG",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "asset_cloud.gemspec",
+     "init.rb",
+     "install.rb",
+     "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/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",
+     "spec/asset_spec.rb",
+     "spec/base_spec.rb",
+     "spec/blackhole_bucket_spec.rb",
+     "spec/bucket_spec.rb",
+     "spec/callbacks_spec.rb",
+     "spec/file_system_spec.rb",
+     "spec/files/products/key.txt",
+     "spec/find_free_key_spec.rb",
+     "spec/memory_bucket_spec.rb",
+     "spec/regexp_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.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.summary = %q{An abstraction layer around arbitrary and diverse asset stores.}
+  s.test_files = [
+    "spec/asset_spec.rb",
+     "spec/base_spec.rb",
+     "spec/blackhole_bucket_spec.rb",
+     "spec/bucket_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"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+# Include hook code here

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/asset_cloud/asset.rb

@@ -0,0 +1,119 @@
+module AssetCloud
+  
+  class AssetError < StandardError
+  end
+  
+  class AssetNotSaved < AssetError
+  end
+
+  class Asset    
+    include Comparable
+    attr_accessor :key, :value, :cloud, :metadata
+    attr_accessor :new_asset
+    
+    def initialize(cloud, key, value = nil, metadata = Metadata.non_existing)    
+      @new_asset = true
+      @cloud     = cloud
+      @key       = key
+      @value     = value                              
+      @metadata  = metadata                                                 
+      
+      if @cloud.blank? 
+        raise ArgumentError, "cloud is not a valid AssetCloud::Base"
+      end
+         
+      yield self if block_given?    
+    end                                                    
+    
+    def self.at(cloud, key, value = nil, metadata = nil, &block)
+      file = self.new(cloud, key, value, metadata,  &block)
+      file.new_asset = false
+      file
+    end
+      
+    def <=>(other)
+      cloud.object_id <=> other.cloud.object_id && key <=> other.key
+    end           
+    
+    def new_asset?
+      @new_asset
+    end              
+    
+    def dirname
+      File.dirname(@key)
+    end              
+  
+    def extname
+      File.extname(@key)
+    end
+      
+    def basename
+      File.basename(@key)
+    end        
+  
+    def basename_without_ext                              
+      File.basename(@key, extname)
+    end     
+    
+    def size
+      metadata.size
+    end
+      
+    def exist?
+      metadata.exist?
+    end       
+    
+    def created_at
+      metadata.created_at
+    end    
+            
+    def delete
+      if new_asset?
+        false
+      else
+        cloud.delete(key)
+      end
+    end
+    
+    def metadata
+      @metadata ||= cloud.stat(key)
+    end
+  
+    def value 
+      @value ||= if new_asset?
+        nil 
+      else        
+        cloud.read(key)
+      end
+    end
+  
+    def store                 
+      unless @value.nil?    
+        @new_asset = false
+        @metadata = nil
+        cloud.write(key, value)         
+      end
+    end               
+
+    def store!                 
+      store or raise AssetNotSaved
+    end               
+ 
+    def to_param
+      basename
+    end
+  
+    def handle
+      basename.to_handle
+    end                            
+      
+    def url    
+      cloud.url_for key
+    end                   
+      
+  
+    def inspect
+      "#<#{self.class.name}: #{key}>"
+    end  
+  end
+end

data/lib/asset_cloud/base.rb

@@ -0,0 +1,178 @@
+
+module AssetCloud
+  
+  class IllegalPath < StandardError
+  end
+
+  class Base    
+    cattr_accessor :logger       
+    
+    VALID_PATHS = /^[a-z0-9][a-z0-9_\-\/]+([a-z0-9][\w\-\ \.]*\.\w{2,6})?$/i
+  
+    attr_accessor :url, :root        
+    
+    class_inheritable_accessor :root_bucket_class
+    self.root_bucket_class = FileSystemBucket
+    class_inheritable_accessor :root_asset_class
+    self.root_asset_class  = Asset
+    
+    class_inheritable_hash :bucket_classes
+    self.bucket_classes = {}
+    class_inheritable_hash :asset_classes
+    self.asset_classes = {}
+    
+    def self.bucket(*args)      
+      asset_class = if args.last.is_a? Hash
+        args.pop[:asset_class]
+      end
+      
+      if args.last.is_a? Class
+        bucket_class = args.pop
+      else
+        raise ArgumentError, 'requires a bucket class'
+      end
+
+      if bucket_name = args.first
+        self.bucket_classes[bucket_name.to_sym] = bucket_class
+        self.asset_classes[bucket_name.to_sym]  = asset_class if asset_class
+      else
+        self.root_bucket_class = bucket_class
+        self.root_asset_class  = asset_class if asset_class
+      end
+    end    
+
+    def buckets
+      @buckets ||= Hash.new do |hash, key|
+        if klass = self.class.bucket_classes[key] 
+          hash[key] = klass.new(self, key)
+        else       
+          hash[key] = nil
+        end
+      end
+    end
+  
+    def initialize(root, url = '/')            
+      @root, @url = root, url
+    end             
+  
+    def url_for(key, secure = false)
+      File.join(@url, key)
+    end                         
+
+    def path_for(key)
+      File.join(path, key) 
+    end              
+    
+    def path
+      root
+    end
+    
+    def find(key)
+      returning asset_at(key) do |asset|
+        asset.value
+      end
+    end
+    
+    def asset_at(key)
+      check_key_for_errors(key)
+      
+      asset_class_for(key).at(self, key)        
+    end            
+  
+    def move(source, destination)
+      return if source == destination                   
+
+      object = copy(source, destination)                      
+      asset_at(source).delete
+      object
+    end       
+  
+    def copy(source, destination)
+      return if source == destination                   
+
+      object = build(destination, read(source))
+      object.store
+      object
+    end    
+  
+    def build(key, value = nil, &block)   
+      logger.info { "  [#{self.class.name}] Building asset #{key}" } if logger
+      asset_class_for(key).new(self, key, value, Metadata.non_existing, &block)        
+    end            
+    
+    def write(key, value)
+      check_key_for_errors(key)
+      logger.info { "  [#{self.class.name}] Writing #{value.size} bytes to #{key}" } if logger
+
+      bucket_for(key).write(key, value)
+    end           
+    
+    def read(key)                      
+      logger.info { "  [#{self.class.name}] Reading from #{key}" } if logger      
+      
+      bucket_for(key).read(key)
+    end
+    
+    def stat(key)
+      logger.info { "  [#{self.class.name}] Statting #{key}" } if logger      
+
+      bucket_for(key).stat(key)
+    end                   
+    
+    def ls(key)  
+      logger.info { "  [#{self.class.name}] Listing objects in #{key}" } if logger      
+      
+      bucket_for(key).ls(key)
+    end
+    
+    def exist?(key)      
+      if fp = stat(key)
+        fp.exist?
+      else
+        false
+      end
+    end      
+    
+    def delete(key)   
+      logger.info { "  [#{self.class.name}] Deleting #{key}" } if logger      
+                 
+      bucket_for(key).delete(key)
+    end
+
+    def bucket_for(key)     
+      bucket = buckets[bucket_symbol_for_key(key)]
+      bucket ? bucket : root_bucket  
+    end
+                      
+    def []=(key, value)
+      write(key, value)
+    end
+
+    def [](key)
+      asset_at(key)
+    end
+       
+    protected
+    
+    def asset_class_for(key)
+      self.class.asset_classes[bucket_symbol_for_key(key)] || self.class.root_asset_class
+    end
+    
+    def bucket_symbol_for_key(key)
+      $1.to_sym if key =~ /^(\w+)(\/|$)/
+    end
+    
+    def root_bucket
+      @default_bucket ||= self.class.root_bucket_class.new(self, '')
+    end
+    
+    def check_key_for_errors(key)
+      raise IllegalPath, "key cannot be empty" if key.blank?
+      raise IllegalPath, "#{key.inspect} contains illegal characters" unless key =~ VALID_PATHS      
+    rescue => e
+      logger.info { "  [#{self.class.name}]   bad key #{e.message}" } if logger      
+      raise      
+    end
+    
+  end
+end

data/lib/asset_cloud/blackhole_bucket.rb

@@ -0,0 +1,24 @@
+                                                                                                                                                                                                        
+module AssetCloud
+  class BlackholeBucket < Bucket
+    def ls(namespace = nil)     
+      []
+    end                               
+
+    def read(key)  
+      nil
+    end          
+
+    def write(key, data)       
+      nil
+    end   
+
+    def delete(key)
+      nil
+    end           
+    
+    def stat(key)
+      Metadata.new(false)
+    end
+  end
+end

data/lib/asset_cloud/bucket.rb

@@ -0,0 +1,57 @@
+                                                                                           
+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}")
+    end
+  end
+  
+  class Bucket
+    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
+    
+    def ls(key = nil)     
+      raise NotImplementedError
+    end                               
+
+    def read(key)  
+      raise NotImplementedError
+    end          
+
+    def write(key, data)       
+      raise NotImplementedError
+    end   
+
+    def delete(key)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/asset_cloud/callbacks.rb

@@ -0,0 +1,62 @@
+module AssetCloud
+  
+  module Callbacks
+    
+    CALLBACKS = [:delete, :write]
+    
+    def self.included(base)
+           
+      CALLBACKS.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.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    
+
+         alias_method_chain :#{method}, 'callbacks'         
+        end_eval
+                        
+        base.class_eval code, __FILE__, __LINE__        
+      end      
+    end
+    
+    def execute_callbacks(symbol, args)
+      callbacks_for(symbol).each do |callback|
+        
+        result = case callback
+        when Symbol
+          self.send(callback, *args)
+        when Proc, Method
+          callback.call(self, *args)
+        else
+          if callback.respond_to?(method)
+            callback.send(method, self, *args)
+          else
+            raise StandardError, "Callbacks must be a symbol denoting the method to call, a string to be evaluated, a block to be invoked, or an object responding to the callback method."
+          end          
+        end  
+        return false if result == false            
+      end       
+      true
+    end               
+      
+    def callbacks_for(symbol)
+      self.class.read_inheritable_attribute(symbol) || []
+    end
+  end
+end