asset_cloud 2.7.1 → 2.7.3

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
@@ -33,13 +35,13 @@ module AssetCloud
         end
 
         define_singleton_method(before) do |*callbacks, &block|
-          callbacks << block if block_given?
+          callbacks << block unless block.nil?
           callbacks = (_callbacks[before] || []) + callbacks
           self._callbacks = _callbacks.merge(before => callbacks).freeze
         end
 
         define_singleton_method(after) do |*callbacks, &block|
-          callbacks << block if block_given?
+          callbacks << block unless block.nil?
           callbacks = (_callbacks[after] || []) + callbacks
           self._callbacks = _callbacks.merge(after => callbacks).freeze
         end
@@ -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,24 +61,30 @@ module AssetCloud
 
     def execute_callbacks(symbol, args)
       callbacks_for(symbol).each do |callback|
-        
-        result = case callback
-        when Symbol
-          send(callback, *args)
-        when Proc, Method
-          callback.call(self, *args)
-        else
-          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."
-          end
-        end
+        result = execute_callback(symbol, callback, args)
         return false if result == false
       end
       true
     end
 
+    def execute_callback(symbol, callback, args)
+      case callback
+      when Symbol
+        send(callback, *args)
+      when Proc, Method
+        callback.call(self, *args)
+      else
+        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."
+        end
+      end
+    end
+
     def callbacks_for(symbol)
       self.class._callbacks[symbol] || []
     end

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,36 +1,38 @@
-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
   include AssetCloud::Callbacks
-  callback_methods :create, :update, :write, :delete
+  callback_methods :write, :delete
 end
 
 AssetCloud::Asset.class_eval do
@@ -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

data/spec/active_record_bucket_spec.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 MockRecords = Object.new
 
 class MockActiveRecordBucket < AssetCloud::ActiveRecordBucket
-  self.key_attribute = 'name'
-  self.value_attribute = 'body'
+  self.key_attribute = "name"
+  self.value_attribute = "body"
 
   protected
 
@@ -19,24 +20,24 @@ class RecordCloud < AssetCloud::Base
 end
 
 describe AssetCloud::ActiveRecordBucket do
-  directory = File.dirname(__FILE__) + '/files'
+  directory = File.dirname(__FILE__) + "/files"
 
   before do
-    @cloud = RecordCloud.new(directory, 'http://assets/files')
+    @cloud = RecordCloud.new(directory, "http://assets/files")
     @bucket = @cloud.buckets[:stuff]
   end
 
-  describe '#ls' do
+  describe "#ls" do
     before do
       expect(MockRecords).to(receive(:connection).and_return(@mock_connection = double("connection")))
-      expect(@mock_connection).to(receive(:quote_column_name).with('name').and_return("`name`"))
-      expect(@mock_record = double("record")).to(receive(:name).and_return('stuff/a1'))
+      expect(@mock_connection).to(receive(:quote_column_name).with("name").and_return("`name`"))
+      expect(@mock_record = double("record")).to(receive(:name).and_return("stuff/a1"))
     end
 
     it "should return a list of assets which start with the given prefix" do
       expect(MockRecords).to(receive(:all).with(conditions: ["`name` LIKE ?", "stuff/a%"]).and_return([@mock_record]))
 
-      expect(@bucket.ls('stuff/a').size).to(eq(1))
+      expect(@bucket.ls("stuff/a").size).to(eq(1))
     end
 
     it "should return a list of all assets when a prefix is not given" do
@@ -46,47 +47,47 @@ describe AssetCloud::ActiveRecordBucket do
     end
   end
 
-  describe '#read' do
+  describe "#read" do
     it "should return the value of a key when it exists" do
-      expect(@mock_record = double("record")).to(receive(:body).and_return('foo'))
-      expect(MockRecords).to(receive(:first).with(conditions: { 'name' => 'stuff/a1' }).and_return(@mock_record))
+      expect(@mock_record = double("record")).to(receive(:body).and_return("foo"))
+      expect(MockRecords).to(receive(:first).with(conditions: { "name" => "stuff/a1" }).and_return(@mock_record))
 
-      @bucket.read('stuff/a1')
+      @bucket.read("stuff/a1")
     end
     it "should raise AssetNotFoundError when nothing is there" do
-      expect(MockRecords).to(receive(:first).with(conditions: { 'name' => 'stuff/a1' }).and_return(nil))
+      expect(MockRecords).to(receive(:first).with(conditions: { "name" => "stuff/a1" }).and_return(nil))
 
-      expect { @bucket.read('stuff/a1') }.to(raise_error(AssetCloud::AssetNotFoundError))
+      expect { @bucket.read("stuff/a1") }.to(raise_error(AssetCloud::AssetNotFoundError))
     end
   end
 
-  describe '#write' do
+  describe "#write" do
     it "should write to the DB" do
-      expect(@mock_record = double("record")).to(receive(:body=).with('foo').and_return('foo'))
+      expect(@mock_record = double("record")).to(receive(:body=).with("foo").and_return("foo"))
       expect(@mock_record).to(receive(:save!).and_return(true))
-      expect(MockRecords).to(receive(:find_or_initialize_by_name).with('stuff/a1').and_return(@mock_record))
+      expect(MockRecords).to(receive(:find_or_initialize_by_name).with("stuff/a1").and_return(@mock_record))
 
