nanoc 4.11.0 → 4.11.1

data/lib/nanoc/base/contracts_support.rb

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

data/lib/nanoc/base/core_ext.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require 'nanoc/base/core_ext/array'
-require 'nanoc/base/core_ext/hash'
-require 'nanoc/base/core_ext/string'

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-# @api private
-module Nanoc::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
-
-# @api private
-class Array
-  include Nanoc::ArrayExtensions
-end

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

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-# @api private
-module Nanoc::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
-
-# @api private
-class Hash
-  include Nanoc::HashExtensions
-end

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

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

data/lib/nanoc/base/entities/code_snippet.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Int
-  # Nanoc::Int::CodeSnippet represent a piece of custom code of a Nanoc site.
-  #
-  # @api private
-  class CodeSnippet
-    include Nanoc::Int::ContractsSupport
-
-    # A string containing the actual code in this code snippet.
-    #
-    # @return [String]
-    attr_reader :data
-
-    # The filename corresponding to this code snippet.
-    #
-    # @return [String]
-    attr_reader :filename
-
-    contract String, String => C::Any
-    # Creates a new code snippet.
-    #
-    # @param [String] data The raw source code which will be executed before
-    #   compilation
-    #
-    # @param [String] filename The filename corresponding to this code snippet
-    def initialize(data, filename)
-      @data     = data
-      @filename = filename
-    end
-
-    contract C::None => nil
-    # Loads the code by executing it.
-    #
-    # @return [void]
-    def load
-      eval('def self.use_helper(mod); Nanoc::Int::Context.instance_eval { include mod }; end', TOPLEVEL_BINDING)
-      eval(@data, TOPLEVEL_BINDING, @filename)
-      nil
-    end
-
-    # Returns an object that can be used for uniquely identifying objects.
-    #
-    # @return [Object] An unique reference to this object
-    def reference
-      "code_snippet:#{filename}"
-    end
-
-    def inspect
-      "<#{self.class} filename=\"#{filename}\">"
-    end
-  end
-end

data/lib/nanoc/base/entities/configuration-schema.json

@@ -1,122 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-04/schema#",
-  "title": "Nanoc configuration schema",
-  "type": "object",
-  "properties": {
-    "text_extensions": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      }
-    },
-    "output_dir": {
-      "type": "string"
-    },
-    "index_filenames": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      }
-    },
-    "enable_output_diff": {
-      "type": "boolean"
-    },
-    "prune": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "auto_prune": {
-          "type": "boolean"
-        },
-        "exclude": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        }
-      }
-    },
-    "commands_dirs": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      }
-    },
-    "lib_dirs": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      }
-    },
-    "data_sources": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string"
-          },
-          "items_root": {
-            "anyOf": [
-              { "type": "string" },
-              { "type": "null" }
-            ]
-          },
-          "layouts_root": {
-            "anyOf": [
-              { "type": "string" },
-              { "type": "null" }
-            ]
-          }
-        }
-      }
-    },
-    "string_pattern_type": {
-      "type": "string",
-      "enum": ["glob", "legacy"]
-    },
-    "checks": {
-      "type": "object",
-      "properties": {
-        "internal_links": {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "exclude": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            }
-          }
-        },
-        "external_links": {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "exclude": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            },
-            "exclude_files": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            }
-          }
-        }
-      }
-    },
-    "environments": {
-      "type": "object",
-      "patternProperties": {
-        "^.*$": {
-          "type": "object"
-        }
-      }
-    }
-  }
-}

