nanoc 4.1.6 → 4.2.0b1

data/lib/nanoc/helpers.rb

@@ -2,6 +2,7 @@ module Nanoc::Helpers
   autoload 'Blogging',    'nanoc/helpers/blogging'
   autoload 'Breadcrumbs', 'nanoc/helpers/breadcrumbs'
   autoload 'Capturing',   'nanoc/helpers/capturing'
+  autoload 'ChildParent', 'nanoc/helpers/child_parent'
   autoload 'Filtering',   'nanoc/helpers/filtering'
   autoload 'HTMLEscape',  'nanoc/helpers/html_escape'
   autoload 'LinkTo',      'nanoc/helpers/link_to'

data/lib/nanoc/helpers/capturing.rb

@@ -25,40 +25,6 @@ module Nanoc::Helpers
   #     <%= content_for(@item, :summary) || '(no summary)' %>
   #   </div>
   module Capturing
-    # @api private
-    class CapturesStore
-      def initialize
-        @store = {}
-      end
-
-      def []=(item, name, content)
-        @store[item.identifier] ||= {}
-        @store[item.identifier][name] = content
-      end
-
-      def [](item, name)
-        @store[item.identifier] ||= {}
-        @store[item.identifier][name]
-      end
-
-      def reset_for(item)
-        @store[item.identifier] = {}
-      end
-    end
-
-    class ::Nanoc::Int::Site
-      # @api private
-      def captures_store
-        @captures_store ||= CapturesStore.new
-      end
-
-      # @api private
-      def captures_store_compiled_items
-        require 'set'
-        @captures_store_compiled_items ||= Set.new
-      end
-    end
-
     # @overload content_for(name, params = {}, &block)
     #
     #   Captures the content inside the block and stores it so that it can be
@@ -114,17 +80,19 @@ module Nanoc::Helpers
         content = capture(&block)
 
         # Prepare for store
-        store = @site.unwrap.captures_store
+        snapshot_contents = @item.reps[:default].unwrap.snapshot_contents
+        capture_name = "__capture_#{name}".to_sym
         case existing_behavior
         when :overwrite
-          store[@item, name.to_sym] = ''
+          snapshot_contents[capture_name] = ''
         when :append
-          store[@item, name.to_sym] ||= ''
+          snapshot_contents[capture_name] ||= ''
         when :error
-          if store[@item, name.to_sym] && store[@item, name.to_sym] != content
+          if snapshot_contents[capture_name] && snapshot_contents[capture_name] != content
+            # FIXME: get proper exception
             raise "a capture named #{name.inspect} for #{@item.identifier} already exists"
           else
-            store[@item, name.to_sym] = ''
+            snapshot_contents[capture_name] = ''
           end
         else
           raise ArgumentError, 'expected :existing_behavior param to #content_for to be one of ' \
@@ -132,38 +100,28 @@ module Nanoc::Helpers
         end
 
         # Store
-        @site.unwrap.captures_store_compiled_items << @item.unwrap
-        store[@item, name.to_sym] << content
+        snapshot_contents[capture_name] << content
       else # Get content
-        # Get args
         if args.size != 2
           raise ArgumentError, 'expected 2 arguments (the item ' \
             "and the name of the capture) but got #{args.size} instead"
         end
-        item = args[0].is_a?(Nanoc::ItemWithRepsView) ? args[0].unwrap : args[0]
+        item = args[0]
         name = args[1]
 
+        rep = item.reps[:default].unwrap
+
         # Create dependency
         if @item.nil? || item != @item.unwrap
-          Nanoc::Int::NotificationCenter.post(:visit_started, item)
-          Nanoc::Int::NotificationCenter.post(:visit_ended,   item)
+          dependency_tracker = @config._context.dependency_tracker
+          dependency_tracker.bounce(item.unwrap)
 
