nanoc 4.0.0b3 → 4.0.0b4

data/lib/nanoc/base/services.rb

@@ -0,0 +1,5 @@
+require_relative 'services/executor'
+require_relative 'services/item_rep_writer'
+require_relative 'services/notification_center'
+require_relative 'services/recording_executor'
+require_relative 'services/temp_filename_factory'

data/lib/nanoc/base/services/executor.rb

@@ -0,0 +1,141 @@
+module Nanoc
+  module Int
+    class Executor
+      def initialize(compiler)
+        @compiler = compiler
+      end
+
+      def filter(rep, filter_name, filter_args = {})
+        # Get filter class
+        klass = Nanoc::Filter.named(filter_name)
+        raise Nanoc::Int::Errors::UnknownFilter.new(filter_name) if klass.nil?
+
+        # Check whether filter can be applied
+        if klass.from_binary? && !rep.binary?
+          raise Nanoc::Int::Errors::CannotUseBinaryFilter.new(rep, klass)
+        elsif !klass.from_binary? && rep.binary?
+          raise Nanoc::Int::Errors::CannotUseTextualFilter.new(rep, klass)
+        end
+
+        begin
+          # Notify start
+          Nanoc::Int::NotificationCenter.post(:filtering_started, rep, filter_name)
+
+          # Create filter
+          filter = klass.new(assigns_for(rep))
+
+          # Run filter
+          last = rep.content_snapshots[:last]
+          source = rep.binary? ? last.filename : last.string
+          result = filter.setup_and_run(source, filter_args)
+          if klass.to_binary?
+            rep.content_snapshots[:last] = Nanoc::Int::BinaryContent.new(filter.output_filename).tap(&:freeze)
+          else
+            rep.content_snapshots[:last] = Nanoc::Int::TextualContent.new(result).tap(&:freeze)
+          end
+
+          # Check whether file was written
+          if klass.to_binary? && !File.file?(filter.output_filename)
+            raise "The #{filter_name.inspect} filter did not write anything to the required output file, #{filter.output_filename}."
+          end
+
+          # Create snapshot
+          snapshot(rep, rep.content_snapshots[:post] ? :post : :pre, final: false) unless rep.binary?
+        ensure
+          # Notify end
+          Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, filter_name)
+        end
+      end
+
+      def layout(rep, layout_identifier, extra_filter_args = nil)
+        layout = find_layout(layout_identifier)
+        filter_name, filter_args = @compiler.rules_collection.filter_for_layout(layout)
+        if filter_name.nil?
+          raise Nanoc::Int::Errors::Generic, "Cannot find rule for layout matching #{layout_identifier}"
+        end
+        filter_args = filter_args.merge(extra_filter_args || {})
+
+        # Check whether item can be laid out
+        raise Nanoc::Int::Errors::CannotLayoutBinaryItem.new(rep) if rep.binary?
+
+        # Create "pre" snapshot
+        if rep.content_snapshots[:post].nil?
+          snapshot(rep, :pre, final: true)
+        end
+
+        # Create filter
+        klass = Nanoc::Filter.named(filter_name)
+        raise Nanoc::Int::Errors::UnknownFilter.new(filter_name) if klass.nil?
+        filter = klass.new(assigns_for(rep).merge({ layout: layout }))
+
+        # Visit
+        Nanoc::Int::NotificationCenter.post(:visit_started, layout)
+        Nanoc::Int::NotificationCenter.post(:visit_ended,   layout)
+
+        begin
+          # Notify start
+          Nanoc::Int::NotificationCenter.post(:processing_started, layout)
+          Nanoc::Int::NotificationCenter.post(:filtering_started,  rep, filter_name)
+
+          # Layout
+          content = layout.content
+          arg = content.binary? ? content.filename : content.string
+          res = filter.setup_and_run(arg, filter_args)
+          rep.content_snapshots[:last] = Nanoc::Int::TextualContent.new(res).tap(&:freeze)
+
+          # Create "post" snapshot
+          snapshot(rep, :post, final: false)
+        ensure
+          # Notify end
+          Nanoc::Int::NotificationCenter.post(:filtering_ended,  rep, filter_name)
+          Nanoc::Int::NotificationCenter.post(:processing_ended, layout)
+        end
+      end
+
+      def snapshot(rep, snapshot_name, params = {})
+        is_final = params.fetch(:final, true)
+
+        unless rep.binary?
+          rep.content_snapshots[snapshot_name] = rep.content_snapshots[:last]
+        end
+
+        if snapshot_name == :pre && is_final
+          rep.snapshots << [:pre, true]
+        end
+
+        if is_final
+          raw_path = rep.raw_path(snapshot: snapshot_name)
+          if raw_path
+            ItemRepWriter.new.write(rep, raw_path)
+          end
+        end
+      end
+
+      def assigns_for(rep)
+        @compiler.assigns_for(rep)
+      end
+
+      def layouts
+        @compiler.site.layouts
+      end
+
+      def find_layout(arg)
+        req_id = arg.__nanoc_cleaned_identifier
+        layout = layouts.find { |l| l.identifier == req_id }
+        return layout if layout
+
+        if use_globs?
+          pat = Nanoc::Int::Pattern.from(arg)
+          layout = layouts.find { |l| pat.match?(l.identifier) }
+          return layout if layout
+        end
+
+        raise Nanoc::Int::Errors::UnknownLayout.new(arg)
+      end
+
+      def use_globs?
+        @compiler.site.config[:string_pattern_type] == 'glob'
+      end
+    end
+  end
+end

