nanoc 4.11.0 → 4.11.1

data/lib/nanoc/base/repos.rb

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
+# Re-exported from Nanoc::Core
+Nanoc::DataSource = Nanoc::Core::DataSource
+
 require_relative 'repos/store'
 
 require_relative 'repos/checksum_store'
 require_relative 'repos/compiled_content_cache'
 require_relative 'repos/config_loader'
-require_relative 'repos/data_source'
 require_relative 'repos/dependency_store'
 require_relative 'repos/item_rep_repo'
 require_relative 'repos/outdatedness_store'
 require_relative 'repos/action_sequence_store'
 require_relative 'repos/site_loader'
-require_relative 'repos/snapshot_repo'
+require_relative 'repos/compiled_content_store'
 require_relative 'repos/in_mem_data_source'
 require_relative 'repos/aggregate_data_source'
 require_relative 'repos/prefixed_data_source'

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

@@ -1,48 +1,50 @@
 # frozen_string_literal: true
 
-module Nanoc::Int
-  # Stores action sequences for objects that can be run through a rule (item
-  # representations and layouts).
-  #
-  # @api private
-  class ActionSequenceStore < ::Nanoc::Int::Store
-    include Nanoc::Int::ContractsSupport
-
-    contract C::KeywordArgs[config: Nanoc::Int::Configuration] => C::Any
-    def initialize(config:)
-      super(Nanoc::Int::Store.tmp_path_for(config: config, store_name: 'rule_memory'), 1)
-
-      @action_sequences = {}
-    end
-
-    # @param [Nanoc::Int::ItemRep, Nanoc::Int::Layout] obj The item representation or
-    #   the layout to get the action sequence for
-    #
-    # @return [Array] The action sequence for the given object
-    def [](obj)
-      @action_sequences[obj.reference]
-    end
-
-    # @param [Nanoc::Int::ItemRep, Nanoc::Int::Layout] obj The item representation or
-    #   the layout to set the action sequence for
-    #
-    # @param [Array] action_sequence The new action sequence to be stored
+module Nanoc
+  module Int
+    # Stores action sequences for objects that can be run through a rule (item
+    # representations and layouts).
     #
-    # @return [void]
-    def []=(obj, action_sequence)
-      @action_sequences[obj.reference] = action_sequence
-    end
-
-    protected
-
-    # @see Nanoc::Int::Store#data
-    def data
-      @action_sequences
-    end
-
-    # @see Nanoc::Int::Store#data=
-    def data=(new_data)
-      @action_sequences = new_data
+    # @api private
+    class ActionSequenceStore < ::Nanoc::Int::Store
+      include Nanoc::Core::ContractsSupport
+
+      contract C::KeywordArgs[config: Nanoc::Core::Configuration] => C::Any
+      def initialize(config:)
+        super(Nanoc::Int::Store.tmp_path_for(config: config, store_name: 'rule_memory'), 1)
+
+        @action_sequences = {}
+      end
+
+      # @param [Nanoc::Core::ItemRep, Nanoc::Core::Layout] obj The item representation or
+      #   the layout to get the action sequence for
+      #
+      # @return [Array] The action sequence for the given object
+      def [](obj)
+        @action_sequences[obj.reference]
+      end
+
+      # @param [Nanoc::Core::ItemRep, Nanoc::Core::Layout] obj The item representation or
+      #   the layout to set the action sequence for
+      #
+      # @param [Array] action_sequence The new action sequence to be stored
+      #
+      # @return [void]
+      def []=(obj, action_sequence)
+        @action_sequences[obj.reference] = action_sequence
+      end
+
+      protected
+
+      # @see Nanoc::Int::Store#data
+      def data
+        @action_sequences
+      end
+
+      # @see Nanoc::Int::Store#data=
+      def data=(new_data)
+        @action_sequences = new_data
+      end
     end
   end
 end

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

@@ -1,34 +1,36 @@
 # frozen_string_literal: true
 
-module Nanoc::Int
-  class AggregateDataSource < Nanoc::DataSource
-    def initialize(data_sources, config)
-      super({}, '/', '/', {})
+module Nanoc
+  module Int
+    class AggregateDataSource < Nanoc::DataSource
+      def initialize(data_sources, config)
+        super({}, '/', '/', {})
 
