nanoc-core 4.11.12 → 4.11.13

data/lib/nanoc/core/item_collection_with_reps_view.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class ItemCollectionWithRepsView < ::Nanoc::Core::IdentifiableCollectionView
+      # @api private
+      def view_class
+        Nanoc::Core::CompilationItemView
+      end
+    end
+  end
+end

data/lib/nanoc/core/item_collection_without_reps_view.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class ItemCollectionWithoutRepsView < ::Nanoc::Core::IdentifiableCollectionView
+      # @api private
+      def view_class
+        Nanoc::Core::BasicItemView
+      end
+    end
+  end
+end

data/lib/nanoc/core/item_rep_builder.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # @api private
+    class ItemRepBuilder
+      include Nanoc::Core::ContractsSupport
+
+      attr_reader :reps
+
+      contract Nanoc::Core::Site, Nanoc::Core::ActionProvider, Nanoc::Core::ItemRepRepo => C::Any
+      def initialize(site, action_provider, reps)
+        @site = site
+        @action_provider = action_provider
+        @reps = reps
+      end
+
+      def run
+        @site.items.each do |item|
+          @action_provider.rep_names_for(item).each do |rep_name|
+            @reps << Nanoc::Core::ItemRep.new(item, rep_name)
+          end
+        end
+
+        action_sequences = Nanoc::Core::ItemRepRouter.new(@reps, @action_provider, @site).run
+
+        @reps.each do |rep|
+          rep.snapshot_defs = self.class.snapshot_defs_for(action_sequences[rep])
+        end
+
+        action_sequences
+      end
+
+      contract Nanoc::Core::ActionSequence => C::ArrayOf[Nanoc::Core::SnapshotDef]
+      def self.snapshot_defs_for(action_sequence)
+        is_binary = action_sequence.item_rep.item.content.binary?
+        snapshot_defs = []
+
+        action_sequence.each do |action|
+          case action
+          when Nanoc::Core::ProcessingActions::Snapshot
+            action.snapshot_names.each do |snapshot_name|
+              snapshot_defs << Nanoc::Core::SnapshotDef.new(snapshot_name, binary: is_binary)
+            end
+          when Nanoc::Core::ProcessingActions::Filter
+            is_binary = Nanoc::Core::Filter.named!(action.filter_name).to_binary?
+          end
+        end
+
+        snapshot_defs
+      end
+    end
+  end
+end

