nanoc-checking 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 86f973e7f2f708f6de4ae3fb3459f0cfd7f3a96e0cd44f0e742ebea4896d6c22
+  data.tar.gz: ec723179cd5cb4c89082367f9f96bb68779d302230ed7b99a689ec3706e4c48f
+SHA512:
+  metadata.gz: 63d9e7bc90d4310c80aee3fe27fbdb760847823704986fef39d20e5875f97c91289c88cc9b2493f29c386ba947a1be1de2741e4cf016fc137fa74838205819d3
+  data.tar.gz: b74f036990496a6cf571398fb00e284c368292097dd94bf0fde6c5a03dd4d9646407ee93d38d07b875fd6435e298059c7789c7e1335d3710f5a159715de01d39

data/NEWS.md

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

data/README.md

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

data/lib/nanoc-checking.rb

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

data/lib/nanoc/checking.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'nanoc-core'
+require 'nanoc-cli'
+
+module Nanoc
+  module Checking
+  end
+end
+
+require_relative 'checking/version'
+require_relative 'checking/check'
+require_relative 'checking/checks'
+require_relative 'checking/command_runners'
+require_relative 'checking/dsl'
+require_relative 'checking/runner'
+require_relative 'checking/loader'
+require_relative 'checking/issue'
+
+root = File.dirname(__FILE__)
+checking_command_path = File.join(root, 'checking', 'commands', 'check.rb')
+check_command = Cri::Command.load_file(checking_command_path, infer_name: true)
+
+Nanoc::CLI.after_setup do
+  Nanoc::CLI.add_command(check_command)
+end

data/lib/nanoc/checking/check.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module 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(self) { 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
+end

data/lib/nanoc/checking/checks.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# @api private
+module Nanoc
+  module Checking
+    module Checks
+    end
+  end
+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

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

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

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

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

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

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

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

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

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

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

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

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

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

data/lib/nanoc/checking/command_runners.rb

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

data/lib/nanoc/checking/command_runners/check.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Checking
+    module CommandRunners
+      class Check < ::Nanoc::CLI::CommandRunner
+        def run
+          site = load_site
+
+          runner = Nanoc::Checking::Runner.new(site)
+
+          if options[:list]
+            runner.list_checks
+            return
+          end
+
+          success =
+            if options[:all]
+              runner.run_all
+            elsif options[:deploy]
+              runner.run_for_deploy
+            elsif arguments.any?
+              runner.run_specific(arguments)
+            else
+              runner.run_for_deploy
+            end
+
+          unless success
+            raise Nanoc::Core::TrivialError, 'One or more checks failed'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/checking/commands/check.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+usage 'check [options] [names]'
+summary 'run issue checks'
+description "
+Run issue checks on the current site. If the `--all` option is passed, all available issue checks will be run. By default, the issue checks marked for deployment will be run.
+"
+
+flag :a, :all,    'run all checks'
+flag :L, :list,   'list all checks'
+flag :d, :deploy, '(deprecated)'
+
+runner Nanoc::Checking::CommandRunners::Check

data/lib/nanoc/checking/dsl.rb

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

data/lib/nanoc/checking/issue.rb

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

data/lib/nanoc/checking/loader.rb

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

data/lib/nanoc/checking/runner.rb

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

data/lib/nanoc/checking/version.rb

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

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: nanoc-checking
+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-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 checking functionality for Nanoc
+email: denis+rubygems@denis.ws
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- NEWS.md
+- README.md
+- lib/nanoc-checking.rb
+- lib/nanoc/checking.rb
+- lib/nanoc/checking/check.rb
+- lib/nanoc/checking/checks.rb
+- lib/nanoc/checking/checks/css.rb
+- lib/nanoc/checking/checks/external_links.rb
+- lib/nanoc/checking/checks/html.rb
+- lib/nanoc/checking/checks/internal_links.rb
+- lib/nanoc/checking/checks/mixed_content.rb
+- lib/nanoc/checking/checks/stale.rb
+- lib/nanoc/checking/checks/w3c_validator.rb
+- lib/nanoc/checking/command_runners.rb
+- lib/nanoc/checking/command_runners/check.rb
+- lib/nanoc/checking/commands/check.rb
+- lib/nanoc/checking/dsl.rb
+- lib/nanoc/checking/issue.rb
+- lib/nanoc/checking/loader.rb
+- lib/nanoc/checking/runner.rb
+- lib/nanoc/checking/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: Checking support for Nanoc
+test_files: []