-      @data_sources = data_sources
-      @config = config
-    end
+        @data_sources = data_sources
+        @config = config
+      end
 
-    def items
-      @_items ||= begin
-        objs = @data_sources.flat_map(&:items)
-        Nanoc::Int::ItemCollection.new(@config, objs)
+      def items
+        @_items ||= begin
+          objs = @data_sources.flat_map(&:items)
+          Nanoc::Core::ItemCollection.new(@config, objs)
+        end
       end
-    end
 
-    def layouts
-      @_layouts ||= begin
-        objs = @data_sources.flat_map(&:layouts)
-        Nanoc::Int::LayoutCollection.new(@config, objs)
+      def layouts
+        @_layouts ||= begin
+          objs = @data_sources.flat_map(&:layouts)
+          Nanoc::Core::LayoutCollection.new(@config, objs)
+        end
       end
-    end
 
-    def item_changes
-      SlowEnumeratorTools.merge(@data_sources.map(&:item_changes))
-    end
+      def item_changes
+        SlowEnumeratorTools.merge(@data_sources.map(&:item_changes))
+      end
 
-    def layout_changes
-      SlowEnumeratorTools.merge(@data_sources.map(&:layout_changes))
+      def layout_changes
+        SlowEnumeratorTools.merge(@data_sources.map(&:layout_changes))
+      end
     end
   end
 end

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

@@ -1,70 +1,72 @@
 # frozen_string_literal: true
 
-module Nanoc::Int
-  # Stores checksums for objects in order to be able to detect whether a file
-  # has changed since the last site compilation.
-  #
-  # @api private
-  class ChecksumStore < ::Nanoc::Int::Store
-    include Nanoc::Int::ContractsSupport
+module Nanoc
+  module Int
+    # Stores checksums for objects in order to be able to detect whether a file
+    # has changed since the last site compilation.
+    #
+    # @api private
+    class ChecksumStore < ::Nanoc::Int::Store
+      include Nanoc::Core::ContractsSupport
 
-    attr_writer :checksums
-    attr_accessor :objects
+      attr_writer :checksums
+      attr_accessor :objects
 
-    c_obj = C::Or[Nanoc::Int::Item, Nanoc::Int::Layout, Nanoc::Int::Configuration, Nanoc::Int::CodeSnippet]
+      c_obj = C::Or[Nanoc::Core::Item, Nanoc::Core::Layout, Nanoc::Core::Configuration, Nanoc::Core::CodeSnippet]
 
-    contract C::KeywordArgs[config: Nanoc::Int::Configuration, objects: C::IterOf[c_obj]] => C::Any
-    def initialize(config:, objects:)
-      super(Nanoc::Int::Store.tmp_path_for(config: config, store_name: 'checksums'), 2)
+      contract C::KeywordArgs[config: Nanoc::Core::Configuration, objects: C::IterOf[c_obj]] => C::Any
+      def initialize(config:, objects:)
+        super(Nanoc::Int::Store.tmp_path_for(config: config, store_name: 'checksums'), 2)
 
-      @objects = objects
+        @objects = objects
 
-      @checksums = {}
-    end
-
-    contract c_obj => C::Maybe[String]
-    def [](obj)
-      @checksums[obj.reference]
-    end
-
-    contract c_obj => self
-    def add(obj)
-      if obj.is_a?(Nanoc::Int::Document)
-        @checksums[[obj.reference, :content]] = Nanoc::Int::Checksummer.calc_for_content_of(obj)
+        @checksums = {}
       end
 
-      if obj.is_a?(Nanoc::Int::Document) || obj.is_a?(Nanoc::Int::Configuration)
-        @checksums[[obj.reference, :each_attribute]] = Nanoc::Int::Checksummer.calc_for_each_attribute_of(obj)
+      contract c_obj => C::Maybe[String]
+      def [](obj)
+        @checksums[obj.reference]
       end
 
-      @checksums[obj.reference] = Nanoc::Int::Checksummer.calc(obj)
+      contract c_obj => self
+      def add(obj)
+        if obj.is_a?(Nanoc::Core::Document)
+          @checksums[[obj.reference, :content]] = Nanoc::Core::Checksummer.calc_for_content_of(obj)
+        end
 
