nanoc-core 4.11.1

data/lib/nanoc/core/content.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class Content
+      include Nanoc::Core::ContractsSupport
+
+      contract C::None => C::Maybe[String]
+      attr_reader :filename
+
+      contract C::Maybe[String] => C::Any
+      def initialize(filename)
+        if filename && Pathname.new(filename).relative?
+          raise ArgumentError, 'Content filename is not absolute'
+        end
+
+        @filename = filename
+      end
+
+      contract C::None => self
+      def freeze
+        super
+        @filename.freeze
+        self
+      end
+
+      contract C::Or[self, String, Proc], C::KeywordArgs[binary: C::Optional[C::Bool], filename: C::Optional[C::Maybe[String]]] => self
+      def self.create(content, binary: false, filename: nil)
+        if content.nil?
+          raise ArgumentError, 'Cannot create nil content'
+        elsif content.is_a?(Nanoc::Core::Content)
+          content
+        elsif binary
+          Nanoc::Core::BinaryContent.new(content)
+        else
+          Nanoc::Core::TextualContent.new(content, filename: filename)
+        end
+      end
+
+      contract C::None => C::Bool
+      def binary?
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/nanoc/core/context.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Provides a context and a binding for use in filters such as the ERB and
+    # Haml ones.
+    class Context
+      # Creates a new context based off the contents of the hash.
+      #
+      # Each pair in the hash will be converted to an instance variable and an
+      # instance method. For example, passing the hash `{ :foo => 'bar' }` will
+      # cause `@foo` to have the value `"bar"`, and the instance method `#foo`
+      # to return the same value `"bar"`.
+      #
+      # @param [Hash] hash A list of key-value pairs to make available
+      #
+      # @example Defining a context and accessing values
+      #
+      #     context = Nanoc::Core::Context.new(
+      #       :name     => 'Max Payne',
+      #       :location => 'in a cheap motel'
+      #     )
+      #     context.instance_eval do
+      #       "I am #{name} and I am hiding #{@location}."
+      #     end
+      #     # => "I am Max Payne and I am hiding in a cheap motel."
+      def initialize(hash)
+        hash.each_pair do |key, value|
+          instance_variable_set('@' + key.to_s, value)
+        end
+      end
+
+      # Returns a binding for this instance.
+      #
+      # @return [Binding] A binding for this instance
+      # rubocop:disable Naming/AccessorMethodName
+      def get_binding
+        binding
+      end
+      # rubocop:enable Naming/AccessorMethodName
+
+      def method_missing(method, *args, &blk)
+        ivar_name = '@' + method.to_s
+        if instance_variable_defined?(ivar_name)
+          instance_variable_get(ivar_name)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_all)
+        ivar_name = '@' + method.to_s
+
+        valid_ivar_name =
+          if defined?(Contracts)
+            ivar_name =~ /\A@[A-Za-z_]+\z/
+          else
+            true # probably good enough
+          end
+
+        (valid_ivar_name && instance_variable_defined?(ivar_name)) || super
+      end
+
+      def include(mod)
+        metaclass = class << self; self; end
+        metaclass.instance_eval { include(mod) }
+      end
+    end
+  end
+end

