gettalong-webgen 0.5.8.20090507 → 0.5.9.20090620

data/lib/webgen/path.rb

@@ -1,11 +1,32 @@
 # -*- encoding: utf-8 -*-
 
+require 'pathname'
 require 'webgen/languages'
 
 module Webgen
 
-  # A path object provides information about a specific path as well as methods for accessing its
-  # content.
+  # == General Information
+  #
+  # A Path object provides information about a path that is used to create a node as well as methods
+  # for accessing its content. In contrast, output paths are always strings and just specify the
+  # location where a specific node should be written to.
+  #
+  # Note the +path+ and +source_path+ attributes of a Path object:
+  #
+  # * The +source_path+ specifies a path string that was directly created by a Source object. Each
+  #   Path object must have such a valid source path sothat webgen can infer the Path the lead to
+  #   the creation of a Node object later.
+  #
+  # * In contrast, the +path+ attribute specifies the path that is used to create the canonical name
+  #   (and by default the output path) of a Node object. Normally it is the same as the
+  #   +source_path+ but can differ (e.g. when fragment nodes are created for page file nodes).
+  #
+  # A Path object can represent one of three different things: a directory, a file or a fragment. If
+  # the +path+ ends with a slash character, then the path object represents a directory, if the path
+  # contains a hash character anywhere, then the path object represents a fragment and else it
+  # represents a file. Have a look at the webgen manual to see the exact format of a path!
+  #
+  # == Relation to Source classes
   #
   # A webgen source class needs to derive a specialized path class from this class and implement an
   # approriate #changed? method that returns +true+ if the path's content has changed since the last
@@ -13,15 +34,21 @@ module Webgen
   class Path
 
     # Helper class for easy access to the content of a path.
+    #
+    # This class is used sothat the creation of the real IO object for #stream can be delayed till
+    # it is actually needed. This is done by not directly requiring the user of this class to supply
+    # the IO object, but by requiring a block that creates the real IO object.
     class SourceIO
 
-      # Create a new SourceIO object. A block has to be specified that returns an IO object.
+      # Create a new SourceIO object. A block has to be specified that returns the to-be-wrapped IO
+      # object.
       def initialize(&block)
         @block = block
-        raise ArgumentError, 'Need to provide a block which returns an IO object' if @block.nil?
+        raise ArgumentError, 'You need to provide a block which returns an IO object' if @block.nil?
       end
 
-      # Provide direct access to the wrapped IO object.
+      # Provide direct access to the wrapped IO object by yielding it. After the method block
+      # returns the IO object is automatically closed.
       def stream
         io = @block.call
         yield(io)
@@ -29,7 +56,7 @@ module Webgen
         io.close
       end
 
-      # Return the content of the wrapped IO object as string.
+      # Return the whole content of the wrapped IO object as string.
       def data
         stream {|io| io.read}
       end
@@ -37,6 +64,13 @@ module Webgen
     end
 
 
