capistrano-s3 2.4.0 → 3.0.0.pre2

data/lib/capistrano/s3/publisher.rb

@@ -1,107 +1,111 @@
-require 'aws-sdk'
-require 'mime/types'
-require 'fileutils'
-require 'capistrano/s3/mime_types'
+# frozen_string_literal: true
+
+require "aws-sdk"
+require "mime/types"
+require "fileutils"
+require "capistrano/s3/mime_types"
+require "yaml"
 
 module Capistrano
   module S3
     module Publisher
-      LAST_PUBLISHED_FILE = '.last_published'
-      LAST_INVALIDATION_FILE = '.last_invalidation'
+      LAST_PUBLISHED_FILE = ".last_published"
+      LAST_INVALIDATION_FILE = ".last_invalidation"
 
-      def self.publish!(region, key, secret, bucket, deployment_path, target_path, distribution_id, invalidations, exclusions, only_gzip, extra_options, stage = 'default')
-        deployment_path_absolute = File.expand_path(deployment_path, Dir.pwd)
-        s3 = self.establish_s3_client_connection!(region, key, secret)
-        updated = false
+      class << self
+        def publish!(region, key, secret, bucket, deployment_path, target_path, distribution_id,
+                     invalidations, exclusions, only_gzip, extra_options, stage = "default")
+          deployment_path_absolute = File.expand_path(deployment_path, Dir.pwd)
+          s3_client = establish_s3_client_connection!(region, key, secret)
 
-        self.files(deployment_path_absolute, exclusions).each do |file|
-          if !File.directory?(file)
-            next if self.published?(file, bucket, stage)
-            next if only_gzip && self.has_gzipped_version?(file)
+          files(deployment_path_absolute, exclusions).each do |file|
+            next if File.directory?(file)
+            next if published?(file, bucket, stage)
+            next if only_gzip && gzipped_version?(file)
 
