nanoc 4.1.6 → 4.2.0b1

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

@@ -20,13 +20,12 @@ module Nanoc::Extra::Checking
       output_filenames = Dir[output_dir + '/**/*'].select { |f| File.file?(f) }
 
       # FIXME: ugly
-      view_context = site.compiler.create_view_context
+      view_context = site.compiler.create_view_context(Nanoc::Int::DependencyTracker::Null.new)
 
       context = {
         items: Nanoc::ItemCollectionWithRepsView.new(site.items, view_context),
         layouts: Nanoc::LayoutCollectionView.new(site.layouts, view_context),
         config: Nanoc::ConfigView.new(site.config, view_context),
-        site: Nanoc::SiteView.new(site, view_context), # TODO: remove me
         output_filenames: output_filenames,
       }
 

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

@@ -1,3 +1,5 @@
+require_relative 'checks/w3c_validator'
+
 # @api private
 module Nanoc::Extra::Checking::Checks
   autoload 'CSS',           'nanoc/extra/checking/checks/css'

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

@@ -1,22 +1,14 @@
 module ::Nanoc::Extra::Checking::Checks
   # @api private
-  class CSS < ::Nanoc::Extra::Checking::Check
+  class CSS < ::Nanoc::Extra::Checking::Checks::W3CValidator
     identifier :css
 
-    def run
-      require 'w3c_validators'
+    def extension
+      'css'
+    end
 
-      Dir[@config[:output_dir] + '/**/*.css'].each do |filename|
-        results = ::W3CValidators::CSSValidator.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
+    def validator_class
+      ::W3CValidators::CSSValidator
     end
   end
 end

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

@@ -1,22 +1,14 @@
 module ::Nanoc::Extra::Checking::Checks
   # @api private
-  class HTML < ::Nanoc::Extra::Checking::Check
+  class HTML < ::Nanoc::Extra::Checking::Checks::W3CValidator
     identifier :html
 
-    def run
-      require 'w3c_validators'
+    def extension
+      '{htm,html}'
+    end
 
-      Dir[@config[:output_dir] + '/**/*.{htm,html}'].each do |filename|
-        results = ::W3CValidators::MarkupValidator.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
+    def validator_class
+      ::W3CValidators::MarkupValidator
     end
   end
 end

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

@@ -34,7 +34,7 @@ module Nanoc::Extra::Checking::Checks
       return true if href == '.'
 
       # Skip hrefs that are specified in the exclude configuration
-      return true if excluded?(href)
+      return true if excluded?(href, origin)
 
       # Remove target
       path = href.sub(/#.*$/, '')
@@ -65,9 +65,20 @@ module Nanoc::Extra::Checking::Checks
       false
     end
 
-    def excluded?(href)
-      excludes = @config.fetch(:checks, {}).fetch(:internal_links, {}).fetch(:exclude, [])
+    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)
+      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

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

@@ -0,0 +1,28 @@
+module ::Nanoc::Extra::Checking::Checks
+  # @api private
+  class W3CValidator < ::Nanoc::Extra::Checking::Check
+    def run
+      require 'w3c_validators'
+
+      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/extra/deployers/fog.rb

@@ -21,104 +21,165 @@ module Nanoc::Extra::Deployers
   #
   # @api private
   class Fog < ::Nanoc::Extra::Deployer
+    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?
+          # FIXME: source_filename file is never closed
+          @directory.files.create(
+            key: destination_key,
+            body: File.open(source_filename),
+            public: true,
+          )
+        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(s)
+        if @is_dry_run
+          puts "[dry run] #{s}"
+        else
+          puts s
+        end
+      end
+    end
+
     # @see Nanoc::Extra::Deployer#run
     def run
       require 'fog'
 
-      # Get params, unsetting anything we don't want to pass through to fog.
       src      = File.expand_path(source_path)
-      bucket   = config.delete(:bucket) || config.delete(:bucket_name)
-      path     = config.delete(:path)
-      cdn_id   = config.delete(:cdn_id)
+      bucket   = config[:bucket] || config[:bucket_name]
+      path     = config[:path]
+      cdn_id   = config[:cdn_id]
 
-      config.delete(:kind)
+      # FIXME: confusing error message
+      raise 'The path requires no trailing slash' if path && path[-1, 1] == '/'
 
-      # Validate params
-      error 'The path requires no trailing slash' if path && path[-1, 1] == '/'
+      connection = connect
+      directory = get_or_create_bucket(connection, bucket, path)
+      wrapper = FogWrapper.new(directory, dry_run?)
 
-      # Mock if necessary
-      if dry_run?
-        puts 'Dry run - simulation'
-        ::Fog.mock!
-      end
+      remote_files = list_remote_files(directory)
+      etags = read_etags(remote_files)
 
-      # Get connection
-      puts 'Connecting'
-      connection = ::Fog::Storage.new(config)
+      modified_keys, retained_keys = upload_all(src, path, etags, wrapper)
 
-      # Get bucket
-      puts 'Getting bucket'
-      begin
-        directory = connection.directories.get(bucket, prefix: path)
-      rescue ::Excon::Errors::NotFound
-        should_create_bucket = true
-      end
-      should_create_bucket = true if directory.nil?
+      removed_keys = remote_files.map(&:key) - retained_keys - modified_keys
+      wrapper.remove(removed_keys)
 
