nanoc 4.8.18 → 4.8.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42c6429f3ab75c70a0616b03c8658442b860f3238e626e3b7a41e21b93558bc6
-  data.tar.gz: 329c3e49d8813363facc58726517a330821866d2ef6dac20279aa61800c0c617
+  metadata.gz: 77b1cd3570e8e94e5d17d18bf9954f0ac8d8a45e48f4e3d2f7d39cbdc8a2e3ff
+  data.tar.gz: a5a95e6ab7be8df7c016fdd659bac76734965ed9aed677110647ae7d0cfa19b8
 SHA512:
-  metadata.gz: 3caf2cc5572e4ccc9615ab06487391f6d691e4dbe9bb08d600f20f2f20284c827a7ce1fd6325e7ed5cd785d16d19b6e77380a2134fa505dd27f11c91defb780b
-  data.tar.gz: 71c7a650d30c2d29ba5a38b8fc2eee74596102506dbc44956a733f914d1c7b58b87bdd0ac5603788eae03758b3ef8ebae6c65c3102b3743e68e17354846b0f0d
+  metadata.gz: 5860e580a17a5ed72590cb7c81eb6b6e1649e5c2973a322ed1ca544af0faa4a37de23343151a6dbbe730cd022b9d58f54feae6546c7f243e7c359bc2e3f1ea2a
+  data.tar.gz: e8642774bd3d54418ae6c78392dedca7eecbc80b2d06d7e83aa9a579ab35074a06de192420476b1ca7dfb48e29f2c7fc3b809925faedb23cb5522b89f170b9f0

data/NEWS.md

@@ -1,5 +1,11 @@
 # Nanoc news
 
