asset_cloud 2.7.0 → 2.7.2

data/lib/asset_cloud/base.rb

@@ -1,42 +1,44 @@
-require 'uri/rfc2396_parser'
+# frozen_string_literal: true
 
-module AssetCloud
+require "uri/rfc2396_parser"
 
+module AssetCloud
   class IllegalPath < StandardError
   end
 
   class Base
     cattr_accessor :logger
 
-    VALID_PATHS = /\A
+    VALID_PATHS = %r{\A
       (
-        (\w)                #Filename can be a single letter or underscore
-        |                     #OR it is many and follows the below rules
+        (\w)                        # Filename can be a single letter or underscore
+        |                           # OR it is many and follows the below rules
         (
-          (\.?[\w\[\]\(\)\-\@])       #It can start with a dot but it must have a following character
+          (\.?[\w\[\]\(\)\-\@])     # It can start with a dot but it must have a following character
           (
-            [\w\[\]\(\)\-\@]          #You can have a letter without any following conditions
+            [\w\[\]\(\)\-\@]        # You can have a letter without any following conditions
             |
-            [\ ][\w\[\]\(\)\-\@\.]      #If there is a space you need to have a normal letter afterward or a dot
+            [\ ][\w\[\]\(\)\-\@\.]  # If there is a space you need to have a normal letter afterward or a dot
             |
-            [\/][\w\[\]\(\)\-\@]      #If there is a slash you need to have a normal letter afterward
+            [/][\w\[\]\(\)\-\@]     # If there is a slash you need to have a normal letter afterward
             |
-            [\/][\.][\w\[\]\(\)\-\@]  #Though a slash could be followed by a dot so long as there is a normal letter afterward
+            [/][\.][\w\[\]\(\)\-\@] # Though a slash could be followed by a dot
+                                    # so long as there is a normal letter afterward
             |
-            [\.]+[\w\[\]\(\)\-\@]+     #One or more dots must be followed by one (or more) normal letters
-          )*                  #Zero to many of these combinations.
+            [\.]+[\w\[\]\(\)\-\@]+  # One or more dots must be followed by one (or more) normal letters
+          )*                        # Zero to many of these combinations.
         )
-      )\z/x
-    MATCH_BUCKET = /^(\w+)(\/|$)/
+      )\z}x
+    MATCH_BUCKET = %r{^(\w+)(/|$)}
 
     URI_PARSER = URI::RFC2396_Parser.new
 
     attr_accessor :url, :root
 
     class_attribute :root_bucket_class
-    self.root_bucket_class = 'AssetCloud::FileSystemBucket'.freeze
+    self.root_bucket_class = "AssetCloud::FileSystemBucket"
     class_attribute :root_asset_class
-    self.root_asset_class  = 'AssetCloud::Asset'.freeze
+    self.root_asset_class = "AssetCloud::Asset"
 
     class_attribute :bucket_classes
     self.bucket_classes = {}.freeze
@@ -45,56 +47,68 @@ module AssetCloud
     class_attribute :asset_extension_classes
     self.asset_extension_classes = {}.freeze
 
-    def self.bucket(*args)
-      asset_class = if args.last.is_a? Hash
-        convert_to_class_name_if_possible(args.pop[:asset_class])
-      end
+    class << self
+      def 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
+        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_classes.merge(bucket_name.to_sym => bucket_class).freeze
-        self.asset_classes = asset_classes.merge(bucket_name.to_sym => asset_class).freeze if asset_class
-      else
-        self.root_bucket_class = bucket_class
-        if asset_class
-          raise ArgumentError, 'asset_class on the root bucket cannot be a proc' if asset_class.is_a?(Proc)
-          self.root_asset_class  = asset_class
+        if (bucket_name = args.first)
+          self.bucket_classes = bucket_classes.merge(bucket_name.to_sym => bucket_class).freeze
+          self.asset_classes = asset_classes.merge(bucket_name.to_sym => asset_class).freeze if asset_class
+        else
+          self.root_bucket_class = bucket_class
+          if asset_class
+            raise ArgumentError, "asset_class on the root bucket cannot be a proc" if asset_class.is_a?(Proc)
+
+            self.root_asset_class = asset_class
+          end
         end
       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)