data/lib/nanoc/core/contracts_support.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module ContractsSupport
+      class Ignorer
+        include Singleton
+
+        def method_missing(*_args) # rubocop:disable Style/MethodMissingSuper
+          self
+        end
+
+        def respond_to_missing?(*_args)
+          true
+        end
+      end
+
+      module DisabledContracts
+        Any         = Ignorer.instance
+        Bool        = Ignorer.instance
+        Num         = Ignorer.instance
+        KeywordArgs = Ignorer.instance
+        Args        = Ignorer.instance
+        Optional    = Ignorer.instance
+        Maybe       = Ignorer.instance
+        None        = Ignorer.instance
+        ArrayOf     = Ignorer.instance
+        Or          = Ignorer.instance
+        Func        = Ignorer.instance
+        RespondTo   = Ignorer.instance
+        Named       = Ignorer.instance
+        IterOf      = Ignorer.instance
+        HashOf      = Ignorer.instance
+        AbsolutePathString = Ignorer.instance
+
+        def contract(*args); end
+      end
+
+      module EnabledContracts
+        class AbstractContract
+          def self.[](*vals)
+            new(*vals)
+          end
+        end
+
+        class Named < AbstractContract
+          def initialize(name)
+            @name = name
+          end
+
+          def valid?(val)
+            val.is_a?(Kernel.const_get(@name))
+          end
+
+          def inspect
+            "#{self.class}(#{@name})"
+          end
+        end
+
+        class IterOf < AbstractContract
+          def initialize(contract)
+            @contract = contract
+          end
+
+          def valid?(val)
+            val.respond_to?(:each) && val.all? { |v| Contract.valid?(v, @contract) }
+          end
+
+          def inspect
+            "#{self.class}(#{@contract})"
+          end
+        end
+
+        class AbsolutePathString < AbstractContract
+          def self.valid?(val)
+            val.is_a?(String) && Pathname.new(val).absolute?
+          end
+        end
+
+        def contract(*args)
+          Contract(*args)
+        end
+      end
+
+      def self.setup_once
+        @_contracts_support__setup ||= false
+        return @_contracts_support__should_enable if @_contracts_support__setup
+
+        @_contracts_support__setup = true
+
+        contracts_loadable =
+          begin
+            require 'contracts'
+            true
+          rescue LoadError
+            false
+          end
+
+        @_contracts_support__should_enable = contracts_loadable && !ENV.key?('DISABLE_CONTRACTS')
+
+        if @_contracts_support__should_enable
+          # FIXME: ugly
+          ::Contracts.const_set('Named', EnabledContracts::Named)
+          ::Contracts.const_set('IterOf', EnabledContracts::IterOf)
+          ::Contracts.const_set('AbsolutePathString', EnabledContracts::AbsolutePathString)
+        end
+
+        @_contracts_support__should_enable
+      end
+
+      def self.enabled?
+        setup_once
+      end
+
+      def self.included(base)
+        should_enable = setup_once
+
+        if should_enable
+          unless base.include?(::Contracts::Core)
+            base.include(::Contracts::Core)
+            base.extend(EnabledContracts)
+            base.const_set('C', ::Contracts)
+          end
+        else
+          base.extend(DisabledContracts)
+          base.const_set('C', DisabledContracts)
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/core_ext/array.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CoreExt
+      module ArrayExtensions
+        # Returns a new array where all items' keys are recursively converted to
+        # symbols by calling {Nanoc::ArrayExtensions#__nanoc_symbolize_keys_recursively} or
+        # {Nanoc::HashExtensions#__nanoc_symbolize_keys_recursively}.
+        #
+        # @return [Array] The converted array
+        def __nanoc_symbolize_keys_recursively
+          array = []
+          each do |element|
+            array << (element.respond_to?(:__nanoc_symbolize_keys_recursively) ? element.__nanoc_symbolize_keys_recursively : element)
+          end
+          array
+        end
+
+        def __nanoc_stringify_keys_recursively
+          array = []
+          each do |element|
+            array << (element.respond_to?(:__nanoc_stringify_keys_recursively) ? element.__nanoc_stringify_keys_recursively : element)
+          end
+          array
+        end
+
+        # Freezes the contents of the array, as well as all array elements. The
+        # array elements will be frozen using {#__nanoc_freeze_recursively} if they respond
+        # to that message, or #freeze if they do not.
+        #
+        # @see Hash#__nanoc_freeze_recursively
+        #
+        # @return [void]
+        def __nanoc_freeze_recursively
+          return if frozen?
+
+          freeze
+          each do |value|
+            if value.respond_to?(:__nanoc_freeze_recursively)
+              value.__nanoc_freeze_recursively
+            else
+              value.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+class Array
+  include Nanoc::Core::CoreExt::ArrayExtensions
+end

