nanoc 4.11.13 → 4.11.18

data/lib/nanoc/base.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-# @api private
-module Nanoc
-  module Int
-  end
-
-  module Base
-  end
-end
-
-require_relative 'base/errors'
-require_relative 'base/changes_stream'

data/lib/nanoc/base/changes_stream.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  class ChangesStream
-    class ChangesListener
-      def initialize(y)
-        @y = y
-      end
-
-      def unknown
-        @y << :unknown
-      end
-
-      def lib
-        @y << :lib
-      end
-
-      def to_stop(&block)
-        if block_given?
-          @to_stop = block
-        else
-          @to_stop
-        end
-      end
-    end
-
-    def initialize(enum: nil)
-      @enum = enum
-      @enum ||=
-        Enumerator.new do |y|
-          @listener = ChangesListener.new(y)
-          yield(@listener)
-        end.lazy
-    end
-
-    def stop
-      @listener&.to_stop&.call
-    end
-
-    def map
-      self.class.new(enum: @enum.map { |e| yield(e) })
-    end
-
-    def to_enum
-      @enum
-    end
-
-    def each
-      @enum.each { |e| yield(e) }
-      nil
-    end
-  end
-end

data/lib/nanoc/base/errors.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  module Int
-    # Module that contains all Nanoc-specific errors.
-    #
-    # @api private
-    module Errors
-      Generic = ::Nanoc::Core::Error
-
-      NoSuchSnapshot = ::Nanoc::Core::Errors::NoSuchSnapshot
-      CannotGetCompiledContentOfBinaryItem = ::Nanoc::Core::Errors::CannotGetCompiledContentOfBinaryItem
-      CannotGetParentOrChildrenOfNonLegacyItem = ::Nanoc::Core::Errors::CannotGetParentOrChildrenOfNonLegacyItem
-      CannotLayoutBinaryItem = ::Nanoc::Core::Errors::CannotLayoutBinaryItem
-      UnknownLayout = ::Nanoc::Core::Errors::UnknownLayout
-      CannotUseBinaryFilter = ::Nanoc::Core::Errors::CannotUseBinaryFilter
-      CannotUseTextualFilter = ::Nanoc::Core::Errors::CannotUseTextualFilter
-
-      # Error that is raised during site compilation when a layout is compiled
-      # for which the filter cannot be determined. This is similar to the
-      # {UnknownFilter} error, but specific for filters for layouts.
-      class CannotDetermineFilter < Generic
-        # @param [String] layout_identifier The identifier of the layout for
-        #   which the filter could not be determined
-        def initialize(layout_identifier)
-          super("The filter to be used for the “#{layout_identifier}” layout could not be determined. Make sure the layout does have a filter.")
-        end
-      end
-
-      # Error that is raised when no rules file can be found in the current
-      # working directory.
-      class NoRulesFileFound < Generic
-        def initialize
-          super('This site does not have a rules file, which is required for Nanoc sites.')
-        end
-      end
-
-      # Error that is raised when no compilation rule that can be applied to the
-      # current item can be found.
-      class NoMatchingCompilationRuleFound < Generic
-        # @param [Nanoc::Core::Item] item The item for which no compilation rule
-        #   could be found
-        def initialize(item)
-          super("No compilation rules were found for the “#{item.identifier}” item.")
-        end
-      end
-
-      # Error that is raised when no routing rule that can be applied to the
-      # current item can be found.
-      class NoMatchingRoutingRuleFound < Generic
-        # @param [Nanoc::Core::ItemRep] rep The item repiresentation for which no
-        #   routing rule could be found
-        def initialize(rep)
-          super("No routing rules were found for the “#{rep.item.identifier}” item (rep “#{rep.name}”).")
-        end
-      end
-
-      class AmbiguousMetadataAssociation < Generic
-        def initialize(content_filenames, meta_filename)
-          super("There are multiple content files (#{content_filenames.sort.join(', ')}) that could match the file containing metadata (#{meta_filename}).")
-        end
-      end
-    end
-  end
-end

data/lib/nanoc/checking.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-# @api private
-module Nanoc::Checking
-end
-
-require_relative 'checking/check'
-require_relative 'checking/checks'
-require_relative 'checking/dsl'
-require_relative 'checking/runner'
-require_relative 'checking/loader'
-require_relative 'checking/issue'
-
-Nanoc::Check = Nanoc::Checking::Check

