asset_cloud 2.7.1 → 2.7.2

data/lib/asset_cloud/bucket.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module AssetCloud
   class AssetNotFoundError < StandardError
-    def initialize(key, version=nil)
+    def initialize(key, version = nil)
       super(version ? "Could not find version #{version} of asset #{key}" : "Could not find asset #{key}")
     end
   end
@@ -10,7 +12,8 @@ module AssetCloud
     attr_accessor :cloud
 
     def initialize(cloud, name)
-      @cloud, @name = cloud, name
+      @cloud = cloud
+      @name = name
     end
 
     def ls(key = nil)

data/lib/asset_cloud/buckets/active_record_bucket.rb

@@ -1,35 +1,37 @@
+# frozen_string_literal: true
+
 module AssetCloud
   class ActiveRecordBucket < AssetCloud::Bucket
     class_attribute :key_attribute, :value_attribute
-    self.key_attribute = 'key'
-    self.value_attribute = 'value'
+    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)]
+    def ls(key = name)
+      col = records.connection.quote_column_name(key_attribute)
+      records.all(conditions: ["#{col} LIKE ?", "#{key}%"]).map do |r|
+        cloud[r.send(key_attribute)]
       end
     end
 
     def read(key)
-      find_record!(key).send(self.value_attribute)
+      find_record!(key).send(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 = records.send("find_or_initialize_by_#{key_attribute}", key.to_s)
+      record.send("#{value_attribute}=", value)
       record.save!
     end
 
     def delete(key)
-      if record = find_record(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)
+      if (record = find_record(key))
+        AssetCloud::Metadata.new(true, record.send(value_attribute).size, record.created_at, record.updated_at)
       else
         AssetCloud::Metadata.new(false)
       end
@@ -47,11 +49,11 @@ module AssetCloud
     end
 
     def find_record(key)
-      records.first(:conditions => {self.key_attribute => key.to_s})
+      records.first(conditions: { key_attribute => key.to_s })
     end
 
     def find_record!(key)
-      find_record(key) or raise(AssetCloud::AssetNotFoundError, key)
+      find_record(key) || raise(AssetCloud::AssetNotFoundError, key)
     end
   end
 end

data/lib/asset_cloud/buckets/blackhole_bucket.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AssetCloud
   class BlackholeBucket < Bucket
     def ls(namespace = nil)

data/lib/asset_cloud/buckets/bucket_chain.rb

@@ -1,61 +1,70 @@
+# frozen_string_literal: true
+
 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)}
+    class << self
+      # returns a new Bucket class which writes to each given Bucket
+      # but only uses the first one for reading
+      def 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
     end
 
-    def ls(key=nil)
-      first_possible_bucket {|b| b.ls(key)}
+    def ls(key = nil)
+      first_possible_bucket { |b| b.ls(key) }
     end
+
     def read(key)
-      first_possible_bucket {|b| b.read(key)}
+      first_possible_bucket { |b| b.read(key) }
     end
-    def stat(key=nil)
-      first_possible_bucket {|b| b.stat(key)}
+
+    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)}
+      first_possible_bucket { |b| b.read_version(key, version) }
     end
+
     def versions(key)
-      first_possible_bucket {|b| b.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)}
+      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)}
+      every_bucket_with_transaction_on_key(key) { |b| b.delete(key) }
     end
 
-    def respond_to?(sym)
-      @chained_buckets.any? {|b| b.respond_to?(sym)}
+    def respond_to_missing?(sym, *)
+      @chained_buckets.any? { |b| b.respond_to?(sym) }
     end
+
     def method_missing(sym, *args)
-      first_possible_bucket {|b| b.send(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
+        return yield(bucket)
+      rescue NoMethodError, NotImplementedError
+        nil
       end
     end
 
-    def every_bucket_with_transaction_on_key(key, i=0, &block)
-      return unless bucket = @chained_buckets[i]
+    def every_bucket_with_transaction_on_key(key, i = 0, &block)
+      return unless (bucket = @chained_buckets[i])
 
       old_value = begin
         bucket.read(key)
@@ -65,8 +74,8 @@ module AssetCloud
       result = yield(bucket)
 
       begin
-        every_bucket_with_transaction_on_key(key, i+1, &block)
-        return result
+        every_bucket_with_transaction_on_key(key, i + 1, &block)
+        result
       rescue StandardError => e
         if old_value
           bucket.write(key, old_value)
@@ -76,7 +85,5 @@ module AssetCloud
         raise e
       end
     end
-
   end
-
 end

data/lib/asset_cloud/buckets/file_system_bucket.rb

@@ -1,27 +1,29 @@
-module AssetCloud
+# frozen_string_literal: true
 
+module AssetCloud
   class FileSystemBucket < Bucket
-
     def ls(key = nil)
       objects = []
-      base_path = File.join(path_for(key), '*')
+      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)]
+
+        objects.push(cloud[relative_path_for(f)])
       end
       objects
     end
 
     def read(key)
       File.read(path_for(key))