-      @bucket.write('stuff/a1', 'foo')
+      @bucket.write("stuff/a1", "foo")
     end
   end
 
-  describe '#delete' do
+  describe "#delete" do
     it "should destroy records" do
       expect(@mock_record = double("record")).to(receive(:destroy).and_return(true))
-      expect(MockRecords).to(receive(:first).with(conditions: { 'name' => 'stuff/a1' }).and_return(@mock_record))
+      expect(MockRecords).to(receive(:first).with(conditions: { "name" => "stuff/a1" }).and_return(@mock_record))
 
-      @bucket.delete('stuff/a1')
+      @bucket.delete("stuff/a1")
     end
   end
 
-  describe '#stat' do
+  describe "#stat" do
     it "should return appropriate metadata" do
       expect(@mock_record = double("record")).to(receive(:created_at).and_return(1982))
       expect(@mock_record).to(receive(:updated_at).and_return(2002))
-      expect(@mock_record).to(receive(:body).and_return('foo'))
-      expect(MockRecords).to(receive(:first).with(conditions: { 'name' => 'stuff/a1' }).and_return(@mock_record))
+      expect(@mock_record).to(receive(:body).and_return("foo"))
+      expect(MockRecords).to(receive(:first).with(conditions: { "name" => "stuff/a1" }).and_return(@mock_record))
 
-      metadata = @bucket.stat('stuff/a1')
+      metadata = @bucket.stat("stuff/a1")
       expect(metadata.created_at).to(eq(1982))
       expect(metadata.updated_at).to(eq(2002))
       expect(metadata.size).to(eq(3))

data/spec/asset_cloud/metadata_spec.rb

@@ -1,5 +1,7 @@
-require 'spec_helper'
-require 'asset_cloud/metadata'
+# frozen_string_literal: true
+
+require "spec_helper"
+require "asset_cloud/metadata"
 
 module AssetCloud
   describe Metadata do

data/spec/asset_extension_spec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 class NoCatsAsset < AssetCloud::Asset
   validate :no_cats
@@ -8,7 +9,7 @@ class NoCatsAsset < AssetCloud::Asset
   private
 
   def no_cats
-    add_error('no cats allowed!') if value =~ /cat/i
+    add_error("no cats allowed!") if value =~ /cat/i
   end
 end
 
@@ -53,33 +54,33 @@ describe "AssetExtension" do
   include AssetCloud
 
   before do
-    @cloud = CatsAndDogsCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/')
+    @cloud = CatsAndDogsCloud.new(File.dirname(__FILE__) + "/files", "http://assets/")
   end
 
   describe "applicability" do
     it "should work" do
-      asset = @cloud['cat_pen/cats.xml']
+      asset = @cloud["cat_pen/cats.xml"]
       expect(XmlAssetExtension.applies_to_asset?(asset)).to(eq(true))
     end
   end
 
   describe "validations" do
     it "should be added to assets in the right bucket with the right extension" do
-      asset = @cloud['cat_pen/cats.css']
-      asset.value = 'foo'
+      asset = @cloud["cat_pen/cats.css"]
+      asset.value = "foo"
       expect(asset.store).to(eq(false))
       expect(asset.errors).to(eq(["not enough curly brackets!"]))
     end
 
     it "should not squash existing validations on the asset" do
-      asset = @cloud['dog_pound/cats.xml']
-      asset.value = 'cats!'
+      asset = @cloud["dog_pound/cats.xml"]
+      asset.value = "cats!"
       expect(asset.store).to(eq(false))
-      expect(asset.errors).to(eq(['no cats allowed!', "not enough angle brackets!"]))
+      expect(asset.errors).to(eq(["no cats allowed!", "not enough angle brackets!"]))
     end
 
     it "should not apply to non-matching assets or those in exempted buckets" do
-      asset = @cloud['cat_pen/cats.xml']
+      asset = @cloud["cat_pen/cats.xml"]
       asset.value = "xml"
       expect(asset.store).to(eq(true))
     end
@@ -87,20 +88,20 @@ describe "AssetExtension" do
 
   describe "callbacks" do
     it "should run alongside the asset's callbacks" do
-      asset = @cloud['dog_pound/dogs.xml']
+      asset = @cloud["dog_pound/dogs.xml"]
       expect(asset).to(receive(:asset_callback))
       expect(asset.extensions.first).to(receive(:xml_callback))
-      asset.value = '<dogs/>'
+      asset.value = "<dogs/>"
       expect(asset.store).to(eq(true))
     end
   end
 
   describe "#method_missing" do
     it "should try to run method on extensions" do
-      asset = @cloud['dog_pound/dogs.xml']
-      asset.value = 'dogs'
+      asset = @cloud["dog_pound/dogs.xml"]
+      asset.value = "dogs"
       asset.turn_into_xml
-      expect(asset.value).to(eq('<xml>dogs</xml>'))
+      expect(asset.value).to(eq("<xml>dogs</xml>"))
     end
 
     it "does not swallow NotImplementedError" do
@@ -108,7 +109,7 @@ describe "AssetExtension" do
         raise NotImplementedError
       end
 
-      asset = @cloud['dog_pound/dogs.xml']
+      asset = @cloud["dog_pound/dogs.xml"]
 
       expect(asset).to(respond_to(:my_unimplemented_extension))
       expect { asset.my_unimplemented_extension }.to(raise_error(NotImplementedError))