nanoc-core 4.11.12 → 4.11.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf201905e79de9d9711910668d228863a48b53e13a78694a50122932960d6189
-  data.tar.gz: ffae70af266ec5c189b0d09976bfb9ebada587f5ea1eeb73b12dfeaebeb07d36
+  metadata.gz: 748b150c5ee93de8c4ce8dcd31ddc4e4dc64897a73d86dd91be9d743b1ff476d
+  data.tar.gz: '008722ff9d57b3c5e13fda3e5ac60dd4860a1240076383067a37664ebb7df2ca'
 SHA512:
-  metadata.gz: bf812e2fc282b019b2d907ee39a84fe7999b2b2f8565139cc442e3ca38cb75949ea70f27b07058ef4bd52af9a1291c0ca73e6db53790e431976a729f6a4dd3c8
-  data.tar.gz: ef670404975dfde21013d6878afbf272e7bd41d7dee120e124cb2c61e37e1ad1f5ac64ccc1f4554f57dcde1d1303cac32ef6e088853d569c24f1c070c72abc7c
+  metadata.gz: 49b011afe4838c9150bd91ccaf17acd7150f5d143af69b13e623f542ff2af7965205f4b2a595b07e651babada9e902a98e2c879f923070be21c14fd199c5674d
+  data.tar.gz: aefeed726b1ac55565446d4fc7ccce5a3d5293029ad7b0e534e33f8f0ff338d0f7d8f9641dfd964125e5a71dbb243aa95e9cf447d071478fea03d1e2a485ea4c

data/lib/nanoc/core.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
 # Ruby stdlib
+require 'fiber'
+require 'find'
 require 'pstore'
 require 'singleton'
 require 'tmpdir'
+require 'yaml'
 
 # External gems
 require 'json_schema'
@@ -12,10 +15,32 @@ require 'ddmetrics'
 require 'ddplugin'
 require 'hamster'
 require 'slow_enumerator_tools'
+require 'tomlrb'
+require 'tty-platform'
 require 'zeitwerk'
 
 module Nanoc
   module Core
+    # Similar to `nil` except that it can only be compared against using
+    # `UNDEFINED.equal?(x)`. Used in places where `nil` already has meaning, and
+    # thus cannot be used to mean the presence of nothing.
+    UNDEFINED = Object.new
+
+    # @return [String] A string containing information about this Nanoc version
+    #   and its environment (Ruby engine and version, Rubygems version if any).
+    #
+    # @api private
+    def self.version_information
+      "Nanoc #{Nanoc::VERSION} © 2007–2019 Denis Defreyne.\n" \
+      "Running #{RUBY_ENGINE} #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) on #{RUBY_PLATFORM} with RubyGems #{Gem::VERSION}.\n"
+    end
+
+    # @return [Boolean] True if the current platform is Windows, false otherwise.
+    #
+    # @api private
+    def self.on_windows?
+      @_on_windows ||= TTY::Platform.new.windows?
+    end
   end
 end
 
@@ -43,3 +68,15 @@ loader.eager_load
 require_relative 'core/core_ext/array'
 require_relative 'core/core_ext/hash'
 require_relative 'core/core_ext/string'
+
+# Tracking issue:
+# https://github.com/nanoc/features/issues/24
+Nanoc::Core::Feature.define('live_cmd', version: '4.11')
+
+# Tracking issue:
+# https://github.com/nanoc/features/issues/40
+Nanoc::Core::Feature.define('toml', version: '4.11')
+
+# Tracking issue:
+# https://github.com/nanoc/features/issues/20
+Nanoc::Core::Feature.define('binary_compiled_content_cache', version: '4.11')

