asset_cloud 1.0.2

data/lib/asset_cloud/bucket.rb

@@ -0,0 +1,39 @@
+module AssetCloud
+  class AssetNotFoundError < StandardError
+    def initialize(key, version=nil)
+      super(version ? "Could not find version #{version} of asset #{key}" : "Could not find asset #{key}")
+    end
+  end
+
+  class Bucket
+    attr_reader :name
+    attr_accessor :cloud
+
+    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
+
+    # versioning
+    #
+    # implement #read_version(key, version) and #versions(key) in subclasses
+    def versioned?
+      respond_to?(:read_version)
+    end
+  end
+end

data/lib/asset_cloud/buckets/active_record_bucket.rb

@@ -0,0 +1,57 @@
+module AssetCloud
+  class ActiveRecordBucket < AssetCloud::Bucket
+    class_attribute :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/blackhole_bucket.rb

@@ -0,0 +1,23 @@
+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/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(cloud, name)
+          @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/buckets/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 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/buckets/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/buckets/memory_bucket.rb

@@ -0,0 +1,42 @@
+module AssetCloud
+
+  class MemoryBucket < Bucket
+
+    def initialize(*args)
+      super
+      @memory = {}
+    end
+
+    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)
+      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, read(key).size)
+    end
+
+  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

@@ -0,0 +1,63 @@
+require 'class_inheritable_attributes'
+
+module AssetCloud
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    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.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
+
+          self.class_eval code, __FILE__, __LINE__
+        end
+      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.send(symbol) || []
+    end
+  end
+end