nanoc-core 4.11.12 → 4.11.13

data/lib/nanoc/core/outdatedness_rules/attributes_modified.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module OutdatednessRules
+      class AttributesModified < Nanoc::Core::OutdatednessRule
+        include Nanoc::Core::ContractsSupport
+
+        affects_props :attributes, :compiled_content
+
+        contract C::Or[Nanoc::Core::ItemRep, Nanoc::Core::Item, Nanoc::Core::Configuration, Nanoc::Core::Layout], C::Named['Nanoc::Core::OutdatednessChecker'] => C::Maybe[Nanoc::Core::OutdatednessReasons::Generic]
+        def apply(obj, outdatedness_checker)
+          case obj
+          when Nanoc::Core::ItemRep
+            apply(obj.item, outdatedness_checker)
+          when Nanoc::Core::Item, Nanoc::Core::Layout, Nanoc::Core::Configuration
+            if outdatedness_checker.checksum_store[obj] == outdatedness_checker.checksums.checksum_for(obj)
+              return nil
+            end
+
+            old_checksums = outdatedness_checker.checksum_store.attributes_checksum_for(obj)
+            unless old_checksums
+              return Nanoc::Core::OutdatednessReasons::AttributesModified.new(true)
+            end
+
+            new_checksums = outdatedness_checker.checksums.attributes_checksum_for(obj)
+
+            attributes = Set.new(old_checksums.keys) + Set.new(new_checksums.keys)
+            changed_attributes = attributes.reject { |a| old_checksums[a] == new_checksums[a] }
+
+            if changed_attributes.any?
+              Nanoc::Core::OutdatednessReasons::AttributesModified.new(changed_attributes)
+            end
+          else
+            raise ArgumentError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/outdatedness_rules/code_snippets_modified.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module OutdatednessRules
+      class CodeSnippetsModified < Nanoc::Core::OutdatednessRule
+        DDMemoize.activate(self)
+
+        include Nanoc::Core::ContractsSupport
+
+        affects_props :raw_content, :attributes, :compiled_content, :path
+
+        def apply(_obj, outdatedness_checker)
+          if any_snippets_modified?(outdatedness_checker)
+            Nanoc::Core::OutdatednessReasons::CodeSnippetsModified
+          end
+        end
+
+        private
+
+        memoized def any_snippets_modified?(outdatedness_checker)
+          outdatedness_checker.site.code_snippets.any? do |cs|
+            ch_old = outdatedness_checker.checksum_store[cs]
+            ch_new = outdatedness_checker.checksums.checksum_for(cs)
+            ch_old != ch_new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/outdatedness_rules/content_modified.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module OutdatednessRules
+      class ContentModified < Nanoc::Core::OutdatednessRule
+        affects_props :raw_content, :compiled_content
+
+        def apply(obj, outdatedness_checker)
+          obj = obj.item if obj.is_a?(Nanoc::Core::ItemRep)
+
+          ch_old = outdatedness_checker.checksum_store.content_checksum_for(obj)
+          ch_new = outdatedness_checker.checksums.content_checksum_for(obj)
+          if ch_old != ch_new
+            Nanoc::Core::OutdatednessReasons::ContentModified
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/outdatedness_rules/item_collection_extended.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module OutdatednessRules
+      class ItemCollectionExtended < Nanoc::Core::OutdatednessRule
+        affects_props :raw_content
+
+        contract Nanoc::Core::ItemCollection, C::Named['Nanoc::Core::OutdatednessChecker'] => C::Maybe[Nanoc::Core::OutdatednessReasons::Generic]
+        def apply(_obj, outdatedness_checker)
+          new_items = outdatedness_checker.dependency_store.new_items
+
+          if new_items.any?
+            Nanoc::Core::OutdatednessReasons::ItemCollectionExtended.new(new_items)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/outdatedness_rules/layout_collection_extended.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module OutdatednessRules
+      class LayoutCollectionExtended < Nanoc::Core::OutdatednessRule
+        affects_props :raw_content
+
+        contract Nanoc::Core::LayoutCollection, C::Named['Nanoc::Core::OutdatednessChecker'] => C::Maybe[Nanoc::Core::OutdatednessReasons::Generic]
+        def apply(_obj, outdatedness_checker)
+          new_layouts = outdatedness_checker.dependency_store.new_layouts
+
+          if new_layouts.any?
+            Nanoc::Core::OutdatednessReasons::LayoutCollectionExtended.new(new_layouts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/outdatedness_rules/not_written.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module OutdatednessRules
+      class NotWritten < Nanoc::Core::OutdatednessRule
+        affects_props :raw_content, :attributes, :compiled_content, :path
+
+        def apply(obj, _outdatedness_checker)
+          if obj.raw_paths.values.flatten.compact.any? { |fn| !File.file?(fn) }
+            Nanoc::Core::OutdatednessReasons::NotWritten
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/outdatedness_rules/rules_modified.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module OutdatednessRules
+      class RulesModified < Nanoc::Core::OutdatednessRule
+        affects_props :compiled_content, :path
+
+        def apply(obj, outdatedness_checker)
+          # Check rules of obj itself
+          if rules_modified?(obj, outdatedness_checker)
+            return Nanoc::Core::OutdatednessReasons::RulesModified
+          end
+
+          # Check rules of layouts used by obj
+          layouts = layouts_touched_by(obj, outdatedness_checker)
+          if layouts.any? { |layout| rules_modified?(layout, outdatedness_checker) }
+            return Nanoc::Core::OutdatednessReasons::RulesModified
+          end
+
+          nil
+        end
+
+        private
+
+        def rules_modified?(obj, outdatedness_checker)
+          seq_old = outdatedness_checker.action_sequence_store[obj]
+          seq_new = outdatedness_checker.action_sequence_for(obj).serialize
+
+          !seq_old.eql?(seq_new)
+        end
+
+        def layouts_touched_by(obj, outdatedness_checker)
+          actions = outdatedness_checker.action_sequence_store[obj]
+          layout_actions = actions.select { |a| a.first == :layout }
+
+          layout_actions.map do |layout_action|
+            layout_pattern = layout_action[1]
+            outdatedness_checker.site.layouts[layout_pattern]
+          end.compact
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/outdatedness_rules/uses_always_outdated_filter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module OutdatednessRules
+      class UsesAlwaysOutdatedFilter < Nanoc::Core::OutdatednessRule
+        affects_props :raw_content, :attributes, :path
+
+        def apply(obj, outdatedness_checker)
+          seq = outdatedness_checker.action_sequence_for(obj)
+          if any_always_outdated?(seq)
+            Nanoc::Core::OutdatednessReasons::UsesAlwaysOutdatedFilter
+          end
+        end
+
+        def any_always_outdated?(seq)
+          seq
+            .select { |a| a.is_a?(Nanoc::Core::ProcessingActions::Filter) }
+            .map { |a| Nanoc::Core::Filter.named(a.filter_name) }
+            .compact
+            .any?(&:always_outdated?)
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/post_compile_item_collection_view.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class PostCompileItemCollectionView < Nanoc::Core::IdentifiableCollectionView
+      # @api private
+      def view_class
+        Nanoc::Core::PostCompileItemView
+      end
+    end
+  end
+end

data/lib/nanoc/core/post_compile_item_rep_collection_view.rb

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

data/lib/nanoc/core/post_compile_item_rep_view.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class PostCompileItemRepView < ::Nanoc::Core::BasicItemRepView
+      def item_view_class
+        Nanoc::Core::PostCompileItemView
+      end
+
+      def compiled_content(snapshot: nil)
+        compilation_context = @context.compilation_context
+        snapshot_contents = compilation_context.compiled_content_cache[_unwrap] || {}
+
+        snapshot_name = snapshot || (snapshot_contents[:pre] ? :pre : :last)
+
+        unless snapshot_contents[snapshot_name]
+          raise Nanoc::Core::Errors::NoSuchSnapshot.new(_unwrap, snapshot_name)
+        end
+
+        content = snapshot_contents[snapshot_name]
+        if content.binary?
+          raise Nanoc::Core::Errors::CannotGetCompiledContentOfBinaryItem.new(_unwrap)
+        end
+
+        content.string
+      end
+
+      def raw_path(snapshot: :last)
+        @item_rep.raw_path(snapshot: snapshot)
+      end
+    end
+  end
+end

data/lib/nanoc/core/post_compile_item_view.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class PostCompileItemView < Nanoc::Core::CompilationItemView
+      def reps
+        Nanoc::Core::PostCompileItemRepCollectionView.new(@context.reps[_unwrap], @context)
+      end
+
+      # @deprecated Use {#modified_reps} instead
+      def modified
+        modified_reps
+      end
+
+      def modified_reps
+        reps.select { |rep| rep._unwrap.modified? }
+      end
+    end
+  end
+end

data/lib/nanoc/core/pruner.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Responsible for finding and deleting files in the site’s output directory
+    # that are not managed by Nanoc.
+    class Pruner
+      include Nanoc::Core::ContractsSupport
+
+      contract Nanoc::Core::Configuration, Nanoc::Core::ItemRepRepo, C::KeywordArgs[dry_run: C::Optional[C::Bool], exclude: C::Optional[C::IterOf[String]]] => C::Any
+      def initialize(config, reps, dry_run: false, exclude: [])
+        @config  = config
+        @reps    = reps
+        @dry_run = dry_run
+        @exclude = Set.new(exclude)
+      end
+
+      def run
+        return unless File.directory?(@config.output_dir)
+
+        compiled_files = @reps.flat_map { |r| r.raw_paths.values.flatten }.compact
+        present_files, present_dirs = files_and_dirs_in(@config.output_dir + '/')
+
+        remove_stray_files(present_files, compiled_files)
+        remove_empty_directories(present_dirs)
+      end
+
+      contract String => C::Bool
+      def filename_excluded?(filename)
+        pathname = Pathname.new(strip_output_dir(filename))
+        @exclude.any? { |e| pathname_components(pathname).include?(e) }
+      end
+
+      contract String => String
+      def strip_output_dir(filename)
+        if filename.start_with?(@config.output_dir)
+          filename[@config.output_dir.size..-1]
+        else
+          filename
+        end
+      end
+
+      contract Pathname => C::ArrayOf[String]
+      def pathname_components(pathname)
+        components = []
+        tmp = pathname
+        loop do
+          old = tmp
+          components << File.basename(tmp)
+          tmp = File.dirname(tmp)
+          break if old == tmp
+        end
+        components.reverse
+      end
+
+      contract C::ArrayOf[String], C::ArrayOf[String] => self
+      # @api private
+      def remove_stray_files(present_files, compiled_files)
+        (present_files - compiled_files).each do |f|
+          delete_file(f) unless filename_excluded?(f)
+        end
+        self
+      end
+
+      contract C::ArrayOf[String] => self
+      # @api private
+      def remove_empty_directories(present_dirs)
+        present_dirs.reverse_each do |dir|
+          next if Dir.foreach(dir) { |n| break true if n !~ /\A\.\.?\z/ }
+          next if filename_excluded?(dir)
+
+          delete_dir(dir)
+        end
+        self
+      end
+
+      contract String => C::ArrayOf[C::ArrayOf[String]]
+      # @api private
+      def files_and_dirs_in(dir)
+        present_files = []
+        present_dirs = []
+
+        expanded_dir = File.expand_path(dir)
+
+        Find.find(dir) do |f|
+          case File.ftype(f)
+          when 'file'
+            unless filename_excluded?(f)
+              present_files << f
+            end
+          when 'directory'
+            if filename_excluded?(f)
+              Find.prune
+            elsif expanded_dir != File.expand_path(f)
+              present_dirs << f
+            end
+          end
+        end
+
+        [present_files, present_dirs]
+      end
+
+      protected
+
+      def delete_file(file)
+        log_delete_and_run(file) { FileUtils.rm(file) }
+      end
+
+      def delete_dir(dir)
+        log_delete_and_run(dir) { Dir.rmdir(dir) }
+      end
+
+      def log_delete_and_run(thing)
+        Nanoc::Core::NotificationCenter.post(:file_pruned, thing)
+        yield unless @dry_run
+      end
+    end
+  end
+end

data/lib/nanoc/core/site_loader.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class SiteLoader
+      ENCODING_REGEX = /\A#\s+(-\*-\s+)?(en)?coding: (?<encoding>[^\s]+)(\s+-\*-\s*)?\n{0,2}/.freeze
+
+      def new_from_cwd
+        site_from_config(Nanoc::Core::ConfigLoader.new.new_from_cwd)
+      end
+
+      # @return [Boolean]
+      def self.cwd_is_nanoc_site?
+        Nanoc::Core::ConfigLoader.cwd_is_nanoc_site?
+      end
+
+      def gen_data_source_for_config(config)
+        data_sources_to_aggregate =
+          with_data_sources(config) do |data_sources|
+            data_sources.map do |ds|
+              Nanoc::Core::PrefixedDataSource.new(ds, ds.items_root, ds.layouts_root)
+            end
+          end
+
+        Nanoc::Core::AggregateDataSource.new(data_sources_to_aggregate, config)
+      end
+
+      private
+
+      def site_from_config(config)
+        code_snippets = code_snippets_from_config(config)
+        code_snippets.each(&:load)
+
+        data_source = gen_data_source_for_config(config)
+
+        Nanoc::Core::Site.new(
+          config: config,
+          code_snippets: code_snippets,
+          data_source: data_source,
+        )
+      end
+
+      def with_data_sources(config, &_block)
+        data_sources = create_data_sources(config)
+
+        begin
+          data_sources.each(&:use)
+          yield(data_sources)
+        ensure
+          data_sources.each(&:unuse)
+        end
+      end
+
+      def create_data_sources(config)
+        config[:data_sources].map do |data_source_hash|
+          # Get data source class
+          data_source_class = Nanoc::Core::DataSource.named(data_source_hash[:type].to_sym)
+          if data_source_class.nil?
+            raise Nanoc::Core::Errors::UnknownDataSource.new(data_source_hash[:type])
+          end
+
+          # Create data source
+          data_source_class.new(
+            config,
+            data_source_hash[:items_root],
+            data_source_hash[:layouts_root],
+            data_source_hash.merge(data_source_hash[:config] || {}),
+          )
+        end
+      end
+
+      def code_snippets_from_config(config)
+        config[:lib_dirs].flat_map do |lib|
+          Dir["#{lib}/**/*.rb"].sort.map do |filename|
+            Nanoc::Core::CodeSnippet.new(
+              read_code_snippet_contents(filename),
+              filename,
+            )
+          end
+        end
+      end
+
+      def encoding_from_magic_comment(raw)
+        match = ENCODING_REGEX.match(raw)
+        match ? match['encoding'] : nil
+      end
+
+      def read_code_snippet_contents(filename)
+        raw = File.read(filename, encoding: 'ASCII-8BIT')
+
+        enc = encoding_from_magic_comment(raw)
+        if enc
+          raw = raw.force_encoding(enc).encode('UTF-8').sub(ENCODING_REGEX, '')
+        else
+          raw.force_encoding('UTF-8')
+        end
+
+        raw
+      end
+    end
+  end
+end