nanoc 3.6.9 → 3.6.10

data/lib/nanoc/base/source_data/code_snippet.rb

@@ -50,7 +50,7 @@ module Nanoc
     # @return [String] The checksum for this object. If its contents change,
     #   the checksum will change as well.
     def checksum
-      @data.checksum
+      Nanoc::Checksummer.calc(self)
     end
 
   end

data/lib/nanoc/base/source_data/item.rb

@@ -247,22 +247,7 @@ module Nanoc
     # @return [String] The checksum for this object. If its contents change,
     #   the checksum will change as well.
     def checksum
-      content_checksum =
-        if binary?
-          if File.exist?(raw_filename)
-            Pathname.new(raw_filename).checksum
-          else
-            ''.checksum
-          end
-        else
-          @raw_content.checksum
-        end
-
-      attributes = @attributes.dup
-      attributes.delete(:file)
-      attributes_checksum = attributes.checksum
-
-      content_checksum + ',' + attributes_checksum
+      Nanoc::Checksummer.calc(self)
     end
     memoize :checksum
 

data/lib/nanoc/base/source_data/layout.rb

@@ -88,9 +88,7 @@ module Nanoc
     # @return [String] The checksum for this object. If its contents change,
     #   the checksum will change as well.
     def checksum
-      attributes = @attributes.dup
-      attributes.delete(:file)
-      @raw_content.checksum + ',' + attributes.checksum
+      Nanoc::Checksummer.calc(self)
     end
     memoize :checksum
 

data/lib/nanoc/base/source_data/site.rb

@@ -245,6 +245,10 @@ module Nanoc
       data_sources.each { |ds| ds.unuse }
       setup_child_parent_links
 
+      # Ensure unique
+      ensure_identifier_uniqueness(@items, 'item')
+      ensure_identifier_uniqueness(@layouts, 'layout')
+
       # Load compiler too
       # FIXME this should not be necessary
       compiler.load
@@ -346,6 +350,16 @@ module Nanoc
       end
     end
 
+    def ensure_identifier_uniqueness(objects, type)
+      seen = Set.new
+      objects.each do |obj|
+        if seen.include?(obj.identifier)
+          raise Nanoc::Errors::DuplicateIdentifier.new(obj.identifier, type)
+        end
+        seen << obj.identifier
+      end
+    end
+
     # Builds the configuration hash based on the given argument. Also see
     # {#initialize} for details.
     def build_config(dir_or_config_hash)

data/lib/nanoc/base/temp_filename_factory.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'tmpdir'
+
+module Nanoc
+
+  class TempFilenameFactory
+
+    # @return [String] The root directory for all temporary filenames
+    attr_reader :root_dir
+
+    # @return [Nanoc::TempFilenameFactory] A common instance
+    def self.instance
+      @instance ||= new
+    end
+
+    def initialize
+      @counts = {}
+      @root_dir = Dir.mktmpdir('nanoc')
+    end
+
+    # @param [String] prefix A string prefix to include in the temporary
+    #   filename, often the type of filename being provided.
+    #
+    # @return [String] A new unused filename
+    def create(prefix)
+      count = @counts.fetch(prefix, 0)
+      @counts[prefix] = count + 1
+
+      dirname  = File.join(@root_dir, prefix)
+      filename = File.join(@root_dir, prefix, count.to_s)
+
+      FileUtils.mkdir_p(dirname)
+
+      filename
+    end
+
+    # @param [String] prefix A string prefix that indicates which temporary
+    #   filenames should be deleted.
+    #
+    # @return [void]
+    def cleanup(prefix)
+      path = File.join(@root_dir, prefix)
+      if File.exist?(path)
+        FileUtils.remove_entry_secure(path)
+      end
+
+      @counts.delete(prefix)
+    end
+
+  end
+
+end

data/lib/nanoc/cli/commands/compile.rb

@@ -233,21 +233,25 @@ module Nanoc::CLI::Commands
 
       def durations_per_filter
         @_durations_per_filter ||= begin