+## 4.8.19 (2018-01-01)
+
+Enhancements:
+
+* Made `write nil` skip routing rule (#1286)
+
 ## 4.8.18 (2017-12-28)
 
 Enhancements:

data/lib/nanoc.rb

@@ -27,6 +27,11 @@ module Nanoc
   def self.on_windows?
     RUBY_PLATFORM =~ /windows|bccwin|cygwin|djgpp|mingw|mswin|wince/i
   end
+
+  # Similar to `nil` except that it can only be compared against using
+  # `UNDEFINED.equal?(x)`. Used in places where `nil` already has meaning, and
+  # thus cannot be used to mean the presence of nothing.
+  UNDEFINED = Object.new
 end
 
 # Load general requirements

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

@@ -51,7 +51,15 @@ module Nanoc::Int
 
     def respond_to_missing?(method, include_all)
       ivar_name = '@' + method.to_s
-      instance_variable_defined?(ivar_name) || super
+
+      valid_ivar_name =
+        if defined?(Contracts)
+          ivar_name =~ /\A@[A-Za-z_]+\z/
+        else
+          true # probably good enough
+        end
+
+      (valid_ivar_name && instance_variable_defined?(ivar_name)) || super
     end
 
     def include(mod)

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

@@ -98,7 +98,7 @@ module Nanoc::Int
           StringUpdateBehavior
         when Nanoc::View
           UnwrapUpdateBehavior
-        when Nanoc::RuleDSL::RuleContext
+        when Nanoc::RuleDSL::CompilationRuleContext
           RuleContextUpdateBehavior
         when Nanoc::Int::Context
           ContextUpdateBehavior

data/lib/nanoc/data_sources/filesystem.rb

@@ -379,114 +379,13 @@ module Nanoc::DataSources
       end
     end
 
-    # @return [ParseResult]
     def parse(content_filename, meta_filename)
-      if meta_filename
-        parse_with_separate_meta_filename(content_filename, meta_filename)
-      else
-        parse_with_frontmatter(content_filename)
-      end
-    end
-
-    # @return [ParseResult]
-    def parse_with_separate_meta_filename(content_filename, meta_filename)
-      content = content_filename ? read(content_filename) : ''
-      meta_raw = read(meta_filename)
-      meta = parse_metadata(meta_raw, meta_filename)
-      ParseResult.new(content: content, attributes: meta, attributes_data: meta_raw)
-    end
-
-    SEPARATOR = /(-{5}|-{3})/.source
-
-    # @return [ParseResult]
-    def parse_with_frontmatter(content_filename)
-      data = read(content_filename)
-
-      if data !~ /\A#{SEPARATOR}\s*$/
-        return ParseResult.new(content: data, attributes: {}, attributes_data: '')
-      end
-
-      pieces = data.split(/^#{SEPARATOR}[ \t]*\r?\n?/, 3)
-      if pieces.size < 4
-        raise Errors::InvalidFormat.new(content_filename)
-      end
-
-      meta = parse_metadata(pieces[2], content_filename)
-      content = pieces[4]
-
-      ParseResult.new(content: content, attributes: meta, attributes_data: pieces[2])
-    end
-
-    # @return [Hash]
-    def parse_metadata(data, filename)
-      begin
-        meta = YAML.load(data) || {}
-      rescue => e
-        raise Errors::UnparseableMetadata.new(filename, e)
-      end
-
-      verify_meta(meta, filename)
-
-      meta
-    end
-
-    class ParseResult
-      attr_reader :content
-      attr_reader :attributes
-      attr_reader :attributes_data
-
-      def initialize(content:, attributes:, attributes_data:)
-        @content = content
-        @attributes = attributes
-        @attributes_data = attributes_data
-      end
-    end
-
-    def verify_meta(meta, filename)
-      return if meta.is_a?(Hash)
-
-      raise Errors::InvalidMetadata.new(filename, meta.class)
-    end
-
-    # Reads the content of the file with the given name and returns a string
-    # in UTF-8 encoding. The original encoding of the string is derived from
-    # the default external encoding, but this can be overridden by the
-    # “encoding” configuration attribute in the data source configuration.
-    def read(filename)
-      # Read
-      begin
-        data = File.read(filename)
-      rescue => e
-        raise Errors::FileUnreadable.new(filename, e)
-      end
-
-      # Set original encoding, if any
-      if @config && @config[:encoding]
-        original_encoding = Encoding.find(@config[:encoding])
-        data.force_encoding(@config[:encoding])
-      else
-        original_encoding = data.encoding
-      end
-
-      # Set encoding to UTF-8
-      begin
-        data.encode!('UTF-8')
-      rescue
-        raise Errors::InvalidEncoding.new(filename, original_encoding)
-      end
-
-      # Verify
-      unless data.valid_encoding?
-        raise Errors::InvalidEncoding.new(filename, original_encoding)
-      end
-
-      # Remove UTF-8 BOM (ugly)
-      data.delete!("\xEF\xBB\xBF")
-
-      data
+      parser = Parser.new(config: @config)
+      parser.call(content_filename, meta_filename)
     end
   end
 end
 
 require_relative 'filesystem/tools'
 require_relative 'filesystem/errors'
+require_relative 'filesystem/parser'

data/lib/nanoc/data_sources/filesystem/parser.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# @api private
+class Nanoc::DataSources::Filesystem
+  class Parser
+    SEPARATOR = /(-{5}|-{3})/.source
+
+    class ParseResult
+      attr_reader :content
+      attr_reader :attributes
+      attr_reader :attributes_data
+
+      def initialize(content:, attributes:, attributes_data:)
+        @content = content
+        @attributes = attributes
+        @attributes_data = attributes_data
+      end
+    end
+
+    def initialize(config:)
+      @config = config
+    end
+
+    # @return [ParseResult]
+    def call(content_filename, meta_filename)
+      if meta_filename
+        parse_with_separate_meta_filename(content_filename, meta_filename)
+      else
+        parse_with_frontmatter(content_filename)
+      end
+    end
+
+    # @return [ParseResult]
+    def parse_with_separate_meta_filename(content_filename, meta_filename)
+      content = content_filename ? Tools.read_file(content_filename, config: @config) : ''
+      meta_raw = Tools.read_file(meta_filename, config: @config)
+      meta = parse_metadata(meta_raw, meta_filename)
+      ParseResult.new(content: content, attributes: meta, attributes_data: meta_raw)
+    end
+
+    # @return [ParseResult]
+    def parse_with_frontmatter(content_filename)
+      data = Tools.read_file(content_filename, config: @config)
+
+      if data !~ /\A#{SEPARATOR}\s*$/
+        return ParseResult.new(content: data, attributes: {}, attributes_data: '')
+      end
+
+      pieces = data.split(/^#{SEPARATOR}[ \t]*\r?\n?/, 3)
+      if pieces.size < 4
+        raise Errors::InvalidFormat.new(content_filename)
+      end
+
+      meta = parse_metadata(pieces[2], content_filename)
+      content = pieces[4]
+
+      ParseResult.new(content: content, attributes: meta, attributes_data: pieces[2])
+    end
+
+    # @return [Hash]
+    def parse_metadata(data, filename)
+      begin
+        meta = YAML.load(data) || {}
+      rescue => e
+        raise Errors::UnparseableMetadata.new(filename, e)
+      end
+
+      verify_meta(meta, filename)
+
+      meta
+    end
+
+    def verify_meta(meta, filename)
+      return if meta.is_a?(Hash)
+      raise Errors::InvalidMetadata.new(filename, meta.class)
+    end
+  end
+end

data/lib/nanoc/data_sources/filesystem/tools.rb

@@ -148,5 +148,44 @@ class Nanoc::DataSources::Filesystem < Nanoc::DataSource
       end
     end
     module_function :resolve_symlink
+
+    # Reads the content of the file with the given name and returns a string
+    # in UTF-8 encoding. The original encoding of the string is derived from
+    # the default external encoding, but this can be overridden by the
+    # “encoding” configuration attribute in the data source configuration.
+    def read_file(filename, config:)
+      # Read
+      begin
+        data = File.read(filename)
+      rescue => e
+        raise Errors::FileUnreadable.new(filename, e)
+      end
+
+      # Set original encoding, if any
+      if config && config[:encoding]
+        original_encoding = Encoding.find(config[:encoding])
+        data.force_encoding(config[:encoding])
+      else
+        original_encoding = data.encoding
+      end
+
+      # Set encoding to UTF-8
+      begin
+        data.encode!('UTF-8')
+      rescue
+        raise Errors::InvalidEncoding.new(filename, original_encoding)
+      end
+
+      # Verify
+      unless data.valid_encoding?
+        raise Errors::InvalidEncoding.new(filename, original_encoding)
+      end
+
+      # Remove UTF-8 BOM (ugly)
+      data.delete!("\xEF\xBB\xBF")
+
+      data
+    end
+    module_function :read_file
   end
 end

data/lib/nanoc/rule_dsl.rb

@@ -1,10 +1,22 @@
 # frozen_string_literal: true
 
+module Nanoc
+  # @api private
+  module RuleDSL
+  end
+end
+
 require_relative 'rule_dsl/compiler_dsl'
 require_relative 'rule_dsl/action_provider'
-require_relative 'rule_dsl/recording_executor'
-require_relative 'rule_dsl/rule_context'
+require_relative 'rule_dsl/action_recorder'
 require_relative 'rule_dsl/action_sequence_calculator'
-require_relative 'rule_dsl/rule'
 require_relative 'rule_dsl/rules_collection'
 require_relative 'rule_dsl/rules_loader'
+
+require_relative 'rule_dsl/rule_context'
+require_relative 'rule_dsl/compilation_rule_context'
+require_relative 'rule_dsl/routing_rule_context'
+
+require_relative 'rule_dsl/rule'
+require_relative 'rule_dsl/compilation_rule'
+require_relative 'rule_dsl/routing_rule'

data/lib/nanoc/rule_dsl/{recording_executor.rb → action_recorder.rb}

@@ -2,7 +2,7 @@
 
 module Nanoc
   module RuleDSL
-    class RecordingExecutor
+    class ActionRecorder
       include Nanoc::Int::ContractsSupport
 
       contract Nanoc::Int::ItemRep => C::Any
@@ -12,6 +12,7 @@ module Nanoc
         @any_layouts = false
         @last_snapshot = false
         @pre_snapshot = false
+        @skip_routing_rule = false
       end
 
       def inspect
@@ -36,10 +37,19 @@ module Nanoc
         @any_layouts = true
       end
 
-      Pathlike = C::Maybe[C::Or[String, Nanoc::Identifier]]
-      contract Symbol, C::KeywordArgs[path: C::Optional[Pathlike]] => nil
-      def snapshot(snapshot_name, path: nil)
-        @action_sequence_builder.add_snapshot(snapshot_name, path&.to_s)
+      MaybePathlike = C::Or[nil, Nanoc::UNDEFINED, String, Nanoc::Identifier]
+      contract Symbol, C::KeywordArgs[path: C::Optional[MaybePathlike]] => nil
+      def snapshot(snapshot_name, path: Nanoc::UNDEFINED)
+        @skip_routing_rule = path.nil?
+
+        path =
+          if Nanoc::UNDEFINED.equal?(path) || path.nil?
+            nil
+          else
+            path.to_s
+          end
+
+        @action_sequence_builder.add_snapshot(snapshot_name, path)
         case snapshot_name
         when :last
           @last_snapshot = true
@@ -59,6 +69,11 @@ module Nanoc
         @any_layouts
       end
 
+      contract C::None => C::Bool
+      def skip_routing_rule?
+        @skip_routing_rule
+      end
+
       contract C::None => C::Bool
       def last_snapshot?
         @last_snapshot

data/lib/nanoc/rule_dsl/action_sequence_calculator.rb

@@ -1,10 +1,6 @@
 # frozen_string_literal: true
 
 module Nanoc::RuleDSL
-  # Calculates action sequences for objects that can be run through a rule (item
-  # representations and layouts).
-  #
-  # @api private
   class ActionSequenceCalculator
     DDMemoize.activate(self)
 
@@ -60,20 +56,20 @@ module Nanoc::RuleDSL
       view_context =
         Nanoc::ViewContextForPreCompilation.new(items: @site.items)
 
-      executor = Nanoc::RuleDSL::RecordingExecutor.new(rep)
+      recorder = Nanoc::RuleDSL::ActionRecorder.new(rep)
       rule = @rules_collection.compilation_rule_for(rep)
 
       unless rule
         raise NoActionSequenceForItemRepException.new(rep)
       end
 
-      executor.snapshot(:raw)
-      rule.apply_to(rep, executor: executor, site: @site, view_context: view_context)
-      executor.snapshot(:post) if executor.any_layouts?
-      executor.snapshot(:last) unless executor.last_snapshot?
-      executor.snapshot(:pre) unless executor.pre_snapshot?
+      recorder.snapshot(:raw)
+      rule.apply_to(rep, recorder: recorder, site: @site, view_context: view_context)
+      recorder.snapshot(:post) if recorder.any_layouts?
+      recorder.snapshot(:last) unless recorder.last_snapshot?
+      recorder.snapshot(:pre) unless recorder.pre_snapshot?
 
-      copy_paths_from_routing_rules(compact_snapshots(executor.action_sequence), rep: rep)
+      copy_paths_from_routing_rules(compact_snapshots(recorder.action_sequence), rep: rep)
     end
 
     # @param [Nanoc::Int::Layout] layout
@@ -138,7 +134,6 @@ module Nanoc::RuleDSL
       basic_path =
         routing_rule.apply_to(
           rep,
-          executor: nil,
           site: @site,
           view_context: view_context,
         )

data/lib/nanoc/rule_dsl/compilation_rule.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Nanoc::RuleDSL
+  class CompilationRule < Rule
+    include Nanoc::Int::ContractsSupport
+
+    contract Nanoc::Int::ItemRep, C::KeywordArgs[
+      site: Nanoc::Int::Site,
+      recorder: Nanoc::RuleDSL::ActionRecorder,
+      view_context: Nanoc::ViewContextForPreCompilation,
+    ] => C::Any
+    def apply_to(rep, site:, recorder:, view_context:)
+      context = Nanoc::RuleDSL::CompilationRuleContext.new(
+        rep: rep,
+        recorder: recorder,
+        site: site,
+        view_context: view_context,
+      )
+
+      context.instance_exec(matches(rep.item.identifier), &@block)
+    end
+  end
+end

data/lib/nanoc/rule_dsl/compilation_rule_context.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Nanoc::RuleDSL
+  class CompilationRuleContext < RuleContext
+    include Nanoc::Int::ContractsSupport
+
+    contract C::KeywordArgs[
+      rep: Nanoc::Int::ItemRep,
+      site: Nanoc::Int::Site,
+      recorder: Nanoc::RuleDSL::ActionRecorder,
+      view_context: Nanoc::ViewContextForPreCompilation,
+    ] => C::Any
+    def initialize(rep:, site:, recorder:, view_context:)
+      @_recorder = recorder
+
+      super(rep: rep, site: site, view_context: view_context)
+    end
+
+    # Filters the current representation (calls {Nanoc::Int::ItemRep#filter} with
+    # the given arguments on the rep).
+    #
+    # @see Nanoc::Int::ItemRep#filter
+    #
+    # @param [Symbol] filter_name The name of the filter to run the item
+    #   representations' content through
+    #
+    # @param [Hash] filter_args The filter arguments that should be passed to
+    #   the filter's #run method
+    #
+    # @return [void]
+    def filter(filter_name, filter_args = {})
+      @_recorder.filter(filter_name, filter_args)
+    end
+
+    # Layouts the current representation (calls {Nanoc::Int::ItemRep#layout} with
+    # the given arguments on the rep).
+    #
+    # @see Nanoc::Int::ItemRep#layout
+    #
+    # @param [String] layout_identifier The identifier of the layout the item
+    #   should be laid out with
+    #
+    # @return [void]
+    def layout(layout_identifier, extra_filter_args = nil)
+      @_recorder.layout(layout_identifier, extra_filter_args)
+    end
+
+    # Creates a snapshot of the current compiled item content. Calls
+    # {Nanoc::Int::ItemRep#snapshot} with the given arguments on the rep.
+    #
+    # @see Nanoc::Int::ItemRep#snapshot
+    #
+    # @param [Symbol] snapshot_name The name of the snapshot to create
+    #
+    # @param [String, nil] path
+    #
+    # @return [void]
+    def snapshot(snapshot_name, path: Nanoc::UNDEFINED)
+      @_recorder.snapshot(snapshot_name, path: path)
+    end
+
+    # Creates a snapshot named :last the current compiled item content, with
+    # the given path. This is a convenience method for {#snapshot}.
+    #
+    # @see #snapshot
+    #
+    # @param [String] path
+    #
+    # @return [void]
+    def write(arg)
+      @_write_snapshot_counter ||= 0
+      snapshot_name = "_#{@_write_snapshot_counter}".to_sym
+      @_write_snapshot_counter += 1
+
+      case arg
+      when String, Nanoc::Identifier, nil
+        snapshot(snapshot_name, path: arg)
+      when Hash
+        if arg.key?(:ext)
+          ext = arg[:ext].sub(/\A\./, '')
+          path = @item.identifier.without_exts + '.' + ext
+          snapshot(snapshot_name, path: path)
+        else
+          raise ArgumentError, 'Cannot call #write this way (need path or :ext)'
+        end
+      else
+        raise ArgumentError, 'Cannot call #write this way (need path or :ext)'
+      end
+    end
+  end
+end

data/lib/nanoc/rule_dsl/compiler_dsl.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
 module Nanoc::RuleDSL
-  # Contains methods that will be executed by the site’s `Rules` file.
-  #
-  # @api private
   class CompilerDSL < Nanoc::Int::Context
     # The current rules filename.
     #
@@ -74,7 +71,7 @@ module Nanoc::RuleDSL
     def compile(identifier, rep: :default, &block)
       raise ArgumentError.new('#compile requires a block') unless block_given?
 
-      rule = Nanoc::RuleDSL::Rule.new(create_pattern(identifier), rep, block)
+      rule = Nanoc::RuleDSL::CompilationRule.new(create_pattern(identifier), rep, block)
       @rules_collection.add_item_compilation_rule(rule)
     end
 
@@ -114,7 +111,7 @@ module Nanoc::RuleDSL
     def route(identifier, rep: :default, snapshot: :last, &block)
       raise ArgumentError.new('#route requires a block') unless block_given?
 
-      rule = Nanoc::RuleDSL::Rule.new(create_pattern(identifier), rep, block, snapshot_name: snapshot)
+      rule = Nanoc::RuleDSL::RoutingRule.new(create_pattern(identifier), rep, block, snapshot_name: snapshot)
       @rules_collection.add_item_routing_rule(rule)
     end
 
@@ -173,7 +170,7 @@ module Nanoc::RuleDSL
       raise ArgumentError.new('#passthrough does not require a block') if block_given?
 
       compilation_block = proc {}
-      compilation_rule = Nanoc::RuleDSL::Rule.new(create_pattern(identifier), rep, compilation_block)
+      compilation_rule = Nanoc::RuleDSL::CompilationRule.new(create_pattern(identifier), rep, compilation_block)
       @rules_collection.add_item_compilation_rule(compilation_rule)
 
       # Create routing rule
@@ -188,7 +185,7 @@ module Nanoc::RuleDSL
           item[:extension].nil? || (item[:content_filename].nil? && item.identifier =~ %r{#{item[:extension]}/$}) ? item.identifier.chop : item.identifier.chop + '.' + item[:extension]
         end
       end
-      routing_rule = Nanoc::RuleDSL::Rule.new(create_pattern(identifier), rep, routing_block, snapshot_name: :last)
+      routing_rule = Nanoc::RuleDSL::RoutingRule.new(create_pattern(identifier), rep, routing_block, snapshot_name: :last)
       @rules_collection.add_item_routing_rule(routing_rule)
     end
 
@@ -213,10 +210,10 @@ module Nanoc::RuleDSL
     def ignore(identifier, rep: :default)
       raise ArgumentError.new('#ignore does not require a block') if block_given?
 
-      compilation_rule = Nanoc::RuleDSL::Rule.new(create_pattern(identifier), rep, proc {})
+      compilation_rule = Nanoc::RuleDSL::CompilationRule.new(create_pattern(identifier), rep, proc {})
       @rules_collection.add_item_compilation_rule(compilation_rule)
 
-      routing_rule = Nanoc::RuleDSL::Rule.new(create_pattern(identifier), rep, proc {}, snapshot_name: :last)
+      routing_rule = Nanoc::RuleDSL::RoutingRule.new(create_pattern(identifier), rep, proc {}, snapshot_name: :last)
       @rules_collection.add_item_routing_rule(routing_rule)
     end
 

data/lib/nanoc/rule_dsl/routing_rule.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Nanoc::RuleDSL
+  class RoutingRule < Rule
+    include Nanoc::Int::ContractsSupport
+
+    contract C::None => C::Maybe[Symbol]
+    attr_reader :snapshot_name
+
+    contract Nanoc::Int::Pattern, Symbol, Proc, C::KeywordArgs[snapshot_name: C::Optional[Symbol]] => C::Any
+    def initialize(pattern, rep_name, block, snapshot_name: nil)
+      super(pattern, rep_name, block)
+
+      @snapshot_name = snapshot_name
+    end
+
+    contract Nanoc::Int::ItemRep, C::KeywordArgs[
+      site: Nanoc::Int::Site,
+      view_context: Nanoc::ViewContextForPreCompilation,
+    ] => C::Any
+    def apply_to(rep, site:, view_context:)
+      context = Nanoc::RuleDSL::RoutingRuleContext.new(
+        rep: rep, site: site, view_context: view_context,
+      )
+
+      context.instance_exec(matches(rep.item.identifier), &@block)
+    end
+  end
+end

data/lib/nanoc/rule_dsl/routing_rule_context.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Nanoc::RuleDSL
+  class RoutingRuleContext < RuleContext
+  end
+end

data/lib/nanoc/rule_dsl/rule.rb

@@ -1,77 +1,29 @@
 # frozen_string_literal: true
 
 module Nanoc::RuleDSL
-  # Contains the processing information for a item.
-  #
-  # @api private
   class Rule
     include Nanoc::Int::ContractsSupport
 
-    # @return [Symbol] The name of the representation that will be compiled
-    #   using this rule
+    contract C::None => Symbol
     attr_reader :rep_name
 
-    # @return [Symbol] The name of the snapshot this rule will apply to.
-    #   Ignored for compilation rules, but used for routing rules.
-    attr_reader :snapshot_name
-
+    contract C::None => Nanoc::Int::Pattern
     attr_reader :pattern
 
-    # Creates a new item compilation rule with the given identifier regex,
-    # compiler and block. The block will be called during compilation with the
-    # item rep as its argument.
-    #
-    # @param [Nanoc::Int::Pattern] pattern
-    #
-    # @param [String, Symbol] rep_name The name of the item representation
-    #   where this rule can be applied to
-    #
-    # @param [Proc] block A block that will be called when matching items are
-    #   compiled
-    #
-    # @param [Symbol, nil] snapshot_name The name of the snapshot this rule will
-    #   apply to. Ignored for compilation rules, but used for routing rules.
-    def initialize(pattern, rep_name, block, snapshot_name: nil)
+    contract Nanoc::Int::Pattern, Symbol, Proc => C::Any
+    def initialize(pattern, rep_name, block)
       @pattern = pattern
       @rep_name = rep_name.to_sym
-      @snapshot_name = snapshot_name
       @block = block
     end
 
-    # @param [Nanoc::Int::Item] item The item to check
-    #
-    # @return [Boolean] true if this rule can be applied to the given item
-    #   rep, false otherwise
+    contract Nanoc::Int::Item => C::Bool
     def applicable_to?(item)
       @pattern.match?(item.identifier)
     end
 
-    contract Nanoc::Int::ItemRep, C::KeywordArgs[
-      site: Nanoc::Int::Site,
-      executor: C::Or[nil, Nanoc::Int::Executor, Nanoc::RuleDSL::RecordingExecutor],
-      view_context: Nanoc::ViewContextForPreCompilation,
-    ] => C::Any
-    def apply_to(rep, site:, executor:, view_context:)
-      # FIXME: allowing executor to be nil is ugly
-
-      context = Nanoc::RuleDSL::RuleContext.new(
-        rep: rep,
-        executor: executor,
-        site: site,
-        view_context: view_context,
-      )
-
-      context.instance_exec(matches(rep.item.identifier), &@block)
-    end
-
-    protected
-
-    # Matches the rule regexp against items identifier and gives back group
-    # captures if any
-    #
-    # @param [String] identifier Identifier to capture groups for
-    #
-    # @return [nil, Array] Captured groups, if any
+    # @api private
+    contract Nanoc::Identifier => C::Or[nil, C::ArrayOf[String]]
     def matches(identifier)
       @pattern.captures(identifier)
     end

data/lib/nanoc/rule_dsl/rule_context.rb

@@ -1,19 +1,15 @@
 # frozen_string_literal: true
 
 module Nanoc::RuleDSL
-  # Provides a context in which compilation and routing rules can be executed.
-  # It provides access to the item representation that is being compiled or
-  # routed.
-  #
-  # @api private
   class RuleContext < Nanoc::Int::Context
-    # @param [Nanoc::Int::ItemRep] rep
-    # @param [Nanoc::Int::Site] site
-    # @param [Nanoc::Int::Executor, Nanoc::RuleDSL::RecordingExecutor] executor
-    # @param [Nanoc::ViewContextForCompilation] view_context
-    def initialize(rep:, site:, executor:, view_context:)
-      @_executor = executor
+    include Nanoc::Int::ContractsSupport
 
+    contract C::KeywordArgs[
+      rep: Nanoc::Int::ItemRep,
+      site: Nanoc::Int::Site,
+      view_context: Nanoc::ViewContextForPreCompilation,
+    ] => C::Any
+    def initialize(rep:, site:, view_context:)
       super({
         item: Nanoc::BasicItemView.new(rep.item, view_context),
         rep: Nanoc::BasicItemRepView.new(rep, view_context),
@@ -23,77 +19,5 @@ module Nanoc::RuleDSL
         config: Nanoc::ConfigView.new(site.config, view_context),
       })
     end
-
-    # Filters the current representation (calls {Nanoc::Int::ItemRep#filter} with
-    # the given arguments on the rep).
-    #
-    # @see Nanoc::Int::ItemRep#filter
-    #
-    # @param [Symbol] filter_name The name of the filter to run the item
-    #   representations' content through
-    #
-    # @param [Hash] filter_args The filter arguments that should be passed to
-    #   the filter's #run method
-    #
-    # @return [void]
-    def filter(filter_name, filter_args = {})
-      @_executor.filter(filter_name, filter_args)
-    end
-
-    # Layouts the current representation (calls {Nanoc::Int::ItemRep#layout} with
-    # the given arguments on the rep).
-    #
-    # @see Nanoc::Int::ItemRep#layout
-    #
-    # @param [String] layout_identifier The identifier of the layout the item
-    #   should be laid out with
-    #
-    # @return [void]
-    def layout(layout_identifier, extra_filter_args = nil)
-      @_executor.layout(layout_identifier, extra_filter_args)
-    end
-
-    # Creates a snapshot of the current compiled item content. Calls
-    # {Nanoc::Int::ItemRep#snapshot} with the given arguments on the rep.
-    #
-    # @see Nanoc::Int::ItemRep#snapshot
-    #
-    # @param [Symbol] snapshot_name The name of the snapshot to create
-    #
-    # @param [String, nil] path
-    #
-    # @return [void]
-    def snapshot(snapshot_name, path: nil)
-      @_executor.snapshot(snapshot_name, path: path)
-    end
-
-    # Creates a snapshot named :last the current compiled item content, with
-    # the given path. This is a convenience method for {#snapshot}.
-    #
-    # @see #snapshot
-    #
-    # @param [String] path
-    #
-    # @return [void]
-    def write(arg)
-      @_write_snapshot_counter ||= 0
-      snapshot_name = "_#{@_write_snapshot_counter}".to_sym
-      @_write_snapshot_counter += 1
-
-      case arg
-      when String, Nanoc::Identifier
-        snapshot(snapshot_name, path: arg)
-      when Hash
-        if arg.key?(:ext)
-          ext = arg[:ext].sub(/\A\./, '')
-          path = @item.identifier.without_exts + '.' + ext
-          snapshot(snapshot_name, path: path)
-        else
-          raise ArgumentError, 'Cannot call #write this way (need path or :ext)'
-        end
-      else
-        raise ArgumentError, 'Cannot call #write this way (need path or :ext)'
-      end
-    end
   end
 end

data/lib/nanoc/rule_dsl/rules_loader.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 module Nanoc::RuleDSL
-  # @api private
   class RulesLoader
     def initialize(config, rules_collection)
       @dsl = Nanoc::RuleDSL::CompilerDSL.new(rules_collection, config)

data/lib/nanoc/spec.rb

@@ -24,6 +24,20 @@ module Nanoc
       def skip_unless_have_command(cmd)
         skip "Could not find external command \"#{cmd}\"" unless command?(cmd)
       end
+
+      def sleep_until(max: 3.0)
+        start = Time.now
+        loop do
+          diff = (Time.now - start).to_f
+          if diff > max
+            raise "Waited for #{diff}s for condition to become true, but it never did"
+          end
+
+          break if yield
+
+          sleep 0.1
+        end
+      end
     end
 
     class HelperContext

data/lib/nanoc/version.rb

@@ -2,5 +2,5 @@
 
 module Nanoc
   # The current Nanoc version.
-  VERSION = '4.8.18'
+  VERSION = '4.8.19'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nanoc
 version: !ruby/object:Gem::Version
-  version: 4.8.18
+  version: 4.8.19
 platform: ruby
 authors:
 - Denis Defreyne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-28 00:00:00.000000000 Z
+date: 2018-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -314,6 +314,7 @@ files:
 - lib/nanoc/data_sources.rb
 - lib/nanoc/data_sources/filesystem.rb
 - lib/nanoc/data_sources/filesystem/errors.rb
+- lib/nanoc/data_sources/filesystem/parser.rb
 - lib/nanoc/data_sources/filesystem/tools.rb
 - lib/nanoc/deploying.rb
 - lib/nanoc/deploying/deployer.rb
@@ -375,9 +376,13 @@ files:
 - lib/nanoc/helpers/xml_sitemap.rb
 - lib/nanoc/rule_dsl.rb
 - lib/nanoc/rule_dsl/action_provider.rb
+- lib/nanoc/rule_dsl/action_recorder.rb
 - lib/nanoc/rule_dsl/action_sequence_calculator.rb
+- lib/nanoc/rule_dsl/compilation_rule.rb
+- lib/nanoc/rule_dsl/compilation_rule_context.rb
 - lib/nanoc/rule_dsl/compiler_dsl.rb
-- lib/nanoc/rule_dsl/recording_executor.rb
+- lib/nanoc/rule_dsl/routing_rule.rb
+- lib/nanoc/rule_dsl/routing_rule_context.rb
 - lib/nanoc/rule_dsl/rule.rb
 - lib/nanoc/rule_dsl/rule_context.rb
 - lib/nanoc/rule_dsl/rules_collection.rb