-          # This is an extremely ugly hack to get the compiler to recompile the
-          # item from which we use content. For this, we need to manually edit
-          # the content attribute to reset it. :(
-          # FIXME: clean this up
-          unless @site.unwrap.captures_store_compiled_items.include?(item)
-            @site.unwrap.captures_store.reset_for(item)
-            item.forced_outdated = true
-            @site.unwrap.compiler.reps[item].each do |r|
-              r.snapshot_contents = { last: item.content }
-              raise Nanoc::Int::Errors::UnmetDependency.new(r)
-            end
+          unless rep.compiled?
+            raise Nanoc::Int::Errors::UnmetDependency.new(rep)
           end
         end
 
-        # Get content
-        @site.unwrap.captures_store[item, name.to_sym]
+        rep.snapshot_contents["__capture_#{name}".to_sym]
       end
     end
 

data/lib/nanoc/helpers/child_parent.rb

@@ -0,0 +1,51 @@
+module Nanoc::Helpers
+  # Provides functionality for fetching the children and the parent of a given
+  # item. This works for both full identifiers and legacy identifiers.
+  module ChildParent
+    # Returns the parent of the given item.
+    #
+    # For items with legacy identifiers, the parent is the item where the
+    # identifier contains one less component than the identifier of the given
+    # item. For # example, the parent of the “/projects/nanoc/” item is the
+    # “/projects/” item.
+    #
+    # For items with full identifiers, the parent is the item where the
+    # identifier contains one less component than the identifier of the given
+    # item, and ends with any extension. For example, the parent of the
+    # “/projects/nanoc.md” item could be the “/projects.md” item, or the
+    # “/projects.html” item, etc. Note that the parent is ambiguous for items
+    # that have a full identifier; only the first candidate parent item will be
+    # returned.
+    def parent_of(item)
+      if item.identifier.legacy?
+        item.parent
+      else
+        path_without_last_component = item.identifier.to_s.sub(/[^\/]+$/, '').chop
+        @items[path_without_last_component + '.*']
+      end
+    end
+
+    # Returns the children of the given item.
+    #
+    # For items with legacy identifiers, the children are the items where the
+    # identifier contains one more component than the identifier of the given
+    # item. For example, the children of the “/projects/” item could be
+    # “/projects/nanoc/” and “/projects/cri/”, but not “/about/” nor
+    # “/projects/nanoc/history/”.
+    #
+    # For items with full identifiers, the children are the item where the
+    # identifier starts with the identifier of the given item, minus the
+    # extension, followed by a slash. For example, the children of the
+    # “/projects.md” item could be the “/projects/nanoc.md” and
+    # “/projects/cri.adoc” items , but not “/about.md” nor
+    # “/projects/nanoc/history.md”.
+    def children_of(item)
+      if item.identifier.legacy?
+        item.children
+      else
+        pattern = item.identifier.without_ext + '/*'
+        @items.find_all(pattern)
+      end
+    end
+  end
+end

data/lib/nanoc/helpers/filtering.rb

@@ -40,7 +40,6 @@ module Nanoc::Helpers
         items: @items,
         layouts: @layouts,
         config: @config,
-        site: @site,
         content: @content,
       }
       filter = klass.new(assigns)

data/lib/nanoc/helpers/html_escape.rb

@@ -34,6 +34,11 @@ module Nanoc::Helpers
         buffer = eval('_erbout', block.binding)
         buffer << escaped_data
       elsif string
+        unless string.is_a? String
+          raise ArgumentError, 'The #html_escape or #h function needs either a ' \
+            "string or a block to HTML-escape, but #{string.class} was given"
+        end
+
         string
           .gsub('&', '&amp;')
           .gsub('<', '&lt;')

data/lib/nanoc/helpers/link_to.rb

@@ -122,6 +122,7 @@ module Nanoc::Helpers
       else
         path = target.path
         if path.nil?
+          # TODO: get proper error
           raise "Cannot get the relative path to #{target.inspect} because this target is not outputted (its routing rule returns nil)"
         end
       end
