nanoc 4.1.0a1 → 4.1.0b1

data/lib/nanoc/{base/services → rule_dsl}/recording_executor.rb

@@ -1,12 +1,6 @@
 module Nanoc
-  module Int
+  module RuleDSL
     class RecordingExecutor
-      class NonFinalSnapshotWithPathError < ::Nanoc::Error
-        def initialize
-          super('This call to #snapshot specifies `final: false`, but it also specifies a path, which is an impossible combination.')
-        end
-      end
-
       class PathWithoutInitialSlashError < ::Nanoc::Error
         def initialize(rep, basic_path)
           super("The path returned for the #{rep.inspect} item representation, “#{basic_path}”, does not start with a slash. Please ensure that all routing rules return a path that starts with a slash.")
@@ -28,14 +22,15 @@ module Nanoc
       end
 
       def layout(_rep, layout_identifier, extra_filter_args = {})
+        unless @rule_memory.any_layouts?
+          @rule_memory.add_snapshot(:pre, true, nil)
+        end
+
         @rule_memory.add_layout(layout_identifier, extra_filter_args)
       end
 
       def snapshot(rep, snapshot_name, final: true, path: nil)
-        actual_path = path || basic_path_from_rules_for(rep, snapshot_name)
-        if !final && actual_path
-          raise NonFinalSnapshotWithPathError
-        end
+        actual_path = final ? (path || basic_path_from_rules_for(rep, snapshot_name)) : nil
         @rule_memory.add_snapshot(snapshot_name, final, actual_path)
       end
 

data/lib/nanoc/{base/compilation → rule_dsl}/rule.rb

@@ -1,4 +1,4 @@
-module Nanoc::Int
+module Nanoc::RuleDSL
   # Contains the processing information for a item.
   #
   # @api private
@@ -48,12 +48,12 @@ module Nanoc::Int
     #
     # @param [Nanoc::Int::ItemRep] rep
     # @param [Nanoc::Int::Site] site
-    # @param [Nanoc::Int::Executor, Nanoc::Int::RecordingExecutor] executor
+    # @param [Nanoc::Int::Executor, Nanoc::RuleDSL::RecordingExecutor] executor
     # @param [Nanoc::ViewContext] view_context
     #
     # @return [void]
     def apply_to(rep, site:, executor:, view_context:)
