asset_cloud 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a3f0421040a068165fb6219c055d4d490c0d1b56
+  data.tar.gz: 539fc589e72c4b3be9eb61e45fb895d75f96f0ae
+SHA512:
+  metadata.gz: 67092177460792fa3892e585bb939b97969b80b96e621d32a619fe24022caccc781db5426c6bc3b8921ed8b950886259ab57a910472cbee922ae27ff9e2f3a28
+  data.tar.gz: b532387d3a18ceceb4710f8a3bd006693e063171ec1792f040d0ee3d1c2534aa3d95f31edc26ad05a604bbfd916ed387571d08785fdb5829c403ce3a058908c6

data/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+Gemfile.lock
+*.orig
+.dotest
+.rvmrc
+*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2013 Tobias Lütke & Shopify, 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,13 @@
+= AssetCloud
+
+An abstraction layer around arbitrary and diverse asset stores.
+
+== Installation
+
+=== as a Gem
+
+    gem install asset_cloud
+
+== Copyright
+
+Copyright (c) 2008-2013 Tobias Lütke & Shopify, Inc. Released under the MIT license (see LICENSE for details).

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rspec'
+
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'rspec/core/rake_task'
+
+desc 'Default: run unit tests.'
+task :default => [:spec]
+
+desc "Run all spec examples"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rspec_opts = ['--color']
+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