data/lib/nanoc/core/item_rep_selector.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Yields item reps to compile.
+    class ItemRepSelector
+      def initialize(reps)
+        @reps = reps
+      end
+
+      class MicroGraph
+        def initialize(reps)
+          @reps = Set.new(reps)
+          @stack = []
+        end
+
+        def next
+          if @stack.any?
+            @stack.last
+          elsif @reps.any?
+            @reps.each { |rep| break rep }.tap do |rep|
+              @reps.delete(rep)
+              @stack.push(rep)
+            end
+          else
+            nil
+          end
+        end
+
+        def mark_ok
+          @stack.pop
+        end
+
+        def mark_failed(dep)
+          if @stack.include?(dep)
+            raise Nanoc::Core::Errors::DependencyCycle.new(@stack + [dep])
+          end
+
+          @reps.delete(dep)
+          @stack.push(dep)
+        end
+      end
+
+      def each
+        mg = MicroGraph.new(@reps)
+
+        loop do
+          rep = mg.next
+          break if rep.nil?
+
+          begin
+            yield(rep)
+            mg.mark_ok
+          rescue => e
+            actual_error = e.is_a?(Nanoc::Core::Errors::CompilationError) ? e.unwrap : e
+
+            if actual_error.is_a?(Nanoc::Core::Errors::UnmetDependency)
+              mg.mark_failed(actual_error.rep)
+            else
+              raise(e)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/item_rep_writer.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class ItemRepWriter
+      include Nanoc::Core::ContractsSupport
+      include Nanoc::Core::Assertions::Mixin
+
+      TMP_TEXT_ITEMS_DIR = 'text_items'
+
+      def write_all(item_rep, compiled_content_store)
+        written_paths = Set.new
+
+        item_rep.snapshot_defs.map(&:name).each do |snapshot_name|
+          write(item_rep, compiled_content_store, snapshot_name, written_paths)
+        end
+      end
+
+      def write(item_rep, compiled_content_store, snapshot_name, written_paths)
+        item_rep.raw_paths.fetch(snapshot_name, []).each do |raw_path|
+          write_single(item_rep, compiled_content_store, snapshot_name, raw_path, written_paths)
+        end
+      end
+
+      def write_single(item_rep, compiled_content_store, snapshot_name, raw_path, written_paths)
+        assert Nanoc::Core::Assertions::PathIsAbsolute.new(path: raw_path)
+
+        # Don’t write twice
+        # TODO: test written_paths behavior
+        return if written_paths.include?(raw_path)
+
+        written_paths << raw_path
+
+        # Create parent directory
+        FileUtils.mkdir_p(File.dirname(raw_path))
+
+        # Check if file will be created
+        is_created = !File.file?(raw_path)
+
+        # Notify
+        Nanoc::Core::NotificationCenter.post(
+          :rep_write_started, item_rep, raw_path
+        )
+
+        content = compiled_content_store.get(item_rep, snapshot_name)
+        if content.binary?
+          temp_path = content.filename
+        else
+          temp_path = temp_filename
+          File.write(temp_path, content.string)
+        end
+
+        # Check whether content was modified
+        is_modified = is_created || !FileUtils.identical?(raw_path, temp_path)
+
+        # Notify ready for diff generation
+        if !is_created && is_modified && !content.binary?
+          Nanoc::Core::NotificationCenter.post(
+            :rep_ready_for_diff, raw_path, File.read(raw_path, encoding: 'UTF-8'), content.string
+          )
+        end
+
+        # Write
+        if is_modified
+          begin
+            FileUtils.ln(temp_path, raw_path, force: true)
+          rescue Errno::EXDEV, Errno::EACCES
+            FileUtils.cp(temp_path, raw_path)
+          end
+        end
+
+        item_rep.modified = is_modified
+
+        # Notify
+        Nanoc::Core::NotificationCenter.post(
+          :rep_write_ended, item_rep, content.binary?, raw_path, is_created, is_modified
+        )
+      end
+
+      def temp_filename
+        Nanoc::Core::TempFilenameFactory.instance.create(TMP_TEXT_ITEMS_DIR)
+      end
+    end
+  end
+end

data/lib/nanoc/core/layout_collection_view.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class LayoutCollectionView < ::Nanoc::Core::IdentifiableCollectionView
+      # @api private
+      def view_class
+        Nanoc::Core::LayoutView
+      end
+    end
+  end
+end

data/lib/nanoc/core/layout_view.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class LayoutView < ::Nanoc::Core::View
+      include Nanoc::Core::DocumentViewMixin
+    end
+  end
+end

data/lib/nanoc/core/mutable_config_view.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class MutableConfigView < Nanoc::Core::ConfigView
+      # Sets the value for the given attribute.
+      #
+      # @param [Symbol] key
+      #
+      # @see Hash#[]=
+      def []=(key, value)
+        @config[key] = value
+      end
+    end
+  end
+end

data/lib/nanoc/core/mutable_document_view_mixin.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module MutableDocumentViewMixin
+      # @api private
+      class DisallowedAttributeValueError < Nanoc::Core::Error
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def message
+          "The #{value.class} cannot be stored inside an attribute. Store its identifier instead."
+        end
+      end
+
+      def raw_content=(arg)
+        _unwrap.content = Nanoc::Core::Content.create(arg)
+      end
+
+      # Sets the value for the given attribute.
+      #
+      # @param [Symbol] key
+      #
+      # @see Hash#[]=
+      def []=(key, value)
+        disallowed_value_classes = Set.new([
+          Nanoc::Core::Item,
+          Nanoc::Core::Layout,
+          Nanoc::Core::CompilationItemView,
+          Nanoc::Core::LayoutView,
+        ])
+        if disallowed_value_classes.include?(value.class)
+          raise DisallowedAttributeValueError.new(value)
+        end
+
+        _unwrap.set_attribute(key, value)
+      end
+
+      # Sets the identifier to the given argument.
+      #
+      # @param [String, Nanoc::Core::Identifier] arg
+      def identifier=(arg)
+        _unwrap.identifier = Nanoc::Core::Identifier.from(arg)
+      end
+
+      # Updates the attributes based on the given hash.
+      #
+      # @param [Hash] hash
+      #
+      # @return [self]
+      def update_attributes(hash)
+        hash.each { |k, v| _unwrap.set_attribute(k, v) }
+        self
+      end
+    end
+  end
+end