-      context = Nanoc::Int::RuleContext.new(
+      context = Nanoc::RuleDSL::RuleContext.new(
         rep: rep, executor: executor, site: site, view_context: view_context)
       context.instance_exec(matches(rep.item.identifier), &@block)
     end

data/lib/nanoc/{base/compilation → rule_dsl}/rule_context.rb

@@ -1,4 +1,4 @@
-module Nanoc::Int
+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.
@@ -7,7 +7,7 @@ module Nanoc::Int
   class RuleContext < Nanoc::Int::Context
     # @param [Nanoc::Int::ItemRep] rep
     # @param [Nanoc::Int::Site] site
-    # @param [Nanoc::Int::Executor, Nanoc::Int::RecordingExecutor] executor
+    # @param [Nanoc::Int::Executor, Nanoc::RuleDSL::RecordingExecutor] executor
     # @param [Nanoc::ViewContext] view_context
     def initialize(rep:, site:, executor:, view_context:)
       @_executor = executor

data/lib/nanoc/{base/services → rule_dsl}/rule_memory_calculator.rb

@@ -1,4 +1,4 @@
-module Nanoc::Int
+module Nanoc::RuleDSL
   # Calculates rule memories for objects that can be run through a rule (item
   # representations and layouts).
   #
@@ -16,7 +16,7 @@ module Nanoc::Int
     attr_accessor :rules_collection
 
     # @param [Nanoc::Int::Site] site
-    # @param [Nanoc::Int::RulesCollection] rules_collection
+    # @param [Nanoc::RuleDSL::RulesCollection] rules_collection
     def initialize(site:, rules_collection:)
       @site = site
       @rules_collection = rules_collection
@@ -26,6 +26,9 @@ module Nanoc::Int
     #
     # @return [Nanoc::Int::RuleMemory]
     def [](obj)
+      # FIXME: Remove this
+      obj = obj.unwrap if obj.respond_to?(:unwrap)
+
       case obj
       when Nanoc::Int::ItemRep
         new_rule_memory_for_rep(obj)
@@ -54,19 +57,21 @@ module Nanoc::Int
     #
     # @return [Nanoc::Int::RuleMemory]
     def new_rule_memory_for_rep(rep)
-      # FIXME: This is more-or-less duplicated from Compiler#recalculate_content_for_rep.
-      # Letting the compiler use the rule memory would fix this.
-
       # FIXME: What if #compilation_rule_for returns nil?
 
-      executor = Nanoc::Int::RecordingExecutor.new(rep, @rules_collection, @site)
+      executor = Nanoc::RuleDSL::RecordingExecutor.new(rep, @rules_collection, @site)
+      rule = @rules_collection.compilation_rule_for(rep)
+
       executor.snapshot(rep, :raw)
       executor.snapshot(rep, :pre, final: false)
-      @rules_collection
-        .compilation_rule_for(rep)
-        .apply_to(rep, executor: executor, site: @site, view_context: nil)
-      executor.snapshot(rep, :post) if rep.has_snapshot?(:post)
-      executor.snapshot(rep, :last) unless executor.rule_memory.snapshot_actions.any? { |sa| sa.snapshot_name == :last }
+      rule.apply_to(rep, executor: executor, site: @site, view_context: nil)
+      if executor.rule_memory.any_layouts?
+        executor.snapshot(rep, :post)
+      end
+      unless executor.rule_memory.snapshot_actions.any? { |sa| sa.snapshot_name == :last }
+        executor.snapshot(rep, :last)
+      end
+
       executor.rule_memory
     end
 

data/lib/nanoc/{base/entities → rule_dsl}/rules_collection.rb

@@ -1,4 +1,4 @@
-module Nanoc::Int
+module Nanoc::RuleDSL
   # Keeps track of the rules in a site.
   #
   # @api private

data/lib/nanoc/{base/services → rule_dsl}/rules_loader.rb

@@ -1,8 +1,8 @@
-module Nanoc::Int
+module Nanoc::RuleDSL
   # @api private
   class RulesLoader
     def initialize(config, rules_collection)
-      @dsl = Nanoc::Int::CompilerDSL.new(rules_collection, config)
+      @dsl = Nanoc::RuleDSL::CompilerDSL.new(rules_collection, config)
     end
 
     def load

data/lib/nanoc/rule_dsl.rb

@@ -0,0 +1,8 @@
+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/rule_memory_calculator'
+require_relative 'rule_dsl/rule'
+require_relative 'rule_dsl/rules_collection'
+require_relative 'rule_dsl/rules_loader'

data/lib/nanoc/version.rb

@@ -1,4 +1,4 @@
 module Nanoc
   # The current Nanoc version.
-  VERSION = '4.1.0a1'
+  VERSION = '4.1.0b1'
 end

data/lib/nanoc.rb

@@ -41,3 +41,4 @@ require 'nanoc/extra'
 require 'nanoc/data_sources'
 require 'nanoc/filters'
 require 'nanoc/helpers'
+require 'nanoc/rule_dsl'

data/test/base/test_compiler.rb

@@ -7,20 +7,17 @@ class Nanoc::Int::CompilerTest < Nanoc::TestCase
       layouts: [],
     )
 
-    rules_collection = Nanoc::Int::RulesCollection.new
-
     reps = Nanoc::Int::ItemRepRepo.new
 
+    action_provider = Nanoc::Int::ActionProvider.named(:rule_dsl).for(site)
+
     params = {
       compiled_content_cache: Nanoc::Int::CompiledContentCache.new,
       checksum_store: Nanoc::Int::ChecksumStore.new(site: site),
       rule_memory_store: Nanoc::Int::RuleMemoryStore.new,
-      rule_memory_calculator: Nanoc::Int::RuleMemoryCalculator.new(
-        rules_collection: rules_collection,
-        site: site,
-      ),
       dependency_store: Nanoc::Int::DependencyStore.new(
         site.items.to_a + site.layouts.to_a),
+      action_provider: action_provider,
       reps: reps,
     }
 