data/lib/nanoc/core/core_ext/hash.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CoreExt
+      module HashExtensions
+        # Returns a new hash where all keys are recursively converted to symbols by
+        # calling {Nanoc::ArrayExtensions#__nanoc_symbolize_keys_recursively} or
+        # {Nanoc::HashExtensions#__nanoc_symbolize_keys_recursively}.
+        #
+        # @return [Hash] The converted hash
+        def __nanoc_symbolize_keys_recursively
+          hash = {}
+          each_pair do |key, value|
+            new_key   = key.respond_to?(:to_sym) ? key.to_sym : key
+            new_value = value.respond_to?(:__nanoc_symbolize_keys_recursively) ? value.__nanoc_symbolize_keys_recursively : value
+            hash[new_key] = new_value
+          end
+          hash
+        end
+
+        def __nanoc_stringify_keys_recursively
+          hash = {}
+          each_pair do |key, value|
+            new_key   = key.is_a?(Symbol) ? key.to_s : key
+            new_value = value.respond_to?(:__nanoc_stringify_keys_recursively) ? value.__nanoc_stringify_keys_recursively : value
+            hash[new_key] = new_value
+          end
+          hash
+        end
+
+        # Freezes the contents of the hash, as well as all hash values. The hash
+        # values will be frozen using {#__nanoc_freeze_recursively} if they respond to
+        # that message, or #freeze if they do not.
+        #
+        # @see Array#__nanoc_freeze_recursively
+        #
+        # @return [void]
+        def __nanoc_freeze_recursively
+          return if frozen?
+
+          freeze
+          each_pair do |_key, value|
+            if value.respond_to?(:__nanoc_freeze_recursively)
+              value.__nanoc_freeze_recursively
+            else
+              value.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+class Hash
+  include Nanoc::Core::CoreExt::HashExtensions
+end

data/lib/nanoc/core/core_ext/string.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module CoreExt
+      module StringExtensions
+        # Transforms string into an actual identifier
+        #
+        # @return [String] The identifier generated from the receiver
+        def __nanoc_cleaned_identifier
+          "/#{self}/".gsub(/^\/+|\/+$/, '/')
+        end
+      end
+    end
+  end
+end
+
+class String
+  include Nanoc::Core::CoreExt::StringExtensions
+end