data/lib/nanoc/core/mutable_identifiable_collection_view.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class MutableIdentifiableCollectionView < Nanoc::Core::IdentifiableCollectionView
+      # Deletes every object for which the block evaluates to true.
+      #
+      # @yieldparam [#identifier] object
+      #
+      # @yieldreturn [Boolean]
+      #
+      # @return [self]
+      def delete_if(&_block)
+        @objects = @objects.reject { |o| yield(view_class.new(o, @context)) }
+        self
+      end
+    end
+  end
+end

data/lib/nanoc/core/mutable_item_collection_view.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class MutableItemCollectionView < Nanoc::Core::MutableIdentifiableCollectionView
+      # @api private
+      def view_class
+        Nanoc::Core::MutableItemView
+      end
+
+      # Creates a new item and adds it to the site’s collection of items.
+      #
+      # @param [String] content The uncompiled item content (if it is a textual
+      #   item) or the path to the filename containing the content (if it is a
+      #   binary item).
+      #
+      # @param [Hash] attributes A hash containing this item's attributes.
+      #
+      # @param [Nanoc::Core::Identifier, String] identifier This item's identifier.
+      #
+      # @param [Boolean] binary Whether or not this item is binary
+      #
+      # @param [String] filename Absolute path to the file
+      #   containing this content (if any)
+      #
+      # @return [self]
+      def create(content, attributes, identifier, binary: false, filename: nil)
+        content = Nanoc::Core::Content.create(content, binary: binary, filename: filename)
+        @objects = @objects.add(Nanoc::Core::Item.new(content, attributes, identifier))
+        self
+      end
+    end
+  end
+end

data/lib/nanoc/core/mutable_item_view.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class MutableItemView < Nanoc::Core::BasicItemView
+      include Nanoc::Core::MutableDocumentViewMixin
+    end
+  end
+end

data/lib/nanoc/core/mutable_layout_collection_view.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class MutableLayoutCollectionView < Nanoc::Core::MutableIdentifiableCollectionView
+      # @api private
+      def view_class
+        Nanoc::Core::MutableLayoutView
+      end
+
+      # Creates a new layout and adds it to the site’s collection of layouts.
+      #
+      # @param [String] content The layout content.
+      #
+      # @param [Hash] attributes A hash containing this layout's attributes.
+      #
+      # @param [Nanoc::Core::Identifier, String] identifier This layout's identifier.
+      #
+      # @return [self]
+      def create(content, attributes, identifier)
+        @objects = @objects.add(Nanoc::Core::Layout.new(content, attributes, identifier))
+        self
+      end
+    end
+  end
+end

data/lib/nanoc/core/mutable_layout_view.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class MutableLayoutView < Nanoc::Core::LayoutView
+      include Nanoc::Core::MutableDocumentViewMixin
+    end
+  end
+end

