nanoc-core 4.11.1

data/lib/nanoc/core/item_rep.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class ItemRep
+      include Nanoc::Core::ContractsSupport
+
+      contract C::None => C::Bool
+      attr_accessor :compiled
+      alias compiled? compiled
+
+      contract C::None => C::HashOf[Symbol => C::IterOf[String]]
+      attr_reader :raw_paths
+
+      contract C::None => C::HashOf[Symbol => C::IterOf[String]]
+      attr_reader :paths
+
+      contract C::None => Nanoc::Core::Item
+      attr_reader :item
+
+      contract C::None => Symbol
+      attr_reader :name
+
+      contract C::None => C::IterOf[C::Named['Nanoc::Core::SnapshotDef']]
+      attr_accessor :snapshot_defs
+
+      contract C::None => C::Bool
+      attr_accessor :modified
+      alias modified? modified
+
+      contract Nanoc::Core::Item, Symbol => C::Any
+      def initialize(item, name)
+        # Set primary attributes
+        @item   = item
+        @name   = name
+
+        # Set default attributes
+        @raw_paths  = {}
+        @paths      = {}
+        @snapshot_defs = []
+
+        # Reset flags
+        @compiled = false
+        @modified = false
+      end
+
+      contract C::HashOf[Symbol => C::IterOf[C::AbsolutePathString]] => C::HashOf[Symbol => C::IterOf[C::AbsolutePathString]]
+      def raw_paths=(val)
+        @raw_paths = val
+      end
+
+      contract C::HashOf[Symbol => C::IterOf[String]] => C::HashOf[Symbol => C::IterOf[String]]
+      def paths=(val)
+        @paths = val
+      end
+
+      contract Symbol => C::Bool
+      def snapshot?(name)
+        snapshot_defs.any? { |sd| sd.name == name }
+      end
+
+      contract C::KeywordArgs[snapshot: C::Optional[Symbol]] => C::Maybe[String]
+      # Returns the item rep’s raw path. It includes the path to the output
+      # directory and the full filename.
+      def raw_path(snapshot: :last)
+        @raw_paths.fetch(snapshot, []).first
+      end
+
+      contract C::KeywordArgs[snapshot: C::Optional[Symbol]] => C::Maybe[String]
+      # 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.
+      def path(snapshot: :last)
+        @paths.fetch(snapshot, []).first
+      end
+
+      # Returns an object that can be used for uniquely identifying objects.
+      def reference
+        "item_rep:#{item.identifier}:#{name}"
+      end
+
+      def to_s
+        "#{item.identifier} (rep name #{name.inspect})"
+      end
+
+      def inspect
+        "<#{self.class} name=\"#{name}\" raw_path=\"#{raw_path}\" item.identifier=\"#{item.identifier}\">"
+      end
+    end
+  end
+end

data/lib/nanoc/core/layout.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class Layout < ::Nanoc::Core::Document
+      def reference
+        "layout:#{identifier}"
+      end
+    end
+  end
+end

data/lib/nanoc/core/layout_collection.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class LayoutCollection < IdentifiableCollection
+      def initialize(config, objects = [])
+        initialize_basic(config, objects, 'layouts')
+      end
+
+      def reference
+        'layouts'
+      end
+    end
+  end
+end

data/lib/nanoc/core/lazy_value.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Holds a value that might be generated lazily.
+    class LazyValue
+      include Nanoc::Core::ContractsSupport
+
+      # Takes a value or a proc to generate the value
+      def initialize(value_or_proc)
+        @value = { raw: value_or_proc }
+      end
+
+      # Returns the value, generated when needed
+      def value
+        if @value.key?(:raw)
+          value = @value.delete(:raw)
+          @value[:final] = value.respond_to?(:call) ? value.call : value
+          @value.__nanoc_freeze_recursively if frozen?
+        end
+        @value[:final]
+      end
+
+      contract C::Func[C::Any => C::Any] => self
+      # Returns a new lazy value that will apply the given transformation when the value is requested.
+      def map
+        self.class.new(-> { yield(value) })
+      end
+
+      contract C::None => self
+      def freeze
+        super
+        @value.__nanoc_freeze_recursively unless @value[:raw]
+        self
+      end
+    end
+  end
+end