-      self
-    end
+        if obj.is_a?(Nanoc::Core::Document) || obj.is_a?(Nanoc::Core::Configuration)
+          @checksums[[obj.reference, :each_attribute]] = Nanoc::Core::Checksummer.calc_for_each_attribute_of(obj)
+        end
 
-    contract c_obj => C::Maybe[String]
-    def content_checksum_for(obj)
-      @checksums[[obj.reference, :content]]
-    end
+        @checksums[obj.reference] = Nanoc::Core::Checksummer.calc(obj)
 
-    contract c_obj => C::Maybe[C::HashOf[Symbol, String]]
-    def attributes_checksum_for(obj)
-      @checksums[[obj.reference, :each_attribute]]
-    end
+        self
+      end
 
-    protected
+      contract c_obj => C::Maybe[String]
+      def content_checksum_for(obj)
+        @checksums[[obj.reference, :content]]
+      end
 
-    def data
-      @checksums
-    end
+      contract c_obj => C::Maybe[C::HashOf[Symbol, String]]
+      def attributes_checksum_for(obj)
+        @checksums[[obj.reference, :each_attribute]]
+      end
+
+      protected
+
+      def data
+        @checksums
+      end
 
-    def data=(new_data)
-      references = Set.new(@objects.map(&:reference))
+      def data=(new_data)
+        references = Set.new(@objects.map(&:reference))
 
-      @checksums = {}
-      new_data.each_pair do |key, checksum|
-        if references.include?(key) || references.include?(key.first)
-          @checksums[key] = checksum
+        @checksums = {}
+        new_data.each_pair do |key, checksum|
+          if references.include?(key) || references.include?(key.first)
+            @checksums[key] = checksum
+          end
         end
       end
     end

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

@@ -1,59 +1,61 @@
 # frozen_string_literal: true
 
-module Nanoc::Int
-  # Represents a cache than can be used to store already compiled content,
-  # to prevent it from being needlessly recompiled.
-  #
-  # @api private
-  class CompiledContentCache < ::Nanoc::Int::Store
-    include Nanoc::Int::ContractsSupport
-
-    contract C::KeywordArgs[config: Nanoc::Int::Configuration] => C::Any
-    def initialize(config:)
-      super(Nanoc::Int::Store.tmp_path_for(config: config, store_name: 'compiled_content'), 2)
-
-      @cache = {}
-    end
-
-    contract Nanoc::Int::ItemRep => C::Maybe[C::HashOf[Symbol => Nanoc::Int::Content]]
-    # Returns the cached compiled content for the given item representation.
+module Nanoc
+  module Int
+    # Represents a cache than can be used to store already compiled content,
+    # to prevent it from being needlessly recompiled.
     #
-    # This cached compiled content is a hash where the keys are the snapshot
-    # names. and the values the compiled content at the given snapshot.
-    def [](rep)
-      item_cache = @cache[rep.item.identifier] || {}
-      item_cache[rep.name]
-    end
+    # @api private
+    class CompiledContentCache < ::Nanoc::Int::Store
+      include Nanoc::Core::ContractsSupport
 
-    contract Nanoc::Int::ItemRep, C::HashOf[Symbol => Nanoc::Int::Content] => C::HashOf[Symbol => Nanoc::Int::Content]
-    # Sets the compiled content for the given representation.
-    #
-    # This cached compiled content is a hash where the keys are the snapshot
-    # names. and the values the compiled content at the given snapshot.
-    def []=(rep, content)
-      @cache[rep.item.identifier] ||= {}
-      @cache[rep.item.identifier][rep.name] = content
-    end
+      contract C::KeywordArgs[config: Nanoc::Core::Configuration] => C::Any
+      def initialize(config:)
+        super(Nanoc::Int::Store.tmp_path_for(config: config, store_name: 'compiled_content'), 2)
 
-    def prune(items:)
-      item_identifiers = Set.new(items.map(&:identifier))
+        @cache = {}
+      end
 
-      @cache.keys.each do |key|
-        @cache.delete(key) unless item_identifiers.include?(key)
+      contract Nanoc::Core::ItemRep => C::Maybe[C::HashOf[Symbol => Nanoc::Core::Content]]
+      # Returns the cached compiled content for the given item representation.
+      #
+      # This cached compiled content is a hash where the keys are the snapshot
+      # names. and the values the compiled content at the given snapshot.
+      def [](rep)
+        item_cache = @cache[rep.item.identifier] || {}
+        item_cache[rep.name]
       end