data/lib/nanoc/base/entities/configuration.rb

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Int
-  # Represents the site configuration.
-  #
-  # @api private
-  class Configuration
-    include Nanoc::Int::ContractsSupport
-
-    NONE = Object.new.freeze
-
-    # The default configuration for a data source. A data source's
-    # configuration overrides these options.
-    DEFAULT_DATA_SOURCE_CONFIG = {
-      type: 'filesystem',
-      items_root: '/',
-      layouts_root: '/',
-      config: {},
-      identifier_type: 'full',
-    }.freeze
-
-    # The default configuration for a site. A site's configuration overrides
-    # these options: when a {Nanoc::Int::Site} is created with a configuration
-    # that lacks some options, the default value will be taken from
-    # `DEFAULT_CONFIG`.
-    DEFAULT_CONFIG = {
-      text_extensions: %w[adoc asciidoc atom css erb haml htm html js less markdown md php rb sass scss tex txt xhtml xml coffee hb handlebars mustache ms slim rdoc].sort,
-      lib_dirs: %w[lib],
-      commands_dirs: %w[commands],
-      output_dir: 'output',
-      data_sources: [{}],
-      index_filenames: ['index.html'],
-      enable_output_diff: false,
-      prune: { auto_prune: false, exclude: ['.git', '.hg', '.svn', 'CVS'] },
-      string_pattern_type: 'glob',
-      action_provider: 'rule_dsl',
-    }.freeze
-
-    # @return [String, nil] The active environment for the configuration
-    attr_reader :env_name
-
-    contract C::None => C::AbsolutePathString
-    attr_reader :dir
-
-    # Configuration environments property key
-    ENVIRONMENTS_CONFIG_KEY = :environments
-    NANOC_ENV = 'NANOC_ENV'
-    NANOC_ENV_DEFAULT = 'default'
-
-    contract C::KeywordArgs[hash: C::Optional[Hash], env_name: C::Maybe[String], dir: C::AbsolutePathString] => C::Any
-    def initialize(hash: {}, dir:, env_name: nil)
-      @env_name = env_name
-      @wrapped = hash.__nanoc_symbolize_keys_recursively
-      @dir = dir
-
-      validate
-    end
-
-    contract C::None => self
-    def with_defaults
-      new_wrapped = DEFAULT_CONFIG.merge(@wrapped)
-      new_wrapped[:data_sources] = new_wrapped[:data_sources].map do |ds|
-        DEFAULT_DATA_SOURCE_CONFIG.merge(ds)
-      end
-
-      self.class.new(hash: new_wrapped, dir: @dir, env_name: @env_name)
-    end
-
-    def with_environment
-      return self unless @wrapped.key?(ENVIRONMENTS_CONFIG_KEY)
-
-      # Set active environment
-      env_name = @env_name || ENV.fetch(NANOC_ENV, NANOC_ENV_DEFAULT)
-
-      # Load given environment configuration
-      env_config = @wrapped[ENVIRONMENTS_CONFIG_KEY].fetch(env_name.to_sym, {})
-
-      self.class.new(hash: @wrapped, dir: @dir, env_name: env_name).merge(env_config)
-    end
-
-    contract C::None => Hash
-    def to_h
-      @wrapped
-    end
-
-    # For compat
-    contract C::None => Hash
-    def attributes
-      to_h
-    end
-
-    contract C::Any => C::Bool
-    def key?(key)
-      @wrapped.key?(key)
-    end
-
-    contract C::Any => C::Any
-    def [](key)
-      @wrapped[key]
-    end
-
-    contract C::Args[C::Any] => C::Any
-    def dig(*keys)
-      @wrapped.dig(*keys)
-    end
-
-    contract C::Any, C::Maybe[C::Any], C::Maybe[C::Func[C::None => C::Any]] => C::Any
-    def fetch(key, fallback = NONE, &_block)
-      @wrapped.fetch(key) do
-        if !fallback.equal?(NONE)
-          fallback
-        elsif block_given?
-          yield(key)
-        else
-          raise KeyError, "key not found: #{key.inspect}"
-        end
-      end
-    end
-
-    contract C::Any, C::Any => C::Any
-    def []=(key, value)
-      @wrapped[key] = value
-    end
-
-    contract C::Or[Hash, self] => self
-    def merge(hash)
-      self.class.new(hash: merge_recursively(@wrapped, hash.to_h), dir: @dir, env_name: @env_name)
-    end
-
-    contract C::Any => self
-    def without(key)
-      self.class.new(hash: @wrapped.reject { |k, _v| k == key }, dir: @dir, env_name: @env_name)
-    end
-
-    contract C::Any => self
-    def update(hash)
-      @wrapped.update(hash)
-      self
-    end
-
-    contract C::Func[C::Any, C::Any => C::Any] => self
-    def each
-      @wrapped.each { |k, v| yield(k, v) }
-      self
-    end
-
-    contract C::None => self
-    def freeze
-      super
-      @wrapped.__nanoc_freeze_recursively
-      self
-    end
-
-    contract C::None => C::AbsolutePathString
-    def output_dir
-      make_absolute(self[:output_dir]).freeze
-    end
-
-    contract C::None => Symbol
-    def action_provider
-      self[:action_provider].to_sym
-    end
-
-    contract C::None => C::IterOf[C::AbsolutePathString]
-    def output_dirs
-      envs = @wrapped.fetch(ENVIRONMENTS_CONFIG_KEY, {})
-      res = [output_dir] + envs.values.map { |v| make_absolute(v[:output_dir]) }
-      res.uniq.compact
-    end
-
-    # Returns an object that can be used for uniquely identifying objects.
-    #
-    # @return [Object] An unique reference to this object
-    def reference
-      'configuration'
-    end
-
-    def inspect
-      "<#{self.class}>"
-    end
-
-    private
-
-    def make_absolute(path)
-      path && @dir && File.absolute_path(path, @dir).encode('UTF-8')
-    end
-
-    def merge_recursively(config1, config2)
-      config1.merge(config2) do |_, value1, value2|
-        if value1.is_a?(Hash) && value2.is_a?(Hash)
-          merge_recursively(value1, value2)
-        else
-          value2
-        end
-      end
-    end
-
-    def validate
-      dir = File.dirname(__FILE__)
-      schema_data = JSON.parse(File.read(dir + '/configuration-schema.json'))
-      schema = JsonSchema.parse!(schema_data)
-      schema.expand_references!
-      schema.validate!(@wrapped.__nanoc_stringify_keys_recursively)
-    end
-  end
-end