nanoc 4.11.14 → 4.11.15

data/lib/nanoc/deploying/deployer.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Deploying
-  # Represents a deployer, an object that allows uploading the compiled site
-  # to a specific (remote) location.
-  #
-  # @abstract Subclass and override {#run} to implement a custom filter.
-  #
-  # @api private
-  class Deployer
-    extend DDPlugin::Plugin
-
-    # @return [String] The path to the directory that contains the files to
-    #   upload. It should not have a trailing slash.
-    attr_reader :source_path
-
-    # @return [Hash] The deployer configuration
-    attr_reader :config
-
-    # @return [Boolean] true if the deployer should only show what would be
-    #   deployed instead of doing the actual deployment
-    attr_reader :dry_run
-    alias dry_run? dry_run
-
-    # @param [String] source_path The path to the directory that contains the
-    #   files to upload. It should not have a trailing slash.
-    #
-    # @return [Hash] config The deployer configuration
-    #
-    # @param [Boolean] dry_run true if the deployer should
-    #   only show what would be deployed instead actually deploying
-    def initialize(source_path, config, dry_run: false)
-      @source_path  = source_path
-      @config       = config
-      @dry_run      = dry_run
-    end
-
-    # Performs the actual deployment.
-    #
-    # @abstract
-    def run
-      raise NotImplementedError.new('Nanoc::Deploying::Deployer subclasses must implement #run')
-    end
-  end
-end

data/lib/nanoc/deploying/deployers.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require 'tty-command'
-
-# @api private
-module Nanoc::Deploying::Deployers
-end
-
-require_relative 'deployers/fog'
-require_relative 'deployers/git'
-require_relative 'deployers/rsync'

data/lib/nanoc/deploying/deployers/fog.rb

