nanoc-core 4.11.12 → 4.11.17

data/lib/nanoc/core/identifiable_collection_view.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class IdentifiableCollectionView < ::Nanoc::Core::View
+      include Enumerable
+
+      NOTHING = Object.new
+
+      # @api private
+      def initialize(objects, context)
+        super(context)
+        @objects = objects
+      end
+
+      # @api private
+      def _unwrap
+        @objects
+      end
+
+      # @abstract
+      #
+      # @api private
+      def view_class
+        raise NotImplementedError
+      end
+
+      # Calls the given block once for each object, passing that object as a parameter.
+      #
+      # @yieldparam [#identifier] object
+      #
+      # @yieldreturn [void]
+      #
+      # @return [self]
+      def each
+        @context.dependency_tracker.bounce(_unwrap, raw_content: true)
+        @objects.each { |i| yield view_class.new(i, @context) }
+        self
+      end
+
+      # @return [Integer]
+      def size
+        @context.dependency_tracker.bounce(_unwrap, raw_content: true)
+        @objects.size
+      end
+
+      # Finds all objects whose identifier matches the given argument.
+      #
+      # @param [String, Regex] arg
+      #
+      # @return [Enumerable]
+      def find_all(arg = NOTHING, &block)
+        if NOTHING.equal?(arg)
+          @context.dependency_tracker.bounce(_unwrap, raw_content: true)
+          return @objects.map { |i| view_class.new(i, @context) }.select(&block)
+        end
+
+        prop_attribute =
+          case arg
+          when String, Nanoc::Core::Identifier
+            [arg.to_s]
+          when Regexp
+            [arg]
+          else
+            true
+          end
+
+        @context.dependency_tracker.bounce(_unwrap, raw_content: prop_attribute)
+        @objects.find_all(arg).map { |i| view_class.new(i, @context) }
+      end
+
+      # @overload [](string)
+      #
+      #   Finds the object whose identifier matches the given string.
+      #
+      #   If the glob syntax is enabled, the string can be a glob, in which case
+      #   this method finds the first object that matches the given glob.
+      #
+      #   @param [String] string
+      #
+      #   @return [nil] if no object matches the string
+      #
+      #   @return [#identifier] if an object was found
+      #
+      # @overload [](regex)
+      #
+      #   Finds the object whose identifier matches the given regular expression.
+      #
+      #   @param [Regex] regex
+      #
+      #   @return [nil] if no object matches the regex
+      #
+      #   @return [#identifier] if an object was found
+      def [](arg)
+        prop_attribute =
+          case arg
+          when String, Nanoc::Core::Identifier
+            [arg.to_s]
+          when Regexp
+            [arg]
+          else
+            true
+          end
+
+        @context.dependency_tracker.bounce(_unwrap, raw_content: prop_attribute)
+        res = @objects[arg]
+        res && view_class.new(res, @context)
+      end
+    end
+  end
+end

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