nanoc 4.7.6 → 4.7.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a40c3389c6ef42f0924566370507dfc3a2e361f8
-  data.tar.gz: '09906841a6aa6ba7dc5d4bdc06e5914a4678d274'
+  metadata.gz: d25ba882d1c709e130d1da34de63b5bee85ffaa2
+  data.tar.gz: 6e3c673ec2c5b30a25edb775f42197813899cabf
 SHA512:
-  metadata.gz: 91221955a35dfd5786f068f6fca88f6c3d2ee06cc9ece04e85aedd769c5d66147aec8d37c663c1dcc2e208ce32c38d0939a78d1539dd963f3380fe427d76d854
-  data.tar.gz: 4ef5eac2bd6d99bbeb5c1276fa13dd498f7cf8e70cce12132945ff682cf90a02a8d11c459bb88300934fd1686f61c6c069a371c196ca51f605516c7454017c89
+  metadata.gz: 914fde5a0e842055cabfa804950d3b355f3b03b33b3a72cddbd1654aa4e9233163848386b728e2ce08238de98311d2af31305e874bc421549ac858acb310b73b
+  data.tar.gz: 2727ef6a9f49eedec58419971d324ce73a50dad71776ff1e303d7a50567b7a47881e4acb8be100cb095bbea68a4a6540da768aedfaaa29f7c05e63fd8732347f

data/Gemfile.lock

@@ -1,6 +1,6 @@
 GIT
   remote: https://github.com/bbatsov/rubocop.git
-  revision: cf07b9a493feed28577032c307ddab3cb7b8c2fc
+  revision: dcb3f160a2e23218a7826aadd0e64baefd6d7521
   specs:
     rubocop (0.48.1)
       parallel (~> 1.10)
@@ -13,7 +13,7 @@ GIT
 PATH
   remote: .
   specs:
-    nanoc (4.7.6)
+    nanoc (4.7.7)
       cri (~> 2.8)
       ddplugin (~> 1.0)
       hamster (~> 3.0)

data/NEWS.md

@@ -1,5 +1,12 @@
 # Nanoc news
 