data/lib/nanoc/core/basic_item_rep_collection_view.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class BasicItemRepCollectionView < ::Nanoc::Core::View
+      include Enumerable
+
+      class NoSuchItemRepError < ::Nanoc::Core::Error
+        def initialize(rep_name)
+          super("No rep named #{rep_name.inspect} was found.")
+        end
+      end
+
+      # @api private
+      def initialize(item_reps, context)
+        super(context)
+        @item_reps = item_reps
+      end
+
+      # @api private
+      def _unwrap
+        @item_reps
+      end
+
+      # @api private
+      def view_class
+        Nanoc::Core::BasicItemRepView
+      end
+
+      def to_ary
+        @item_reps.map { |ir| view_class.new(ir, @context) }
+      end
+
+      # Calls the given block once for each item rep, passing that item rep as a parameter.
+      #
+      # @yieldparam [Object] item rep view
+      #
+      # @yieldreturn [void]
+      #
+      # @return [self]
+      def each
+        @item_reps.each { |ir| yield view_class.new(ir, @context) }
+        self
+      end
+
+      # @return [Integer]
+      def size
+        @item_reps.size
+      end
+
+      # Return the item rep with the given name, or nil if no item rep exists.
+      #
+      # @param [Symbol] rep_name
+      #
+      # @return [nil] if no item rep with the given name was found
+      #
+      # @return [Nanoc::Core::BasicItemRepView] if an item rep with the given name was found
+      def [](rep_name)
+        case rep_name
+        when Symbol
+          res = @item_reps.find { |ir| ir.name == rep_name }
+          res && view_class.new(res, @context)
+        when Integer
+          raise ArgumentError, "expected BasicItemRepCollectionView#[] to be called with a symbol (you likely want `.reps[:default]` rather than `.reps[#{rep_name}]`)"
+        else
+          raise ArgumentError, 'expected BasicItemRepCollectionView#[] to be called with a symbol'
+        end
+      end
+
+      # Return the item rep with the given name, or raises an exception if there
+      # is no rep with the given name.
+      #
+      # @param [Symbol] rep_name
+      #
+      # @return [Nanoc::Core::BasicItemRepView]
+      #
+      # @raise if no rep was found
+      def fetch(rep_name)
+        res = @item_reps.find { |ir| ir.name == rep_name }
+        if res
+          view_class.new(res, @context)
+        else
+          raise NoSuchItemRepError.new(rep_name)
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/basic_item_rep_view.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class BasicItemRepView < ::Nanoc::Core::View
+      # @api private
+      def initialize(item_rep, context)
+        super(context)
+        @item_rep = item_rep
+      end
+
+      # @abstract
+      def item_view_class
+        Nanoc::Core::BasicItemView
+      end
+
+      # @api private
+      def _unwrap
+        @item_rep
+      end
+
+      # @see Object#==
+      def ==(other)
+        other.respond_to?(:item) && other.respond_to?(:name) && item == other.item && name == other.name
+      end
+
+      # @see Object#eql?
+      def eql?(other)
+        other.is_a?(self.class) &&
+          item.eql?(other.item) &&
+          name.eql?(other.name)
+      end
+
+      # @see Object#hash
+      def hash
+        self.class.hash ^ item.identifier.hash ^ name.hash
+      end
+
+      # @return [Symbol]
+      def name
+        @item_rep.name
+      end
+
+      def snapshot?(name)
+        @context.dependency_tracker.bounce(_unwrap.item, compiled_content: true)
+        @item_rep.snapshot?(name)
+      end
+
+      # Returns the item rep’s path, as used when being linked to. It starts
+      # with a slash and it is relative to the output directory. It does not
+      # include the path to the output directory. It will not include the
+      # filename if the filename is an index filename.
+      #
+      # @param [Symbol] snapshot The snapshot for which the path should be
+      #   returned.
+      #
+      # @return [String] The item rep’s path.
+      def path(snapshot: :last)
+        @context.dependency_tracker.bounce(_unwrap.item, path: true)
+        @item_rep.path(snapshot: snapshot)
+      end
+
+      # Returns the item that this item rep belongs to.
+      #
+      # @return [Nanoc::Core::CompilationItemView]
+      def item
+        item_view_class.new(@item_rep.item, @context)
+      end
+
+      # @api private
+      def binary?
+        snapshot_def = _unwrap.snapshot_defs.find { |sd| sd.name == :last }
+        raise Nanoc::Core::Errors::NoSuchSnapshot.new(_unwrap, :last) if snapshot_def.nil?
+
+        snapshot_def.binary?
+      end
+
+      def inspect
+        "<#{self.class} item.identifier=#{item.identifier} name=#{name}>"
+      end
+    end
+  end
+end

data/lib/nanoc/core/basic_item_view.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class BasicItemView < ::Nanoc::Core::View
+      include Nanoc::Core::DocumentViewMixin
+
+      # Returns the children of this item. For items with identifiers that have
+      # extensions, returns an empty collection.
+      #
+      # @return [Enumerable<Nanoc::Core::CompilationItemView>]
+      def children
+        unless _unwrap.identifier.legacy?
+          raise Nanoc::Core::Errors::CannotGetParentOrChildrenOfNonLegacyItem.new(_unwrap.identifier)
+        end
+
+        children_pattern = Nanoc::Core::Pattern.from(_unwrap.identifier.to_s + '*/')
+        children = @context.items.select { |i| children_pattern.match?(i.identifier) }
+
+        children.map { |i| self.class.new(i, @context) }.freeze
+      end
+
+      # Returns the parent of this item, if one exists. For items with identifiers
+      # that have extensions, returns nil.
+      #
+      # @return [Nanoc::Core::CompilationItemView] if the item has a parent
+      #
+      # @return [nil] if the item has no parent
+      def parent
+        unless _unwrap.identifier.legacy?
+          raise Nanoc::Core::Errors::CannotGetParentOrChildrenOfNonLegacyItem.new(_unwrap.identifier)
+        end
+
+        parent_identifier = '/' + _unwrap.identifier.components[0..-2].join('/') + '/'
+        parent_identifier = '/' if parent_identifier == '//'
+
+        parent = @context.items[parent_identifier]
+
+        parent && self.class.new(parent, @context)
+      end
+
+      # @return [Boolean] True if the item is binary, false otherwise
+      def binary?
+        _unwrap.content.binary?
+      end
+
+      # @return [String, nil] The path to the file containing the uncompiled content of this item.
+      def raw_filename
+        @context.dependency_tracker.bounce(_unwrap, raw_content: true)
+        _unwrap.content.filename
+      end
+    end
+  end
+end