-          @times.keys.each_with_object({}) do |filter_name, result|
+          result = {}
+          @times.keys.each do |filter_name|
             durations = durations_for_filter(filter_name)
             if durations
               result[filter_name] = durations
             end
           end
+          result
         end
       end
 
       def durations_for_filter(filter_name)
-        @times[filter_name].each_with_object([]) do |sample, result|
+        result = []
+        @times[filter_name].each do |sample|
           if sample[:start] && sample[:stop]
             result << sample[:stop] - sample[:start]
           end
         end
+        result
       end
 
     end

data/lib/nanoc/cli/commands/create-site.rb

@@ -84,6 +84,9 @@ data_sources:
     # will have the identifier “/about/” when turned off, but when turned on
     # it will become “/about.html/” instead.
     allow_periods_in_identifiers: false
+
+    # The default encoding for all files in `content/` and `layouts/`.
+    encoding: utf-8
 EOS
 
     DEFAULT_RULES = <<EOS unless defined? DEFAULT_RULES

data/lib/nanoc/cli/error_handler.rb

@@ -58,12 +58,16 @@ module Nanoc::CLI
           exit!(0)
         end
       end
-      begin
-        Signal.trap('USR1') do
-          puts 'Caught USR1; dumping a stack trace'
-          puts caller.map { |i| "  #{i}" }.join("\n")
+
+      # Set stack trace dump handler
+      if !defined?(RUBY_ENGINE) || RUBY_ENGINE != 'jruby'
+        begin
+          Signal.trap('USR1') do
+            puts 'Caught USR1; dumping a stack trace'
+            puts caller.map { |i| "  #{i}" }.join("\n")
+          end
+        rescue ArgumentError
         end
-      rescue ArgumentError
       end
 
       # Run

data/lib/nanoc/extra.rb

@@ -2,14 +2,15 @@
 
 module Nanoc::Extra
 
-  autoload 'AutoCompiler',      'nanoc/extra/auto_compiler'
-  autoload 'Checking',          'nanoc/extra/checking'
-  autoload 'CHiCk',             'nanoc/extra/chick'
-  autoload 'FilesystemTools',   'nanoc/extra/filesystem_tools'
-  autoload 'LinkCollector',     'nanoc/extra/link_collector.rb'
-  autoload 'Pruner',            'nanoc/extra/pruner'
-  autoload 'Validators',        'nanoc/extra/validators'
-  autoload 'Piper',             'nanoc/extra/piper'
+  autoload 'AutoCompiler',        'nanoc/extra/auto_compiler'
+  autoload 'Checking',            'nanoc/extra/checking'
+  autoload 'CHiCk',               'nanoc/extra/chick'
+  autoload 'FilesystemTools',     'nanoc/extra/filesystem_tools'
+  autoload 'LinkCollector',       'nanoc/extra/link_collector.rb'
+  autoload 'Pruner',              'nanoc/extra/pruner'
+  autoload 'Validators',          'nanoc/extra/validators'
+  autoload 'Piper',               'nanoc/extra/piper'
+  autoload 'JRubyNokogiriWarner', 'nanoc/extra/jruby_nokogiri_warner'
 
   # Deprecated; use {Nanoc::Context} instead
   # TODO [in nanoc 4.0] remove me

data/lib/nanoc/extra/jruby_nokogiri_warner.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'singleton'
+
+module Nanoc::Extra
+
+  class JRubyNokogiriWarner
+
+    include Singleton
+
+    TEXT = <<EOS
+--------------------------------------------------------------------------------
+Note:
+
+The behavior of Pure Java Nokogiri differs from the Nokogiri used on the
+standard Ruby interpreter (MRI) due to differences in underlying libraries.
+
+These sometimes problematic behavioral differences can cause nanoc filters not
+to function properly, if at all. If you need reliable (X)HTML and XML handling
+functionality, consider not using Nokogiri on JRuby for the time being.
+
+These issues are being worked on both from the Nokogiri and the nanoc side. Keep
+your Nokogiri and nanoc versions up to date!
+
+For details, see https://github.com/nanoc/nanoc/pull/422.
+--------------------------------------------------------------------------------
+EOS
+
+    def self.check_and_warn
+      instance.check_and_warn
+    end
+
+    def initialize
+      @warned = false
+    end
+
+    def check_and_warn
+      return if !defined?(RUBY_ENGINE)
+      return if RUBY_ENGINE != 'jruby'
+      return if @warned
+
+      $stderr.puts TEXT
+      @warned = true
+    end
+
+  end
+
+end