-    rescue Errno::ENOENT => e
+    rescue Errno::ENOENT
       raise AssetCloud::AssetNotFoundError, key
     end
 
     def delete(key)
       File.delete(path_for(key))
     rescue Errno::ENOENT
+      nil
     end
 
     def write(key, data)
@@ -32,12 +34,10 @@ module AssetCloud
     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
+      stat = File.stat(path_for(key))
+      Metadata.new(true, stat.size, stat.ctime, stat.mtime)
+    rescue Errno::ENOENT
+      Metadata.new(false)
     end
 
     protected
@@ -53,11 +53,11 @@ module AssetCloud
     private
 
     def remove_full_path_regexp
-      @regexp ||= /^#{path}\//
+      @regexp ||= %r{^#{path}/}
     end
 
     def relative_path_for(f)
-      f.sub(remove_full_path_regexp, '')
+      f.sub(remove_full_path_regexp, "")
     end
 
     def execute_in_full_path(key, &block)
@@ -71,10 +71,9 @@ module AssetCloud
 
       begin
         yield(path)
-      rescue Errno::ENOENT => e
+      rescue Errno::ENOENT
         raise if retried
 
-        directory = File.dirname(path)
         FileUtils.mkdir_p(File.dirname(path))
         retried = true
         retry

data/lib/asset_cloud/buckets/gcs_bucket.rb

@@ -31,12 +31,10 @@ module AssetCloud
     end
 
     def stat(key)
-      begin
-        file = find_by_key!(key)
-        Metadata.new(true, file.size, file.created_at, file.updated_at)
-      rescue AssetCloud::AssetNotFoundError
-        Metadata.new(false)
-      end
+      file = find_by_key!(key)
+      Metadata.new(true, file.size, file.created_at, file.updated_at)
+    rescue AssetCloud::AssetNotFoundError
+      Metadata.new(false)
     end
 
     private
@@ -47,11 +45,11 @@ module AssetCloud
 
     def absolute_key(key = nil)
       if key.to_s.starts_with?(path_prefix)
-        return key
+        key
       else
         args = [path_prefix]
         args << key.to_s if key
-        args.join('/')
+        args.join("/")
       end
     end
 

data/lib/asset_cloud/buckets/invalid_bucket.rb

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

data/lib/asset_cloud/buckets/memory_bucket.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AssetCloud
   class MemoryBucket < Bucket
     def initialize(*args)
@@ -5,16 +7,17 @@ module AssetCloud
       @memory = {}
     end
 
-    def ls(prefix=nil)
+    def ls(prefix = nil)
       results = []
-      @memory.each do |k,v|
+      @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)
+      raise AssetCloud::AssetNotFoundError, key unless @memory.key?(key)
+
       @memory[key]
     end
 
@@ -29,7 +32,7 @@ module AssetCloud
     end
 
     def stat(key)
-      return Metadata.non_existing unless @memory.has_key?(key)
+      return Metadata.non_existing unless @memory.key?(key)
 
       Metadata.new(true, read(key).size)
     end

data/lib/asset_cloud/buckets/s3_bucket.rb

@@ -1,4 +1,6 @@
-require 'aws-sdk-s3'
+# frozen_string_literal: true
+
+require "aws-sdk-s3"
 
 module AssetCloud
   class S3Bucket < Bucket
@@ -18,7 +20,7 @@ module AssetCloud
       options[:range] = http_byte_range(options[:range]) if options[:range]
 
       bucket = cloud.s3_bucket(key)
-      if encryption_key = options.delete(:encryption_key)
+      if (encryption_key = options.delete(:encryption_key))
         bucket = encrypted_bucket(bucket, encryption_key)
       end
 
@@ -33,7 +35,7 @@ module AssetCloud
       options = options.dup
 
       bucket = cloud.s3_bucket(key)
-      if encryption_key = options.delete(:encryption_key)
+      if (encryption_key = options.delete(:encryption_key))
         bucket = encrypted_bucket(bucket, encryption_key)
       end
 
@@ -63,7 +65,7 @@ module AssetCloud
         client: Aws::S3::Encryption::Client.new(
           client: source_bucket.client,
           encryption_key: key,
-        )
+        ),
       ).bucket(source_bucket.name)
     end
 
@@ -73,21 +75,22 @@ module AssetCloud
 
     def absolute_key(key = nil)
       if key.to_s.starts_with?(path_prefix)
-        return key
+        key
       else
         args = [path_prefix]
         args << key.to_s if key
-        args.join('/')
+        args.join("/")
       end
     end
 
     def relative_key(key)