-      # Create bucket if necessary
-      if should_create_bucket
-        puts 'Creating bucket'
-        directory = connection.directories.create(key: bucket, prefix: path)
+      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
 
-      # Get list of remote files
-      files = directory.files
-      truncated = files.respond_to?(:is_truncated) && files.is_truncated
-      while truncated
-        set = directory.files.all(marker: files.last.key)
-        truncated = set.is_truncated
-        files += set
+    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
-      keys_to_destroy = files.map(&:key)
-      keys_to_invalidate = []
-      etags = read_etags(files)
-
-      # Upload all the files in the output folder to the clouds
-      puts 'Uploading local files'
-      FileUtils.cd(src) do
-        files = Dir['**/*'].select { |f| File.file?(f) }
-        files.each do |file_path|
-          key = path ? File.join(path, file_path) : file_path
-          upload(key, file_path, etags, keys_to_destroy, keys_to_invalidate, directory)
+    end
+
+    def connect
+      ::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}\//, '')
 
-      # delete extraneous remote files
-      puts 'Removing remote files'
-      keys_to_destroy.each do |key|
-        directory.files.get(key).destroy
+      if path
+        File.join(path, relative_local_filename)
+      else
+        relative_local_filename
       end
+    end
 
-      # invalidate CDN objects
-      if cdn_id
-        puts 'Invalidating CDN distribution'
-        keys_to_invalidate.concat(keys_to_destroy)
-        cdn = ::Fog::CDN.new(config)
-        # fog cannot mock CDN requests
-        unless dry_run?
-          distribution = cdn.get_distribution(cdn_id)
-          # usual limit per invalidation: 1000 objects
-          keys_to_invalidate.each_slice(1000) do |paths|
-            cdn.post_invalidation(distribution, paths)
-          end
+    def list_remote_files(directory)
+      if directory
+        [].tap do |files|
+          directory.files.each { |file| files << file }
         end
+      else
+        []
       end
-
-      puts 'Done!'
     end
 
-    private
-
-    def upload(key, file_path, etags, keys_to_destroy, keys_to_invalidate, dir)
-      keys_to_destroy.delete(key)
+    def list_local_files(src)
+      Dir[src + '/**/*'].select { |f| File.file?(f) }
+    end
 
-      return unless needs_upload?(key, file_path, etags)
+    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
 
-      dir.files.create(
-        key: key,
-        body: File.open(file_path),
-        public: true)
-      keys_to_invalidate.push(key)
+      [modified_keys, retained_keys]
     end
 
     def needs_upload?(key, file_path, etags)
@@ -146,10 +207,5 @@ module Nanoc::Extra::Deployers
         Digest::MD5.file(file_path).hexdigest
       end
     end
-
-    # Prints the given message on stderr and exits.
-    def error(msg)
-      raise RuntimeError.new(msg)
-    end
   end
 end

data/lib/nanoc/extra/link_collector.rb

@@ -32,27 +32,11 @@ module ::Nanoc::Extra
     end
 
     def filenames_per_href
-      require 'nokogiri'
-      filenames_per_href = {}
-      @filenames.each do |filename|
-        hrefs_in_file(filename).each do |href|
-          filenames_per_href[href] ||= Set.new
-          filenames_per_href[href] << filename
-        end
-      end
-      filenames_per_href
+      grouped_filenames { |filename| hrefs_in_file(filename) }
     end
 
     def filenames_per_resource_uri
-      require 'nokogiri'
-      filenames_per_resource_uri = {}
-      @filenames.each do |filename|
-        resource_uris_in_file(filename).each do |resouce_uri|
-          filenames_per_resource_uri[resouce_uri] ||= Set.new
-          filenames_per_resource_uri[resouce_uri] << filename
-        end
-      end
-      filenames_per_resource_uri
+      grouped_filenames { |filename| resource_uris_in_file(filename) }
     end
 
     def external_href?(href)
@@ -69,6 +53,18 @@ module ::Nanoc::Extra
 
     private
 
+    def grouped_filenames
+      require 'nokogiri'
+      grouped_filenames = {}
+      @filenames.each do |filename|
+        yield(filename).each do |resouce_uri|
+          grouped_filenames[resouce_uri] ||= Set.new
+          grouped_filenames[resouce_uri] << filename
+        end
+      end
+      grouped_filenames
+    end
+
     def uris_in_file(filename, tag_names)
       uris = Set.new
       doc = Nokogiri::HTML(::File.read(filename))

data/lib/nanoc/filters/sass.rb

@@ -18,9 +18,9 @@ module Nanoc::Filters
       engine.render
     end
 
-    def self.item_filename_map_for_site(site, items)
+    def self.item_filename_map_for_config(config, items)
       @item_filename_map ||= {}
-      @item_filename_map[site] ||=
+      @item_filename_map[config] ||=
         {}.tap do |map|
           items.each do |item|
             if item.raw_filename
@@ -34,7 +34,7 @@ module Nanoc::Filters
     def imported_filename_to_item(filename)
       realpath = Pathname.new(filename).realpath.to_s
 
-      map = self.class.item_filename_map_for_site(@site, @items)
+      map = self.class.item_filename_map_for_config(@config, @items)
       map[realpath]
     end
   end