data/lib/nanoc/extra/link_collector.rb

@@ -7,6 +7,8 @@ module ::Nanoc::Extra
   class LinkCollector
 
     def initialize(filenames, mode = nil)
+      Nanoc::Extra::JRubyNokogiriWarner.check_and_warn
+
       @filenames = filenames
       @filter =
         case mode

data/lib/nanoc/extra/piper.rb

@@ -44,7 +44,7 @@ module Nanoc::Extra
 
         exit_status = wait_thr.value
         if !exit_status.success?
-          raise Error.new(exit_status.to_i, cmd)
+          raise Error.new(cmd, exit_status.to_i)
         end
       end
     end

data/lib/nanoc/filters/colorize_syntax.rb

@@ -83,6 +83,8 @@ module Nanoc::Filters
     #
     # @return [String] The filtered content
     def run(content, params = {})
+      Nanoc::Extra::JRubyNokogiriWarner.check_and_warn
+
       # Take colorizers from parameters
       @colorizers = Hash.new(params[:default_colorizer] || DEFAULT_COLORIZER)
       (params[:colorizers] || {}).each_pair do |language, colorizer|

data/lib/nanoc/filters/pandoc.rb

@@ -12,8 +12,8 @@ module Nanoc::Filters
     # @param [String] content The content to filter
     #
     # @return [String] The filtered content
-    def run(content, params = {})
-      PandocRuby.convert(content, params)
+    def run(content, *params)
+      PandocRuby.convert(content, *params)
     end
 
   end

data/lib/nanoc/filters/relativize_paths.rb

@@ -29,6 +29,8 @@ module Nanoc::Filters
     #
     # @return [String] The filtered content
     def run(content, params = {})
+      Nanoc::Extra::JRubyNokogiriWarner.check_and_warn
+
       # Set assigns so helper function can be used
       @item_rep = assigns[:item_rep] if @item_rep.nil?
 

data/lib/nanoc/filters/xsl.rb

@@ -34,6 +34,8 @@ module Nanoc::Filters
     #
     # @return [String] The transformed content
     def run(content, params = {})
+      Nanoc::Extra::JRubyNokogiriWarner.check_and_warn
+
       if assigns[:layout].nil?
         raise 'The XSL filter can only be run as a layout'
       end

data/lib/nanoc/version.rb

@@ -3,6 +3,6 @@
 module Nanoc
 
   # The current nanoc version.
-  VERSION = '3.6.9'
+  VERSION = '3.6.10'
 
 end

data/tasks/rubocop.rake

@@ -1,5 +1,9 @@
-require 'rubocop/rake_task'
+begin
+  require 'rubocop/rake_task'
 
-Rubocop::RakeTask.new(:rubocop) do |task|
-  task.patterns = ['lib/**/*.rb']
+  Rubocop::RakeTask.new(:rubocop) do |task|
+    task.patterns = ['lib/**/*.rb']
+  end
+rescue LoadError
+  warn "Could not load Rubocop. Rubocop rake tasks will be unavailable."
 end

data/test/base/checksummer_spec.rb