data/lib/nanoc/base/services/item_rep_writer.rb

@@ -0,0 +1,40 @@
+module Nanoc::Int
+  # @api private
+  class ItemRepWriter
+    TMP_TEXT_ITEMS_DIR = 'text_items'
+
+    def write(item_rep, raw_path)
+      # Create parent directory
+      FileUtils.mkdir_p(File.dirname(raw_path))
+
+      # Check if file will be created
+      is_created = !File.file?(raw_path)
+
+      # Notify
+      Nanoc::Int::NotificationCenter.post(
+        :will_write_rep, item_rep, raw_path)
+
+      content = item_rep.content_snapshots[:last]
+      if content.binary?
+        temp_path = content.filename
+      else
+        temp_path = temp_filename
+        File.write(temp_path, content.string)
+      end
+
+      # Check whether content was modified
+      is_modified = is_created || !FileUtils.identical?(raw_path, temp_path)
+
+      # Write
+      FileUtils.cp(temp_path, raw_path) if is_modified
+
+      # Notify
+      Nanoc::Int::NotificationCenter.post(
+        :rep_written, item_rep, raw_path, is_created, is_modified)
+    end
+
+    def temp_filename
+      Nanoc::Int::TempFilenameFactory.instance.create(TMP_TEXT_ITEMS_DIR)
+    end
+  end
+end

data/lib/nanoc/base/services/recording_executor.rb

@@ -0,0 +1,41 @@
+module Nanoc
+  module Int
+    class RecordingExecutor
+      attr_reader :rule_memory
+
+      def initialize
+        @rule_memory = []
+      end
+
+      def filter(rep, filter_name, filter_args = {})
+        @rule_memory << [:filter, filter_name, filter_args]
+      end
+
+      def layout(rep, layout_identifier, extra_filter_args = nil)
+        if extra_filter_args
+          @rule_memory << [:layout, layout_identifier, extra_filter_args]
+        else
+          @rule_memory << [:layout, layout_identifier]
+        end
+      end
+
+      def snapshot(rep, snapshot_name, params = {})
+        @rule_memory << [:snapshot, snapshot_name, params]
+
+        # Count
+        existing = Set.new
+        names = @rule_memory.select { |r| r[0] == :snapshot }.map { |r| r[1] }
+        names.each do |n|
+          if existing.include?(n)
+            raise Nanoc::Int::Errors::CannotCreateMultipleSnapshotsWithSameName.new(@item_rep, snapshot_name)
+          end
+          existing << n
+        end
+      end
+
+      def record_write(rep, path)
+        @rule_memory << [:write, path]
+      end
+    end
+  end
+end

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

@@ -44,11 +44,5 @@ module Nanoc::Int
     def inspect
       "<#{self.class} filename=\"#{filename}\">"
     end
-
-    # @return [String] The checksum for this object. If its contents change,
-    #   the checksum will change as well.
-    def __nanoc_checksum
-      Nanoc::Int::Checksummer.calc(self)
-    end
   end
 end

data/lib/nanoc/base/source_data/data_source.rb

@@ -143,7 +143,7 @@ module Nanoc
     # Creates a new in-memory item instance. This is intended for use within
     # the {#items} method.
     #
-    # @param [String] raw_content_or_raw_filename The uncompiled item content
+    # @param [String] 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).
     #