-    end
 
-    protected
+      contract Nanoc::Core::ItemRep, C::HashOf[Symbol => Nanoc::Core::Content] => C::HashOf[Symbol => Nanoc::Core::Content]
+      # Sets the compiled content for the given representation.
+      #
+      # This cached compiled content is a hash where the keys are the snapshot
+      # names. and the values the compiled content at the given snapshot.
+      def []=(rep, content)
+        @cache[rep.item.identifier] ||= {}
+        @cache[rep.item.identifier][rep.name] = content
+      end
 
-    def data
-      @cache
-    end
+      def prune(items:)
+        item_identifiers = Set.new(items.map(&:identifier))
+
+        @cache.keys.each do |key|
+          @cache.delete(key) unless item_identifiers.include?(key)
+        end
+      end
+
+      protected
+
+      def data
+        @cache
+      end
 
-    def data=(new_data)
-      @cache = {}
+      def data=(new_data)
+        @cache = {}
 
-      new_data.each_pair do |item_identifier, content_per_rep|
-        @cache[item_identifier] ||= content_per_rep
+        new_data.each_pair do |item_identifier, content_per_rep|
+          @cache[item_identifier] ||= content_per_rep
+        end
       end
     end
   end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Int
+    # @api private
+    class CompiledContentStore
+      include Nanoc::Core::ContractsSupport
+
+      def initialize
+        @contents = Hash.new { |hash, rep| hash[rep] = {} }
+        @current_content = {}
+      end
+
+      contract Nanoc::Core::ItemRep, Symbol => C::Maybe[Nanoc::Core::Content]
+      def get(rep, snapshot_name)
+        @contents[rep][snapshot_name]
+      end
+
+      contract Nanoc::Core::ItemRep => C::Maybe[Nanoc::Core::Content]
+      def get_current(rep)
+        @current_content[rep]
+      end
+
+      contract Nanoc::Core::ItemRep, Symbol, Nanoc::Core::Content => C::Any
+      def set(rep, snapshot_name, contents)
+        @contents[rep][snapshot_name] = contents
+      end
+
+      contract Nanoc::Core::ItemRep, Nanoc::Core::Content => C::Any
+      def set_current(rep, content)
+        @current_content[rep] = content
+      end
+
+      contract Nanoc::Core::ItemRep => C::HashOf[Symbol => Nanoc::Core::Content]
+      def get_all(rep)
+        @contents[rep]
+      end
+
+      contract Nanoc::Core::ItemRep, C::HashOf[Symbol => Nanoc::Core::Content] => C::Any
+      def set_all(rep, contents_per_snapshot)
+        @contents[rep] = contents_per_snapshot
+      end
+
+      contract C::KeywordArgs[rep: Nanoc::Core::ItemRep, snapshot: C::Optional[C::Maybe[Symbol]]] => Nanoc::Core::Content
+      def raw_compiled_content(rep:, snapshot: nil)
+        # Get name of last pre-layout snapshot
+        snapshot_name = snapshot || (get(rep, :pre) ? :pre : :last)
+
+        # Check existance of snapshot
+        snapshot_def = rep.snapshot_defs.reverse.find { |sd| sd.name == snapshot_name }
+        unless snapshot_def
+          raise Nanoc::Int::Errors::NoSuchSnapshot.new(rep, snapshot_name)
+        end
+
+        # Return content if it is available
+        content = get(rep, snapshot_name)
+        return content if content
+
+        # Content is unavailable; notify and try again
+        Fiber.yield(Nanoc::Int::Errors::UnmetDependency.new(rep, snapshot_name))
+        get(rep, snapshot_name)
+      end
+
+      contract C::KeywordArgs[rep: Nanoc::Core::ItemRep, snapshot: C::Optional[C::Maybe[Symbol]]] => String
+      def compiled_content(rep:, snapshot: nil)
+        snapshot_content = raw_compiled_content(rep: rep, snapshot: snapshot)
+
+        if snapshot_content.binary?
+          raise Nanoc::Int::Errors::CannotGetCompiledContentOfBinaryItem.new(rep)
+        end
+
+        snapshot_content.string
+      end
+    end
+  end
+end