@@ -134,6 +135,7 @@ module Nanoc::Helpers
       # Get source and destination paths
       dst_path = Pathname.new(path)
       if @item_rep.path.nil?
+        # TODO: get proper error
         raise "Cannot get the relative path to #{path} because the current item representation, #{@item_rep.inspect}, is not outputted (its routing rule returns nil)"
       end
       src_path = Pathname.new(@item_rep.path)

data/lib/nanoc/helpers/rendering.rb

@@ -80,8 +80,8 @@ module Nanoc::Helpers
       raise Nanoc::Int::Errors::UnknownLayout.new(identifier) if layout.nil?
 
       # Visit
-      Nanoc::Int::NotificationCenter.post(:visit_started, layout)
-      Nanoc::Int::NotificationCenter.post(:visit_ended,   layout)
+      dependency_tracker = @config._context.dependency_tracker
+      dependency_tracker.bounce(layout)
 
       # Capture content, if any
       captured_content = block_given? ? capture(&block) : nil
@@ -95,11 +95,10 @@ module Nanoc::Helpers
         layout: layout,
         layouts: @layouts,
         config: @config,
-        site: @site,
       }.merge(other_assigns)
 
       # Get filter name
-      filter_name, filter_args = *@site.unwrap.compiler.filter_name_and_args_for_layout(layout)
+      filter_name, filter_args = *@config._context.compiler.filter_name_and_args_for_layout(layout)
       raise Nanoc::Int::Errors::CannotDetermineFilter.new(layout.identifier) if filter_name.nil?
 
       # Get filter class

data/lib/nanoc/rule_dsl/action_provider.rb

@@ -48,7 +48,14 @@ module Nanoc::RuleDSL
     end
 
     def postprocess(site, reps)
-      view_context = Nanoc::ViewContext.new(reps: reps, items: site.items)
+      dependency_tracker = Nanoc::Int::DependencyTracker::Null.new
+      view_context =
+        Nanoc::ViewContext.new(
+          reps: reps,
+          items: site.items,
+          dependency_tracker: dependency_tracker,
+          compiler: site.compiler,
+        )
       ctx = new_postprocessor_context(site, view_context)
 
       @rules_collection.postprocessors.each_value do |postprocessor|
@@ -58,10 +65,19 @@ module Nanoc::RuleDSL
 
     # @api private
     def new_preprocessor_context(site)
+      dependency_tracker = Nanoc::Int::DependencyTracker::Null.new
+      view_context =
+        Nanoc::ViewContext.new(
+          reps: nil,
+          items: nil,
+          dependency_tracker: dependency_tracker,
+          compiler: nil,
+        )
+
       Nanoc::Int::Context.new(
-        config: Nanoc::MutableConfigView.new(site.config, nil),
-        items: Nanoc::MutableItemCollectionView.new(site.items, nil),
-        layouts: Nanoc::MutableLayoutCollectionView.new(site.layouts, nil),
+        config: Nanoc::MutableConfigView.new(site.config, view_context),
+        items: Nanoc::MutableItemCollectionView.new(site.items, view_context),
+        layouts: Nanoc::MutableLayoutCollectionView.new(site.layouts, view_context),
       )
     end
 

data/lib/nanoc/rule_dsl/recording_executor.rb

@@ -39,7 +39,9 @@ module Nanoc
         routing_rule = routing_rules[snapshot_name]
         return nil if routing_rule.nil?
 
-        basic_path = routing_rule.apply_to(rep, executor: nil, site: @site, view_context: nil)
+        dependency_tracker = Nanoc::Int::DependencyTracker::Null.new
+        view_context = Nanoc::ViewContext.new(reps: nil, items: nil, dependency_tracker: dependency_tracker, compiler: nil)
+        basic_path = routing_rule.apply_to(rep, executor: nil, site: @site, view_context: view_context)
         if basic_path && !basic_path.start_with?('/')
           raise PathWithoutInitialSlashError.new(rep, basic_path)
         end

