nanoc 4.11.12 → 4.11.13

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

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  module Int
-    # Yields item reps to compile.
-    #
-    # @api private
-    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::Int::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::Int::Errors::CompilationError) ? e.unwrap : e
-
-            if actual_error.is_a?(Nanoc::Int::Errors::UnmetDependency)
-              mg.mark_failed(actual_error.rep)
-            else
-              raise(e)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  module Int
-    # @api private
-    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), 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/base/services/outdatedness_checker.rb

@@ -1,222 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  module Int
-    # 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::Int::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::Int::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

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  module Int
-    # @api private
-    module OutdatednessRules
-    end
-  end
-end
-
-require_relative 'outdatedness_rules/attributes_modified'
-require_relative 'outdatedness_rules/code_snippets_modified'
-require_relative 'outdatedness_rules/content_modified'
-require_relative 'outdatedness_rules/not_written'
-require_relative 'outdatedness_rules/rules_modified'
-require_relative 'outdatedness_rules/uses_always_outdated_filter'
-require_relative 'outdatedness_rules/item_collection_extended'
-require_relative 'outdatedness_rules/layout_collection_extended'

data/lib/nanoc/base/services/outdatedness_rules/attributes_modified.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  module Int
-    module OutdatednessRules
-      class AttributesModified < Nanoc::Core::OutdatednessRule
-        include Nanoc::Core::ContractsSupport
-
-        affects_props :attributes, :compiled_content
-
-        contract C::Or[Nanoc::Core::ItemRep, Nanoc::Core::Item, Nanoc::Core::Configuration, Nanoc::Core::Layout], C::Named['Nanoc::Int::OutdatednessChecker'] => C::Maybe[Nanoc::Core::OutdatednessReasons::Generic]
-        def apply(obj, outdatedness_checker)
-          case obj
-          when Nanoc::Core::ItemRep
-            apply(obj.item, outdatedness_checker)
-          when Nanoc::Core::Item, Nanoc::Core::Layout, Nanoc::Core::Configuration
-            if outdatedness_checker.checksum_store[obj] == outdatedness_checker.checksums.checksum_for(obj)
-              return nil
-            end
-
-            old_checksums = outdatedness_checker.checksum_store.attributes_checksum_for(obj)
-            unless old_checksums
-              return Nanoc::Core::OutdatednessReasons::AttributesModified.new(true)
-            end
-
-            new_checksums = outdatedness_checker.checksums.attributes_checksum_for(obj)
-
-            attributes = Set.new(old_checksums.keys) + Set.new(new_checksums.keys)
-            changed_attributes = attributes.reject { |a| old_checksums[a] == new_checksums[a] }
-
-            if changed_attributes.any?
-              Nanoc::Core::OutdatednessReasons::AttributesModified.new(changed_attributes)
-            end
-          else
-            raise ArgumentError
-          end
-        end
-      end
-    end
-  end
-end

data/lib/nanoc/base/services/outdatedness_rules/code_snippets_modified.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  module Int
-    module OutdatednessRules
-      class CodeSnippetsModified < Nanoc::Core::OutdatednessRule
-        DDMemoize.activate(self)
-
-        include Nanoc::Core::ContractsSupport
-
-        affects_props :raw_content, :attributes, :compiled_content, :path
-
-        def apply(_obj, outdatedness_checker)
-          if any_snippets_modified?(outdatedness_checker)
-            Nanoc::Core::OutdatednessReasons::CodeSnippetsModified
-          end
-        end
-
-        private
-
-        memoized def any_snippets_modified?(outdatedness_checker)
-          outdatedness_checker.site.code_snippets.any? do |cs|
-            ch_old = outdatedness_checker.checksum_store[cs]
-            ch_new = outdatedness_checker.checksums.checksum_for(cs)
-            ch_old != ch_new
-          end
-        end
-      end
-    end
-  end
-end