data/lib/nanoc/core/changes_stream.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class ChangesStream
+      class ChangesListener
+        def initialize(y)
+          @y = y
+        end
+
+        def unknown
+          @y << :unknown
+        end
+
+        def lib
+          @y << :lib
+        end
+
+        def to_stop(&block)
+          if block_given?
+            @to_stop = block
+          else
+            @to_stop
+          end
+        end
+      end
+
+      def initialize(enum: nil)
+        @enum = enum
+        @enum ||=
+          Enumerator.new do |y|
+            @listener = ChangesListener.new(y)
+            yield(@listener)
+          end.lazy
+      end
+
+      def stop
+        @listener&.to_stop&.call
+      end
+
+      def map
+        self.class.new(enum: @enum.map { |e| yield(e) })
+      end
+
+      def to_enum
+        @enum
+      end
+
+      def each
+        @enum.each { |e| yield(e) }
+        nil
+      end
+    end
+  end
+end

data/lib/nanoc/core/checksum_store.rb

@@ -64,7 +64,7 @@ module Nanoc
 
         @checksums = {}
         new_data.each_pair do |key, checksum|
-          if references.include?(key) || references.include?(key.first)
+          if references.include?(key) || (key.respond_to?(:first) && references.include?(key.first))
             @checksums[key] = checksum
           end
         end

data/lib/nanoc/core/checksummer.rb

@@ -50,8 +50,8 @@ module Nanoc
         end
 
         def calc_for_each_attribute_of(obj, digest_class = CompactDigest)
-          obj.attributes.each_with_object({}) do |(key, value), memo|
-            memo[key] = Nanoc::Core::Checksummer.calc(value, digest_class)
+          obj.attributes.transform_values do |value|
+            Nanoc::Core::Checksummer.calc(value, digest_class)
           end
         end
 
@@ -95,12 +95,14 @@ module Nanoc
           define_behavior(Nanoc::Core::BinaryContent, BinaryContentUpdateBehavior)
           define_behavior(Nanoc::Core::Configuration, HashUpdateBehavior)
           define_behavior(Nanoc::Core::Context, ContextUpdateBehavior)
+          define_behavior(Nanoc::Core::CodeSnippet, DataUpdateBehavior)
           define_behavior(Nanoc::Core::IdentifiableCollection, ArrayUpdateBehavior)
           define_behavior(Nanoc::Core::Identifier, ToSUpdateBehavior)
           define_behavior(Nanoc::Core::Item, DocumentUpdateBehavior)
           define_behavior(Nanoc::Core::ItemRep, ItemRepUpdateBehavior)
           define_behavior(Nanoc::Core::Layout, DocumentUpdateBehavior)
           define_behavior(Nanoc::Core::TextualContent, StringUpdateBehavior)
+          define_behavior(Nanoc::Core::View, UnwrapUpdateBehavior)
 
           @behaviors
         end

data/lib/nanoc/core/compilation_item_rep_collection_view.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class CompilationItemRepCollectionView < ::Nanoc::Core::BasicItemRepCollectionView
+      # @api private
+      def view_class
+        Nanoc::Core::CompilationItemRepView
+      end
+    end
+  end
+end

data/lib/nanoc/core/compilation_item_rep_view.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class CompilationItemRepView < ::Nanoc::Core::BasicItemRepView
+      # How long to wait before the requested file appears.
+      #
+      # This is a bit of a hack -- ideally, Nanoc would know that the file is
+      # being generated, and wait the appropriate amount of time.
+      FILE_APPEAR_TIMEOUT = 10.0
+
+      # @abstract
+      def item_view_class
+        Nanoc::Core::CompilationItemView
+      end
+
+      # Returns the item rep’s raw path. It includes the path to the output
+      # directory and the full filename.
+      #
+      # @param [Symbol] snapshot The snapshot for which the path should be
+      #   returned.
+      #
+      # @return [String] The item rep’s raw path.
+      def raw_path(snapshot: :last)
+        @context.dependency_tracker.bounce(_unwrap.item, compiled_content: true)
+
+        res = @item_rep.raw_path(snapshot: snapshot)
+
+        unless @item_rep.compiled?
+          Fiber.yield(Nanoc::Core::Errors::UnmetDependency.new(@item_rep, snapshot))
+        end
+
+        # Wait for file to exist
+        if res
+          start = Time.now
+          sleep 0.05 until File.file?(res) || Time.now - start > FILE_APPEAR_TIMEOUT
+          raise Nanoc::Core::Errors::InternalInconsistency, "File did not apear in time: #{res}" unless File.file?(res)
+        end
+
+        res
+      end
+
+      # Returns the compiled content.
+      #
+      # @param [String] snapshot The name of the snapshot from which to
+      #   fetch the compiled content. By default, the returned compiled content
+      #   will be the content compiled right before the first layout call (if
+      #   any).
+      #
+      # @return [String] The content at the given snapshot.
+      def compiled_content(snapshot: nil)
+        @context.dependency_tracker.bounce(_unwrap.item, compiled_content: true)
+        @context.compiled_content_store.compiled_content(rep: _unwrap, snapshot: snapshot)
+      end
+    end
+  end
+end