data/lib/nanoc/checking/check.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Checking
-  # @api private
-  class OutputDirNotFoundError < ::Nanoc::Core::Error
-    def initialize(directory_path)
-      super("Unable to run check against output directory at “#{directory_path}”: directory does not exist.")
-    end
-  end
-
-  # @api private
-  class Check < Nanoc::Core::Context
-    extend DDPlugin::Plugin
-
-    DDMemoize.activate(self)
-
-    attr_reader :issues
-
-    def self.define(ident, &block)
-      klass = Class.new(::Nanoc::Checking::Check) { identifier(ident) }
-      klass.send(:define_method, :run) do
-        instance_exec(&block)
-      end
-    end
-
-    def self.create(site)
-      output_dir = site.config.output_dir
-      unless File.exist?(output_dir)
-        raise Nanoc::Checking::OutputDirNotFoundError.new(output_dir)
-      end
-
-      output_filenames = Dir[output_dir + '/**/*'].select { |f| File.file?(f) }
-
-      # FIXME: ugly
-      compiler = Nanoc::Core::Compiler.new_for(site)
-      res = compiler.run_until_reps_built
-      reps = res.fetch(:reps)
-      view_context =
-        Nanoc::Core::ViewContextForShell.new(
-          items: site.items,
-          reps: reps,
-        )
-
-      context = {
-        items: Nanoc::Core::PostCompileItemCollectionView.new(site.items, view_context),
-        layouts: Nanoc::Core::LayoutCollectionView.new(site.layouts, view_context),
-        config: Nanoc::Core::ConfigView.new(site.config, view_context),
-        output_filenames: output_filenames,
-      }
-
-      new(context)
-    end
-
-    def initialize(context)
-      super(context)
-
-      @issues = Set.new
-    end
-
-    def run
-      raise NotImplementedError.new('Nanoc::Checking::Check subclasses must implement #run')
-    end
-
-    def add_issue(desc, subject: nil)
-      # Simplify subject
-      # FIXME: do not depend on working directory
-      if subject&.start_with?(Dir.getwd)
-        subject = subject[(Dir.getwd.size + 1)..subject.size]
-      end
-
-      @issues << Issue.new(desc, subject, self.class)
-    end
-
-    # @private
-    def output_filenames
-      super.reject { |f| excluded_patterns.any? { |pat| pat.match?(f) } }
-    end
-
-    # @private
-    memoized def excluded_patterns
-      @config
-        .fetch(:checks, {})
-        .fetch(:all, {})
-        .fetch(:exclude_files, [])
-        .map { |pattern| Regexp.new(pattern) }
-    end
-
-    # @private
-    def output_html_filenames
-      output_filenames.select { |f| File.extname(f) =~ /\A\.x?html?\z/ }
-    end
-  end
-end