@@ -155,8 +155,9 @@ module Nanoc
     #
     # @option params [Symbol, nil] :binary (true) Whether or not this item is
     #   binary
-    def new_item(raw_content_or_raw_filename, attributes, identifier, params = {})
-      Nanoc::Int::Item.new(raw_content_or_raw_filename, attributes, identifier, params)
+    def new_item(content, attributes, identifier, params = {})
+      content = Nanoc::Int::Content.create(content, params)
+      Nanoc::Int::Item.new(content, attributes, identifier)
     end
 
     # Creates a new in-memory layout instance. This is intended for use within

data/lib/nanoc/base/source_data/item.rb

@@ -1,32 +1,9 @@
 module Nanoc::Int
-  # Represents a compileable item in a site. It has content and attributes, as
-  # well as an identifier (which starts and ends with a slash). It can also
-  # store the modification time to speed up compilation.
-  #
   # @api private
-  class Item
-    extend Nanoc::Int::Memoization
-
-    # @return [Hash] This item's attributes
-    attr_accessor :attributes
-
-    # @return [Nanoc::Identifier] This item's identifier
-    attr_accessor :identifier
-
+  class Item < ::Nanoc::Int::Document
     # @return [Array<Nanoc::Int::ItemRep>] This item’s list of item reps
     attr_reader :reps
 
-    # @return [String] This item's raw, uncompiled content of this item (only
-    #   available for textual items)
-    attr_reader :raw_content
-
-    # @return [String] The filename pointing to the file containing this
-    #   item’s content
-    attr_reader :raw_filename
-
-    # @return [Nanoc::Int::Site] The site this item belongs to
-    attr_accessor :site
-
     # @return [Nanoc::Int::Item, nil] The parent item of this item. This can be
     #   nil even for non-root items.
     attr_accessor :parent
@@ -34,148 +11,19 @@ module Nanoc::Int
     # @return [Array<Nanoc::Int::Item>] The child items of this item
     attr_accessor :children
 
-    # Creates a new item with the given content or filename, attributes and
-    # identifier.
-    #
-    # @param [String] raw_content_or_raw_filename 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] attributes A hash containing this item's attributes.
-    #
-    # @param [String] identifier This item's identifier.
-    #
-    # @param [Hash] params Extra parameters.
-    #
-    # @option params [Symbol, nil] :binary (true) Whether or not this item is
-    #   binary
-    def initialize(raw_content_or_raw_filename, attributes, identifier, params = {})
-      # Parse params
-      params = params.merge(binary: false) unless params.key?(:binary)
-
-      if raw_content_or_raw_filename.nil?
-        raise "attempted to create an item with no content/filename (identifier #{identifier})"
-      end
-
-      # Get type and raw content or raw filename
-      @is_binary = params[:binary]
-      if @is_binary
-        @raw_filename = raw_content_or_raw_filename
-      else
-        @raw_filename = attributes[:content_filename]
-        @raw_content  = raw_content_or_raw_filename
-      end
-
-      # Get rest of params
-      @attributes   = attributes.__nanoc_symbolize_keys_recursively
-      @identifier   = Nanoc::Identifier.from(identifier)
-
-      # Set mtime
-      @attributes.merge!(mtime: params[:mtime]) if params[:mtime]
+    # @see Document#initialize
+    def initialize(content, attributes, identifier)
+      super
 
-      @parent       = nil
-      @children     = []
-
-      @reps         = []
-    end
-
-    # Returns the rep with the given name.
-    #
-    # @param [Symbol] rep_name The name of the representation to return
-    #
-    # @return [Nanoc::Int::ItemRep] The representation with the given name
-    def rep_named(rep_name)
-      @reps.find { |r| r.name == rep_name }
+      @parent = nil
+      @children = []
+      @reps = []
+      @forced_outdated_status = ForcedOutdatedStatus.new
     end
 