-      key =~ /^#{path_prefix}\/(.+)/ ? $1 : key
+      key =~ %r{^#{path_prefix}/(.+)} ? Regexp.last_match(1) : key
     end
 
     def http_byte_range(range)
       # follows https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35
-      return "bytes=#{[range.begin, range.max].join('-')}" if range.is_a?(Range)
+      return "bytes=#{[range.begin, range.max].join("-")}" if range.is_a?(Range)
+
       range
     end
   end

data/lib/asset_cloud/buckets/versioned_memory_bucket.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module AssetCloud
   class VersionedMemoryBucket < MemoryBucket
-
     def read(key)
-      raise AssetCloud::AssetNotFoundError, key unless @memory.has_key?(key)
+      raise AssetCloud::AssetNotFoundError, key unless @memory.key?(key)
+
       read_version(key, latest_version(key))
     end
 

data/lib/asset_cloud/callbacks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AssetCloud
   module Callbacks
     extend ActiveSupport::Concern
@@ -50,7 +52,7 @@ module AssetCloud
       def extension_module
         @extension_module ||= begin
           mod = Module.new
-          self.const_set(:AssetCloudCallbacks, mod)
+          const_set(:AssetCloudCallbacks, mod)
           prepend(mod)
           mod
         end
@@ -59,7 +61,6 @@ module AssetCloud
 
     def execute_callbacks(symbol, args)
       callbacks_for(symbol).each do |callback|
-        
         result = case callback
         when Symbol
           send(callback, *args)
@@ -69,7 +70,10 @@ module AssetCloud
           if callback.respond_to?(symbol)
             callback.send(symbol, 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."
+            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

data/lib/asset_cloud/free_key_locator.rb

@@ -1,26 +1,26 @@
-require 'securerandom'
+# frozen_string_literal: true
 
-module AssetCloud
+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 !exist?(key) && !options[:force_uuid]
+      if !options[:force_uuid] && !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        = 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'
+        raise StandardError, "Filesystem out of free filenames"
       end
     end
   end

data/lib/asset_cloud/metadata.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 module AssetCloud
   class Metadata
     attr_accessor :exist, :size, :created_at, :updated_at, :value_hash, :checksum
 
     def new?
-      !self.exist
+      !exist
     end
 
     def exist?
-      self.exist
+      exist
     end
 
     # rubocop:disable Metrics/ParameterLists
@@ -21,12 +23,14 @@ module AssetCloud
     end
     # rubocop:enable Metrics/ParameterLists
 
-    def self.existing
-      self.new(true)
-    end
+    class << self
+      def existing
+        new(true)
+      end
 
-    def self.non_existing
-      self.new false
+      def non_existing
+        new(false)
+      end
     end
 
     def inspect

data/lib/asset_cloud/validations.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 module AssetCloud
   module Validations
-    def self.included(base)
-      base.send(:alias_method, :store_without_validation, :store)
-      base.extend(ClassMethods)
-      base.prepend(PrependedMethods)
+    class << self
+      def included(base)
+        base.send(:alias_method, :store_without_validation, :store)
+        base.extend(ClassMethods)
+        base.prepend(PrependedMethods)
+      end
     end
 
     module PrependedMethods
@@ -15,7 +19,7 @@ module AssetCloud
 
     module ClassMethods
       def validate(*extra_validations, &block)
-        validations = self._callbacks[:validate] || []
+        validations = _callbacks[:validate] || []
         validations += extra_validations
         validations << block if block_given?
 

data/lib/asset_cloud.rb

@@ -1,31 +1,33 @@
-require 'addressable'
-require 'active_support'
+# frozen_string_literal: true
+
+require "addressable"
+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'
+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"
 
 # S3
-require 'asset_cloud/buckets/s3_bucket'
+require "asset_cloud/buckets/s3_bucket"
 
 # GCS
-require 'asset_cloud/buckets/gcs_bucket'
+require "asset_cloud/buckets/gcs_bucket"
 
 # Extensions
-require 'asset_cloud/free_key_locator'
-require 'asset_cloud/callbacks'
-require 'asset_cloud/validations'
+require "asset_cloud/free_key_locator"
+require "asset_cloud/callbacks"
+require "asset_cloud/validations"
 
-require 'asset_cloud/asset_extension'
+require "asset_cloud/asset_extension"
 
 AssetCloud::Base.class_eval do
   include AssetCloud::FreeKeyLocator
@@ -56,9 +58,9 @@ AssetCloud::Asset.class_eval do
 
   def valid_key
     if key.blank?
-      add_error "key cannot be empty"
+      add_error("key cannot be empty")
     elsif !valid_key_path?(key)
-      add_error "#{key.inspect} contains illegal characters"
+      add_error("#{key.inspect} contains illegal characters")
     end
   end
 end