+    # Make the given +path+ absolute by prepending the absolute directory path +base+ if necessary.
+    # Also resolves all '..' and '.' references in +path+.
+    def self.make_absolute(base, path)
+      raise(ArgumentError, 'base has to be an absolute path, ie. needs to start with a slash') unless base =~ /\//
+      Pathname.new(path =~ /^\// ? path : File.join(base, path)).cleanpath.to_s
+    end
+
     # Return +true+ if the given +path+ matches the given +pattern+ (trailing slashes of directories
     # are not respected). For information on which patterns are supported, have a look at the
     # documentation of File.fnmatch.
@@ -49,66 +83,86 @@ module Webgen
 
     include Comparable
 
-    # The full path.
-    attr_accessor :path
+    # The full path for which this Path object was created.
+    attr_reader :path
 
-    # The source path that lead to the creation of this path.
-    attr_accessor :source_path
+    # A string specifying the path that lead to the creation of this path.
+    attr_reader :source_path
 
-    # The basename part of the path.
-    attr_accessor :basename
+    # The string specifying the parent path
+    attr_reader :parent_path
 
-    # The directory part of the path.
-    attr_accessor :directory
-
-    # The canonical name without the extension.
-    attr_accessor :cnbase
+    # The canonical name of the path without the extension.
+    attr_accessor :basename
 
-    # The extension.
+    # The extension of the +path+.
     attr_accessor :ext
 
     # Extracted meta information for the path.
     attr_accessor :meta_info
 
+    # Specifies whether this path should be used during the "tree update" phase of a webgen run or
+    # only later during node resolution.
+    attr_writer :passive
+
+    # Is this path only used later during node resolution? Defaults to +false+, i.e. used during the
+    # "tree update" phase.
+    def passive?; @passive; end
+
+
     # Create a new Path object for +path+. The optional +source_path+ parameter specifies the path
-    # that lead to the creation of this path. The optional block needs to return an IO object for
-    # the content of the path.
+    # string that lead to the creation of this path. The optional block needs to return an IO object
+    # for getting the content of the path.
+    #
+    # The +path+ needs to be in a well defined format which can be looked up in the webgen manual.
     def initialize(path, source_path = path, &ioblock)
       @meta_info = {}
       @io = block_given? ? SourceIO.new(&ioblock) : nil
       @source_path = source_path
+      @passive = false
       analyse(path)
     end
 
-    # Mount this path at the mount point +mp+ optionally stripping +prefix+ from the path and return
-    # the new path object.
+    # Mount this path at the mount point +mp+, optionally stripping +prefix+ from the parent path,
+    # and return the new path object.
+    #
+    # The parameters +mp+ and +prefix+ have to be absolute directory paths, ie. they have to start
+    # and end with a slash and must not contain any hash characters!
+    #
+    #--
+    # Can't use self.class.new(...) here because the semantics of the sub constructors is not know
+    #++
     def mount_at(mp, prefix = nil)
+      raise(ArgumentError, "The mount point (#{mp}) must be a valid directory path") if mp =~ /^[^\/]|#|[^\/]$/
+      raise(ArgumentError, "The strip prefix (#{prefix}) must be a valid directory path") if !prefix.nil? && prefix =~ /^[^\/]|#|[^\/]$/
+
       temp = dup
-      temp.path = temp.path.sub(/^#{Regexp.escape(prefix.chomp("/"))}/, '') if prefix     #"
-      reanalyse = (@path == '/' || temp.path == '/')
-      temp.path = File.join(mp, temp.path)
-      temp.source_path = temp.path if @path == @source_path
+      strip_re = /^#{Regexp.escape(prefix.to_s)}/
+      temp.instance_variable_set(:@path, temp.path.sub(strip_re, ''))
+      reanalyse = (@path == '/' || temp.path == '')
+      temp.instance_variable_set(:@path, File.join(mp, temp.path))
+      temp.instance_variable_set(:@source_path, temp.path) if @path == @source_path
       if reanalyse
         temp.send(:analyse, temp.path)
       else
-        temp.directory = File.join(File.dirname(temp.path), '/')
+        temp.instance_variable_set(:@parent_path, File.join(mp, temp.parent_path.sub(strip_re, '')))
       end
       temp
     end
 
-    # Has the content of this path changed since the last webgen run? This default implementation
-    # always returns +true+, a specialized sub class needs to override this behaviour!
-    def changed?
-      true
-    end
-
     # Duplicate the path object.
     def dup
       temp = super
-      temp.meta_info = @meta_info.dup
+      temp.instance_variable_set(:@meta_info, @meta_info.dup)
       temp
     end
 
+    # Has the content of this path changed since the last webgen run? This default implementation
+    # always returns +true+, a specialized sub class needs to override this behaviour!
+    def changed?
+      true
+    end
+
     # The SourceIO object associated with the path.
     def io
       if @io
@@ -118,26 +172,45 @@ module Webgen
       end
     end
 
-    # The canonical name created from the filename (created from cnbase and extension).
+    # The canonical name created from the +path+ (namely from the parts +basename+ and +extension+).
     def cn
-      @cnbase + (@ext.length > 0 ? '.' + @ext : '')
+      @basename + (@ext.length > 0 ? '.' + @ext : '') + (@basename != '/' && @path =~ /.\/$/ ? '/' : '')
     end
 
-    # Utility method for creating the lcn from +cn+ and the language +lang+.
+    # Utility method for creating the lcn from the +cn+ and the language +lang+.
     def self.lcn(cn, lang)
       if lang.nil?
         cn
       else
-        cn.split('.').insert(1, lang.to_s).join('.')
+        cn.split('.').insert((cn =~ /^\./ ? 2 : 1), lang.to_s).join('.')
       end
     end
 
-    # The localized canonical name created from the filename.
+    # The localized canonical name created from the +path+.
     def lcn
       self.class.lcn(cn, @meta_info['lang'])
     end
 
-    # Compare this object to another Path or a String.
+    # The absolute canonical name of this path.
+    def acn
+      if @path =~ /#/
+        self.class.new(@parent_path).acn + cn
+      else
+        @parent_path + cn
+      end
+    end
+
+    # The absolute localized canonical name of this path.
+    def alcn
+      if @path =~ /#/
+        self.class.new(@parent_path).alcn + lcn
+      else
+        @parent_path + lcn
+      end
+    end
+
+    # Equality -- Return +true+ if +other+ is a Path object with the same #path or if +other+ is a
+    # String equal to the #path. Else return +false+.
     def ==(other)
       if other.kind_of?(Path)
         other.path == @path
@@ -149,13 +222,12 @@ module Webgen
     end
     alias_method(:eql?, :==)
 
-    # Implemented sothat a Path looks like a String when used as key in a hash.
+    # Compare the #path of this object to <tt>other.path</tt>
     def <=>(other)
-      @path <=> other.to_str
+      @path <=> other.path
     end
 
-    # Implemented sothat a Path looks like a String when used as key in a hash.
-    def hash
+    def hash #:nodoc:
       @path.hash
     end
 
@@ -172,21 +244,46 @@ module Webgen
     private
     #######
 
-    FILENAME_RE = /^(?:(\d+)\.)?([^.]*?)(?:\.(\w\w\w?)(?=.))?(?:\.(.*))?$/
-
     # Analyse the +path+ and fill the object with the extracted information.
     def analyse(path)
       @path = path
-      @basename = File.basename(path)
-      @directory = File.join(File.dirname(path), '/')
-      matchData = FILENAME_RE.match(@basename)
+      if @path =~ /#/
+        analyse_fragment
+      elsif @path =~ /\/$/
+        analyse_directory
+      else
+        analyse_file
+      end
+      @meta_info['title'] = @basename.tr('_-', ' ').capitalize
+      @ext ||= ''
+      raise "The basename of a path may not be empty: #{@path}" if @basename.empty? || @basename == '#'
+      raise "The parent path must start with a slash: #{@path}" if @path !~ /^\// && @path != '/'
+    end
 
-      @meta_info['sort_info'] = (matchData[1].nil? ? nil : matchData[1].to_i)
-      @cnbase                 = matchData[2]
-      @meta_info['lang']      = Webgen::LanguageManager.language_for_code(matchData[3])
-      @ext                    = (@meta_info['lang'].nil? && !matchData[3].nil? ? matchData[3].to_s + '.' : '') + matchData[4].to_s
+    # Analyse the path assuming it is a directory.
+    def analyse_directory
+      @parent_path = (@path == '/' ? '' : File.join(File.dirname(@path), '/'))
+      @basename = File.basename(@path)
+    end
+
+    FILENAME_RE = /^(?:(\d+)\.)?(\.?[^.]*?)(?:\.(\w\w\w?)(?=\.))?(?:\.(.*))?$/
+
+    # Analyse the path assuming it is a file.
+    def analyse_file
+      @parent_path = File.join(File.dirname(@path), '/')
+      match_data = FILENAME_RE.match(File.basename(@path))
+
+      @meta_info['sort_info'] = (match_data[1].nil? ? nil : match_data[1].to_i)
+      @basename               = match_data[2]
+      @meta_info['lang']      = Webgen::LanguageManager.language_for_code(match_data[3])
+      @ext                    = (@meta_info['lang'].nil? && !match_data[3].nil? ? match_data[3].to_s : '') + match_data[4].to_s
+    end
 
-      @meta_info['title']     = @cnbase.tr('_-', ' ').capitalize
+    # Analyse the path assuming it is a fragment.
+    def analyse_fragment
+      @parent_path, @basename =  @path.scan(/^(.*?)(#.*?)$/).first
+      raise "The parent path of a fragment path must be a file path and not a directory path: #{@path}" if @parent_path =~ /\/$/
+      raise "A fragment path must only contain one hash character: #{path}" if @path.count("#") > 1
     end
 
   end

data/lib/webgen/source.rb

@@ -10,9 +10,10 @@ module Webgen
   #
   # A source class only needs to respond to the method +paths+ which needs to return a set of paths
   # for the source. The returned paths must respond to the method <tt>changed?</tt> (has to return
-  # +true+ if the paths has changed since the last webgen run). The default implementation in the
-  # Path class just returns +true+. One can either derive a specialized path class or define
-  # singleton methods on each path object.
+  # +true+ if the paths has changed since the last webgen run). If a path represents a directory, it
+  # needs to have a trailing slash! The default implementation in the Path class just returns
+  # +true+. One can either derive a specialized path class or define singleton methods on each path
+  # object.
   #
   # == Sample Source Class
   #
@@ -36,10 +37,9 @@ module Webgen
   #   end
   #
   # You can use this source class in your website (after placing the code in, for example,
-  # <tt>ext/init.rb</tt>) by updating the <tt>sources</tt> configuration option (the following code
-  # has to be placed after the definition of the +MemorySource+ class):
+  # <tt>ext/init.rb</tt>) by updating the <tt>sources</tt> configuration option:
   #
-  #   WebsiteAccess.website.config['sources'] << ['/', MemorySource]
+  #   WebsiteAccess.website.config['sources'] << ['/', 'MemorySource']
   #
   module Source
 

data/lib/webgen/source/stacked.rb

@@ -17,20 +17,27 @@ module Webgen::Source
   # source, it is discarded and not used.
   class Stacked
 
-    # Return the stack of Webgen::Source objects.
+    # Return the stack of mount point to Webgen::Source object maps.
     attr_reader :stack
 
+    # Specifies whether the result of #paths calls should be cached (default: +false+). If caching
+    # is activated, new maps cannot be added to the stacked source anymore!
+    attr_accessor :cache_paths
+
     # Create a new stack. The optional +map+ parameter can be used to provide initial mappings of
-    # mount points to source objects (see #add for details).
-    def initialize(map = {})
+    # mount points to source objects (see #add for details). You cannot add other maps after a call
+    # to #paths if +cache_paths+ is +true+
+    def initialize(map = {}, cache_paths = false)
       @stack = []
+      @cache_paths = cache_paths
       add(map)
     end
 
     # Add all mappings found in +maps+ to the stack. The parameter +maps+ should be an array of
-    # two-element arrays which contain an absolute directoriy (ie. starting with a slash) and a
-    # source object.
+    # two-element arrays which contain an absolute directory (ie. starting and ending with a slash)
+    # and a source object.
     def add(maps)
+      raise "Cannot add new maps since caching is activated for this source" if defined?(@paths) && @cache_paths
       maps.each do |mp, source|
         raise "Invalid mount point specified: #{mp}" unless mp =~ /^\//
         @stack << [mp, source]
@@ -41,6 +48,7 @@ module Webgen::Source
     # returned by later source objects are not used if a prior source object has returned the same
     # path.
     def paths
+      return @paths if defined?(@paths) && @cache_paths
       @paths = Set.new
       @stack.each do |mp, source|
         source.paths.each do |path|

data/lib/webgen/sourcehandler.rb

@@ -28,6 +28,7 @@ module Webgen
     # * collects all source paths using the source classes
     # * creates nodes using the source handler classes
     # * writes changed nodes out using an output class
+    # * deletes old nodes
     class Main
 
       include WebsiteAccess
@@ -35,34 +36,40 @@ module Webgen
 
       def initialize #:nodoc:
         website.blackboard.add_service(:create_nodes, method(:create_nodes))
+        website.blackboard.add_service(:create_nodes_from_paths, method(:create_nodes_from_paths))
         website.blackboard.add_service(:source_paths, method(:find_all_source_paths))
         website.blackboard.add_listener(:node_meta_info_changed?, method(:meta_info_changed?))
+
+        website.blackboard.add_listener(:before_node_deleted) do |node|
+          website.blackboard.invoke(:output_instance).delete(node.path)
+        end if website.config['output.do_deletion']
       end
 
-      # Render the nodes provided in the +tree+. Before the actual rendering is done, the sources
-      # are checked (nodes for deleted sources are deleted, nodes for new and changed sources).
-      def render(tree)
+      # Render the current website. Before the actual rendering is done, the sources are checked for
+      # changes, i.e. nodes for deleted sources are deleted, nodes for new and changed sources are
+      # updated.
+      def render
         begin
           website.logger.mark_new_cycle if website.logger
 
           puts "Updating tree..."
           time = Benchmark.measure do
             website.cache.reset_volatile_cache
-            update_tree(tree)
+            update_tree
           end
           puts "...done in " + ('%2.4f' % time.real) + ' seconds'
 
-          if !tree.root
+          if !website.tree.root
             puts 'No source files found - maybe not a webgen website?'
             return nil
           end
 
           puts "Writing changed nodes..."
           time = Benchmark.measure do
-            write_tree(tree)
+            write_tree
           end
           puts "...done in " + ('%2.4f' % time.real) + ' seconds'
-        end while tree.node_access[:alcn].any? {|name,node| node.flagged?(:created) || node.flagged?(:reinit)}
+        end while website.tree.node_access[:alcn].any? {|name,node| node.flagged?(:created) || node.flagged?(:reinit)}
         :success
       end
 
@@ -70,45 +77,60 @@ module Webgen
       private
       #######
 
-      # Update the +tree+ by creating/reinitializing all needed nodes.
-      def update_tree(tree)
+      # Update the <tt>website.tree</tt> by creating/reinitializing all needed nodes.
+      def update_tree
         unused_paths = Set.new
+        referenced_nodes = Set.new
+        all_but_passive_paths = Set.new(find_all_source_paths.select {|name, path| !path.passive?}.collect {|name, path| name})
         begin
-          used_paths = Set.new(find_all_source_paths.keys) - unused_paths
+          used_paths = all_but_passive_paths - unused_paths
           paths_to_use = Set.new
           nodes_to_delete = Set.new
+          passive_nodes = Set.new
 
-          tree.node_access[:alcn].each do |alcn, node|
-            next if node == tree.dummy_root
+          website.tree.node_access[:alcn].each do |alcn, node|
+            next if node == website.tree.dummy_root
             used_paths.delete(node.node_info[:src])
 
-            deleted = !find_all_source_paths.include?(node.node_info[:src])
-            if deleted
+            src_path = find_all_source_paths[node.node_info[:src]]
+            if !src_path
               nodes_to_delete << node
-              #TODO: delete output path
-            elsif (!node.flagged?(:created) && find_all_source_paths[node.node_info[:src]].changed?) || node.meta_info_changed?
+            elsif (!node.flagged?(:created) && src_path.changed?) || node.meta_info_changed?
               node.flag(:reinit)
               paths_to_use << node.node_info[:src]
             elsif node.changed?
-              # nothing to be done here
+              # nothing to be done here but method node.changed? has to be called
+            end
+
+            if src_path && src_path.passive?
+              passive_nodes << node
+            elsif src_path
+              referenced_nodes += node.node_info[:used_meta_info_nodes] + node.node_info[:used_nodes]
             end
           end
 
-          nodes_to_delete.each {|node| tree.delete_node(node)}
+          # add unused passive nodes to node_to_delete set
+          unreferenced_passive_nodes, other_passive_nodes = passive_nodes.partition do |pnode|
+            !referenced_nodes.include?(pnode.alcn)
+          end
+          refs = other_passive_nodes.collect {|n| (n.node_info[:used_meta_info_nodes] + n.node_info[:used_nodes]).to_a}.flatten
+          unreferenced_passive_nodes.each {|n| nodes_to_delete << n if !refs.include?(n.alcn)}
+
+          nodes_to_delete.each {|node| website.tree.delete_node(node)}
           used_paths.merge(paths_to_use)
-          paths = create_nodes_from_paths(tree, used_paths.to_a.sort)
+          paths = create_nodes_from_paths(used_paths.to_a.sort)
           unused_paths.merge(used_paths - paths)
-          tree.node_access[:alcn].each {|name, node| tree.delete_node(node) if node.flagged?(:reinit)}
+          website.tree.node_access[:alcn].each {|name, node| website.tree.delete_node(node) if node.flagged?(:reinit)}
           website.cache.reset_volatile_cache
         end until used_paths.empty?
       end
 
-      # Write out all changed nodes of the +tree+.
-      def write_tree(tree)
+      # Write out all changed nodes of the <tt>website.tree</tt>.
+      def write_tree
         output = website.blackboard.invoke(:output_instance)
 
-        tree.node_access[:alcn].select do |name, node|
-          use_node = (node != tree.dummy_root && node.flagged?(:dirty))
+        website.tree.node_access[:alcn].select do |name, node|
+          use_node = (node != website.tree.dummy_root && node.flagged?(:dirty))
           node.unflag(:dirty_meta_info)
           node.unflag(:created)
           node.unflag(:dirty)
@@ -127,7 +149,7 @@ module Webgen
                    end
             output.write(node.path, content, type)
           rescue
-            raise RuntimeError, "Error while processing <#{node.absolute_lcn}>: #{$!.message}", $!.backtrace
+            raise RuntimeError, "Error while processing <#{node.alcn}>: #{$!.message}", $!.backtrace
           end
         end
       end
@@ -135,9 +157,15 @@ module Webgen
       # Return a hash with all source paths.
       def find_all_source_paths
         if !defined?(@paths)
-          source = Webgen::Source::Stacked.new(website.config['sources'].collect do |mp, name, *args|
-                                                 [mp, constant(name).new(*args)]
-                                               end)
+          active_source = Webgen::Source::Stacked.new(website.config['sources'].collect do |mp, name, *args|
+                                                        [mp, constant(name).new(*args)]
+                                                      end)
+          passive_source = Webgen::Source::Stacked.new(website.config['passive_sources'].collect do |mp, name, *args|
+                                                         [mp, constant(name).new(*args)]
+                                                       end, true)
+          passive_source.paths.each {|path| path.passive = true }
+          source = Webgen::Source::Stacked.new([['/', active_source], ['/', passive_source]])
+
           @paths = {}
           source.paths.each do |path|
             if !(website.config['sourcehandler.ignore'].any? {|pat| File.fnmatch(pat, path, File::FNM_CASEFOLD|File::FNM_DOTMATCH)})
@@ -155,13 +183,13 @@ module Webgen
 
         options = (website.config['sourcehandler.casefold'] ? File::FNM_CASEFOLD : 0) |
           (website.config['sourcehandler.use_hidden_files'] ? File::FNM_DOTMATCH : 0)
-        find_all_source_paths.values_at(*paths).select do |path|
+        find_all_source_paths.values_at(*paths).compact.select do |path|
           patterns.any? {|pat| File.fnmatch(pat, path, options)}
         end
       end
 
-      # Use the source handlers to create nodes for the +paths+ in the +tree+.
-      def create_nodes_from_paths(tree, paths)
+      # Use the source handlers to create nodes for the +paths+ in the <tt>website.tree</tt>.
+      def create_nodes_from_paths(paths)
         used_paths = Set.new
         website.config['sourcehandler.invoke'].sort.each do |priority, shns|
           shns.each do |shn|
@@ -169,31 +197,29 @@ module Webgen
             handler_paths = paths_for_handler(shn, paths)
             used_paths.merge(handler_paths)
             handler_paths.sort {|a,b| a.path.length <=> b.path.length}.each do |path|
-              parent_dir = path.directory.split('/').collect {|p| Path.new(p).cn}.join('/')
-              parent_dir += '/' if path != '/' && parent_dir == ''
-              create_nodes(tree, parent_dir, path, sh)
+              if !website.tree[path.parent_path]
+                used_paths.merge(create_nodes_from_paths([path.parent_path]))
+              end
+              create_nodes(path, sh)
             end
           end
         end
         used_paths
       end
 
-      # Prepare everything to create nodes under the absolute lcn path +parent_path_name+ in the
-      # +tree from the +path+ using the +source_handler+. If a block is given, the actual creation
-      # of the nodes is deferred to it. After the nodes are created, it is also checked if they have
-      # all needed properties.
-      def create_nodes(tree, parent_path_name, path, source_handler) #:yields: parent, path
-        if !(parent = tree[parent_path_name])
-          raise "The specified parent path <#{parent_path_name}> does not exist"
-        end
+      # Prepare everything to create from the +path+ using the +source_handler+. If a block is
+      # given, the actual creation of the nodes is deferred to it. Otherwise the #create_node method
+      # of the +source_handler+ is used. After the nodes are created, it is also checked if they
+      # have all needed properties.
+      def create_nodes(path, source_handler) #:yields: path
         path = path.dup
         path.meta_info = default_meta_info(path, source_handler.class.name)
         (website.cache[:sourcehandler_path_mi] ||= {})[[path.path, source_handler.class.name]] = path.meta_info.dup
-        website.blackboard.dispatch_msg(:before_node_created, parent, path)
+        website.blackboard.dispatch_msg(:before_node_created, path)
         *nodes = if block_given?
-                   yield(parent, path)
+                   yield(path)
                  else
-                   source_handler.create_node(parent, path)
+                   source_handler.create_node(path)
                  end
         nodes.flatten.compact.each do |node|
           website.blackboard.dispatch_msg(:after_node_created, node)