data/lib/nanoc/rule_dsl/rule_context.rb

@@ -19,7 +19,6 @@ module Nanoc::RuleDSL
         items: Nanoc::ItemCollectionWithoutRepsView.new(site.items, view_context),
         layouts: Nanoc::LayoutCollectionView.new(site.layouts, view_context),
         config: Nanoc::ConfigView.new(site.config, view_context),
-        site: Nanoc::SiteView.new(site, view_context),
       })
     end
 

data/lib/nanoc/rule_dsl/rule_memory_calculator.rb

@@ -59,12 +59,15 @@ module Nanoc::RuleDSL
     def new_rule_memory_for_rep(rep)
       # FIXME: What if #compilation_rule_for returns nil?
 
+      dependency_tracker = Nanoc::Int::DependencyTracker::Null.new
+      view_context = @site.compiler.create_view_context(dependency_tracker)
+
       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)
-      rule.apply_to(rep, executor: executor, site: @site, view_context: nil)
+      rule.apply_to(rep, executor: executor, site: @site, view_context: view_context)
       if executor.rule_memory.any_layouts?
         executor.snapshot(rep, :post)
       end

data/lib/nanoc/spec.rb

@@ -0,0 +1,217 @@
+module Nanoc
+  # @api private
+  module Spec
+    class HelperContext
+      # @return [Nanoc::Int::DependencyTracker]
+      attr_reader :dependency_tracker
+
+      attr_reader :erbout
+
+      # @param [Module] mod The helper module to create a context for
+      def initialize(mod)
+        @mod = mod
+
+        @erbout = ''
+        @rule_memory = {}
+        @config = Nanoc::Int::Configuration.new.with_defaults
+        @reps = Nanoc::Int::ItemRepRepo.new
+        @items = Nanoc::Int::IdentifiableCollection.new(@config)
+        @layouts = Nanoc::Int::IdentifiableCollection.new(@config)
+        @dependency_tracker = Nanoc::Int::DependencyTracker.new(Object.new)
+      end
+
+      # Creates a new item and adds it to the site’s collection of items.
+      #
+      # @param [String] content The uncompiled item content
+      #
+      # @param [Hash] attributes A hash containing this item's attributes
+      #
+      # @param [Nanoc::Identifier, String] identifier This item's identifier
+      #
+      # @return [Nanoc::ItemWithRepsView] A view for the newly created item
+      def create_item(content, attributes, identifier)
+        item = Nanoc::Int::Item.new(content, attributes, identifier)
+        @items << item
+        Nanoc::ItemWithRepsView.new(item, view_context)
+      end
+
+      # TODO: document
+      def create_layout(content, attributes, identifier)
+        layout = Nanoc::Int::Layout.new(content, attributes, identifier)
+        @layouts << layout
+        Nanoc::LayoutView.new(layout, view_context)
+      end
+
+      # Creates a new representation for the given item.
+      #
+      # @param [Nanoc::ItemWithRepsView] item The item to create a represetation for
+      #
+      # @param [String] path The path of the `:last` snapshot of this item representation
+      def create_rep(item, path)
+        rep = Nanoc::Int::ItemRep.new(item.unwrap, :default)
+        rep.paths[:last] = path
+        @reps << rep
+        Nanoc::ItemRepView.new(rep, view_context)
+      end
+
+      # @return [Object] An object that includes the helper functions
+      def helper
+        mod = @mod
+        klass = Class.new(Nanoc::Int::Context) { include mod }
+        klass.new(assigns)
+      end
+
+      def item=(item)
+        @item = item ? item.unwrap : nil
+      end
+
+      def item_rep=(item_rep)
+        @item_rep = item_rep ? item_rep.unwrap : nil
+      end
+
+      # @return [Nanoc::MutableConfigView]
+      def config
+        assigns[:config]
+      end
+
+      # @return [Nanoc::ItemWithRepsView, nil]
+      def item
+        assigns[:item]
+      end
+
+      # @return [Nanoc::ItemRepView, nil]
+      def item_rep
+        assigns[:item_rep]
+      end
+
+      # @return [Nanoc::ItemCollectionWithRepsView]
+      def items
+        assigns[:items]
+      end
+
+      # @return [Nanoc::LayoutCollectionView]
+      def layouts
+        assigns[:layouts]
+      end
+
+      def rule_memory_for(obj)
+        @rule_memory.fetch(obj, [])
+      end
+
+      def update_rule_memory(obj, memory)
+        @rule_memory[obj] = memory
+      end
+
+      private
+
+      def view_context
+        Nanoc::ViewContext.new(
+          reps: @reps,
+          items: @items,
+          dependency_tracker: @dependency_tracker,
+          compiler: new_site.compiler,
+        )
+      end
+
+      def new_action_provider
+        Class.new(Nanoc::Int::ActionProvider) do
+          def self.for(_context)
+            raise NotImplementedError
+          end
+
+          def initialize(context)
+            @context = context
+          end
+
+          def rep_names_for(_item)
+            [:default]
+          end
+
+          def memory_for(obj)
+            @context.rule_memory_for(obj)
+          end
+
+          def snapshots_defs_for(_rep)
+            [Nanoc::Int::SnapshotDef.new(:last, false)]
+          end
+        end.new(self)
+      end
+
+      def new_compiler_for(site)
+        rule_memory_store = Nanoc::Int::RuleMemoryStore.new
+
+        dependency_store =
+          Nanoc::Int::DependencyStore.new(site.items.to_a + site.layouts.to_a)
+
+        checksum_store =
+          Nanoc::Int::ChecksumStore.new(site: site)
+
+        item_rep_repo = Nanoc::Int::ItemRepRepo.new
+
+        action_provider = new_action_provider
+
+        outdatedness_checker =
+          Nanoc::Int::OutdatednessChecker.new(
+            site: site,
+            checksum_store: checksum_store,
+            dependency_store: dependency_store,
+            rule_memory_store: rule_memory_store,
+            action_provider: action_provider,
+            reps: item_rep_repo,
+          )
+
+        params = {
+          compiled_content_cache: Nanoc::Int::CompiledContentCache.new,
+          checksum_store: checksum_store,
+          rule_memory_store: rule_memory_store,
+          dependency_store: dependency_store,
+          outdatedness_checker: outdatedness_checker,
+          reps: item_rep_repo,
+          action_provider: action_provider,
+        }
+
+        Nanoc::Int::Compiler.new(site, params)
+      end
+
+      def new_site
+        site = Nanoc::Int::Site.new(
+          config: @config,
+          code_snippets: [],
+          items: @items,
+          layouts: @layouts,
+        )
+        site.compiler = new_compiler_for(site)
+        site
+      end
+
+      def assigns
+        site = Nanoc::Int::Site.new(
+          config: @config,
+          code_snippets: [],
+          items: @items,
+          layouts: @layouts,
+        )
+        site.compiler = new_compiler_for(site)
+
+        {
+          config: Nanoc::MutableConfigView.new(@config, view_context),
+          item_rep: @item_rep ? Nanoc::ItemRepView.new(@item_rep, view_context) : nil,
+          item: @item ? Nanoc::ItemWithRepsView.new(@item, view_context) : nil,
+          items: Nanoc::ItemCollectionWithRepsView.new(@items, view_context),
+          layouts: Nanoc::LayoutCollectionView.new(@layouts, view_context),
+          _erbout: @erbout,
+        }
+      end
+    end
+
+    module HelperHelper
+      def ctx
+        @_ctx ||= HelperContext.new(described_class)
+      end
+
+      def helper
+        @_helper ||= ctx.helper
+      end
+    end
+  end
+end