@@ -1,220 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Deploying::Deployers
-  # A deployer that deploys a site using [fog](https://github.com/fog/fog).
-  #
-  # @example A deployment configuration with public and staging configurations
-  #
-  #   deploy:
-  #     public:
-  #       kind:       fog
-  #       bucket:     nanoc-site
-  #       cdn_id:     XXXXXX
-  #     preprod:
-  #       kind:       fog
-  #       provider:   local
-  #       local_root: ~/myCloud
-  #       bucket:     nanoc-site
-  #     staging:
-  #       kind:       fog
-  #       provider:   local
-  #       local_root: ~/myCloud
-  #       bucket:     nanoc-site-staging
-  #
-  # @api private
-  class Fog < ::Nanoc::Deploying::Deployer
-    identifier :fog
-
-    class FogWrapper
-      def initialize(directory, is_dry_run)
-        @directory = directory
-        @is_dry_run = is_dry_run
-      end
-
-      def upload(source_filename, destination_key)
-        log_effectful("uploading #{source_filename} -> #{destination_key}")
-
-        unless dry_run?
-          File.open(source_filename) do |io|
-            @directory.files.create(
-              key: destination_key,
-              body: io,
-              public: true,
-            )
-          end
-        end
-      end
-
-      def remove(keys)
-        keys.each do |key|
-          log_effectful("removing #{key}")
-
-          unless dry_run?
-            @directory.files.get(key).destroy
-          end
-        end
-      end
-
-      def invalidate(keys, cdn, distribution)
-        keys.each_slice(1000) do |keys_slice|
-          keys_slice.each do |key|
-            log_effectful("invalidating #{key}")
-          end
-
-          unless dry_run?
-            cdn.post_invalidation(distribution, keys_slice)
-          end
-        end
-      end
-
-      def dry_run?
-        @is_dry_run
-      end
-
-      def log_effectful(str)
-        if @is_dry_run
-          puts "[dry run] #{str}"
-        else
-          puts str
-        end
-      end
-    end
-
-    # @see Nanoc::Deploying::Deployer#run
-    def run
-      require 'fog/core'
-
-      src      = File.expand_path(source_path)
-      bucket   = config[:bucket] || config[:bucket_name]
-      path     = config[:path]
-      cdn_id   = config[:cdn_id]
-
-      if path&.end_with?('/')
-        raise "The path `#{path}` is not supposed to have a trailing slash"
-      end
-
-      connection = connect
-      directory = get_or_create_bucket(connection, bucket, path)
-      wrapper = FogWrapper.new(directory, dry_run?)
-
-      remote_files = list_remote_files(directory)
-      etags = read_etags(remote_files)
-
-      modified_keys, retained_keys = upload_all(src, path, etags, wrapper)
-
-      removed_keys = remote_files.map(&:key) - retained_keys - modified_keys
-      wrapper.remove(removed_keys)
-
-      if cdn_id
-        cdn = ::Fog::CDN.new(config_for_fog)
-        distribution = cdn.get_distribution(cdn_id)
-        wrapper.invalidate(modified_keys + removed_keys, cdn, distribution)
-      end
-    end
-
-    private
-
-    def config_for_fog
-      config.dup.tap do |c|
-        c.delete(:bucket)
-        c.delete(:bucket_name)
-        c.delete(:path)
-        c.delete(:cdn_id)
-        c.delete(:kind)
-      end
-    end
-
-    def connect
-      ::Fog::Storage.new(config_for_fog)
-    rescue ArgumentError
-      require "fog/#{config[:provider]}"
-      ::Fog::Storage.new(config_for_fog)
-    end
-
-    def get_or_create_bucket(connection, bucket, path)
-      directory =
-        begin
-          connection.directories.get(bucket, prefix: path)
-        rescue ::Excon::Errors::NotFound
-          nil
-        end
-
-      if directory
-        directory
-      elsif dry_run?
-        puts '[dry run] creating bucket'
-      else
-        puts 'creating bucket'
-        connection.directories.create(key: bucket, prefix: path)
-      end
-    end
-
-    def remote_key_for_local_filename(local_filename, src, path)
-      relative_local_filename = local_filename.sub(/\A#{src}\//, '')
-
-      if path
-        File.join(path, relative_local_filename)
-      else
-        relative_local_filename
-      end
-    end
-
-    def list_remote_files(directory)
-      if directory
-        [].tap do |files|
-          directory.files.each { |file| files << file }
-        end
-      else
-        []
-      end
-    end
-
-    def list_local_files(src)
-      Dir[src + '/**/*'].select { |f| File.file?(f) }
-    end
-
-    def upload_all(src, path, etags, wrapper)
-      modified_keys = []
-      retained_keys = []
-
-      local_files = list_local_files(src)
-      local_files.each do |file_path|
-        key = remote_key_for_local_filename(file_path, src, path)
-        if needs_upload?(key, file_path, etags)
-          wrapper.upload(file_path, key)
-          modified_keys.push(key)
-        else
-          retained_keys.push(key)
-        end
-      end
-
-      [modified_keys, retained_keys]
-    end
-
-    def needs_upload?(key, file_path, etags)
-      remote_etag = etags[key]
-      return true if remote_etag.nil?
-
-      local_etag = calc_local_etag(file_path)
-      remote_etag != local_etag
-    end
-
-    def read_etags(files)
-      case config[:provider]
-      when 'aws'
-        files.each_with_object({}) do |file, etags|
-          etags[file.key] = file.etag
-        end
-      else
-        {}
-      end
-    end
-
-    def calc_local_etag(file_path)
-      case config[:provider]
-      when 'aws'
-        Digest::MD5.file(file_path).hexdigest
-      end
-    end
-  end
-end

data/lib/nanoc/deploying/deployers/git.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Deploying::Deployers
-  # A deployer that deploys a site using [Git](https://git-scm.com).
-  #
-  # @example A deployment configuration for GitHub Pages:
-  #
-  #   deploy:
-  #     default:
-  #       kind:       git
-  #       remote:     git@github.com:myself/myproject.git
-  #       branch:     gh-pages
-  #       forced:     true
-  #
-  class Git < ::Nanoc::Deploying::Deployer
-    identifier :git
-
-    module Errors
-      class Generic < ::Nanoc::Core::Error
-      end
-
-      class OutputDirDoesNotExist < Generic
-        def initialize(path)
-          super("The directory to deploy, #{path}, does not exist.")
-        end
-      end
-
-      class OutputDirIsNotAGitRepo < Generic
-        def initialize(path)
-          super("The directory to deploy, #{path}, is not a Git repository.")
-        end
-      end
-
-      class RemoteDoesNotExist < Generic
-        def initialize(remote)
-          super("The remote to deploy to, #{remote}, does not exist.")
-        end
-      end
-
-      class BranchDoesNotExist < Generic
-        def initialize(branch)
-          super("The branch to deploy, #{branch}, does not exist.")
-        end
-      end
-    end
-
-    def run
-      unless File.exist?(source_path)
-        raise Errors::OutputDirDoesNotExist.new(source_path)
-      end
-
-      remote = config.fetch(:remote, 'origin')
-      branch = config.fetch(:branch, 'master')
-      forced = config.fetch(:forced, false)
-
-      puts "Deploying via Git to branch “#{branch}” on remote “#{remote}”…"
-
-      Dir.chdir(source_path) do
-        unless File.exist?('.git')
-          raise Errors::OutputDirIsNotAGitRepo.new(source_path)
-        end
-
-        # Verify existence of remote, if remote is not a URL
-        if remote_is_name?(remote)
-          begin
-            run_cmd(%W[git config --get remote.#{remote}.url])
-          rescue TTY::Command::ExitError
-            raise Errors::RemoteDoesNotExist.new(remote)
-          end
-        end
-
-        # If the branch exists then switch to it, otherwise prompt the user to create one.
-        begin
-          run_cmd_unless_dry(%W[git checkout #{branch}])
-        rescue TTY::Command::ExitError
-          raise Errors::BranchDoesNotExist.new(branch)
-        end
-
-        return if clean_repo?
-
-        msg = "Automated commit at #{Time.now.utc} by Nanoc #{Nanoc::VERSION}"
-        author = 'Nanoc <>'
-        run_cmd_unless_dry(%w[git add -A])
-        run_cmd_unless_dry(%W[git commit -a --author #{author} -m #{msg}])
-
-        if forced
-          run_cmd_unless_dry(%W[git push -f #{remote} #{branch}])
-        else
-          run_cmd_unless_dry(%W[git push #{remote} #{branch}])
-        end
-      end
-    end
-
-    private
-
-    def remote_is_name?(remote)
-      remote !~ /:\/\/|@.+:/
-    end
-
-    def run_cmd(cmd, dry_run: false)
-      TTY::Command.new(printer: :null).run(*cmd, dry_run: dry_run)
-    end
-
-    def run_cmd_unless_dry(cmd)
-      run_cmd(cmd, dry_run: dry_run)
-    end
-
-    def clean_repo?
-      TTY::Command.new(printer: :null).run('git status --porcelain').out.empty?
-    end
-  end
-end

data/lib/nanoc/deploying/deployers/rsync.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Deploying::Deployers
-  # A deployer that deploys a site using rsync.
-  #
-  # The configuration has should include a `:dst` value, a string containing
-  # the destination to where rsync should upload its data. It will likely be
-  # in `host:path` format. It should not end with a slash. For example,
-  # `"example.com:/var/www/sites/mysite/html"`.
-  #
-  # @example A deployment configuration with public and staging configurations
-  #
-  #   deploy:
-  #     public:
-  #       kind: rsync
-  #       dst: "ectype:sites/stoneship/public"
-  #     staging:
-  #       kind: rsync
-  #       dst: "ectype:sites/stoneship-staging/public"
-  #       options: [ "-glpPrtvz" ]
-  #
-  # @api private
-  class Rsync < ::Nanoc::Deploying::Deployer
-    identifier :rsync
-
-    # Default rsync options
-    DEFAULT_OPTIONS = [
-      '--group',
-      '--links',
-      '--perms',
-      '--partial',
-      '--progress',
-      '--recursive',
-      '--times',
-      '--verbose',
-      '--compress',
-      '--exclude=".hg"',
-      '--exclude=".svn"',
-      '--exclude=".git"',
-    ].freeze
-
-    # @see Nanoc::Deploying::Deployer#run
-    def run
-      # Get params
-      src = source_path + '/'
-      dst = config[:dst]
-      options = config[:options] || DEFAULT_OPTIONS
-
-      # Validate
-      raise 'No dst found in deployment configuration' if dst.nil?
-      raise 'dst requires no trailing slash' if dst[-1, 1] == '/'
-
-      # Run
-      if dry_run
-        warn 'Performing a dry-run; no actions will actually be performed'
-        run_shell_cmd(['echo', 'rsync', options, src, dst].flatten)
-      else
-        run_shell_cmd(['rsync', options, src, dst].flatten)
-      end
-    end
-
-    private
-
-    def run_shell_cmd(cmd)
-      TTY::Command.new(printer: :null).run(*cmd)
-    end
-  end
-end