nanoc 3.7.5 → 3.8.0

data/lib/nanoc/extra/deployers/fog.rb

@@ -8,6 +8,10 @@ module Nanoc::Extra::Deployers
   #   deploy:
   #     public:
   #       kind:       fog
+  #       bucket:     nanoc-site
+  #       cdn_id:     XXXXXX
+  #     preprod:
+  #       kind:       fog
   #       provider:   local
   #       local_root: ~/myCloud
   #       bucket:     nanoc-site
@@ -25,6 +29,7 @@ module Nanoc::Extra::Deployers
       src      = File.expand_path(source_path)
       bucket   = config.delete(:bucket) || config.delete(:bucket_name)
       path     = config.delete(:path)
+      cdn_id   = config.delete(:cdn_id)
 
       config.delete(:kind)
 
@@ -33,6 +38,7 @@ module Nanoc::Extra::Deployers
 
       # Mock if necessary
       if self.dry_run?
+        puts 'Dry run - simulation'
         ::Fog.mock!
       end
 
@@ -51,6 +57,7 @@ module Nanoc::Extra::Deployers
 
       # Create bucket if necessary
       if should_create_bucket
+        puts 'Creating bucket'
         directory = connection.directories.create(key: bucket, prefix: path)
       end
 
@@ -63,6 +70,7 @@ module Nanoc::Extra::Deployers
         files += set
       end
       keys_to_destroy = files.all.map(&:key)
+      keys_to_invalidate = []
 
       # Upload all the files in the output folder to the clouds
       puts 'Uploading local files'
@@ -75,6 +83,7 @@ module Nanoc::Extra::Deployers
             body: File.open(file_path),
             public: true)
           keys_to_destroy.delete(key)
+          keys_to_invalidate.push(key)
         end
       end
 
@@ -84,6 +93,21 @@ module Nanoc::Extra::Deployers
         directory.files.get(key).destroy
       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 self.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
+        end
+      end
+
       puts 'Done!'
     end
 

data/lib/nanoc/extra/link_collector.rb

@@ -4,6 +4,17 @@ require 'set'
 
 module ::Nanoc::Extra
   class LinkCollector
+    URI_ATTRS = {
+      'a' => :href,
+      'audio' => :src,
+      'form' => :action,
+      'iframe' => :src,
+      'img' => :src,
+      'link' => :href,
+      'script' => :src,
+      'video' => :src
+    }
+
     def initialize(filenames, mode = nil)
       Nanoc::Extra::JRubyNokogiriWarner.check_and_warn
 
@@ -33,24 +44,46 @@ module ::Nanoc::Extra
       filenames_per_href
     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
+    end
+
     def external_href?(href)
       href =~ %r{^(\/\/|[a-z\-]+:)}
     end
 
     def hrefs_in_file(filename)
-      hrefs_in_file = Set.new
-      doc = Nokogiri::HTML(::File.read(filename))
-      doc.css('a').each { |e| hrefs_in_file << e[:href] unless e[:href].nil? }
-      doc.css('img').each { |e| hrefs_in_file << e[:src]  }
+      uris_in_file filename, %w(a img)
+    end
+
+    def resource_uris_in_file(filename)
+      uris_in_file filename, %w(audio form img iframe link script video)
+    end
+
+    private
 