-    # Returns the compiled content from a given representation and a given
-    # snapshot. This is a convenience method that makes fetching compiled
-    # content easier.
-    #
-    # @option params [String] :rep (:default) The name of the representation
-    #   from which the compiled content should be fetched. By default, the
-    #   compiled content will be fetched from the default representation.
-    #
-    # @option params [String] :snapshot The name of the snapshot from which to
-    #   fetch the compiled content. By default, the returned compiled content
-    #   will be the content compiled right before the first layout call (if
-    #   any).
-    #
-    # @return [String] The compiled content of the given rep (or the default
-    #   rep if no rep is specified) at the given snapshot (or the default
-    #   snapshot if no snapshot is specified)
-    #
-    # @see ItemRep#compiled_content
-    def compiled_content(params = {})
-      # Get rep
-      rep_name = params[:rep] || :default
-      rep = reps.find { |r| r.name == rep_name }
-      if rep.nil?
-        raise Nanoc::Int::Errors::Generic,
-          "No rep named #{rep_name.inspect} was found."
-      end
-
-      # Get rep's content
-      rep.compiled_content(params)
-    end
-
-    # Returns the path from a given representation. This is a convenience
-    # method that makes fetching the path of a rep easier.
-    #
-    # @option params [String] :rep (:default) The name of the representation
-    #   from which the path should be fetched. By default, the path will be
-    #   fetched from the default representation.
-    #
-    # @return [String] The path of the given rep ( or the default rep if no
-    #   rep is specified)
-    def path(params = {})
-      rep_name = params[:rep] || :default
-
-      # Get rep
-      rep = reps.find { |r| r.name == rep_name }
-      if rep.nil?
-        raise Nanoc::Int::Errors::Generic,
-          "No rep named #{rep_name.inspect} was found."
-      end
-
-      # Get rep's path
-      rep.path
-    end
-
-    # Requests the attribute with the given key.
-    #
-    # @param [Symbol] key The name of the attribute to fetch
-    #
-    # @return [Object] The value of the requested attribute
-    def [](key)
-      Nanoc::Int::NotificationCenter.post(:visit_started, self)
-      Nanoc::Int::NotificationCenter.post(:visit_ended,   self)
-
-      @attributes[key]
-    end
-
-    # Sets the attribute with the given key to the given value.
-    #
-    # @param [Symbol] key The name of the attribute to set
-    #
-    # @param [Object] value The value of the attribute to set
-    def []=(key, value)
-      @attributes[key] = value
-    end
-
-    # @return [Boolean] True if the item is binary; false if it is not
-    def binary?
-      @is_binary
-    end
-
-    # Returns the type of this object. Will always return `:item`, because
-    # this is an item. For layouts, this method returns `:layout`.
-    #
-    # @api private
-    #
-    # @return [Symbol] :item
-    def type
-      :item
+    def freeze
+      super
+      @children.freeze
     end
 
     # Returns an object that can be used for uniquely identifying objects.
@@ -184,69 +32,31 @@ module Nanoc::Int
     #
     # @return [Object] An unique reference to this object
     def reference
-      [type, identifier.to_s]
+      [:item, identifier.to_s]
     end
 
-    # Prevents all further modifications to its attributes.
+    # Hack to allow a frozen item to still have modifiable frozen status.
     #
-    # @return [void]
-    def freeze
-      attributes.__nanoc_freeze_recursively
-      children.freeze
-      identifier.freeze
-      raw_filename.freeze if raw_filename
-      raw_content.freeze  if raw_content
-    end
-
-    def inspect
-      "<#{self.class} identifier=\"#{identifier}\" binary?=#{self.binary?}>"
-    end
-
-    # @return [String] The checksum for this object. If its contents change,
-    #   the checksum will change as well.
-    def __nanoc_checksum
-      Nanoc::Int::Checksummer.calc(self)
-    end
-    memoize :__nanoc_checksum
-
-    def hash
-      self.class.hash ^ identifier.hash
-    end
-
-    def eql?(other)
-      self.class == other.class && identifier == other.identifier
-    end
-
-    def ==(other)
-      self.eql?(other)
-    end
+    # FIXME: Remove this.
+    class ForcedOutdatedStatus
+      attr_accessor :bool
 
-    def marshal_dump
-      [
-        @is_binary,
-        @raw_filename,
-        @raw_content,
-        @attributes,
-        @identifier
-      ]
-    end
+      def initialize
+        @bool = false
+      end
 
-    def marshal_load(source)
-      @is_binary,
-      @raw_filename,
-      @raw_content,
-      @attributes,
-      @identifier = *source
+      def freeze
+      end
     end
 
     # @api private
     def forced_outdated=(bool)
-      @forced_outdated = bool
+      @forced_outdated_status.bool = bool
     end
 
     # @api private
     def forced_outdated?
-      @forced_outdated || false
+      @forced_outdated_status.bool
     end
   end
 end