@@ -29,157 +26,58 @@ class Nanoc::Int::CompilerTest < Nanoc::TestCase
         site: site,
         checksum_store: params[:checksum_store],
         dependency_store: params[:dependency_store],
-        rules_collection: params[:rules_collection],
         rule_memory_store: params[:rule_memory_store],
-        rule_memory_calculator: params[:rule_memory_calculator],
+        action_provider: action_provider,
         reps: reps,
       )
 
-    Nanoc::Int::Compiler.new(site, rules_collection, params)
-  end
-
-  def test_compilation_rule_for
-    # Mock rules
-    rules = [mock, mock, mock]
-    rules[0].expects(:applicable_to?).returns(false)
-    rules[1].expects(:applicable_to?).returns(true)
-    rules[1].expects(:rep_name).returns('wrong')
-    rules[2].expects(:applicable_to?).returns(true)
-    rules[2].expects(:rep_name).returns('right')
-
-    # Create compiler
-    compiler = new_compiler
-    compiler.rules_collection.instance_eval { @item_compilation_rules = rules }
-
-    # Mock rep
-    rep = mock
-    rep.stubs(:name).returns('right')
-    item = mock
-    rep.stubs(:item).returns(item)
-
-    # Test
-    assert_equal rules[2], compiler.rules_collection.compilation_rule_for(rep)
-  end
-
-  def test_filter_for_layout_with_existant_layout
-    # Create compiler
-    compiler = new_compiler
-    compiler.rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(/.*/)] = [:erb, { foo: 'bar' }]
-
-    # Mock layout
-    layout = MiniTest::Mock.new
-    layout.expect(:identifier, '/some_layout/')
-
-    # Check
-    assert_equal([:erb, { foo: 'bar' }], compiler.rules_collection.filter_for_layout(layout))
+    Nanoc::Int::Compiler.new(site, params)
   end
 
-  def test_filter_for_layout_with_existant_layout_and_unknown_filter
-    # Create compiler
-    compiler = new_compiler
-    compiler.rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(/.*/)] = [:some_unknown_filter, { foo: 'bar' }]
-
-    # Mock layout
-    layout = MiniTest::Mock.new
-    layout.expect(:identifier, '/some_layout/')
-
-    # Check
-    assert_equal([:some_unknown_filter, { foo: 'bar' }], compiler.rules_collection.filter_for_layout(layout))
-  end
-
-  def test_filter_for_layout_with_nonexistant_layout
-    # Create compiler
-    compiler = new_compiler
-    compiler.rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/foo/$})] = [:erb, { foo: 'bar' }]
-
-    # Mock layout
-    layout = MiniTest::Mock.new
-    layout.expect(:identifier, '/bar/')
-
-    # Check
-    assert_equal(nil, compiler.rules_collection.filter_for_layout(layout))
-  end
-
-  def test_filter_for_layout_with_many_layouts
-    # Create compiler
-    compiler = new_compiler
-    compiler.rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/a/b/c/.*/$})] = [:erb, { char: 'd' }]
-    compiler.rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/a/.*/$})]     = [:erb, { char: 'b' }]
-    compiler.rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/a/b/.*/$})]   = [:erb, { char: 'c' }] # never used!
-    compiler.rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/.*/$})]       = [:erb, { char: 'a' }]
-
-    # Mock layout
-    layouts = [mock, mock, mock, mock]
-    layouts[0].stubs(:identifier).returns('/a/b/c/d/')
-    layouts[1].stubs(:identifier).returns('/a/b/c/')
-    layouts[2].stubs(:identifier).returns('/a/b/')
-    layouts[3].stubs(:identifier).returns('/a/')
-
-    # Get expectations
-    expectations = {
-      0 => 'd',
-      1 => 'b', # never used! not c, because b takes priority
-      2 => 'b',
-      3 => 'a',
-    }
+  def test_compile_rep_should_write_proper_snapshots_real
+    with_site do |site|
+      File.write('content/moo.txt', '<%= 1 %> <%%= 2 %> <%%%= 3 %>')
+      File.write('layouts/default.erb', 'head <%= yield %> foot')
 
