nanoc-core 4.11.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6b14c2953e85fe025ebc7b886e49e7c5479f9a2a5e4ae490b427760ed916646b
+  data.tar.gz: cdc17c42152a6ef9474e1406d1f2078884b298833213707b54cd2825785fe448
+SHA512:
+  metadata.gz: 0b039e4fdf615feb7cacd556600fa3cf967290335d2034cbe9046b59613ea0e8b736078aa83ca2fc2c921869ee50cf4e62f5fa823341674612ae72801df53dbc
+  data.tar.gz: e1b1374ba0c0bd461de1ccb8ec658dbe65f49c9b0eae2a48efe138757cea4f0f66c0a3b79e0243b9cbc6d6ad312b6a589dbbd3f620bea0948da37b79b82d156d

data/NEWS.md

@@ -0,0 +1,3 @@
+# nanoc-core news
+
+See the release notes for Nanoc for details.

data/README.md

@@ -0,0 +1,3 @@
+# nanoc-core
+
+This repository contains the core of Nanoc. It is designed to have no dependencies (neither gems nor external applications), and be operating system-agnostic.

data/lib/nanoc/core/binary_content.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class BinaryContent < Content
+      contract C::None => C::Bool
+      def binary?
+        true
+      end
+    end
+  end
+end

data/lib/nanoc/core/checksummer.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Creates checksums for given objects.
+    #
+    # A checksum is a string, such as “mL+TaqNsEeiPkWloPgCtAofT1yg=”, that is used
+    # to determine whether a piece of data has changed.
+    class Checksummer
+      class VerboseDigest
+        def initialize
+          @str = +''
+        end
+
+        def update(str)
+          @str << str
+        end
+
+        def to_s
+          @str
+        end
+      end
+
+      class CompactDigest
+        def initialize
+          @digest = Digest::SHA1.new
+        end
+
+        def update(str)
+          @digest.update(str)
+        end
+
+        def to_s
+          @digest.base64digest
+        end
+      end
+
+      class << self
+        # @param obj The object to create a checksum for
+        #
+        # @return [String] The digest
+        def calc(obj, digest_class = CompactDigest)
+          digest = digest_class.new
+          update(obj, digest)
+          digest.to_s
+        end
+
+        def calc_for_content_of(obj)
+          obj.content_checksum_data || obj.checksum_data || Nanoc::Core::Checksummer.calc(obj.content)
+        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)
+          end
+        end
+
+        def define_behavior(klass, behavior)
+          behaviors[klass] = behavior
+        end
+
+        private
+
+        def update(obj, digest, visited = Hamster::Set.new)
+          digest.update(obj.class.to_s)
+
+          if visited.include?(obj)
+            digest.update('<recur>')
+          else
+            digest.update('<')
+            behavior_for(obj).update(obj, digest) { |o| update(o, digest, visited.add(obj)) }
+            digest.update('>')
+          end
+        end
+
+        def behaviors
+          return @behaviors if @behaviors
+
+          @behaviors = {}
+
+          # NOTE: Other behaviors are registered elsewhere
+          # (search for `define_behavior`).
+
+          define_behavior(Array, ArrayUpdateBehavior)
+          define_behavior(FalseClass, NoUpdateBehavior)
+          define_behavior(Hash, HashUpdateBehavior)
+          define_behavior(NilClass, NoUpdateBehavior)
+          define_behavior(Numeric, RawUpdateBehavior)
+          define_behavior(Pathname, PathnameUpdateBehavior)
+          define_behavior(String, RawUpdateBehavior)
+          define_behavior(Symbol, RawUpdateBehavior)
+          define_behavior(Time, ToIToSUpdateBehavior)
+          define_behavior(TrueClass, NoUpdateBehavior)
+
+          define_behavior(Nanoc::Core::BinaryContent, BinaryContentUpdateBehavior)
+          define_behavior(Nanoc::Core::Configuration, HashUpdateBehavior)
+          define_behavior(Nanoc::Core::Context, ContextUpdateBehavior)
+          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)
+
+          @behaviors
+        end
+
+        def behavior_for_class(klass)
+          behaviors.fetch(klass) do
+            if Object.equal?(klass.superclass)
+              RescueUpdateBehavior
+            else
+              behavior_for_class(klass.superclass)
+            end
+          end
+        end
+
+        def behavior_for(obj)
+          behavior_for_class(obj.class)
+        end
+      end
+
+      class UpdateBehavior
+        def self.update(_obj, _digest)
+          raise NotImpementedError
+        end
+      end
+
+      class RuleContextUpdateBehavior < UpdateBehavior
+        def self.update(obj, digest)
+          digest.update('item=')
+          yield(obj.item)
+          digest.update(',rep=')
+          yield(obj.rep)
+          digest.update(',items=')
+          yield(obj.items)
+          digest.update(',layouts=')
+          yield(obj.layouts)
+          digest.update(',config=')
+          yield(obj.config)
+        end
+      end
+
+      class ContextUpdateBehavior < UpdateBehavior
+        def self.update(obj, digest)
+          obj.instance_variables.each do |var|
+            digest.update(var.to_s)
+            digest.update('=')
+            yield(obj.instance_variable_get(var))
+            digest.update(',')
+          end
+        end
+      end
+
+      class RawUpdateBehavior < UpdateBehavior
+        def self.update(obj, digest)
+          digest.update(obj.to_s)
+        end
+      end
+
+      class ToSUpdateBehavior < UpdateBehavior
+        def self.update(obj, _digest)
+          yield(obj.to_s)
+        end
+      end
+
+      class ToIToSUpdateBehavior < UpdateBehavior
+        def self.update(obj, digest)
+          digest.update(obj.to_i.to_s)
+        end
+      end
+
+      class StringUpdateBehavior < UpdateBehavior
+        def self.update(obj, _digest)
+          yield(obj.string)
+        end
+      end
+
+      class DataUpdateBehavior < UpdateBehavior
+        def self.update(obj, _digest)
+          yield(obj.data)
+        end
+      end
+
+      class NoUpdateBehavior < UpdateBehavior
+        def self.update(_obj, _digest); end
+      end
+
+      class UnwrapUpdateBehavior < UpdateBehavior
+        def self.update(obj, _digest)
+          yield(obj._unwrap)
+        end
+      end
+
+      class ArrayUpdateBehavior < UpdateBehavior
+        def self.update(obj, digest)
+          obj.each do |el|
+            yield(el)
+            digest.update(',')
+          end
+        end
+      end
+
+      class HashUpdateBehavior < UpdateBehavior
+        def self.update(obj, digest)
+          obj.each do |key, value|
+            yield(key)
+            digest.update('=')
+            yield(value)
+            digest.update(',')
+          end
+        end
+      end
+
+      class DocumentUpdateBehavior < UpdateBehavior
+        def self.update(obj, digest)
+          if obj.checksum_data
+            digest.update('checksum_data=' + obj.checksum_data)
+          else
+            if obj.content_checksum_data
+              digest.update('content_checksum_data=' + obj.content_checksum_data)
+            else
+              digest.update('content=')
+              yield(obj.content)
+            end
+
+            if obj.attributes_checksum_data
+              digest.update(',attributes_checksum_data=' + obj.attributes_checksum_data)
+            else
+              digest.update(',attributes=')
+              yield(obj.attributes)
+            end
+
+            digest.update(',identifier=')
+            yield(obj.identifier)
+          end
+        end
+      end
+
+      class ItemRepUpdateBehavior < UpdateBehavior
+        def self.update(obj, digest)
+          digest.update('item=')
+          yield(obj.item)
+          digest.update(',name=')
+          yield(obj.name)
+        end
+      end
+
+      class PathnameUpdateBehavior < UpdateBehavior
+        def self.update(obj, digest)
+          filename = obj.to_s
+          if File.exist?(filename)
+            stat = File.stat(filename)
+            digest.update(stat.size.to_s + '-' + stat.mtime.to_i.to_s)
+          else
+            digest.update('???')
+          end
+        end
+      end
+
+      class BinaryContentUpdateBehavior < UpdateBehavior
+        def self.update(obj, _digest)
+          yield(Pathname.new(obj.filename))
+        end
+      end
+
+      class RescueUpdateBehavior < UpdateBehavior
+        def self.update(obj, digest)
+          if obj.class.to_s == 'Sass::Importers::Filesystem'
+            digest.update('root=')
+            digest.update(obj.root)
+            return
+          end
+
+          data =
+            begin
+              Marshal.dump(obj)
+            rescue
+              obj.inspect
+            end
+
+          digest.update(data)
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/code_snippet.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Nanoc::Core::CodeSnippet represent a piece of custom code of a Nanoc site.
+    #
+    # @api private
+    class CodeSnippet
+      include Nanoc::Core::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
+        # rubocop:disable Security/Eval
+        eval('def self.use_helper(mod); Nanoc::Core::Context.instance_eval { include mod }; end', TOPLEVEL_BINDING)
+        eval(@data, TOPLEVEL_BINDING, @filename)
+        # rubocop:enable Security/Eval
+        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
+end

data/lib/nanoc/core/configuration-schema.json

@@ -0,0 +1,122 @@
+{
+  "$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/core/configuration.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Represents the site configuration.
+    class Configuration
+      include Nanoc::Core::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
+end