+## 4.7.7 (2017-04-16)
+
+Enhancements:
+
+* Added `--diff` option to `compile` command as a one-time alternative to `enable_output_diff` (#1155)
+* Sped up incremental compilation (#1156, #1157)
+
 ## 4.7.6 (2017-04-15)
 
 Enhancements:

data/lib/nanoc/base/entities/identifiable_collection.rb

@@ -64,6 +64,14 @@ module Nanoc::Int
       self.class.new(@config, @objects.reject(&block))
     end
 
+    def object_with_identifier(identifier)
+      if frozen?
+        @mapping[identifier.to_s]
+      else
+        @objects.find { |i| i.identifier == identifier }
+      end
+    end
+
     protected
 
     contract C::Any => C::Maybe[C::RespondTo[:identifier]]
@@ -96,14 +104,6 @@ module Nanoc::Int
       find_all_unmemoized(arg)
     end
 
-    def object_with_identifier(identifier)
-      if frozen?
-        @mapping[identifier.to_s]
-      else
-        @objects.find { |i| i.identifier == identifier }
-      end
-    end
-
     def object_matching_glob(glob)
       if use_globs?
         pat = Nanoc::Int::Pattern.from(glob)

data/lib/nanoc/base/entities/outdatedness_reasons.rb

@@ -62,11 +62,6 @@ module Nanoc::Int
       end
     end
 
-    PathsModified = Generic.new(
-      'One or more output paths of this item have been modified since the last time the site was compiled.',
-      Props.new(path: true),
-    )
-
     UsesAlwaysOutdatedFilter = Generic.new(
       'This item rep uses one or more filters that cannot track dependencies, and will thus always be considered as outdated.',
       Props.new(raw_content: true, attributes: true, compiled_content: true),

data/lib/nanoc/base/repos/dependency_store.rb

@@ -3,16 +3,17 @@ module Nanoc::Int
   class DependencyStore < ::Nanoc::Int::Store
     include Nanoc::Int::ContractsSupport
 
-    # @return [Array<Nanoc::Int::Item, Nanoc::Int::Layout>]
-    attr_accessor :objects
+    attr_accessor :items
+    attr_accessor :layouts
 
-    # @param [Array<Nanoc::Int::Item, Nanoc::Int::Layout>] objects
-    def initialize(objects, site: nil)
+    def initialize(items, layouts, site: nil)
       super(Nanoc::Int::Store.tmp_path_for(site: site, store_name: 'dependencies'), 4)
 
-      @objects = objects
+      @items = items
+      @layouts = layouts
+
       @new_objects = []
-      @graph = Nanoc::Int::DirectedGraph.new([nil] + @objects)
+      @graph = Nanoc::Int::DirectedGraph.new([nil] + @items.to_a + @layouts.to_a)
     end
 
     contract C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] => C::ArrayOf[Nanoc::Int::Dependency]
@@ -113,12 +114,25 @@ module Nanoc::Int
     end
 
     def data=(new_data)
+      objects = @items.to_a + @layouts.to_a
+
       # Create new graph
-      @graph = Nanoc::Int::DirectedGraph.new([nil] + @objects)
+      @graph = Nanoc::Int::DirectedGraph.new([nil] + objects)
 
       # Load vertices
       previous_objects = new_data[:vertices].map do |reference|
-        @objects.find { |obj| reference == obj.reference }
+        if reference
+          case reference[0]
+          when :item
+            @items.object_with_identifier(reference[1])
+          when :layout
+            @layouts.object_with_identifier(reference[1])
+          else
+            raise Nanoc::Int::Errors::InternalInconsistency, "unrecognised reference #{reference[0].inspect}"
+          end
+        else
+          nil
+        end
       end
 
       # Load edges
@@ -130,7 +144,7 @@ module Nanoc::Int
       end
 
       # Record dependency from all items on new items
-      @new_objects = @objects - previous_objects
+      @new_objects = objects - previous_objects
     end
   end
 end

data/lib/nanoc/base/services/compiler/stages/preprocess.rb

@@ -12,7 +12,8 @@ module Nanoc::Int::Compiler::Stages
         @site.data_source = Nanoc::Int::InMemDataSource.new(@site.items, @site.layouts)
         @action_provider.preprocess(@site)
 
-        @dependency_store.objects = @site.items.to_a + @site.layouts.to_a
+        @dependency_store.items = @site.items
+        @dependency_store.layouts = @site.layouts
         @checksum_store.objects = @site.items.to_a + @site.layouts.to_a + @site.code_snippets + [@site.config]
       end
 

data/lib/nanoc/base/services/compiler_loader.rb

@@ -5,7 +5,7 @@ module Nanoc::Int
       action_sequence_store = Nanoc::Int::ActionSequenceStore.new(site: site)
 
       dependency_store =
-        Nanoc::Int::DependencyStore.new(site.items.to_a + site.layouts.to_a, site: site)
+        Nanoc::Int::DependencyStore.new(site.items, site.layouts, site: site)
 
       objects = site.items.to_a + site.layouts.to_a + site.code_snippets + [site.config]
 

data/lib/nanoc/base/services/outdatedness_checker.rb

@@ -13,7 +13,6 @@ module Nanoc::Int
       RULES_FOR_ITEM_REP =
         [
           Rules::RulesModified,
-          Rules::PathsModified,
           Rules::ContentModified,
           Rules::AttributesModified,
           Rules::NotWritten,

data/lib/nanoc/base/services/outdatedness_rules.rb

@@ -9,6 +9,5 @@ require_relative 'outdatedness_rules/code_snippets_modified'
 require_relative 'outdatedness_rules/configuration_modified'
 require_relative 'outdatedness_rules/content_modified'
 require_relative 'outdatedness_rules/not_written'
-require_relative 'outdatedness_rules/paths_modified'
 require_relative 'outdatedness_rules/rules_modified'
 require_relative 'outdatedness_rules/uses_always_outdated_filter'

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

@@ -4,6 +4,7 @@ description <<-EOS
 Compile all items of the current site.
 EOS
 flag nil, :profile, 'profile compilation' if Nanoc::Feature.enabled?(Nanoc::Feature::PROFILER)
+flag nil, :diff, 'generate diff'
 
 require_relative 'compile_listeners/abstract'
 require_relative 'compile_listeners/debug_printer'

data/lib/nanoc/cli/commands/compile_listeners/diff_generator.rb

@@ -2,7 +2,7 @@ module Nanoc::CLI::Commands::CompileListeners
   class DiffGenerator < Abstract
     # @see Listener#enable_for?
     def self.enable_for?(command_runner)
-      command_runner.site.config[:enable_output_diff]
+      command_runner.site.config[:enable_output_diff] || command_runner.options[:diff]
     end
 
     # @see Listener#start

data/lib/nanoc/filters/colorize_syntax.rb

@@ -5,92 +5,14 @@ module Nanoc::Filters
 
     requires 'nokogiri', 'stringio', 'open3'
 
-    # The default colorizer to use for a language if the colorizer for that
-    # language is not overridden.
     DEFAULT_COLORIZER = :coderay
 
-    # Syntax-highlights code blocks in the given content. Code blocks should
-    # be enclosed in `pre` elements that contain a `code` element. The code
-    # element should have an indication of the language the code is in. There
-    # are two possible ways of adding such an indication:
-    #
-    # 1. A HTML class starting with `language-` and followed by the
-    # code language, as specified by HTML5. For example, `<code class="language-ruby">`.
-    #
-    # 2. A comment on the very first line of the code block in the format
-    # `#!language` where `language` is the language the code is in. For
-    # example, `#!ruby`.
-    #
-    # Options for individual colorizers will be taken from the {#run}
-    # options’ value for the given colorizer. For example, if the filter is
-    # invoked with a `:coderay => coderay_options_hash` option, the
-    # `coderay_options_hash` hash will be passed to the CodeRay colorizer.
-    #
-    # Currently, the following colorizers are supported:
-    #
-    # * `:coderay` for [Coderay](http://coderay.rubychan.de/)
-    # * `:pygmentize` for [pygmentize](http://pygments.org/docs/cmdline/), the
-    #   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)
-    # * `:rouge` for [Rouge](https://github.com/jayferd/rouge/)
-    #
-    # Additional colorizer implementations are welcome!
-    #
-    # @example Using a class to indicate type of code be highlighted
-    #
-    #     <pre><code class="language-ruby">
-    #     def foo
-    #       "asdf"
-    #     end
-    #     </code></pre>
-    #
-    # @example Using a comment to indicate type of code be highlighted
-    #
-    #     <pre><code>
-    #     #!ruby
-    #     def foo
-    #       "asdf"
-    #     end
-    #     </code></pre>
-    #
-    # @example Invoking the filter with custom parameters
-    #
-    #     filter :colorize_syntax,
-    #            :colorizers => { :ruby => :coderay },
-    #            :coderay    => { :line_numbers => :list }
-    #
-    # @param [String] content The content to filter
-    #
-    # @option params [Symbol] :default_colorizer (DEFAULT_COLORIZER) The
-    #   default colorizer, i.e. the colorizer that will be used when the
-    #   colorizer is not overriden for a specific language.
-    #
-    # @option params [Symbol] :syntax (:html) The syntax to use, which can be
-    #   `:html`, `:xml` or `:xhtml`, the latter two being the same.
-    #
-    # @option params [Hash] :colorizers ({}) A hash containing
-    #   a mapping of programming languages (symbols, not strings) onto
-    #   colorizers (symbols).
-    #
-    # @option params [Boolean] :outside_pre (false) `true` if the colorizer
-    #   should be applied on `code` elements outside `pre` elements, false
-    #   if only `code` elements inside` pre` elements should be colorized.
-    #
-    # @option params [Symbol] :is_fullpage (false) Whether to treat the input
-    #   as a full HTML page or a page fragment. When true, HTML boilerplate
-    #   such as the doctype, `html`, `head` and `body` elements will be added.
-    #
-    # @return [String] The filtered content
+    ExtractedLanguage = Struct.new(:language, :from_class)
+
     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|
-        @colorizers[language] = colorizer
-      end
+      @colorizers = colorizers_from_params(params)
 
       syntax = params.fetch(:syntax, :html)
       parser = parser_for(syntax)
@@ -100,42 +22,56 @@ module Nanoc::Filters
       selector = params[:outside_pre] ? 'code' : 'pre > code'
       doc.css(selector).each do |element|
         # Get language
-        has_class = false
-        language = nil
-        if element['class']
-          # Get language from class
-          match = element['class'].match(/(^| )language-([^ ]+)/)
-          language = match[2] if match
-          has_class = true if language
-        else
-          # Get language from comment line
-          match = element.inner_text.strip.split[0].match(/^#!([^\/][^\n]*)$/)
-          language = match[1] if match
-          element.content = element.content.sub(/^#!([^\/][^\n]*)$\n/, '') if language
-        end
+        extracted_language = extract_language(element)
 
         # Give up if there is no hope left
-        next if language.nil?
+        next unless extracted_language
 
         # Highlight
         raw = strip(element.inner_text)
-        highlighted_code = highlight(raw, language, params)
+        highlighted_code = highlight(raw, extracted_language.language, params)
         element.children = parse_fragment(parser, strip(highlighted_code))
 
         # Add language-something class
-        unless has_class
+        unless extracted_language.from_class
           klass = element['class'] || ''
           klass << ' ' unless [' ', nil].include?(klass[-1, 1])
-          klass << "language-#{language}"
+          klass << "language-#{extracted_language.language}"
           element['class'] = klass
         end
 
-        highlight_postprocess(language, element.parent)
+        highlight_postprocess(extracted_language.language, element.parent)
       end
 
       serialize(doc, syntax)
     end
 
+    def extract_language(element)
+      has_class = false
+      language = nil
+      if element['class']
+        # Get language from class
+        match = element['class'].match(/(^| )language-([^ ]+)/)
+        language = match[2] if match
+        has_class = true if language
+      else
+        # Get language from comment line
+        match = element.inner_text.strip.split[0].match(/^#!([^\/][^\n]*)$/)
+        language = match[1] if match
+        element.content = element.content.sub(/^#!([^\/][^\n]*)$\n/, '') if language
+      end
+
+      language ? ExtractedLanguage.new(language, has_class) : nil
+    end
+
+    def colorizers_from_params(params)
+      colorizers = Hash.new(params[:default_colorizer] || DEFAULT_COLORIZER)
+      (params[:colorizers] || {}).each_pair do |language, colorizer|
+        colorizers[language] = colorizer
+      end
+      colorizers
+    end
+
     def parser_for(syntax)
       case syntax
       when :html
@@ -173,16 +109,6 @@ module Nanoc::Filters
       parser_class.fragment(content)
     end
 
-    # Parses the given content using the given class. This method also handles
-    # an issue with Nokogiri on JRuby causing “cannot modify frozen string”
-    # errors.
-    #
-    # @param [String] content The content to parse
-    #
-    # @param [Class] klass The Nokogiri parser class
-    #
-    # @param [Boolean] is_fullpage true if the given content is a full page,
-    #   false if it is a fragment
     def parse(content, klass, is_fullpage)
       if is_fullpage
         parse_full(klass, content)
@@ -197,225 +123,37 @@ module Nanoc::Filters
       end
     end
 
-    # Runs the code through [CodeRay](http://coderay.rubychan.de/).
-    #
-    # @param [String] code The code to colorize
-    #
-    # @param [String] language The language the code is written in
-    #
-    # @param [Hash] params Parameters to pass on to CodeRay
-    #
-    # @return [String] The colorized output
-    def coderay(code, language, params = {})
-      require 'coderay'
-
-      ::CodeRay.scan(code, language).html(params)
-    end
-
-    # Returns the input itself, not performing any code highlighting.
-    #
-    # @param [String] code The code to colorize
-    #
-    # @param [String] language The language the code is written in (unused)
-    #
-    # @return [String] The colorized output, which is identical to the input
-    #   in this case
-    def dummy(code, language, params = {}) # rubocop:disable Lint/UnusedMethodArgument
-      code
-    end
-
-    # Runs the content through [pygmentize](http://pygments.org/docs/cmdline/),
-    # the command-line frontend for [Pygments](http://pygments.org/).
-    #
-    # @param [String] code The code to colorize
-    #
-    # @param [String] language The language the code is written in
-    #
-    # @option params [String, Symbol] :encoding The encoding of the code block
-    #
-    # @return [String] The colorized output
-    def pygmentize(code, language, params = {})
-      check_availability('pygmentize', '-V')
-
-      params[:encoding] ||= 'utf-8'
-      params[:nowrap] ||= 'True'
-
-      cmd = ['pygmentize', '-l', language, '-f', 'html']
-      cmd << '-O' << params.map { |k, v| "#{k}=#{v}" }.join(',') unless params.empty?
-
-      stdout = StringIO.new
-      stderr = $stderr
-      piper = Nanoc::Extra::Piper.new(stdout: stdout, stderr: stderr)
-      piper.run(cmd, code)
-
-      stdout.string
-    end
-
-    # Runs the content through [Pygments](http://pygments.org/) via
-    # [pygments.rb](https://github.com/tmm1/pygments.rb).
-    #
-    # @param [String] code The code to colorize
-    #
-    # @param [String] language The language the code is written in
-    #
-    # @return [String] The colorized output
-    def pygmentsrb(code, language, params = {})
-      require 'pygments'
-
-      args = params.dup
-      args[:lexer] ||= language
-      args[:options] ||= {}
-      args[:options][:encoding] ||= 'utf-8'
-      args[:options][:nowrap] ||= 'True'
-
-      Pygments.highlight(code, args)
-    end
-
-    SIMON_HIGHLIGHT_OPT_MAP = {
-      wrap: '-W',
-      include_style: '-I',
-      line_numbers: '-l',
-    }.freeze
-
-    # Runs the content through [Highlight](http://www.andre-simon.de/doku/highlight/en/highlight.html).
-    #
-    # @param [String] code The code to colorize
-    #
-    # @param [String] language The language the code is written in
-    #
-    # @option params [String] :style The style to use
-    #
-    # @return [String] The colorized output
-    def simon_highlight(code, language, params = {})
-      check_availability('highlight', '--version')
-
-      cmd = ['highlight', '--syntax', language, '--fragment']
-      params.each do |key, _value|
-        if SIMON_HIGHLIGHT_OPT_MAP[key]
-          cmd << SIMON_HIGHLIGHT_OPT_MAP[key]
-        else
-          # TODO: allow passing other options
-          case key
-          when :style
-            cmd << '--style' << params[:style]
-          end
-        end
-      end
-
-      stdout = StringIO.new
-      stderr = $stderr
-      piper = Nanoc::Extra::Piper.new(stdout: stdout, stderr: stderr)
-      piper.run(cmd, code)
-
-      stdout.string
-    end
-
-    # Wraps the element in <div class="CodeRay"><div class="code">
-    def coderay_postprocess(_language, element)
-      # Skip if we're a free <code>
-      return if element.parent.nil?
-
-      # <div class="code">
-      div_inner = Nokogiri::XML::Node.new('div', element.document)
-      div_inner['class'] = 'code'
-      div_inner.children = element.dup
-
-      # <div class="CodeRay">
-      div_outer = Nokogiri::XML::Node.new('div', element.document)
-      div_outer['class'] = 'CodeRay'
-      div_outer.children = div_inner
-
-      # orig element
-      element.swap div_outer
-    end
-
-    # Runs the content through [Rouge](https://github.com/jayferd/rouge/.
-    #
-    # @param [String] code The code to colorize
-    #
-    # @param [String] language The language the code is written in
-    #
-    # @return [String] The colorized output
-    def rouge(code, language, params = {})
-      require 'rouge'
-
-      if Rouge.version < '2' || params.fetch(:legacy, false)
-        # Rouge 1.x or Rouge 2.x legacy options
-        formatter_options = {
-          css_class: params.fetch(:css_class, 'highlight'),
-          inline_theme: params.fetch(:inline_theme, nil),
-          line_numbers: params.fetch(:line_numbers, false),
-          start_line: params.fetch(:start_line, 1),
-          wrap: params.fetch(:wrap, false),
-        }
-        formatter_cls = Rouge::Formatters.const_get(Rouge.version < '2' ? 'HTML' : 'HTMLLegacy')
-        formatter = formatter_cls.new(formatter_options)
-      else
-        formatter = params.fetch(:formatter, Rouge::Formatters::HTML.new)
-      end
-
-      lexer = Rouge::Lexer.find_fancy(language, code) || Rouge::Lexers::PlainText
-      formatter.format(lexer.lex(code))
-    end
-
-    # Removes the double wrapping.
-    #
-    # Before:
-    #
-    #   <pre><code class="language-ruby"><pre class="highlight"><code>
-    #
-    # After:
-    #
-    #   <pre><code class="language-ruby highlight">
-    def rouge_postprocess(_language, element)
-      return if element.name != 'pre'
-
-      code1 = element.xpath('code').first
-      return if code1.nil?
-
-      pre = code1.xpath('pre').first
-      return if pre.nil?
-
-      code2 = pre.xpath('code').first
-      return if code2.nil?
-
-      code1.inner_html = code2.inner_html
-      code1['class'] = [code1['class'], pre['class']].compact.join(' ')
-    end
-
     protected
 
-    KNOWN_COLORIZERS = %i[coderay dummy pygmentize pygmentsrb simon_highlight rouge].freeze
-
     # Removes the first blank lines and any whitespace at the end.
     def strip(s)
       s.lines.drop_while { |line| line.strip.empty? }.join.rstrip
     end
 
-    def highlight(code, language, params = {})
-      colorizer = @colorizers[language.to_sym]
-      if KNOWN_COLORIZERS.include?(colorizer)
-        send(colorizer, code, language, params[colorizer] || {})
-      else
-        raise "I don’t know how to highlight code using the “#{colorizer}” colorizer"
-      end
+    def colorizer_name_for(language)
+      @colorizers[language.to_sym]
     end
 
-    def highlight_postprocess(language, element)
-      colorizer = @colorizers[language.to_sym]
-      if KNOWN_COLORIZERS.include?(colorizer)
-        sym = (colorizer.to_s + '_postprocess').to_sym
-        if respond_to?(sym)
-          send(sym, language, element)
-        end
-      else
-        raise "I don’t know how to highlight code using the “#{colorizer}” colorizer"
+    def colorizer_named(name)
+      colorizer = Colorizers::Abstract.named(name.to_sym)
+      unless colorizer
+        raise "I don’t know how to highlight code using the “#{name}” colorizer"
       end
+      colorizer
+    end
+
+    def highlight(code, language, params = {})
+      colorizer_name = colorizer_name_for(language)
+      colorizer = colorizer_named(colorizer_name)
+      colorizer.new.process(code, language, params[colorizer_name] || {})
     end
 
-    def check_availability(*cmd)
-      piper = Nanoc::Extra::Piper.new(stdout: StringIO.new, stderr: StringIO.new)
-      piper.run(cmd, nil)
+    def highlight_postprocess(language, element)
+      colorizer_name = colorizer_name_for(language)
+      colorizer = colorizer_named(colorizer_name)
+      colorizer.new.postprocess(language, element)
     end
   end
 end
+
+require_relative 'colorize_syntax/colorizers'