+      def 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 = asset_extension_classes.merge(klass => opts).freeze
+        end
       end
 
-      args.each do |klass|
-        klass = convert_to_class_name_if_possible(klass)
-        self.asset_extension_classes = asset_extension_classes.merge(klass => opts).freeze
+      private
+
+      def convert_to_class_name_if_possible(klass)
+        if klass.is_a?(Class) && klass.name.present?
+          klass.name
+        else
+          klass
+        end
       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
+        hash[key] = if (klass = self.class.bucket_classes[key])
+          constantize_if_necessary(klass).new(self, key)
         end
       end
     end
 
-    def initialize(root, url = '/')
-      @root, @url = root, url
+    def initialize(root, url = "/")
+      @root = root
+      @url = url
     end
 
-    def url_for(key, options={})
+    def url_for(key, options = {})
       File.join(@url, URI_PARSER.escape(key))
     end
 
@@ -140,13 +154,13 @@ module AssetCloud
     end
 
     def build(key, value = nil, &block)
-      logger.info { "  [#{self.class.name}] Building asset #{key}" } if logger
+      logger&.info { "  [#{self.class.name}] Building asset #{key}" }
       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
+      logger&.info { "  [#{self.class.name}] Writing #{value.size} bytes to #{key}" }
 
       bucket_for(key).write(key, value)
     end
@@ -158,25 +172,25 @@ module AssetCloud
     end
 
     def read(key)
-      logger.info { "  [#{self.class.name}] Reading from #{key}" } if logger
+      logger&.info { "  [#{self.class.name}] Reading from #{key}" }
 
       bucket_for(key).read(key)
     end
 
     def stat(key)
-      logger.info { "  [#{self.class.name}] Statting #{key}" } if logger
+      logger&.info { "  [#{self.class.name}] Statting #{key}" }
 
       bucket_for(key).stat(key)
     end
 
     def ls(key)
-      logger.info { "  [#{self.class.name}] Listing objects in #{key}" } if logger
+      logger&.info { "  [#{self.class.name}] Listing objects in #{key}" }
 
       bucket_for(key).ls(key)
     end
 
     def exist?(key)
-      if fp = stat(key)
+      if (fp = stat(key))
         fp.exist?
       else
         false
@@ -188,7 +202,7 @@ module AssetCloud
     end
 
     def delete(key)
-      logger.info { "  [#{self.class.name}] Deleting #{key}" } if logger
+      logger&.info { "  [#{self.class.name}] Deleting #{key}" }
 
       bucket_for(key).delete(key)
     end
@@ -211,17 +225,17 @@ module AssetCloud
     # versioning
 
     def read_version(key, version)
-      logger.info { "  [#{self.class.name}] Reading from #{key} at version #{version}" } if logger
+      logger&.info { "  [#{self.class.name}] Reading from #{key} at version #{version}" }
       bucket_for(key).read_version(key, version)
     end
 
     def versions(key)
-      logger.info { "  [#{self.class.name}] Getting all versions for #{key}" } if logger
+      logger&.info { "  [#{self.class.name}] Getting all versions for #{key}" }
       bucket_for(key).versions(key)
     end
 
     def version_details(key)
-      logger.info { "  [#{self.class.name}] Getting all version details for #{key}" } if logger
+      logger&.info { "  [#{self.class.name}] Getting all version details for #{key}" }
       bucket_for(key).version_details(key)
     end
 
@@ -239,40 +253,31 @@ module AssetCloud
       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)
+          (opts.key?(:except) ? !opts[:except].include?(bucket) : true)
       end
-      klasses.map {|klass| constantize_if_necessary(klass)}
+      klasses.map { |klass| constantize_if_necessary(klass) }
     end
 
     protected
 
     def bucket_symbol_for_key(key)
-      $1.to_sym if key =~ MATCH_BUCKET
+      Regexp.last_match(1).to_sym if key =~ MATCH_BUCKET
     end
 
     def root_bucket
-      @default_bucket ||= constantize_if_necessary(self.class.root_bucket_class).new(self, '')
+      @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
+      logger&.info { "  [#{self.class.name}]   bad key #{e.message}" }
       raise
     end
-
   end
 end

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