data/lib/nanoc/checking/checks.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-# @api private
-module Nanoc::Checking::Checks
-end
-
-require_relative 'checks/w3c_validator'
-
-require_relative 'checks/css'
-require_relative 'checks/external_links'
-require_relative 'checks/html'
-require_relative 'checks/internal_links'
-require_relative 'checks/mixed_content'
-require_relative 'checks/stale'

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module ::Nanoc::Checking::Checks
-  # @api private
-  class CSS < ::Nanoc::Checking::Checks::W3CValidator
-    identifier :css
-
-    def extension
-      'css'
-    end
-
-    def validator_class
-      ::W3CValidators::CSSValidator
-    end
-  end
-end

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

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-module ::Nanoc::Checking::Checks
-  # A validator that verifies that all external links point to a location that exists.
-  #
-  # @api private
-  class ExternalLinks < ::Nanoc::Checking::Check
-    identifiers :external_links, :elinks
-
-    def run
-      # Find all broken external hrefs
-      # TODO: de-duplicate this (duplicated in internal links check)
-      filenames = output_html_filenames.reject { |f| excluded_file?(f) }
-      hrefs_with_filenames = ::Nanoc::Extra::LinkCollector.new(filenames, :external).filenames_per_href
-      results = select_invalid(hrefs_with_filenames.keys.shuffle)
-
-      # Report them
-      results.each do |res|
-        filenames = hrefs_with_filenames[res.href]
-        filenames.each do |filename|
-          add_issue(
-            "broken reference to #{res.href}: #{res.explanation}",
-            subject: filename,
-          )
-        end
-      end
-    end
-
-    class Result
-      attr_reader :href
-      attr_reader :explanation
-
-      def initialize(href, explanation)
-        @href        = href
-        @explanation = explanation
-      end
-    end
-
-    def select_invalid(hrefs)
-      ::Parallel.map(hrefs, in_threads: 10) { |href| validate(href) }.compact
-    end
-
-    def validate(href)
-      # Parse
-      url = nil
-      begin
-        url = URI.parse(href)
-      rescue URI::Error
-        return Result.new(href, 'invalid URI')
-      end
-
-      # Skip excluded URLs
-      return nil if excluded?(href)
-
-      # Skip non-HTTP URLs
-      return nil if url.scheme !~ /^https?$/
-
-      # Get status
-      res = nil
-      last_err = nil
-      timeouts = [3, 5, 10, 30, 60]
-      5.times do |i|
-        begin
-          Timeout.timeout(timeouts[i]) do
-            res = request_url_once(url)
-          end
-        rescue => e
-          last_err = e
-          next
-        end
-
-        if /^3..$/.match?(res.code)
-          if i == 4
-            return Result.new(href, 'too many redirects')
-          end
-
-          location = extract_location(res, url)
-          return Result.new(href, 'redirection without a target location') if location.nil?
-
-          if /^30[18]$/.match?(res.code)
-            return Result.new(href, "link has moved permanently to '#{location}'")
-          end
-
-          url = URI.parse(location)
-        elsif res.code == '200'
-          return nil
-        else
-          return Result.new(href, res.code)
-        end
-      end
-      if last_err
-        return Result.new(href, last_err.message)
-      else
-        raise Nanoc::Core::Errors::InternalInconsistency, 'last_err cannot be nil'
-      end
-    end
-
-    def extract_location(res, url)
-      location = res['Location']
-
-      case location
-      when nil
-        nil
-      when /^https?:\/\//
-        location
-      else
-        base_url = url.dup
-        base_url.path = (/^\//.match?(location) ? '' : '/')
-        base_url.query = nil
-        base_url.fragment = nil
-        base_url.to_s + location
-      end
-    end
-
-    def path_for_url(url)
-      path =
-        if url.path.nil? || url.path.empty?
-          '/'
-        else
-          url.path
-        end
-
-      if url.query
-        path = path + '?' + url.query
-      end
-
-      path
-    end
-
-    def request_url_once(url)
-      req = Net::HTTP::Get.new(path_for_url(url))
-      req['User-Agent'] = "Mozilla/5.0 Nanoc/#{Nanoc::VERSION} (link rot checker)"
-      http = Net::HTTP.new(url.host, url.port)
-      if url.instance_of? URI::HTTPS
-        http.use_ssl = true
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      end
-      http.request(req)
-    end
-
-    def excluded?(href)
-      excludes = @config.fetch(:checks, {}).fetch(:external_links, {}).fetch(:exclude, [])
-      excludes.any? { |pattern| Regexp.new(pattern).match(href) }
-    end
-
-    def excluded_file?(file)
-      excludes = @config.fetch(:checks, {}).fetch(:external_links, {}).fetch(:exclude_files, [])
-      excludes.any? { |pattern| Regexp.new(pattern).match(file) }
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module ::Nanoc::Checking::Checks
-  # @api private
-  class HTML < ::Nanoc::Checking::Checks::W3CValidator
-    identifier :html
-
-    def extension
-      '{htm,html}'
-    end
-
-    def validator_class
-      ::W3CValidators::NuValidator
-    end
-  end
-end

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

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Checking::Checks
-  # A check that verifies that all internal links point to a location that exists.
-  #
-  # @api private
-  class InternalLinks < ::Nanoc::Checking::Check
-    identifiers :internal_links, :ilinks
-
-    # Starts the validator. The results will be printed to stdout.
-    #
-    # Internal links that match a regexp pattern in `@config[:checks][:internal_links][:exclude]` will
-    # be skipped.
-    #
-    # @return [void]
-    def run
-      # TODO: de-duplicate this (duplicated in external links check)
-      filenames = output_html_filenames
-      uris = ::Nanoc::Extra::LinkCollector.new(filenames, :internal).filenames_per_href
-
-      uris.each_pair do |href, fns|
-        fns.each do |filename|
-          next if valid?(href, filename)
-
-          add_issue(
-            "broken reference to #{href}",
-            subject: filename,
-          )
-        end
-      end
-    end
-
-    protected
-
-    def valid?(href, origin)
-      # Skip hrefs that point to self
-      # FIXME: this is ugly and won’t always be correct
-      return true if href == '.'
-
-      # Turn file: into output_dir-as-root relative paths
-
-      output_dir = @config.output_dir
-      output_dir += '/' unless output_dir.end_with?('/')
-      base_uri = URI("file://#{output_dir}")
-      path = href.sub(/#{base_uri}/, '').sub(/file:\/{1,3}/, '')
-
-      path = "/#{path}" unless path.start_with?('/')
-
-      # Skip hrefs that are specified in the exclude configuration
-      return true if excluded?(path, origin)
-
-      # Make an absolute path
-      path = ::File.join(output_dir, path[1..path.length])
-
-      # Remove fragment
-      path = path.sub(/#.*$/, '')
-      return true if path.empty?
-
-      # Remove query string
-      path = path.sub(/\?.*$/, '')
-      return true if path.empty?
-
-      # Decode URL (e.g. '%20' -> ' ')
-      path = CGI.unescape(path)
-
-      # Check whether file exists
-      return true if File.file?(path)
-
-      # Check whether directory with index file exists
-      return true if File.directory?(path) && @config[:index_filenames].any? { |fn| File.file?(File.join(path, fn)) }
-
-      # Nope :(
-      false
-    end
-
-    def excluded?(href, origin)
-      config = @config.fetch(:checks, {}).fetch(:internal_links, {})
-      excluded_target?(href, config) || excluded_origin?(origin, config)
-    end
-
-    def excluded_target?(href, config)
-      excludes = config.fetch(:exclude_targets, config.fetch(:exclude, []))
-      excludes.any? { |pattern| Regexp.new(pattern).match(href) }
-    end
-
-    def excluded_origin?(origin, config)
-      # FIXME: do not depend on current working directory
-      origin = File.absolute_path(origin)
-
-      relative_origin = origin[@config.output_dir.size..-1]
-      excludes = config.fetch(:exclude_origins, [])
-      excludes.any? { |pattern| Regexp.new(pattern).match(relative_origin) }
-    end
-  end
-end