-    # Check
-    expectations.each_pair do |num, char|
-      filter_and_args = compiler.rules_collection.filter_for_layout(layouts[num])
-      refute_nil(filter_and_args)
-      assert_equal(char, filter_and_args[1][:char])
-    end
-  end
+      File.open('Rules', 'w') do |io|
+        io.write "compile '/**/*' do\n"
+        io.write "  filter :erb\n"
+        io.write "  filter :erb\n"
+        io.write "  layout 'default'\n"
+        io.write "  filter :erb\n"
+        io.write "end\n"
+        io.write "\n"
+        io.write "route '/**/*', snapshot: :raw do\n"
+        io.write "  '/moo-raw.txt'\n"
+        io.write "end\n"
+        io.write "\n"
+        io.write "route '/**/*', snapshot: :pre do\n"
+        io.write "  '/moo-pre.txt'\n"
+        io.write "end\n"
+        io.write "\n"
+        io.write "route '/**/*', snapshot: :post do\n"
+        io.write "  '/moo-post.txt'\n"
+        io.write "end\n"
+        io.write "\n"
+        io.write "route '/**/*' do\n"
+        io.write "  '/moo-last.txt'\n"
+        io.write "end\n"
+        io.write "\n"
+        io.write "layout '/**/*', :erb\n"
+      end
 
-  def test_compile_rep_should_write_proper_snapshots
-    # Mock rep
-    item = Nanoc::Int::Item.new('<%= 1 %> <%%= 2 %> <%%%= 3 %>', {}, '/moo/')
-    rep  = Nanoc::Int::ItemRep.new(item, :blah)
-
-    # Set snapshot filenames
-    rep.raw_paths = {
-      raw: 'raw.txt',
-      pre: 'pre.txt',
-      post: 'post.txt',
-      last: 'last.txt',
-    }
+      site = Nanoc::Int::SiteLoader.new.new_from_cwd
+      site.compile
 
-    # Create rule
-    rule_block = proc do
-      filter :erb
-      filter :erb
-      layout '/blah/'
-      filter :erb
+      assert File.file?('output/moo-raw.txt')
+      # assert File.file?('output/moo-pre.txt')
+      assert File.file?('output/moo-post.txt')
+      assert File.file?('output/moo-last.txt')
+      assert_equal '<%= 1 %> <%%= 2 %> <%%%= 3 %>', File.read('output/moo-raw.txt')
+      # assert_equal '1 2 <%= 3 %>',                  File.read('output/moo-pre.txt')
+      assert_equal 'head 1 2 3 foot',               File.read('output/moo-post.txt')
+      assert_equal 'head 1 2 3 foot',               File.read('output/moo-last.txt')
     end
-    rule = Nanoc::Int::Rule.new(Nanoc::Int::Pattern.from(/blah/), :meh, rule_block)
-
-    # Create layout
-    layout = Nanoc::Int::Layout.new('head <%= yield %> foot', {}, '/blah/')
-
-    # Create site
-    site = mock
-    site.stubs(:config).returns({})
-    site.stubs(:items).returns([])
-    site.stubs(:layouts).returns([layout])
-
-    # Create compiler
-    compiler = new_compiler(site)
-    compiler.rules_collection.expects(:compilation_rule_for).times(2).with(rep).returns(rule)
-    compiler.rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/blah/$})] = [:erb, {}]
-    site.stubs(:compiler).returns(compiler)
-
-    # Compile
-    compiler.send(:compile_rep, rep)
-
-    # Test
-    assert File.file?('raw.txt')
-    assert File.file?('pre.txt')
-    assert File.file?('post.txt')
-    assert File.file?('last.txt')
-    assert_equal '<%= 1 %> <%%= 2 %> <%%%= 3 %>', File.read('raw.txt')
-    assert_equal '1 2 <%= 3 %>',                  File.read('pre.txt')
-    assert_equal 'head 1 2 3 foot',               File.read('post.txt')
-    assert_equal 'head 1 2 3 foot',               File.read('last.txt')
   end
 
   def test_compile_with_no_reps