-            path = self.base_file_path(deployment_path_absolute, file)
-            path.gsub!(/^\//, "") # Remove preceding slash for S3
+            path = base_file_path(deployment_path_absolute, file)
+            path.gsub!(%r{^/}, "") # Remove preceding slash for S3
 
-            self.put_object(s3, bucket, target_path, path, file, only_gzip, extra_options)
+            put_object(s3_client, bucket, target_path, path, file, only_gzip, extra_options)
           end
-        end
 
-        # invalidate CloudFront distribution if needed
-        if distribution_id && !invalidations.empty?
-          cf = self.establish_cf_client_connection!(region, key, secret)
-
-          response = cf.create_invalidation({
-            :distribution_id => distribution_id,
-            :invalidation_batch => {
-              :paths => {
-                :quantity => invalidations.count,
-                :items => invalidations.map do |path|
-                  File.join('/', self.add_prefix(path, prefix: target_path))
-                end
-              },
-              :caller_reference => SecureRandom.hex
-            }
-          })
-
-          if response && response.successful?
-            File.open(LAST_INVALIDATION_FILE, 'w') { |file| file.write(response[:invalidation][:id]) }
+          # invalidate CloudFront distribution if needed
+          if distribution_id && !invalidations.empty?
+            cf = establish_cf_client_connection!(region, key, secret)
+
+            response = cf.create_invalidation(
+              distribution_id: distribution_id,
+              invalidation_batch: {
+                paths: {
+                  quantity: invalidations.count,
+                  items: invalidations.map do |path|
+                    File.join("/", add_prefix(path, prefix: target_path))
+                  end
+                },
+                caller_reference: SecureRandom.hex
+              }
+            )
+
+            if response&.successful?
+              File.write(LAST_INVALIDATION_FILE, response[:invalidation][:id])
+            end
           end
-        end
 
-        self.published_to!(bucket, stage)
-      end
+          published_to!(bucket, stage)
+        end
 
-      def self.clear!(region, key, secret, bucket, stage = 'default')
-        s3 = self.establish_s3_connection!(region, key, secret)
-        s3.buckets[bucket].clear!
+        def clear!(region, key, secret, bucket, stage = "default")
+          s3 = establish_s3_connection!(region, key, secret)
+          s3.buckets[bucket].clear!
 
-        self.clear_published!(bucket, stage)
-        FileUtils.rm(LAST_INVALIDATION_FILE)
-      end
+          clear_published!(bucket, stage)
+          FileUtils.rm(LAST_INVALIDATION_FILE)
+        end
 
-      def self.check_invalidation(region, key, secret, distribution_id, stage = 'default')
-        last_invalidation_id = File.read(LAST_INVALIDATION_FILE).strip
+        def check_invalidation(region, key, secret, distribution_id, _stage = "default")
+          last_invalidation_id = File.read(LAST_INVALIDATION_FILE).strip
 
-        cf = self.establish_cf_client_connection!(region, key, secret)
-        cf.wait_until(:invalidation_completed, distribution_id: distribution_id, id: last_invalidation_id) do |w|
-          w.max_attempts = nil
-          w.delay = 30
+          cf = establish_cf_client_connection!(region, key, secret)
+          cf.wait_until(:invalidation_completed, distribution_id: distribution_id,
+                                                 id: last_invalidation_id) do |w|
+            w.max_attempts = nil
+            w.delay = 30
+          end
         end
-      end
 
-      private
+        private
 
         # Establishes the connection to Amazon S3
-        def self.establish_connection!(klass, region, key, secret)
+        def establish_connection!(klass, region, key, secret)
           # Send logging to STDOUT
           Aws.config[:logger] = ::Logger.new(STDOUT)
           Aws.config[:log_formatter] = Aws::Log::Formatter.colored
           klass.new(
-            :region => region,
-            :access_key_id => key,
-            :secret_access_key => secret
+            region: region,
+            access_key_id: key,
+            secret_access_key: secret
           )
         end
 
-        def self.establish_cf_client_connection!(region, key, secret)
-          self.establish_connection!(Aws::CloudFront::Client, region, key, secret)
+        def establish_cf_client_connection!(region, key, secret)
+          establish_connection!(Aws::CloudFront::Client, region, key, secret)
         end
 
-        def self.establish_s3_client_connection!(region, key, secret)
-          self.establish_connection!(Aws::S3::Client, region, key, secret)
+        def establish_s3_client_connection!(region, key, secret)
+          establish_connection!(Aws::S3::Client, region, key, secret)
         end
 
-        def self.establish_s3_connection!(region, key, secret)
-          self.establish_connection!(Aws::S3, region, key, secret)
+        def establish_s3_connection!(region, key, secret)
+          establish_connection!(Aws::S3, region, key, secret)
         end
 
-        def self.base_file_path(root, file)
+        def base_file_path(root, file)
           file.gsub(root, "")
         end
 
-        def self.files(deployment_path, exclusions)
+        def files(deployment_path, exclusions)
           globbed_paths = Dir.glob(
-            File.join(deployment_path, '**', '*'),
+            File.join(deployment_path, "**", "*"),
             File::FNM_DOTMATCH # Else Unix-like hidden files will be ignored
           )
 
@@ -112,41 +116,42 @@ module Capistrano
           globbed_paths - excluded_paths
         end
 
-        def self.last_published
-          if File.exists? LAST_PUBLISHED_FILE
+        def last_published
+          if File.exist? LAST_PUBLISHED_FILE
             YAML.load_file(LAST_PUBLISHED_FILE) || {}
           else
             {}
           end
         end
 
-        def self.published_to!(bucket, stage)
-          current_publish = self.last_published
+        def published_to!(bucket, stage)
+          current_publish = last_published
           current_publish["#{bucket}::#{stage}"] = Time.now.iso8601
           File.write(LAST_PUBLISHED_FILE, current_publish.to_yaml)
         end
 
-        def self.clear_published!(bucket, stage)
-          current_publish = self.last_published
+        def clear_published!(bucket, stage)
+          current_publish = last_published
           current_publish["#{bucket}::#{stage}"] = nil
           File.write(LAST_PUBLISHED_FILE, current_publish.to_yaml)
         end
 
-        def self.published?(file, bucket, stage)
-          return false unless last_publish_time = self.last_published["#{bucket}::#{stage}"]
+        def published?(file, bucket, stage)
+          return false unless (last_publish_time = last_published["#{bucket}::#{stage}"])
+
           File.mtime(file) < Time.parse(last_publish_time)
         end
 
-        def self.put_object(s3, bucket, target_path, path, file, only_gzip, extra_options)
+        def put_object(s3_client, bucket, target_path, path, file, only_gzip, extra_options)
           prefer_cf_mime_types = extra_options[:prefer_cf_mime_types] || false
 
           base_name = File.basename(file)
           mime_type = mime_type_for_file(base_name, prefer_cf_mime_types)
           options   = {
-            :bucket => bucket,
-            :key    => self.add_prefix(path, prefix: target_path),
-            :body   => open(file),
-            :acl    => 'public-read',
+            bucket: bucket,
+            key: add_prefix(path, prefix: target_path),
+            body: File.read(file),
+            acl: "public-read"
           }
 
           options.merge!(build_redirect_hash(path, extra_options[:redirect]))
@@ -154,9 +159,7 @@ module Capistrano
 
           object_write_options = extra_options[:object_write] || {}
           object_write_options.each do |pattern, object_options|
-            if File.fnmatch(pattern, options[:key])
-              options.merge!(object_options)
-            end
+            options.merge!(object_options) if File.fnmatch(pattern, options[:key])
           end
 
           if mime_type
@@ -167,69 +170,68 @@ module Capistrano
               options.merge!(build_gzip_content_type_hash(file, mime_type, prefer_cf_mime_types))
 
               # upload as original file name
-              options.merge!(key: self.add_prefix(self.orig_name(path), prefix: target_path)) if only_gzip
+              options[:key] = add_prefix(orig_name(path), prefix: target_path) if only_gzip
             end
           end
 
-          s3.put_object(options)
+          s3_client.put_object(options)
         end
 
-        def self.build_redirect_hash(path, redirect_options)
+        def build_redirect_hash(path, redirect_options)
           return {} unless redirect_options && redirect_options[path]
 
-          { :website_redirect_location => redirect_options[path] }
+          { website_redirect_location: redirect_options[path] }
         end
 
-        def self.build_content_type_hash(mime_type)
-          { :content_type => mime_type.content_type }
+        def build_content_type_hash(mime_type)
+          { content_type: mime_type.content_type }
         end
 
-        def self.build_gzip_content_encoding_hash
-          { :content_encoding => "gzip" }
+        def build_gzip_content_encoding_hash
+          { content_encoding: "gzip" }
         end
 
-        def self.has_gzipped_version?(file)
-          File.exist?(self.gzip_name(file))
+        def gzipped_version?(file)
+          File.exist?(gzip_name(file))
         end
 
-        def self.build_gzip_content_type_hash(file, mime_type, prefer_cf_mime_types)
-          orig_name = self.orig_name(file)
+        def build_gzip_content_type_hash(file, _mime_type, prefer_cf_mime_types)
+          orig_name = orig_name(file)
           orig_mime = mime_type_for_file(orig_name, prefer_cf_mime_types)
 
           return {} unless orig_mime && File.exist?(orig_name)
 
-          { :content_type => orig_mime.content_type }
+          { content_type: orig_mime.content_type }
         end
 
-        def self.mime_type_for_file(file, prefer_cf_mime_types)
+        def mime_type_for_file(file, prefer_cf_mime_types)
           types = MIME::Types.type_for(file)
 
           if prefer_cf_mime_types
             intersection = types & Capistrano::S3::MIMETypes::CF_MIME_TYPES
 
-            unless intersection.empty?
-              types = intersection
-            end
+            types = intersection unless intersection.empty?
           end
 
           types.first
         end
 
-        def self.gzip_name(file)
+        def gzip_name(file)
           "#{file}.gz"
         end
 
-        def self.orig_name(file)
+        def orig_name(file)
           file.sub(/\.gz$/, "")
         end
 
-        def self.add_prefix(path, prefix:)
+        def add_prefix(path, prefix:)
           if prefix.empty?
             path
           else
             File.join(prefix, path)
           end
         end
+      end
     end
   end
 end

data/lib/capistrano/s3/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Capistrano
   module S3
-    VERSION = "2.4.0"
+    VERSION = "3.0.0.pre2"
   end
 end

data/lib/capistrano/s3.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require "capistrano"
 require "capistrano/s3/publisher"
 require "capistrano/s3/version"
 require "capistrano/s3/defaults"
 require "capistrano/s3/mime_types"
 
-if Gem::Specification.find_by_name('capistrano').version >= Gem::Version.new('3.0.0')
-  load File.expand_path('../tasks/capistrano_3.rb', __FILE__)
+if Gem::Specification.find_by_name("capistrano").version >= Gem::Version.new("3.0.0")
+  load File.expand_path("tasks/capistrano_3.rb", __dir__)
 else
-  require_relative 'tasks/capistrano_2'
+  require_relative "tasks/capistrano_2"
 end

data/lib/capistrano/tasks/capistrano_2.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 module Capistrano
+  # rubocop:disable Metrics/BlockLength
   Configuration.instance(true).load do
     def _cset(name, *args, &block)
-      set(name, *args, &block) if !exists?(name)
+      set(name, *args, &block) unless exists?(name)
     end
 
     Capistrano::S3::Defaults.populate(self, :_cset)
@@ -16,14 +19,21 @@ module Capistrano
 
         desc "Waits until the last CloudFront invalidation batch is completed"
         task :wait_for_invalidation do
-          S3::Publisher.check_invalidation(region, access_key_id, secret_access_key, distribution_id)
+          S3::Publisher.check_invalidation(region, access_key_id, secret_access_key,
+                                           distribution_id)
         end
 
         desc "Upload files to the bucket in the current state"
         task :upload_files do
-          extra_options = { :write => bucket_write_options, :redirect => redirect_options, :object_write => object_write_options, :prefer_cf_mime_types => prefer_cf_mime_types }
+          extra_options = {
+            write: bucket_write_options,
+            redirect: redirect_options,
+            object_write: object_write_options,
+            prefer_cf_mime_types: prefer_cf_mime_types
+          }
           S3::Publisher.publish!(region, access_key_id, secret_access_key,
-                             bucket, deployment_path, target_path, distribution_id, invalidations, exclusions, only_gzip, extra_options)
+                                 bucket, deployment_path, target_path, distribution_id,
+                                 invalidations, exclusions, only_gzip, extra_options)
         end
       end
 