data/asset_cloud.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{asset_cloud}
+  s.version = "1.0.2"
+
+  s.authors = %w(Shopify)
+  s.date = %q{2009-08-04}
+  s.summary = %q{An abstraction layer around arbitrary and diverse asset stores.}
+  s.description = %q{An abstraction layer around arbitrary and diverse asset stores.}
+
+  s.email = %q{developers@shopify.com}
+  s.homepage = %q{http://github.com/Shopify/asset_cloud}
+  s.require_paths = %w(lib)
+
+  s.files = `git ls-files`.split($/)
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+
+  s.add_dependency 'activesupport'
+  s.add_dependency 'class_inheritable_attributes'
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rake'
+end

data/lib/asset_cloud.rb

@@ -0,0 +1,54 @@
+require 'active_support'
+
+# Core
+require 'asset_cloud/asset'
+require 'asset_cloud/metadata'
+require 'asset_cloud/bucket'
+require 'asset_cloud/buckets/active_record_bucket'
+require 'asset_cloud/buckets/blackhole_bucket'
+require 'asset_cloud/buckets/bucket_chain'
+require 'asset_cloud/buckets/file_system_bucket'
+require 'asset_cloud/buckets/invalid_bucket'
+require 'asset_cloud/buckets/memory_bucket'
+require 'asset_cloud/buckets/versioned_memory_bucket'
+require 'asset_cloud/base'
+
+
+# Extensions
+require 'asset_cloud/free_key_locator'
+require 'asset_cloud/callbacks'
+require 'asset_cloud/validations'
+
+require 'asset_cloud/asset_extension'
+
+
+AssetCloud::Base.class_eval do
+  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
+  callback_methods :validate
+  validate :valid_key
+
+  def execute_callbacks(symbol, args)
+    super
+    @extensions.each {|ext| ext.execute_callbacks(symbol, args)}
+  end
+
+  private
+
+  def valid_key
+    if key.blank?
+      add_error "key cannot be empty"
+    elsif key !~ AssetCloud::Base::VALID_PATHS
+      add_error "#{key.inspect} contains illegal characters"
+    end
+  end
+end
+

data/lib/asset_cloud/asset.rb

@@ -0,0 +1,187 @@
+module AssetCloud
+
+  class AssetError < StandardError
+  end
+
+  class AssetNotSaved < AssetError
+  end
+
+  class Asset
+    include Comparable
+    attr_accessor :key, :value, :cloud, :metadata, :new_asset
+    attr_reader   :extensions
+
+    def initialize(cloud, key, value = nil, metadata = Metadata.non_existing)
+      @new_asset = true
+      @cloud     = cloud
+      @key       = key
+      @value     = value
+      @metadata  = metadata
+
+      apply_extensions
+
+      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 relative_key
+      @key.split("/",2).last
+    end
+
+    def relative_key_without_ext
+      relative_key.gsub(/\.[^.]+$/,"")
+    end
+
+    def dirname
+      File.dirname(@key)
+    end
+
+    def extname
+      File.extname(@key)
+    end
+
+    def format
+      extname.sub('.', '')
+    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 updated_at
+      metadata.updated_at
+    end
+
+    def value_hash
+      metadata.value_hash
+    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(options = {})
+      cloud.url_for key, options
+    end
+
+    def bucket_name
+      @key.split('/').first
+    end
+
+    def bucket
+      cloud.buckets[bucket_name.to_sym]
+    end
+
+    def inspect
+      "#<#{self.class.name}: #{key}>"
+    end
+
+    # versioning
+
+    def versioned?
+      bucket.versioned?
+    end
+
+    def rollback(version)
+      self.value = cloud.read_version(key, version)
+      self
+    end
+
+    def versions
+      cloud.versions(key)
+    end
+
+    def version_details
+      cloud.version_details(key)
+    end
+
+    def method_missing(method, *args)
+      @extensions.each do |ext|
+        begin
+          return ext.send(method, *args)
+        rescue NoMethodError, NotImplementedError => e
+          nil
+        end
+      end
+      super
+    end
+
+    private
+
+    def apply_extensions
+      @extensions ||= []
+      @cloud.asset_extension_classes_for_bucket(bucket_name).each do |ext|
+        @extensions << ext.new(self) if ext.applies_to_asset?(self)
+      end
+    end
+  end
+end

data/lib/asset_cloud/asset_extension.rb

@@ -0,0 +1,42 @@
+module AssetCloud
+  class AssetExtension
+    class AssetMismatch < StandardError
+    end
+    def store; true; end
+    def delete; true; end
+
+    include AssetCloud::Callbacks
+    include AssetCloud::Validations
+
+    callback_methods :store, :delete, :validate
+
+    attr_reader :asset
+    delegate :add_error, :to => :asset
+
+    class_attribute :extnames
+
+    def self.applies_to(*args)
+      extnames = args.map do |arg|
+        arg = arg.to_s.downcase
+        arg = ".#{arg}" unless arg.starts_with?('.')
+        arg
+      end
+      self.extnames = extnames
+    end
+
+    def self.applies_to_asset?(asset)
+      extnames = self.extnames || []
+      extnames.each do |extname|
+        return true if asset.key.downcase.ends_with?(extname)
+      end
+      false
+    end
+
+    def initialize(asset)
+      unless self.class.applies_to_asset?(asset)
+        raise AssetMismatch, "Instances of #{self.class.name} cannot be applied to asset #{asset.key.inspect}"
+      end
+      @asset = asset
+    end
+  end
+end

data/lib/asset_cloud/base.rb

@@ -0,0 +1,247 @@
+require 'uri'
+require 'class_inheritable_attributes'
+
+module AssetCloud
+
+  class IllegalPath < StandardError
+  end
+
+  class Base
+    cattr_accessor :logger
+
+    VALID_PATHS = /\A[a-z0-9][a-z0-9_\-\/]+([a-z0-9][\w\-\ \.\@]*\.\w{2,6})?\z/i
+    MATCH_BUCKET = /^(\w+)(\/|$)/
+
+    attr_accessor :url, :root
+
+    class_attribute :root_bucket_class
+    self.root_bucket_class = 'AssetCloud::FileSystemBucket'
+    class_attribute :root_asset_class
+    self.root_asset_class  = 'AssetCloud::Asset'
+
+    class_inheritable_hash :bucket_classes
+    self.bucket_classes = {}
+    class_inheritable_hash :asset_classes
+    self.asset_classes = {}
+    class_inheritable_hash :asset_extension_classes
+    self.asset_extension_classes = {}
+
+    def self.bucket(*args)
+      asset_class = if args.last.is_a? Hash
+        convert_to_class_name_if_possible(args.pop[:asset_class])
+      end
+
+      bucket_class = if args.last.is_a? Class
+        convert_to_class_name_if_possible(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 self.asset_extensions(*args)
+      opts = args.last.is_a?(Hash) ? args.pop.slice(:only, :except) : {}
+      opts.each do |k,v|
+        opts[k] = [v].flatten.map(&:to_sym)
+      end
+
+      args.each do |klass|
+        klass = convert_to_class_name_if_possible(klass)
+        self.asset_extension_classes[klass] = opts
+      end
+    end
+
+    def buckets
+      @buckets ||= Hash.new do |hash, key|
+        if klass = self.class.bucket_classes[key]
+          hash[key] = constantize_if_necessary(klass).new(self, key)
+        else
+          hash[key] = nil
+        end
+      end
+    end
+
+    def initialize(root, url = '/')
+      @root, @url = root, url
+    end
+
+    def url_for(key, options={})
+      File.join(@url, URI.encode(key))
+    end
+
+    def path_for(key)
+      File.join(path, key)
+    end
+
+    def path
+      root
+    end
+
+    def find(key)
+      asset = asset_at(key)
+      asset.value
+      asset
+    end
+
+    def asset_at(*args)
+      asset_class_for(args.first).at(self, *args)
+    end
+
+    def asset_at!(*args)
+      check_key_for_errors(args.first)
+      asset_at(*args)
+    end
+
+    def move(source, destination)
+      return if source == destination
+
+      object = copy(source, destination)
+      if object.errors.none?
+        asset_at(source).delete
+      end
+      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 supports?(key)
+      key =~ VALID_PATHS
+    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)
+      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
+
+    def version_details(key)
+      logger.info { "  [#{self.class.name}] Getting all version details for #{key}" } if logger
+      bucket_for(key).version_details(key)
+    end
+
+    def asset_class_for(key)
+      klass = self.class.asset_classes[bucket_symbol_for_key(key)] || self.class.root_asset_class
+      constantize_if_necessary(klass)
+    end
+
+    def asset_extension_classes_for_bucket(bucket)
+      bucket = bucket.to_sym
+      extensions = self.class.asset_extension_classes
+      klasses = extensions.keys.select do |ext|
+        opts = extensions[ext]
+        (opts.key?(:only) ? opts[:only].include?(bucket) : true) &&
+        (opts.key?(:except) ? !opts[:except].include?(bucket) : true)
+      end
+      klasses.map {|klass| constantize_if_necessary(klass)}
+    end
+
+    protected
+
+    def bucket_symbol_for_key(key)
+      $1.to_sym if key =~ MATCH_BUCKET
+    end
+
+    def root_bucket
+      @default_bucket ||= constantize_if_necessary(self.class.root_bucket_class).new(self, '')
+    end
+
+    def constantize_if_necessary(klass)
+      klass.is_a?(Class) ? klass : klass.constantize
+    end
+
+    def self.convert_to_class_name_if_possible(klass)
+      if klass.is_a?(Class) && klass.name.present?
+        klass.name
+      else
+        klass
+      end
+    end
+
+    def check_key_for_errors(key)
+      raise IllegalPath, "key cannot be empty" if key.blank?
+      raise IllegalPath, "#{key.inspect} contains illegal characters" unless supports?(key)
+    rescue => e
+      logger.info { "  [#{self.class.name}]   bad key #{e.message}" } if logger
+      raise
+    end
+
+  end
+end