nanoc 4.11.13 → 4.11.18

data/lib/nanoc/checking/checks/mixed_content.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Checking::Checks
-  # A check that verifies HTML files do not reference external resources with
-  # URLs that would trigger "mixed content" warnings.
-  #
-  # @api private
-  class MixedContent < ::Nanoc::Checking::Check
-    identifier :mixed_content
-
-    PROTOCOL_PATTERN = /^(\w+):\/\//.freeze
-
-    def run
-      filenames = output_html_filenames
-      resource_uris_with_filenames = ::Nanoc::Extra::LinkCollector.new(filenames).filenames_per_resource_uri
-
-      resource_uris_with_filenames.each_pair do |uri, fns|
-        next unless guaranteed_insecure?(uri)
-
-        fns.each do |filename|
-          add_issue(
-            "mixed content include: #{uri}",
-            subject: filename,
-          )
-        end
-      end
-    end
-
-    private
-
-    def guaranteed_insecure?(href)
-      protocol = PROTOCOL_PATTERN.match(href)
-
-      protocol && protocol[1].casecmp('http').zero?
-    end
-  end
-end

data/lib/nanoc/checking/checks/stale.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Checking::Checks
-  # @api private
-  class Stale < ::Nanoc::Checking::Check
-    identifier :stale
-
-    def run
-      output_filenames.each do |f|
-        next if pruner.filename_excluded?(f)
-        next if item_rep_paths.include?(f)
-
-        add_issue(
-          'file without matching item',
-          subject: f,
-        )
-      end
-    end
-
-    protected
-
-    def item_rep_paths
-      @item_rep_paths ||=
-        Set.new(
-          @items
-            .flat_map(&:reps)
-            .map(&:_unwrap)
-            .flat_map(&:raw_paths)
-            .flat_map(&:values)
-            .flatten,
-        )
-    end
-
-    def pruner
-      exclude_config = @config.fetch(:prune, {}).fetch(:exclude, [])
-      # FIXME: specifying reps this way is icky
-      reps = Nanoc::Core::ItemRepRepo.new
-      @pruner ||= Nanoc::Core::Pruner.new(@config._unwrap, reps, exclude: exclude_config)
-    end
-  end
-end

data/lib/nanoc/checking/checks/w3c_validator.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module ::Nanoc::Checking::Checks
-  # @api private
-  class W3CValidator < ::Nanoc::Checking::Check
-    def run
-      require 'w3c_validators'
-      require 'resolv-replace'
-
-      Dir[@config.output_dir + '/**/*.' + extension].each do |filename|
-        results = validator_class.new.validate_file(filename)
-        lines = File.readlines(filename)
-        results.errors.each do |e|
-          line_num = e.line.to_i - 1
-          line = lines[line_num]
-          message = e.message.gsub(%r{\s+}, ' ').strip.sub(/\s+:$/, '')
-          desc = "line #{line_num + 1}: #{message}: #{line}"
-          add_issue(desc, subject: filename)
-        end
-      end
-    end
-
-    def extension
-      raise NotImplementedError
-    end
-
-    def validator_class
-      raise NotImplementedError
-    end
-  end
-end

data/lib/nanoc/checking/dsl.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Checking
-  # @api private
-  class DSL
-    def self.from_file(filename, enabled_checks:)
-      dsl = new(enabled_checks: enabled_checks)
-      absolute_filename = File.expand_path(filename)
-      dsl.instance_eval(File.read(filename), absolute_filename)
-      dsl
-    end
-
-    def initialize(enabled_checks:)
-      @enabled_checks = enabled_checks
-    end
-
-    def check(identifier, &block)
-      klass = Class.new(::Nanoc::Checking::Check)
-      klass.send(:define_method, :run, &block)
-      klass.send(:identifier, identifier)
-    end
-
-    def deploy_check(*identifiers)
-      identifiers.each { |i| @enabled_checks << i }
-    end
-  end
-end

data/lib/nanoc/checking/issue.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Checking
-  # @api private
-  class Issue
-    attr_reader :description
-    attr_reader :subject
-    attr_reader :check_class
-
-    def initialize(desc, subject, check_class)
-      @description   = desc
-      @subject       = subject
-      @check_class = check_class
-    end
-  end
-end

