nanoc-deploying 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ab7916826cd210ddc7bfacca3b6798df30ce86a5945cd1848e7ec4b6ed4d2dd5
+  data.tar.gz: '059736d6529ced037de1e7cebd6aa7071ab1d0213a2dae47f6b1e1b46c41dabc'
+SHA512:
+  metadata.gz: f02b27a4e978eb3edc2b339e07924defdc7643953c03e61035916fc8eb934b00a16a5537ae81e8cef6658187dc71a81e09c095ba230fc1be4897814fd6667ff9
+  data.tar.gz: 40a9a102559188234e1185d9a23c5f4bd23458bf88a0a0b6a09eec2f58dcdaa845836da937a0b1bfd0ee15a679d40a4db5ba378ed2c63b2c156ab10704025007

data/NEWS.md

@@ -0,0 +1,5 @@
+# nanoc-deploying news
+
+## 1.0.0 (2020-03-07)
+
+Initial release (extracted from nanoc)

data/README.md

@@ -0,0 +1,5 @@
+# nanoc-deploying
+
+This provides the `deploy` command and associated functionality for [Nanoc](https://nanoc.ws).
+
+For details, see the [Deploying Nanoc sites](https://nanoc.ws/doc/deploying/) chapter of the Nanoc documentation.

data/lib/nanoc-deploying.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'nanoc/deploying'

data/lib/nanoc/deploying.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'nanoc-core'
+require 'nanoc-cli'
+
+module Nanoc
+  module Deploying
+  end
+end
+
+require 'nanoc/deploying/version'
+require 'nanoc/deploying/deployer'
+require 'nanoc/deploying/deployers'
+
+require 'nanoc/deploying/command_runners'
+
+root = File.dirname(__FILE__)
+deploying_command_path = File.join(root, 'deploying', 'commands', 'deploy.rb')
+command = Cri::Command.load_file(deploying_command_path, infer_name: true)
+
+Nanoc::CLI.after_setup do
+  Nanoc::CLI.add_command(command)
+  Nanoc::CLI::Commands::ShowPlugins.add_plugin_class(Nanoc::Deploying::Deployer, 'Deployers')
+end

data/lib/nanoc/deploying/command_runners.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# @api private
+module Nanoc
+  module Deploying
+    module CommandRunners
+    end
+  end
+end
+
+require_relative 'command_runners/deploy'

data/lib/nanoc/deploying/command_runners/deploy.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Deploying
+    module CommandRunners
+      class Deploy < ::Nanoc::CLI::CommandRunner
+        def run
+          @site = load_site
+          Nanoc::Core::Compiler.new_for(@site).run_until_preprocessed
+
+          if options[:'list-deployers']
+            list_deployers
+          elsif options[:list]
+            list_deploy_configs
+          else
+            deploy
+          end
+        end
+
+        private
+
+        def list_deployers
+          deployers      = Nanoc::Deploying::Deployer.all
+          deployer_names = deployers.map(&:identifier).sort
+          puts 'Available deployers:'
+          deployer_names.each do |name|
+            puts "  #{name}"
+          end
+        end
+
+        def list_deploy_configs
+          if deploy_configs.empty?
+            puts 'No deployment configurations.'
+          else
+            puts 'Available deployment configurations:'
+            deploy_configs.each_key do |name|
+              puts "  #{name}"
+            end
+          end
+        end
+
+        def deploy
+          deployer = deployer_for(deploy_config)
+
+          checks_successful = options[:'no-check'] ? true : check
+          return unless checks_successful
+
+          deployer.run
+        end
+
+        def deploy_config
+          if deploy_configs.empty?
+            raise Nanoc::Core::TrivialError, 'The site has no deployment configurations.'
+          end
+
+          if arguments.length > 1
+            raise Nanoc::Core::TrivialError, "usage: #{command.usage}"
+          end
+
+          target_from_arguments = arguments[0]
+          target_from_options = options.fetch(:target, nil)
+          if target_from_arguments && target_from_options
+            raise Nanoc::Core::TrivialError, 'Only one deployment target can be specified on the command line.'
+          end
+
+          target = target_from_arguments || target_from_options || :default
+          deploy_configs.fetch(target.to_sym) do
+            raise Nanoc::Core::TrivialError, "The site has no deployment configuration named `#{target}`."
+          end
+        end
+
+        def deployer_for(config)
+          deployer_class_for_config(config).new(
+            @site.config.output_dir,
+            config,
+            dry_run: options[:'dry-run'],
+          )
+        end
+
+        def check
+          runner = Nanoc::Checking::Runner.new(@site)
+          if runner.any_enabled_checks?
+            puts 'Running issue checks…'
+            is_success = runner.run_for_deploy
+            if is_success
+              puts 'No issues found. Deploying!'
+            else
+              puts 'Issues found, deploy aborted.'
+            end
+            is_success
+          else
+            true
+          end
+        end
+
+        def deploy_configs
+          @site.config.fetch(:deploy, {})
+        end
+
+        def deployer_class_for_config(config)
+          name = config.fetch(:kind) do
+            $stderr.puts 'Warning: The specified deploy target does not have a kind attribute. Assuming rsync.'
+            'rsync'
+          end
+
+          deployer_class = Nanoc::Deploying::Deployer.named(name.to_sym)
+          if deployer_class.nil?
+            names = Nanoc::Deploying::Deployer.all.map(&:identifier)
+            raise Nanoc::Core::TrivialError, "The specified deploy target has an unrecognised kind “#{name}” (expected one of #{names.join(', ')})."
+          end
+          deployer_class
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/deploying/commands/deploy.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+usage 'deploy [target] [options]'
+summary 'deploy the compiled site'
+description "
+Deploys the compiled site. The compiled site contents in the output directory will be uploaded to the destination, which is specified using the `--target` option.
+"
+
+option :t, :target,         'specify the location to deploy to (default: `default`)', argument: :required
+flag :C, :'no-check',       'do not run the issue checks marked for deployment'
+flag :L, :list,             'list available locations to deploy to'
+flag :D, :'list-deployers', 'list available deployers'
+option :n, :'dry-run',      'show what would be deployed'
+
+runner Nanoc::Deploying::CommandRunners::Deploy

data/lib/nanoc/deploying/deployer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module 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
+end

data/lib/nanoc/deploying/deployers.rb

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

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

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Deploying
+    module 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
+  end
+end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Deploying
+    module 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
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Deploying
+    module 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
+  end
+end

data/lib/nanoc/deploying/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Deploying
+    VERSION = '1.0.0'
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: nanoc-deploying
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Denis Defreyne
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nanoc-checking
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: nanoc-cli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.11.15
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.11.15
+- !ruby/object:Gem::Dependency
+  name: nanoc-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.11.15
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.11.15
+description: Provides deploying functionality for Nanoc
+email: denis+rubygems@denis.ws
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- NEWS.md
+- README.md
+- lib/nanoc-deploying.rb
+- lib/nanoc/deploying.rb
+- lib/nanoc/deploying/command_runners.rb
+- lib/nanoc/deploying/command_runners/deploy.rb
+- lib/nanoc/deploying/commands/deploy.rb
+- lib/nanoc/deploying/deployer.rb
+- lib/nanoc/deploying/deployers.rb
+- lib/nanoc/deploying/deployers/fog.rb
+- lib/nanoc/deploying/deployers/git.rb
+- lib/nanoc/deploying/deployers/rsync.rb
+- lib/nanoc/deploying/version.rb
+homepage: https://nanoc.ws/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Deploying support for Nanoc
+test_files: []