nanoc 3.2.4 → 3.3.0

data/lib/nanoc/extra/validators.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module Nanoc::Extra
+
+  module Validators
+
+    autoload 'W3C',   'nanoc/extra/validators/w3c'
+    autoload 'Links', 'nanoc/extra/validators/links'
+
+  end
+
+end

data/lib/nanoc/extra/validators/links.rb

@@ -0,0 +1,268 @@
+# encoding: utf-8
+
+module Nanoc::Extra::Validators
+
+  # A validator that verifies that all links (`<a href="…">…</a>`) point to a
+  # location that exists.
+  class Links
+
+    # @param [String] dir The directory that will be searched for HTML files
+    #   to validate
+    #
+    # @param [Array<String>] index_filenames An array of index filenames that
+    #   will be appended to URLs by web servers if a directory is requested
+    #   instead of a file
+    #
+    # @option params [Boolean] :internal (false) True if internal links should
+    #   be checked; false if they should not
+    #
+    # @option params [Boolean] :external (false) True if external links should
+    #   be checked; false if they should not
+    def initialize(dir, index_filenames, params={})
+      @dir              = dir
+      @index_filenames  = index_filenames
+      @include_internal = params.has_key?(:internal) && params[:internal]
+      @include_external = params.has_key?(:external) && params[:external]
+    end
+
+    # Starts the validator. The results will be printed to stdout.
+    #
+    # @return [void]
+    def run
+      require 'nokogiri'
+
+      @delegate = self
+      links = all_broken_hrefs
+      if links.empty?
+        puts "No broken links found!"
+      else
+        links.each_pair do |href, origins|
+          puts "Broken link: #{href} -- referenced from:"
+          origins.each do |origin|
+            puts "    #{origin}"
+          end
+          puts
+        end
+      end
+    end
+
+  private
+
+    # Enumerates all key-value pairs of a given hash in a thread-safe way.
+    #
+    # @api private
+    class ThreadsafeHashEnumerator
+
+      # Creates a new enumerator for the given hash.
+      #
+      # @param [Hash] hash The hash for which the enumerator should return
+      #   key-value pairs
+      def initialize(hash)
+        @hash             = hash
+        @unprocessed_keys = @hash.keys.dup
+        @mutex            = Mutex.new
+      end
+
+      # Returns the next key-value pair in the hash.
+      #
+      # @return [Array] An array containing the key and the corresponding
+      #   value of teh next key-value pair
+      def next_pair
+        @mutex.synchronize do
+          key = @unprocessed_keys.shift
+          return (key ? [ key, @hash[key] ] : nil)
+        end
+      end
+
+    end
+
+    def all_broken_hrefs
+      broken_hrefs = {}
+
+      internal_hrefs = {}
+      external_hrefs = {}
+
+      # Split into internal and external hrefs
+      all_hrefs_per_filename.each_pair do |filename, hrefs|
+        hrefs.each do |href|
+          if is_external_href?(href)
+            external_hrefs[href] ||= []
+            external_hrefs[href] << filename
+          else
+            internal_hrefs[href] ||= []
+            internal_hrefs[href] << filename
+          end
+        end
+      end
+
+      # Validate hrefs
+      validate_internal_hrefs(internal_hrefs, broken_hrefs) if @include_internal
+      validate_external_hrefs(external_hrefs, broken_hrefs) if @include_external
+
+      # Done
+      broken_hrefs
+    end
+
+    def all_files
+      Dir[@dir + '/**/*.html']
+    end
+
+    def all_hrefs_per_filename
+      hrefs = {}
+      all_files.each do |filename|
+        hrefs[filename] ||= all_hrefs_in_file(filename)
+      end
+      hrefs
+    end
+
+    def all_hrefs_in_file(filename)
+      doc = Nokogiri::HTML(::File.read(filename))
+      doc.css('a').map { |l| l[:href] }.compact
+    end
+
+    def is_external_href?(href)
+      !!(href =~ %r{^[a-z\-]+:})
+    end
+
+    def is_valid_internal_href?(href, origin)
+      # Skip hrefs that point to self
+      # FIXME this is ugly and won’t always be correct
+      return true if href == '.'
+
+      # Remove target
+      path = href.sub(/#.*$/, '')
+      return true if path.empty?
+
+      # Make absolute
+      if path[0, 1] == '/'
+        path = @dir + path
+      else
+        path = ::File.expand_path(path, ::File.dirname(origin))
+      end
+
+      # Check whether file exists
+      return true if File.file?(path)
+
+      # Check whether directory with index file exists
+      return true if File.directory?(path) && @index_filenames.any? { |fn| File.file?(File.join(path, fn)) }
+
+      # Nope :(
+      return false
+    end
+
+    def is_valid_external_href?(href)
+      require 'net/http'
+      require 'uri'
+
+      # Parse
+      uri = nil
+      begin
+        uri = URI.parse(href)
+      rescue URI::InvalidURIError
+        @delegate && @delegate.send(:external_href_validated, href, false)
+        return false
+      end
+
+      # Skip non-HTTP URLs
+      return true if uri.scheme !~ /^https?$/
+
+      # Get status
+      status = fetch_http_status_for(uri)
+      is_valid = !!(status && status >= 200 && status <= 299)
+
+      # Notify
+      @delegate && @delegate.send(:external_href_validated, href, is_valid)
+
+      # Done
+      is_valid
+    end
+
+    def validate_internal_hrefs(hrefs, broken_hrefs)
+      hrefs.each_pair do |href, filenames|
+        filenames.each do |filename|
+          if !is_valid_internal_href?(href, filename)
+            broken_hrefs[href] = filenames
+          end
+        end
+      end
+    end
+
+    def validate_external_hrefs(hrefs, broken_hrefs)
+      @mutex = Mutex.new
+
+      enum = ThreadsafeHashEnumerator.new(hrefs)
+
+      threads = []
+      10.times do
+        threads << Thread.new do
+          loop do
+            # Get next pair
+            pair = enum.next_pair
+            break if pair.nil?
+            href, filenames = pair[0], pair[1]
+
+            # Validate
+            if !is_valid_external_href?(href)
+              @mutex.synchronize do
+                broken_hrefs[href] = filenames
+              end
+            end
+          end
+        end
+      end
+      threads.each { |t| t.join }
+    end
+
+    def fetch_http_status_for(url, params={})
+      5.times do |i|
+        begin
+          res = nil
+          Timeout::timeout(10) do
+            res = request_url_once(url)
+          end
+
+          if res.code =~ /^3..$/
+            url = URI.parse(res['location'])
+            return nil if i == 5
+          else
+            return res.code.to_i
+          end
+        rescue
+          return nil
+        end
+      end
+    end
+
+    def request_url_once(url)
+      require 'net/https'
+
+      path = (url.path.nil? || url.path.empty? ? '/' : url.path)
+      req = Net::HTTP::Head.new(path)
+      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
+      res = http.request(req)
+    end
+
+    def external_href_validated(href, is_valid)
+      texts = {
+        true  => 'ok',
+        false => ' ERROR '
+      }
+
+      colors = {
+        true     => "\e[32m",
+        false    => "\e[41m\e[37m",
+        :off     => "\033[0m"
+      }
+
+      @mutex.synchronize do
+        puts href + ': ' + colors[is_valid] + texts[is_valid] + colors[:off]
+      end
+    end
+
+  end
+
+end

data/lib/nanoc/extra/validators/w3c.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+module Nanoc::Extra::Validators
+
+  # A validator that uses the W3C web service to validate HTML and CSS files.
+  class W3C
+
+    # @param [String] dir The directory that will be searched for HTML and/or
+    #   CSS files to validate
+    #
+    # @param [Array<Symbol>] types A list of types to check. Allowed types are
+    #   `:html` and `:css`.
+    def initialize(dir, types)
+      @dir   = dir
+      @types = types
+    end
+
+    # Starts the validator. The results will be printed to stdout.
+    #
+    # @return [void]
+    def run
+      # Load validator
+      require 'w3c_validators'
+
+      # Find all files
+      filenames = []
+      extensions = types_to_extensions(@types)
+      extensions.each { |extension| filenames.concat(Dir[@dir + '/**/*.' + extension]) }
+
+      # Validate each file
+      filenames.each do |filename|
+        validation_started(filename)
+
+        extension = File.extname(filename)[1..-1]
+        results = validator_for(extension).validate_file(filename)
+
+        validation_ended(filename, results.errors)
+      end
+    end
+
+  private
+
+    # Returns all extensions for the given types
+    def types_to_extensions(types)
+      extensions = []
+      types.each { |type| extensions.concat(type_to_extensions(type)) }
+      extensions
+    end
+
+    # Returns all extensions for the given type
+    def type_to_extensions(type)
+      case type
+        when :html
+          [ 'html', 'htm' ]
+        when :css
+          [ 'css' ]
+        else
+          raise RuntimeError, "unknown type: #{type}"
+      end
+    end
+
+    # Returns the validator class for the given extension
+    def validator_class_for(extension)
+      case extension
+      when 'html', 'htm'
+        ::W3CValidators::MarkupValidator
+      when 'css'
+        ::W3CValidators::CSSValidator
+      else
+        raise RuntimeError, "unknown extension: #{extension}"
+      end
+    end
+
+    # Returns the validator for the given extension
+    def validator_for(extension)
+      @validators ||= {}
+      @validators[extension] ||= validator_class_for(extension).new
+    end
+
+    def validation_started(file)
+      $stdout.print "Validating #{file}... "
+      $stdout.flush
+    end
+
+    def validation_ended(file, errors)
+      $stdout.puts(errors.empty? ? "valid" : "INVALID")
+
+      errors.each do |err|
+        puts "    #{err}"
+      end
+    end
+
+  end
+
+end

data/lib/nanoc/extra/vcs.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+module Nanoc::Extra
+
+  # A very simple representation of a version control system (VCS) that
+  # abstracts the add, remove and move operations. It does not commit. This
+  # class is primarily used by data sources that store data as flat files on
+  # the disk.
+  #
+  # @abstract Subclass and override {#add}, {#remove} and {#move} to implement
+  #   a custom VCS.
+  class VCS
+
+    extend Nanoc::PluginRegistry::PluginMethods
+
+    # Adds the file with the given filename to the working copy.
+    #
+    # @param [String] filename The name of the file to add
+    #
+    # @return [void]
+    #
+    # @abstract
+    def add(filename)
+      not_implemented('add')
+    end
+
+    # Removes the file with the given filename from the working copy. When
+    # this method is executed, the file should no longer be present on the
+    # disk.
+    #
+    # @param [String] filename The name of the file to remove
+    #
+    # @return [void]
+    #
+    # @abstract
+    def remove(filename)
+      not_implemented('remove')
+    end
+
+    # Moves the file with the given filename to a new location. When this
+    # method is executed, the original file should no longer be present on the
+    # disk.
+    #
+    # @param [String] src The old filename
+    #
+    # @param [String] dst The new filename
+    #
+    # @return [void]
+    #
+    # @abstract
+    def move(src, dst)
+      not_implemented('move')
+    end
+
+  private
+
+    def not_implemented(name)
+      raise NotImplementedError.new(
+        "#{self.class} does not override ##{name}, which is required for " +
+        "this data source to be used."
+      )
+    end
+
+  end
+
+end

data/lib/nanoc/extra/vcses.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Nanoc::Extra::VCSes
+
+  autoload 'Bazaar',     'nanoc/extra/vcses/bazaar'
+  autoload 'Dummy',      'nanoc/extra/vcses/dummy'
+  autoload 'Git',        'nanoc/extra/vcses/git'
+  autoload 'Mercurial',  'nanoc/extra/vcses/mercurial'
+  autoload 'Subversion', 'nanoc/extra/vcses/subversion'
+
+  Nanoc::Extra::VCS.register '::Nanoc::Extra::VCSes::Bazaar',     :bazaar, :bzr
+  Nanoc::Extra::VCS.register '::Nanoc::Extra::VCSes::Dummy',      :dummy
+  Nanoc::Extra::VCS.register '::Nanoc::Extra::VCSes::Git',        :git
+  Nanoc::Extra::VCS.register '::Nanoc::Extra::VCSes::Mercurial',  :mercurial, :hg
+  Nanoc::Extra::VCS.register '::Nanoc::Extra::VCSes::Subversion', :subversion, :svn
+
+end