data/lib/nanoc/checking/loader.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Checking
-  # @api private
-  class Loader
-    CHECKS_FILENAMES = ['Checks', 'Checks.rb', 'checks', 'checks.rb'].freeze
-
-    def initialize(config:)
-      @config = config
-    end
-
-    def run
-      dsl
-    end
-
-    def enabled_checks
-      (enabled_checks_from_dsl + enabled_checks_from_config).uniq
-    end
-
-    private
-
-    def dsl_present?
-      checks_filename && File.file?(checks_filename)
-    end
-
-    def enabled_checks_from_dsl
-      dsl
-      @enabled_checks_from_dsl
-    end
-
-    def enabled_checks_from_config
-      @config.fetch(:checking, {}).fetch(:enabled_checks, []).map(&:to_sym)
-    end
-
-    def dsl
-      @enabled_checks_from_dsl ||= []
-
-      @dsl ||=
-        if dsl_present?
-          Nanoc::Checking::DSL.from_file(checks_filename, enabled_checks: @enabled_checks_from_dsl)
-        else
-          Nanoc::Checking::DSL.new(enabled_checks: @enabled_checks_from_dsl)
-        end
-    end
-
-    def checks_filename
-      @_checks_filename ||= CHECKS_FILENAMES.find { |f| File.file?(f) }
-    end
-  end
-end

data/lib/nanoc/checking/runner.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Checking
-  # Runner is reponsible for running issue checks.
-  #
-  # @api private
-  class Runner
-    # @param [Nanoc::Core::Site] site The Nanoc site this runner is for
-    def initialize(site)
-      @site = site
-    end
-
-    def any_enabled_checks?
-      enabled_checks.any?
-    end
-
-    # Lists all available checks on stdout.
-    #
-    # @return [void]
-    def list_checks
-      load_all
-
-      puts 'Available checks:'
-      puts
-      puts all_check_classes.map { |i| '  ' + i.identifier.to_s }.sort.join("\n")
-    end
-
-    # Runs all checks.
-    #
-    # @return [Boolean] true if successful, false otherwise
-    def run_all
-      load_all
-      run_check_classes(all_check_classes)
-    end
-
-    # Runs the checks marked for deployment.
-    #
-    # @return [Boolean] true if successful, false otherwise
-    def run_for_deploy
-      # TODO: rename to #run_enabled
-      load_all
-      run_check_classes(check_classes_named(enabled_checks))
-    end
-
-    # Runs the checks with the given names.
-    #
-    # @param [Array<Symbol>] check_class_names The names of the checks
-    #
-    # @return [Boolean] true if successful, false otherwise
-    def run_specific(check_class_names)
-      load_all
-      run_check_classes(check_classes_named(check_class_names))
-    end
-
-    private
-
-    def loader
-      @loader ||= Nanoc::Checking::Loader.new(config: @site.config)
-    end
-
-    def load_all
-      loader.run
-    end
-
-    def enabled_checks
-      loader.enabled_checks
-    end
-
-    def run_check_classes(classes)
-      issues = run_checks(classes)
-      print_issues(issues)
-      issues.empty? ? true : false
-    end
-
-    def all_check_classes
-      Nanoc::Checking::Check.all
-    end
-
-    def check_classes_named(names)
-      names.map do |name|
-        name = name.to_s.tr('-', '_').to_sym
-        klass = Nanoc::Checking::Check.named(name)
-        raise Nanoc::Core::TrivialError, "Unknown check: #{name}" if klass.nil?
-
-        klass
-      end
-    end
-
-    def run_checks(classes)
-      return [] if classes.empty?
-
-      # TODO: remove me
-      Nanoc::Core::Compiler.new_for(@site).run_until_reps_built
-
-      checks = []
-      issues = Set.new
-      length = classes.map { |c| c.identifier.to_s.length }.max + 18
-      classes.each do |klass|
-        print format("  %-#{length}s", "Running check #{klass.identifier}… ")
-
-        check = klass.create(@site)
-        check.run
-
-        checks << check
-        issues.merge(check.issues)
-
-        # TODO: report progress
-
-        puts check.issues.empty? ? 'ok'.green : 'error'.red
-      end
-      issues
-    end
-
-    def subject_to_s(str)
-      str || '(global)'
-    end
-
-    def print_issues(issues)
-      require 'colored'
-
-      return if issues.empty?
-
-      puts 'Issues found!'
-      issues.group_by(&:subject).to_a.sort_by { |s| subject_to_s(s.first) }.each do |pair|
-        subject = pair.first
-        issues  = pair.last
-        next if issues.empty?
-
-        puts "  #{subject_to_s(subject)}:"
-        issues.each do |i|
-          puts "    [ #{'ERROR'.red} ] #{i.check_class.identifier} - #{i.description}"
-        end
-      end
-    end
-  end
-end

data/lib/nanoc/deploying.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  # @api private
-  module Deploying
-  end
-end
-
-require 'nanoc/deploying/deployer'
-require 'nanoc/deploying/deployers'

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