@@ -31,7 +41,10 @@ module Capistrano
         s3.upload_files
       end
 
-      task :restart do; end
+      task :restart do
+        # @todo remove?
+      end
     end
   end
+  # rubocop:enable Metrics/BlockLength
 end

data/lib/capistrano/tasks/capistrano_3.rb

@@ -1,26 +1,42 @@
+# frozen_string_literal: true
+
 namespace :load do
   task :defaults do
     Capistrano::S3::Defaults.populate(self, :set)
   end
 end
 
+# rubocop:disable Metrics/BlockLength
 namespace :deploy do
   namespace :s3 do
     desc "Empties bucket of all files. Caution when using this command, as it cannot be undone!"
     task :empty do
-      Capistrano::S3::Publisher.clear!(fetch(:region), fetch(:access_key_id), fetch(:secret_access_key), fetch(:bucket), fetch(:stage))
+      Capistrano::S3::Publisher.clear!(fetch(:region), fetch(:access_key_id),
+                                       fetch(:secret_access_key), fetch(:bucket), fetch(:stage))
     end
 
     desc "Waits until the last CloudFront invalidation batch is completed"
     task :wait_for_invalidation do
-      Capistrano::S3::Publisher.check_invalidation(fetch(:region), fetch(:access_key_id), fetch(:secret_access_key), fetch(:distribution_id), fetch(:stage))
+      Capistrano::S3::Publisher.check_invalidation(fetch(:region), fetch(:access_key_id),
+                                                   fetch(:secret_access_key),
+                                                   fetch(:distribution_id),
+                                                   fetch(:stage))
     end
 
     desc "Upload files to the bucket in the current state"
     task :upload_files do