@@ -0,0 +1,274 @@
+# encoding: utf-8
+
+require 'tempfile'
+
+describe Nanoc::Checksummer do
+
+  subject { Nanoc::Checksummer }
+
+  CHECKSUM_REGEX = /\A[0-9a-zA-Z\/+]+=*\Z/
+
+  describe 'for String' do
+
+    it 'should checksum strings' do
+      subject.calc('foo').must_equal('+5k/BWvkYc6T1qhGaSyf3861CyE=')
+    end
+
+  end
+
+  describe 'for Array' do
+
+    it 'should checksum arrays' do
+      subject.calc([1, 'a', :a]).must_equal 'YtWOEFUAMQritkY38KXHFZM/n2E='
+    end
+
+    it 'should take order into account when checksumming arrays' do
+      subject.calc([:a, 'a', 1]).wont_equal(subject.calc([1, 'a', :a]))
+    end
+
+    it 'should checksum non-serializable arrays' do
+      subject.calc([-> {}]).must_match(CHECKSUM_REGEX)
+    end
+
+  end
+
+  describe 'for Hash' do
+
+    it 'should checksum hashes' do
+      subject.calc({ a: 1, b: 2 }).must_equal 'qY8fW6gWK7F1XQ9MLrx3Gru/RTY='
+    end
+
+    it 'should take order into account when checksumming hashes' do
+      subject.calc({ a: 1, b: 2 }).wont_equal(subject.calc({ b: 2, a: 1 }))
+    end
+
+    it 'should checksum non-serializable hashes' do
+      subject.calc({ a: ->{} }).must_match(CHECKSUM_REGEX)
+    end
+
+  end
+
+  describe 'for Pathname' do
+
+    let(:file)            { Tempfile.new('foo') }
+    let(:filename)        { file.path }
+    let(:pathname)        { Pathname.new(filename) }
+    let(:atime)           { 1234567890 }
+    let(:mtime)           { 1234567890 }
+    let(:data)            { 'stuffs' }
+    let(:normal_checksum) { 'THy7Y28oroov/KvPxT6wcMnXr/s=' }
+
+    before do
+      file.write(data)
+      file.close
+      File.utime(atime, mtime, filename)
+    end
+
+    after do
+      file.unlink
+    end
+
+    describe 'does not exist' do
+
+      let(:non_existing_filename) { 'askldjfklaslasdfkjsajdf' }
+      let(:pathname)              { Pathname.new(filename) }
+
+      it 'should still checksum' do
+        subject.calc(pathname).must_equal(normal_checksum)
+      end
+
+    end
+
+    it 'should get the mtime right' do
+      stat = File.stat(filename)
+      stat.mtime.to_i.must_equal(mtime)
+    end
+
+    it 'should get the file size right' do
+      stat = File.stat(filename)
+      stat.size.must_equal(6)
+    end
+
+    it 'should checksum binary content' do
+      subject.calc(pathname).must_equal(normal_checksum)
+    end
+
+    describe 'if the mtime changes' do
+
+      let(:mtime) { 1333333333 }
+
+      it 'should have a different checksum' do
+        subject.calc(pathname).must_match(CHECKSUM_REGEX)
+        subject.calc(pathname).wont_equal(normal_checksum)
+      end
+
+    end
+
+    describe 'if the content changes, but not the file size' do
+
+      let(:data) { 'STUFF!' }
+
+      it 'should have the same checksum' do
+        subject.calc(pathname).must_equal(normal_checksum)
+      end
+
+    end
+
+    describe 'if the file size changes' do
+
+      let(:data) { 'stuff and stuff and stuff!!!' }
+
+      it 'should have a different checksum' do
+        subject.calc(pathname).must_match(CHECKSUM_REGEX)
+        subject.calc(pathname).wont_equal(normal_checksum)
+      end
+
+    end
+
+  end
+
+  it 'should not have the same checksum for same content but different class'
+
+  describe 'for Nanoc::RulesCollection' do
+
+    let(:data)            { 'STUFF!' }
+    let(:normal_checksum) { 'r4SwDpCp5saBPeZk2gQOJcipTZU=' }
+
+    let(:rules_collection) do
+      coll = Nanoc::RulesCollection.new(nil)
+      coll.data = data
+      coll
+    end
+
+    it 'should calculate' do
+      subject.calc(rules_collection).must_equal(normal_checksum)
+    end
+
+    describe 'if the content changes' do
+
+      let(:data) { 'Other stuff!' }
+
+      it 'should have a different checksum' do
+        subject.calc(rules_collection).must_match(CHECKSUM_REGEX)
+        subject.calc(rules_collection).wont_equal(normal_checksum)
+      end
+
+    end
+
+  end
+
+  describe 'for Nanoc::CodeSnippet' do
+
+    let(:data)            { 'asdf' }
+    let(:filename)        { File.expand_path('bob.txt') }
+    let(:code_snippet)    { Nanoc::CodeSnippet.new(data, filename) }
+    let(:normal_checksum) { 'ZSo56CFoBcNgiDsWOfLLquH2sF0=' }
+
+    it 'should checksum the data' do
+      subject.calc(code_snippet).must_equal(normal_checksum)
+    end
+
+    describe 'if the filename changes' do
+
+      let(:filename) { File.expand_path('george.txt') }
+
+      it 'should have the same checksum' do
+        subject.calc(code_snippet).must_equal(normal_checksum)
+      end
+
+    end
+
+    describe 'if the content changes' do
+
+      let(:data) { 'Other stuff!' }
+
+      it 'should have a different checksum' do
+        subject.calc(code_snippet).must_match(CHECKSUM_REGEX)
+        subject.calc(code_snippet).wont_equal(normal_checksum)
+      end
+
+    end
+
+  end
+
+  describe 'for Nanoc::Configuration' do
+
+    let(:wrapped)         { { a: 1, b: 2 } }
+    let(:configuration)   { Nanoc::Configuration.new(wrapped) }
+    let(:normal_checksum) { 'eYYQ74x29njbtXMtuKZX/ogD8JA=' }
+
+    it 'should checksum the hash' do
+      subject.calc(configuration).must_equal('eYYQ74x29njbtXMtuKZX/ogD8JA=')
+    end
+
+    describe 'if the content changes' do
+
+      let(:wrapped) { { a: 666, b: 2 } }
+
+      it 'should have a different checksum' do
+        subject.calc(configuration).must_match(CHECKSUM_REGEX)
+        subject.calc(configuration).wont_equal(normal_checksum)
+      end
+
+    end
+
+  end
+
+  describe 'for Nanoc::Item' do
+
+    let(:content)         { 'asdf' }
+    let(:filename)        { File.expand_path('bob.txt') }
+    let(:attributes)      { { a: 1, b: 2 } }
+    let(:identifier)      { '/foo/' }
+    let(:item)            { Nanoc::Item.new(content, attributes, identifier) }
+    let(:normal_checksum) { 'eTPdmaG7UAuPzH210HM1JvJaWDo=' }
+
+    it 'should checksum item' do
+      subject.calc(item).must_equal(normal_checksum)
+    end
+
+    describe 'with changed attributes' do
+
+      let(:attributes) { { x: 4, y: 5 } }
+
+      it 'should have a different checksum' do
+        subject.calc(item).must_match(CHECKSUM_REGEX)
+        subject.calc(item).wont_equal(normal_checksum)
+      end
+
+    end
+
+    describe 'with changed content' do
+
+      let(:content) { 'something drastically different' }
+
+      it 'should have a different checksum' do
+        subject.calc(item).must_match(CHECKSUM_REGEX)
+        subject.calc(item).wont_equal(normal_checksum)
+      end
+
+    end
+
+  end
+
+  describe 'for other marshal-able classes' do
+
+    let(:obj) { :foobar }
+
+    it 'should checksum' do
+      subject.calc(obj).must_match(CHECKSUM_REGEX)
+    end
+
+  end
+
+  describe 'for other non-marshal-able classes' do
+
+    let(:obj) { proc {} }
+
+    it 'should checksum' do
+      subject.calc(obj).must_match(CHECKSUM_REGEX)
+    end
+
+  end
+
+end