data/lib/nanoc/core/notification_center.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Provides a way to send notifications between objects. It allows blocks
+    # associated with a certain notification name to be registered; these blocks
+    # will be called when the notification with the given name is posted.
+    #
+    # It is a slightly different implementation of the Observer pattern; the
+    # table of subscribers is not stored in the observable object itself, but in
+    # the notification center.
+    class NotificationCenter
+      DONE = Object.new
+      SYNC = Object.new
+
+      def initialize
+        @thread = nil
+
+        # name => observers dictionary
+        @notifications = Hash.new { |hash, name| hash[name] = [] }
+
+        @queue = Queue.new
+
+        @sync_queue = Queue.new
+        on(SYNC, self) { @sync_queue << true }
+      end
+
+      def start
+        @thread ||= Thread.new do
+          Thread.current.abort_on_exception = true
+
+          loop do
+            elem = @queue.pop
+            break if DONE.equal?(elem)
+
+            name = elem[0]
+            args = elem[1]
+
+            @notifications[name].each do |observer|
+              observer[:block].call(*args)
+            end
+          end
+        end
+      end
+
+      def stop
+        @queue << DONE
+        @thread.join
+      end
+
+      def on(name, id = nil, &block)
+        @notifications[name] << { id: id, block: block }
+      end
+
+      def remove(name, id)
+        @notifications[name].reject! { |i| i[:id] == id }
+      end
+
+      def post(name, *args)
+        @queue << [name, args]
+        self
+      end
+
+      def sync
+        post(SYNC)
+        @sync_queue.pop
+      end
+
+      class << self
+        def instance
+          @_instance ||= new.tap(&:start)
+        end
+
+        def on(name, id = nil, &block)
+          instance.on(name, id, &block)
+        end
+
+        def post(name, *args)
+          instance.post(name, *args)
+        end
+
+        def remove(name, id)
+          instance.remove(name, id)
+        end
+
+        def reset
+          instance.stop
+          @_instance = nil
+        end
+
+        def sync
+          instance.sync
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/pattern.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class Pattern
+      include Nanoc::Core::ContractsSupport
+
+      contract C::Any => self
+      def self.from(obj)
+        case obj
+        when Nanoc::Core::StringPattern, Nanoc::Core::RegexpPattern
+          obj
+        when String
+          Nanoc::Core::StringPattern.new(obj)
+        when Regexp
+          Nanoc::Core::RegexpPattern.new(obj)
+        when Symbol
+          Nanoc::Core::StringPattern.new(obj.to_s)
+        else
+          raise ArgumentError, "Do not know how to convert `#{obj.inspect}` into a Nanoc::Pattern"
+        end
+      end
+
+      def initialize(_obj)
+        raise NotImplementedError
+      end
+
+      def match?(_identifier)
+        raise NotImplementedError
+      end
+
+      def captures(_identifier)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/nanoc/core/processing_action.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class ProcessingAction
+      def serialize
+        raise NotImplementedError.new('Nanoc::ProcessingAction subclasses must implement #serialize and #to_s')
+      end
+
+      def to_s
+        raise NotImplementedError.new('Nanoc::ProcessingAction subclasses must implement #serialize and #to_s')
+      end
+
+      def inspect
+        format(
+          '<%s %s>',
+          self.class.to_s,
+          serialize[1..-1].map(&:inspect).join(', '),
+        )
+      end
+    end
+  end
+end

data/lib/nanoc/core/processing_actions/filter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module ProcessingActions
+      class Filter < Nanoc::Core::ProcessingAction
+        # filter :foo
+        # filter :foo, params
+
+        attr_reader :filter_name
+        attr_reader :params
+
+        def initialize(filter_name, params)
+          @filter_name = filter_name
+          @params      = params
+        end
+
+        def serialize
+          [:filter, @filter_name, Nanoc::Core::Checksummer.calc(@params)]
+        end
+
+        def to_s
+          "filter #{@filter_name.inspect}, #{@params.inspect}"
+        end
+
+        def hash
+          self.class.hash ^ filter_name.hash ^ params.hash
+        end
+
+        def ==(other)
+          self.class == other.class && filter_name == other.filter_name && params == other.params
+        end
+
+        def eql?(other)
+          self == other
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/processing_actions/layout.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module ProcessingActions
+      class Layout < Nanoc::Core::ProcessingAction
+        # layout '/foo.erb'
+        # layout '/foo.erb', params
+
+        attr_reader :layout_identifier
+        attr_reader :params
+
+        def initialize(layout_identifier, params)
+          @layout_identifier = layout_identifier
+          @params = params
+        end
+
+        def serialize
+          [:layout, @layout_identifier, Nanoc::Core::Checksummer.calc(@params)]
+        end
+
+        def to_s
+          "layout #{@layout_identifier.inspect}, #{@params.inspect}"
+        end
+
+        def hash
+          self.class.hash ^ layout_identifier.hash ^ params.hash
+        end
+
+        def ==(other)
+          self.class == other.class && layout_identifier == other.layout_identifier && params == other.params
+        end
+
+        def eql?(other)
+          self == other
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/processing_actions/snapshot.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module ProcessingActions
+      class Snapshot < Nanoc::Core::ProcessingAction
+        # snapshot :before_layout
+        # snapshot :before_layout, path: '/about.md'
+
+        include Nanoc::Core::ContractsSupport
+
+        attr_reader :snapshot_names
+        attr_reader :paths
+
+        contract C::IterOf[Symbol], C::IterOf[String] => C::Any
+        def initialize(snapshot_names, paths)
+          @snapshot_names = snapshot_names
+          @paths = paths
+        end
+
+        contract C::None => Array
+        def serialize
+          [:snapshot, @snapshot_names, true, @paths]
+        end
+
+        contract C::KeywordArgs[snapshot_names: C::Optional[C::IterOf[Symbol]], paths: C::Optional[C::IterOf[String]]] => self
+        def update(snapshot_names: [], paths: [])
+          self.class.new(@snapshot_names + snapshot_names.to_a, @paths + paths.to_a)
+        end
+
+        contract C::None => String
+        def to_s
+          "snapshot #{@snapshot_names.inspect}, paths: #{@paths.inspect}"
+        end
+
+        def hash
+          self.class.hash ^ snapshot_names.hash ^ paths.hash
+        end
+
+        def ==(other)
+          self.class == other.class && snapshot_names == other.snapshot_names && paths == other.paths
+        end
+
+        def eql?(other)
+          self == other
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/processing_actions.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module ProcessingActions
+    end
+  end
+end
+
+require 'nanoc/core/processing_actions/filter'
+require 'nanoc/core/processing_actions/layout'
+require 'nanoc/core/processing_actions/snapshot'