-      # Convert protocol-relative urls
-      # e.g. //example.com => http://example.com
-      hrefs_in_file.map! { |href| href.gsub(/^\/\//, 'http://') }
+    def uris_in_file(filename, tag_names)
+      uris = Set.new
+      doc = Nokogiri::HTML(::File.read(filename))
+      tag_names.each do |tag_name|
+        attr = URI_ATTRS[tag_name]
+        doc.css(tag_name).each do |e|
+          uris << e[attr] unless e[attr].nil?
+        end
+      end
 
       # Strip fragment
-      hrefs_in_file.map! { |href| href.gsub(/#.*$/, '') }
+      uris.map! { |href| href.gsub(/#.*$/, '') }
 
-      hrefs_in_file.select(&@filter)
+      uris.select(&@filter)
     end
   end
 end

data/lib/nanoc/extra/pruner.rb

@@ -35,7 +35,7 @@ module Nanoc::Extra
       present_dirs = []
       Find.find(site.config[:output_dir] + '/') do |f|
         present_files << f if File.file?(f)
-        present_dirs  << f if File.directory?(f)
+        present_dirs << f if File.directory?(f)
       end
 
       # Remove stray files

data/lib/nanoc/filters/colorize_syntax.rb

@@ -29,7 +29,7 @@ module Nanoc::Filters
     #
     # * `:coderay` for [Coderay](http://coderay.rubychan.de/)
     # * `:pygmentize` for [pygmentize](http://pygments.org/docs/cmdline/), the
-    #   commandline frontend for [Pygments](http://pygments.org/)
+    #   command-line frontend for [Pygments](http://pygments.org/)
     # * `:pygmentsrb` for [pygments.rb](https://github.com/tmm1/pygments.rb),
     #   a Ruby interface for [Pygments](http://pygments.org/)
     # * `:simon_highlight` for [Highlight](http://www.andre-simon.de/doku/highlight/en/highlight.html)
@@ -201,7 +201,7 @@ module Nanoc::Filters
     end
 
     # Runs the content through [pygmentize](http://pygments.org/docs/cmdline/),
-    # the commandline frontend for [Pygments](http://pygments.org/).
+    # the command-line frontend for [Pygments](http://pygments.org/).
     #
     # @api private
     #
@@ -216,7 +216,7 @@ module Nanoc::Filters
       check_availability('pygmentize', '-V')
 
       params[:encoding] ||= 'utf-8'
-      params[:nowrap]   ||= 'True'
+      params[:nowrap] ||= 'True'
 
       cmd = ['pygmentize', '-l', language, '-f', 'html']
       cmd << '-O' << params.map { |k, v| "#{k}=#{v}" }.join(',') unless params.empty?
@@ -246,7 +246,7 @@ module Nanoc::Filters
       args[:lexer] ||= language
       args[:options] ||= {}
       args[:options][:encoding] ||= 'utf-8'
-      args[:options][:nowrap]   ||= 'True'
+      args[:options][:nowrap] ||= 'True'
 
       Pygments.highlight(code, args)
     end

data/lib/nanoc/filters/pandoc.rb

@@ -5,14 +5,33 @@ module Nanoc::Filters
     requires 'pandoc-ruby'
 
     # Runs the content through [Pandoc](http://johnmacfarlane.net/pandoc/)
-    # using [PandocRuby](https://github.com/alphabetum/pandoc-ruby). Options
-    # are passed on to PandocRuby.
+    # using [PandocRuby](https://github.com/alphabetum/pandoc-ruby).
+    #
+    # Arguments can be passed to PandocRuby in two ways:
+    #
+    # * Use the `:args` option. This approach is more flexible, since it
+    #   allows passing an array instead of a hash.
+    #
+    # * Pass the arguments directly to the filter. With this approach, only
+    #   hashes can be passed, which is more limiting than the `:args` approach.
+    #
+    # The `:args` approach is recommended.
+    #
+    # @example Passing arguments using `:arg`
+    #
+    #     filter :pandoc, args: [:s, {:f => :markdown, :to => :html}, 'no-wrap', :toc]
+    #
+    # @example Passing arguments not using `:arg`
+    #
+    #     filter :pandoc, :f => :markdown, :to => :html
     #
     # @param [String] content The content to filter
     #
     # @return [String] The filtered content
-    def run(content, *params)
-      PandocRuby.convert(content, *params)
+    def run(content, params = {})
+      args = params.key?(:args) ? params[:args] : params
+
+      PandocRuby.convert(content, *args)
     end
   end
 end

data/lib/nanoc/filters/sass/sass_filesystem_importer.rb

@@ -10,8 +10,10 @@ class ::Sass::Importers::Filesystem
 
     # Create dependency
     filter = options[:nanoc_current_filter]
-    item = filter.imported_filename_to_item(full_filename)
-    filter.depend_on([item]) unless item.nil?
+    if filter
+      item = filter.imported_filename_to_item(full_filename)
+      filter.depend_on([item]) unless item.nil?
+    end
 
     # Call original _find
     _orig_find(dir, name, options)

data/lib/nanoc/helpers/blogging.rb

@@ -56,6 +56,7 @@ module Nanoc::Helpers
 
       attr_accessor :limit
       attr_accessor :relevant_articles
+      attr_accessor :preserve_order
       attr_accessor :content_proc
       attr_accessor :excerpt_proc
       attr_accessor :title
@@ -85,9 +86,13 @@ module Nanoc::Helpers
       protected
 
       def sorted_relevant_articles
-        relevant_articles.sort_by do |a|
-          attribute_to_time(a[:created_at])
-        end.reverse.first(limit)
+        all = relevant_articles
+
+        unless @preserve_order
+          all = all.sort_by { |a| attribute_to_time(a[:created_at]) }
+        end
+
+        all.reverse.first(limit)
       end
 
       def last_article
@@ -172,7 +177,7 @@ module Nanoc::Helpers
           if a[:author_name] || a[:author_uri]
             xml.author do
               xml.name a[:author_name] || author_name
-              xml.uri a[:author_uri]  || author_uri
+              xml.uri a[:author_uri] || author_uri
             end
           end
 
@@ -268,8 +273,13 @@ module Nanoc::Helpers
     # @option params [Number] :limit (5) The maximum number of articles to
     #   show
     #
-    # @option params [Array] :articles (sorted_articles) A list of articles to
-    #   include in the feed
+    # @option params [Array] :articles (articles) A list of articles to include
+    #   in the feed
+    #
+    # @option params [Boolean] :preserve_order (false) Whether or not the
+    #   ordering of the list of articles should be preserved. If false, the
+    #   articles will be sorted by `created_at`. If true, the list of articles
+    #   will be used as-is, and should have the most recent articles last.
     #
     # @option params [Proc] :content_proc (->{ |article|
     #   article.compiled_content(:snapshot => :pre) }) A proc that returns the
@@ -303,6 +313,7 @@ module Nanoc::Helpers
       # Fill builder
       builder.limit             = params[:limit] || 5
       builder.relevant_articles = params[:articles] || articles || []
+      builder.preserve_order    = params.fetch(:preserve_order, false)
       builder.content_proc      = params[:content_proc] || ->(a) { a.compiled_content(snapshot: :pre) }
       builder.excerpt_proc      = params[:excerpt_proc] || ->(a) { a[:excerpt] }
       builder.title             = params[:title] || @item[:title] || @site.config[:title]

data/lib/nanoc/helpers/tagging.rb

@@ -29,7 +29,7 @@ module Nanoc::Helpers
     #
     # @return [String] A hyperlinked list of tags for the given item
     def tags_for(item, params = {})
-      base_url  = params[:base_url]  || 'http://technorati.com/tag/'
+      base_url  = params[:base_url] || 'http://technorati.com/tag/'
       none_text = params[:none_text] || '(none)'
       separator = params[:separator] || ', '
 

data/lib/nanoc/helpers/text.rb

@@ -18,7 +18,7 @@ module Nanoc::Helpers
     # @return [String] The excerpt of the given string
     def excerptize(string, params = {})
       # Initialize params
-      params[:length]   ||= 25
+      params[:length] ||= 25
       params[:omission] ||= '...'
 
       # Get excerpt

data/lib/nanoc/version.rb

@@ -2,5 +2,5 @@
 
 module Nanoc
   # The current nanoc version.
-  VERSION = '3.7.5'
+  VERSION = '3.8.0'
 end

data/tasks/test.rake

@@ -12,7 +12,7 @@ def run_tests(dir_glob)
   test_files = Dir["#{dir_glob}*_spec.rb"] + Dir["#{dir_glob}test_*.rb"]
   test_files.each { |f| require f }
 
-  res = MiniTest::Unit.new.run(ENV['ARGS'].split)
+  res = Minitest.run(ENV['ARGS'].split)
   exit(res) if res != 0
 end
 

data/test/base/test_item_array.rb

@@ -96,6 +96,14 @@ class Nanoc::ItemArrayTest < Nanoc::TestCase
     assert_nil @items.at('/tenthousand/')
   end
 
+  def test_regex
+    foo = Nanoc::Item.new('Item Foo', {}, '/foo/')
+    @items << foo
+
+    assert_equal [@one], @items[/n/]
+    assert_equal [@two, foo], @items[%r{o/}]
+  end
+
   def test_less_than_less_than
     assert_nil @items[2]
     assert_nil @items['/foo/']

data/test/base/test_item_rep.rb

@@ -77,6 +77,57 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     end
   end
 
+  def test_compiled_content_with_moving_pre_snapshot
+    # Create rep
+    item = Nanoc::Item.new(
+      'blah blah', {}, '/',
+      binary: false
+    )
+    rep = Nanoc::ItemRep.new(item, nil)
+    rep.expects(:compiled?).returns(false)
+    rep.instance_eval { @content = { pre: 'pre!', last: 'last!' } }
+
+    # Check
+    assert_raises(Nanoc::Errors::UnmetDependency) do
+      rep.compiled_content(snapshot: :pre)
+    end
+  end
+
+  def test_compiled_content_with_non_moving_pre_snapshot
+    # Create rep
+    item = Nanoc::Item.new(
+      'blah blah', {}, '/',
+      binary: false
+    )
+    rep = Nanoc::ItemRep.new(item, nil)
+    rep.expects(:compiled?).returns(false)
+    rep.snapshots = [[:pre, true]]
+    rep.instance_eval { @content = { pre: 'pre!', post: 'post!', last: 'last!' } }
+
+    # Check
+    assert_equal 'pre!', rep.compiled_content(snapshot: :pre)
+  end
+
+  def test_compiled_content_with_final_pre_snapshot_in_layout
+    # Mock layout
+    layout = Nanoc::Layout.new(
+      %(BEFORE <%= @item_rep.compiled_content(snapshot: :pre) %> AFTER),
+      {},
+      '/somelayout/')
+
+    # Create item and item rep
+    item = Nanoc::Item.new(
+      'blah blah', {}, '/',
+      binary: false
+    )
+    rep = create_rep_for(item, :foo)
+    rep.assigns = { item_rep: rep }
+
+    # Run and check
+    rep.layout(layout, :erb, {})
+    assert_equal('BEFORE blah blah AFTER', rep.instance_eval { @content[:last] })
+  end
+
   def test_filter
     # Mock site
     site = MiniTest::Mock.new

data/test/base/test_item_rep_recorder_proxy.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+class Nanoc::ItemRepRecorderProxyTest < Nanoc::TestCase
+  def test_double_names
+    proxy = Nanoc::ItemRepRecorderProxy.new(mock)
+
+    proxy.snapshot(:foo, stuff: :giraffe)
+    assert_raises(Nanoc::Errors::CannotCreateMultipleSnapshotsWithSameName) do
+      proxy.snapshot(:foo, stuff: :donkey)
+    end
+  end
+
+  def test_double_params
+    proxy = Nanoc::ItemRepRecorderProxy.new(mock)
+
+    proxy.snapshot(:foo)
+    proxy.snapshot(:bar)
+  end
+end

data/test/base/test_rule.rb

@@ -12,4 +12,14 @@ class Nanoc::RuleTest < Nanoc::TestCase
   def test_apply_to
     # TODO: implement
   end
+
+  def test_matches
+    regexp     = %r</(.*)/(.*)/>
+    identifier = '/anything/else/'
+    expected   = ['anything', 'else']
+
+    rule = Nanoc::Rule.new(regexp, :string, Proc.new {})
+
+    assert_equal expected, rule.send(:matches, identifier)
+  end
 end