data/lib/nanoc/core/outdatedness_checker.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Responsible for determining whether an item or a layout is outdated.
+    #
+    # @api private
+    class OutdatednessChecker
+      class Basic
+        DDMemoize.activate(self)
+
+        include Nanoc::Core::ContractsSupport
+
+        Rules = Nanoc::Core::OutdatednessRules
+
+        RULES_FOR_ITEM_REP =
+          [
+            Rules::RulesModified,
+            Rules::ContentModified,
+            Rules::AttributesModified,
+            Rules::NotWritten,
+            Rules::CodeSnippetsModified,
+            Rules::UsesAlwaysOutdatedFilter,
+          ].freeze
+
+        RULES_FOR_LAYOUT =
+          [
+            Rules::RulesModified,
+            Rules::ContentModified,
+            Rules::AttributesModified,
+            Rules::UsesAlwaysOutdatedFilter,
+          ].freeze
+
+        RULES_FOR_CONFIG =
+          [
+            Rules::AttributesModified,
+          ].freeze
+
+        RULES_FOR_ITEM_COLLECTION =
+          [
+            Rules::ItemCollectionExtended,
+          ].freeze
+
+        RULES_FOR_LAYOUT_COLLECTION =
+          [
+            Rules::LayoutCollectionExtended,
+          ].freeze
+
+        C_OBJ_MAYBE_REP = C::Or[Nanoc::Core::Item, Nanoc::Core::ItemRep, Nanoc::Core::Configuration, Nanoc::Core::Layout, Nanoc::Core::ItemCollection, Nanoc::Core::LayoutCollection]
+
+        contract C::KeywordArgs[outdatedness_checker: OutdatednessChecker, reps: Nanoc::Core::ItemRepRepo] => C::Any
+        def initialize(outdatedness_checker:, reps:)
+          @outdatedness_checker = outdatedness_checker
+          @reps = reps
+        end
+
+        contract C_OBJ_MAYBE_REP => C::Maybe[Nanoc::Core::OutdatednessStatus]
+        memoized def outdatedness_status_for(obj)
+          case obj
+          when Nanoc::Core::ItemRep
+            apply_rules(RULES_FOR_ITEM_REP, obj)
+          when Nanoc::Core::Item
+            apply_rules_multi(RULES_FOR_ITEM_REP, @reps[obj])
+          when Nanoc::Core::Layout
+            apply_rules(RULES_FOR_LAYOUT, obj)
+          when Nanoc::Core::Configuration
+            apply_rules(RULES_FOR_CONFIG, obj)
+          when Nanoc::Core::ItemCollection
+            apply_rules(RULES_FOR_ITEM_COLLECTION, obj)
+          when Nanoc::Core::LayoutCollection
+            apply_rules(RULES_FOR_LAYOUT_COLLECTION, obj)
+          else
+            raise Nanoc::Core::Errors::InternalInconsistency, "do not know how to check outdatedness of #{obj.inspect}"
+          end
+        end
+
+        private
+
+        contract C::ArrayOf[Class], C_OBJ_MAYBE_REP, Nanoc::Core::OutdatednessStatus => C::Maybe[Nanoc::Core::OutdatednessStatus]
+        def apply_rules(rules, obj, status = Nanoc::Core::OutdatednessStatus.new)
+          rules.inject(status) do |acc, rule|
+            if !acc.useful_to_apply?(rule)
+              acc
+            else
+              reason = rule.instance.call(obj, @outdatedness_checker)
+              if reason
+                acc.update(reason)
+              else
+                acc
+              end
+            end
+          end
+        end
+
+        contract C::ArrayOf[Class], C::ArrayOf[C_OBJ_MAYBE_REP] => C::Maybe[Nanoc::Core::OutdatednessStatus]
+        def apply_rules_multi(rules, objs)
+          objs.inject(Nanoc::Core::OutdatednessStatus.new) { |acc, elem| apply_rules(rules, elem, acc) }
+        end
+      end
+
+      DDMemoize.activate(self)
+
+      include Nanoc::Core::ContractsSupport
+
+      attr_reader :checksum_store
+      attr_reader :checksums
+      attr_reader :dependency_store
+      attr_reader :action_sequence_store
+      attr_reader :action_sequences
+      attr_reader :site
+
+      Reasons = Nanoc::Core::OutdatednessReasons
+
+      C_OBJ = C::Or[Nanoc::Core::Item, Nanoc::Core::ItemRep, Nanoc::Core::Configuration, Nanoc::Core::Layout, Nanoc::Core::ItemCollection]
+      C_ITEM_OR_REP = C::Or[Nanoc::Core::Item, Nanoc::Core::ItemRep]
+      C_ACTION_SEQUENCES = C::HashOf[C_OBJ => Nanoc::Core::ActionSequence]
+
+      contract C::KeywordArgs[site: Nanoc::Core::Site, checksum_store: Nanoc::Core::ChecksumStore, checksums: Nanoc::Core::ChecksumCollection, dependency_store: Nanoc::Core::DependencyStore, action_sequence_store: Nanoc::Core::ActionSequenceStore, action_sequences: C_ACTION_SEQUENCES, reps: Nanoc::Core::ItemRepRepo] => C::Any
+      def initialize(site:, checksum_store:, checksums:, dependency_store:, action_sequence_store:, action_sequences:, reps:)
+        @site = site
+        @checksum_store = checksum_store
+        @checksums = checksums
+        @dependency_store = dependency_store
+        @action_sequence_store = action_sequence_store
+        @action_sequences = action_sequences
+        @reps = reps
+
+        @objects_outdated_due_to_dependencies = {}
+      end
+
+      def action_sequence_for(rep)
+        @action_sequences.fetch(rep)
+      end
+
+      contract C_OBJ => C::Bool
+      def outdated?(obj)
+        outdatedness_reasons_for(obj).any?
+      end
+
+      contract C_OBJ => C::IterOf[Reasons::Generic]
+      def outdatedness_reasons_for(obj)
+        reasons = basic.outdatedness_status_for(obj).reasons
+        if reasons.any?
+          reasons
+        elsif outdated_due_to_dependencies?(obj)
+          [Reasons::DependenciesOutdated]
+        else
+          []
+        end
+      end
+
+      private
+
+      contract C::None => Basic
+      def basic
+        @_basic ||= Basic.new(outdatedness_checker: self, reps: @reps)
+      end
+
+      contract C_OBJ, Hamster::Set => C::Bool
+      def outdated_due_to_dependencies?(obj, processed = Hamster::Set.new)
+        # Convert from rep to item if necessary
+        obj = obj.item if obj.is_a?(Nanoc::Core::ItemRep)
+
+        # Only items can have dependencies
+        return false unless obj.is_a?(Nanoc::Core::Item)
+
+        # Get from cache
+        if @objects_outdated_due_to_dependencies.key?(obj)
+          return @objects_outdated_due_to_dependencies[obj]
+        end
+
+        # Check processed
+        # Don’t return true; the false will be or’ed into a true if there
+        # really is a dependency that is causing outdatedness.
+        return false if processed.include?(obj)
+
+        # Calculate
+        is_outdated = dependency_store.dependencies_causing_outdatedness_of(obj).any? do |dep|
+          dependency_causes_outdatedness?(dep) ||
+            (dep.props.compiled_content? &&
+              outdated_due_to_dependencies?(dep.from, processed.merge([obj])))
+        end
+
+        # Cache
+        @objects_outdated_due_to_dependencies[obj] = is_outdated
+
+        # Done
+        is_outdated
+      end
+
+      contract Nanoc::Core::Dependency => C::Bool
+      def dependency_causes_outdatedness?(dependency)
+        return true if dependency.from.nil?
+
+        status = basic.outdatedness_status_for(dependency.from)
+
+        active = status.props.active & dependency.props.active
+        active.delete(:attributes) if attributes_unaffected?(status, dependency)
+        active.delete(:raw_content) if raw_content_unaffected?(status, dependency)
+
+        active.any?
+      end
+
+      def attributes_unaffected?(status, dependency)
+        reason = status.reasons.find { |r| r.is_a?(Nanoc::Core::OutdatednessReasons::AttributesModified) }
+        reason && dependency.props.attributes.is_a?(Enumerable) && (dependency.props.attributes & reason.attributes).empty?
+      end
+
+      def raw_content_unaffected?(status, dependency)
+        reason = status.reasons.find { |r| r.is_a?(Nanoc::Core::OutdatednessReasons::DocumentCollectionExtended) }
+        if reason.nil?
+          false
+        elsif !dependency.props.raw_content.is_a?(Enumerable)
+          false
+        else
+          patterns = dependency.props.raw_content.map { |r| Nanoc::Core::Pattern.from(r) }
+          patterns.none? { |pat| reason.objects.any? { |obj| pat.match?(obj.identifier) } }
+        end
+      end
+    end
+  end
+end