data/test/filters/test_erb.rb

@@ -77,7 +77,7 @@ class Nanoc::Filters::ERBTest < Nanoc::TestCase
 
     # With
     assert_raises(SecurityError) do
-      res = filter.setup_and_run('<%= File.read("moo") %>', safe_level: 3)
+      res = filter.setup_and_run('<%= eval File.read("moo") %>', safe_level: 1)
     end
   end
 

data/test/helper.rb

@@ -95,11 +95,11 @@ EOS
         end
 
         File.open('nanoc.yaml', 'w') do |io|
-          io << 'string_pattern_type: legacy' << "\n"
+          io << 'string_pattern_type: legacy' << "\n" if params.fetch(:legacy, true)
           io << 'data_sources:' << "\n"
           io << '  -' << "\n"
           io << '    type: filesystem' << "\n"
-          io << '    identifier_type: legacy' << "\n"
+          io << '    identifier_type: legacy' << "\n" if params.fetch(:legacy, true)
         end
 
         File.open('Rules', 'w') { |io| io.write(rules_content) }

data/test/rule_dsl/test_action_provider.rb

@@ -0,0 +1,70 @@
+class Nanoc::RuleDSL::ActionProviderTest < Nanoc::TestCase
+  def new_action_provider(site)
+    rules_collection = Nanoc::RuleDSL::RulesCollection.new
+
+    rule_memory_calculator =
+      Nanoc::RuleDSL::RuleMemoryCalculator.new(
+        rules_collection: rules_collection, site: site)
+
+    action_provider = Nanoc::RuleDSL::ActionProvider.new(
+      rules_collection, rule_memory_calculator)
+
+    Nanoc::RuleDSL::RulesLoader.new(site.config, rules_collection).load
+
+    action_provider
+  end
+
+  def test_per_rules_file_preprocessor
+    # Create site
+    Nanoc::CLI.run %w( create_site foo )
+    FileUtils.cd('foo') do
+      # Create a bonus rules file
+      File.write(
+        'more_rules.rb',
+        "preprocess { @items['/index.*'][:preprocessed] = true }")
+
+      # Adjust normal rules file
+      File.write(
+        'Rules',
+        "include_rules 'more_rules'\n\npreprocess {}\n\n" + File.read('Rules'))
+
+      # Create site and compiler
+      site = Nanoc::Int::SiteLoader.new.new_from_cwd
+      action_provider = new_action_provider(site)
+
+      # Check that the two preprocess blocks have been added
+      assert_equal 2, action_provider.rules_collection.preprocessors.size
+      refute_nil action_provider.rules_collection.preprocessors.first
+      refute_nil action_provider.rules_collection.preprocessors.to_a.last
+
+      # Apply preprocess blocks
+      action_provider.preprocess(site)
+      assert site.items['/index.*'].attributes[:preprocessed]
+    end
+  end
+
+  def test_per_rules_file_postprocessor
+    # Create site
+    Nanoc::CLI.run %w( create_site foo )
+    FileUtils.cd('foo') do
+      # Create a bonus rules file
+      File.write(
+        'more_rules.rb',
+        'postprocess {}')
+
+      # Adjust normal rules file
+      File.write(
+        'Rules',
+        "include_rules 'more_rules'\n\npostprocess {}\n\n" + File.read('Rules'))
+
+      # Create site and compiler
+      site = Nanoc::Int::SiteLoader.new.new_from_cwd
+      action_provider = new_action_provider(site)
+
+      # Check that the two postprocess blocks have been added
+      assert_equal 2, action_provider.rules_collection.postprocessors.size
+      refute_nil action_provider.rules_collection.postprocessors.first
+      refute_nil action_provider.rules_collection.postprocessors.to_a.last
+    end
+  end
+end