data/lib/nanoc/core/regexp_pattern.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class RegexpPattern < Pattern
+      contract Regexp => C::Any
+      def initialize(regexp)
+        @regexp = regexp
+      end
+
+      contract C::Or[Nanoc::Core::Identifier, String] => C::Bool
+      def match?(identifier)
+        (identifier.to_s =~ @regexp) != nil
+      end
+
+      contract C::Or[Nanoc::Core::Identifier, String] => C::Maybe[C::ArrayOf[String]]
+      def captures(identifier)
+        matches = @regexp.match(identifier.to_s)
+        matches&.captures
+      end
+
+      contract C::None => String
+      def to_s
+        @regexp.to_s
+      end
+    end
+  end
+end

data/lib/nanoc/core/snapshot_def.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class SnapshotDef
+      include Nanoc::Core::ContractsSupport
+
+      attr_reader :name
+      attr_reader :binary
+
+      contract Symbol, C::KeywordArgs[binary: C::Optional[C::Bool]] => C::Any
+      def initialize(name, binary:)
+        @name = name
+        @binary = binary
+      end
+
+      def binary?
+        @binary
+      end
+    end
+  end
+end

data/lib/nanoc/core/string_pattern.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class StringPattern < Pattern
+      MATCH_OPTS = File::FNM_PATHNAME | File::FNM_EXTGLOB
+
+      contract String => C::Any
+      def initialize(string)
+        @string = string
+      end
+
+      contract C::Or[Nanoc::Core::Identifier, String] => C::Bool
+      def match?(identifier)
+        File.fnmatch(@string, identifier.to_s, MATCH_OPTS)
+      end
+
+      contract C::Or[Nanoc::Core::Identifier, String] => nil
+      def captures(_identifier)
+        nil
+      end
+
+      contract C::None => String
+      def to_s
+        @string
+      end
+    end
+  end
+end

data/lib/nanoc/core/temp_filename_factory.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class TempFilenameFactory
+      # @return [String] The root directory for all temporary filenames
+      attr_reader :root_dir
+
+      # @return [Nanoc::Core::TempFilenameFactory] A common instance
+      def self.instance
+        @instance ||= new
+      end
+
+      def initialize
+        @counts = {}
+        @root_dir = Dir.mktmpdir('nanoc')
+      end
+
+      # @param [String] prefix A string prefix to include in the temporary
+      #   filename, often the type of filename being provided.
+      #
+      # @return [String] A new unused filename
+      def create(prefix)
+        count = @counts.fetch(prefix, 0)
+        @counts[prefix] = count + 1
+
+        dirname  = File.join(@root_dir, prefix)
+        filename = File.join(@root_dir, prefix, count.to_s)
+
+        FileUtils.mkdir_p(dirname)
+
+        filename
+      end
+
+      # @param [String] prefix A string prefix that indicates which temporary
+      #   filenames should be deleted.
+      #
+      # @return [void]
+      def cleanup(prefix)
+        path = File.join(@root_dir, prefix)
+        if File.exist?(path)
+          FileUtils.rm_rf(path)
+        end
+
+        @counts.delete(prefix)
+
+        if @counts.empty? && File.directory?(@root_dir)
+          FileUtils.rm_rf(@root_dir)
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/textual_content.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class TextualContent < Content
+      contract C::None => String
+      def string
+        @string.value
+      end
+
+      contract C::Or[String, Proc], C::KeywordArgs[filename: C::Optional[C::Maybe[String]]] => C::Any
+      def initialize(string, filename: nil)
+        super(filename)
+        @string = Nanoc::Core::LazyValue.new(string)
+      end
+
+      contract C::None => self
+      def freeze
+        super
+        @string.freeze
+        self
+      end
+
+      contract C::None => C::Bool
+      def binary?
+        false
+      end
+
+      contract C::None => Array
+      def marshal_dump
+        [filename, string]
+      end
+
+      contract Array => C::Any
+      def marshal_load(array)
+        @filename = array[0]
+        @string = Nanoc::Core::LazyValue.new(array[1])
+      end
+    end
+  end
+end

data/lib/nanoc/core/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    VERSION = '4.11.1'
+  end
+end