-      extra_options = { :write => fetch(:bucket_write_options), :redirect => fetch(:redirect_options), :object_write => fetch(:object_write_options), :prefer_cf_mime_types => fetch(:prefer_cf_mime_types) }
-      Capistrano::S3::Publisher.publish!(fetch(:region), fetch(:access_key_id), fetch(:secret_access_key),
-                             fetch(:bucket), fetch(:deployment_path), fetch(:target_path), fetch(:distribution_id), fetch(:invalidations), fetch(:exclusions), fetch(:only_gzip), extra_options, fetch(:stage))
+      extra_options = {
+        write: fetch(:bucket_write_options),
+        redirect: fetch(:redirect_options),
+        object_write: fetch(:object_write_options),
+        prefer_cf_mime_types: fetch(:prefer_cf_mime_types)
+      }
+      Capistrano::S3::Publisher.publish!(fetch(:region), fetch(:access_key_id),
+                                         fetch(:secret_access_key), fetch(:bucket),
+                                         fetch(:deployment_path), fetch(:target_path),
+                                         fetch(:distribution_id), fetch(:invalidations),
+                                         fetch(:exclusions), fetch(:only_gzip), extra_options,
+                                         fetch(:stage))
     end
   end
 
@@ -28,3 +44,4 @@ namespace :deploy do
     invoke("deploy:s3:upload_files")
   end
 end
+# rubocop:enable Metrics/BlockLength