data/lib/nanoc/core/data_source.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Responsible for loading site data. It is the (abstract) superclass for all
+    # data sources. Subclasses must at least implement the data reading methods
+    # ({#items} and {#layouts}).
+    #
+    # Apart from the methods for loading and storing data, there are the {#up}
+    # and {#down} methods for bringing up and tearing down the connection to the
+    # data source. These should be overridden in subclasses. The {#loading}
+    # method wraps {#up} and {#down}. {#loading} is a convenience method for the
+    # more low-level methods {#use} and {#unuse}, which respectively increment
+    # and decrement the reference count; when the reference count goes from 0 to
+    # 1, the data source will be loaded ({#up} will be called) and when the
+    # reference count goes from 1 to 0, the data source will be unloaded
+    # ({#down} will be called).
+    #
+    # @abstract Subclasses should at least implement {#items} and {#layouts}.
+    class DataSource
+      # @return [String] The root path where items returned by this data source
+      #   should be mounted.
+      attr_reader :items_root
+
+      # @return [String] The root path where layouts returned by this data
+      #   source should be mounted.
+      attr_reader :layouts_root
+
+      # @return [Hash] The configuration for this data source. For example,
+      #   online data sources could contain authentication details.
+      attr_reader :config
+
+      extend DDPlugin::Plugin
+
+      def initialize(site_config, items_root, layouts_root, config)
+        @site_config  = site_config
+        @items_root   = items_root
+        @layouts_root = layouts_root
+        @config       = config || {}
+
+        @references = 0
+      end
+
+      # Marks the data source as used by the caller.
+      #
+      # Calling this method increases the internal reference count. When the
+      # data source is used for the first time (first {#use} call), the data
+      # source will be loaded ({#up} will be called).
+      #
+      # @return [void]
+      def use
+        up if @references.zero?
+        @references += 1
+      end
+
+      # Marks the data source as unused by the caller.
+      #
+      # Calling this method decreases the internal reference count. When the
+      # reference count reaches zero, i.e. when the data source is not used any
+      # more, the data source will be unloaded ({#down} will be called).
+      #
+      # @return [void]
+      def unuse
+        @references -= 1
+        down if @references.zero?
+      end
+
+      # Brings up the connection to the data. Depending on the way data is
+      # stored, this may not be necessary. This is the ideal place to connect to
+      # the database, for example.
+      #
+      # Subclasses may override this method, but are not required to do so; the
+      # default implementation simply does nothing.
+      #
+      # @return [void]
+      def up; end
+
+      # Brings down the connection to the data. This method should undo the
+      # effects of the {#up} method. For example, a database connection
+      # established in {#up} should be closed in this method.
+      #
+      # Subclasses may override this method, but are not required to do so; the
+      # default implementation simply does nothing.
+      #
+      # @return [void]
+      def down; end
+
+      # Returns the collection of items (represented by {Nanoc::Core::Item}) in
+      # this site. The default implementation simply returns an empty array.
+      #
+      # Subclasses should not prepend `items_root` to the item's identifiers, as
+      # this will be done automatically.
+      #
+      # Subclasses may override this method, but are not required to do so; the
+      # default implementation simply does nothing.
+      #
+      # @return [Enumerable] The collection of items
+      def items
+        []
+      end
+
+      # @api private
+      def item_changes
+        warn "Caution: Data source #{self.class.identifier.inspect} does not implement #item_changes; live compilation will not pick up changes in this data source."
+        Enumerator.new { |_y| sleep }
+      end
+
+      # @api private
+      def layout_changes
+        warn "Caution: Data source #{self.class.identifier.inspect} does not implement #layout_changes; live compilation will not pick up changes in this data source."
+        Enumerator.new { |_y| sleep }
+      end
+
+      # Returns the collection of layouts (represented by {Nanoc::Core::Layout}) in
+      # this site. The default implementation simply returns an empty array.
+      #
+      # Subclasses should prepend `layout_root` to the layout's identifiers,
+      # since this is not done automatically.
+      #
+      # Subclasses may override this method, but are not required to do so; the
+      # default implementation simply does nothing.
+      #
+      # @return [Enumerable] The collection of layouts
+      def layouts
+        []
+      end
+
+      # Creates a new in-memory item instance. This is intended for use within
+      # the {#items} method.
+      #
+      # @param [String, Proc] 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, Proc] attributes A hash containing this item's attributes.
+      #
+      # @param [String] identifier This item's identifier.
+      #
+      # @param [Boolean] binary Whether or not this item is binary
+      #
+      # @param [String, nil] checksum_data
+      #
+      # @param [String, nil] content_checksum_data
+      #
+      # @param [String, nil] attributes_checksum_data
+      def new_item(content, attributes, identifier, binary: false, checksum_data: nil, content_checksum_data: nil, attributes_checksum_data: nil)
+        content = Nanoc::Core::Content.create(content, binary: binary)
+        Nanoc::Core::Item.new(content, attributes, identifier, checksum_data: checksum_data, content_checksum_data: content_checksum_data, attributes_checksum_data: attributes_checksum_data)
+      end
+
+      # Creates a new in-memory layout instance. This is intended for use within
+      # the {#layouts} method.
+      #
+      # @param [String] raw_content The raw content of this layout.
+      #
+      # @param [Hash] attributes A hash containing this layout's attributes.
+      #
+      # @param [String] identifier This layout's identifier.
+      #
+      # @param [String, nil] checksum_data
+      #
+      # @param [String, nil] content_checksum_data
+      #
+      # @param [String, nil] attributes_checksum_data
+      def new_layout(raw_content, attributes, identifier, checksum_data: nil, content_checksum_data: nil, attributes_checksum_data: nil)
+        Nanoc::Core::Layout.new(raw_content, attributes, identifier, checksum_data: checksum_data, content_checksum_data: content_checksum_data, attributes_checksum_data: attributes_checksum_data)
+      end
+    end
+  end
+end