webgen 1.0.0.beta1 → 1.0.0.beta2

data/lib/webgen/item_tracker.rb

@@ -32,7 +32,7 @@ module Webgen
   # [item_data(*item)]
   #   Return the data for the item so that it can be correctly checked later if it has changed.
   #
-  # [changed?(item_id, old_data)]
+  # [item_changed?(item_id, old_data)]
   #   Return +true+ if the item identified by its unique ID has changed. The parameter +old_data+
   #   contains the last known data of the item.
   #
@@ -40,6 +40,11 @@ module Webgen
   #   Return +true+ if the node identified by +node_alcn+ is referenced in the old data identified
   #   by the unique ID.
   #
+  # [item_description(item_id, data)]
+  #   Return a string or an array of strings which describe the item (identified by its unique ID)
+  #   and the given item data. This is used for display purposes and should therefore include a
+  #   nice, human readable interpretation of the item.
+  #
   # The parameter +item+ for the methods +item_id+ and +item_data+ contains the information needed
   # to identify the item and is depdendent on the specific item tracker extension class. Therefore
   # you need to look at the documentation for an item tracker extension to see what it expects as
@@ -67,7 +72,7 @@ module Webgen
   #       @website.config[config_key]
   #     end
   #
-  #     def changed?(config_key, old_val)
+  #     def item_changed?(config_key, old_val)
   #       @website.config[config_key] != old_val
   #     end
   #
@@ -75,6 +80,10 @@ module Webgen
   #       false
   #     end
   #
+  #     def item_description(config_key, old_val)
+  #       "The website configuration option '#{config_key}'"
+  #     end
+  #
   #   end
   #
   #   website.ext.item_tracker.register ConfigTracker, name: :config
@@ -134,10 +143,11 @@ module Webgen
 
       @website.blackboard.add_listener(:website_generated, self) do
         @cached[:node_dependencies].reject! {|alcn, data| !@website.tree[alcn]}
+
+        used_uids = @cached[:node_dependencies].each_with_object(Set.new) {|(_, uids), obj| obj.merge(uids)}
         @cached[:item_data].merge!(@item_data)
-        @cached[:item_data].reject! do |uid, _|
-          !@cached[:node_dependencies].find {|alcn, data| data.include?(uid)}
-        end
+        @cached[:item_data].reject! {|uid, _| !used_uids.include?(uid)}
+
         @website.cache[:item_tracker_data] = @cached
       end
     end
@@ -187,17 +197,16 @@ module Webgen
 
     # Return +true+ if the given node has been referenced by any item tracker extension.
     def node_referenced?(node)
-      node_alcn = node.alcn
-      checked_uids = Set.new
-      @cached[:node_dependencies].each do |alcn, uids|
-        next if alcn == node_alcn
-        uids.each do |uid|
-          next if checked_uids.include?(uid)
-          checked_uids << uid
-          return true if item_tracker(uid.first).node_referenced?(uid.last, @cached[:item_data][uid], node_alcn)
+      if (cached = @website.cache.volatile[:item_tracker_referenced_nodes]).nil?
+        cached = @website.cache.volatile[:item_tracker_referenced_nodes] = Set.new
+        @cached[:node_dependencies].each do |alcn, uids|
+          uids.each do |uid|
+            cached.merge(item_tracker(uid.first).referenced_nodes(uid.last, @cached[:item_data][uid]) - [alcn])
+          end
         end
       end
-      false
+
+      cached.include?(node.alcn)
     end
 
     # Return +true+ if the given item that is handled by the item tracker extension +name+ has
@@ -206,6 +215,24 @@ module Webgen
       item_changed_by_uid?(unique_id(name, item))
     end
 
+    # Return a hash with mappings from node ALCNs to their used items (items are converted to
+    # a human readable representation by using the #item_description method).
+    #
+    # If the parameter +include_default+ is set to +false+, the default items added to each node so
+    # that it is possible to correctly detect changes, are not included.
+    #
+    # The cached data, not the current data, is used. So this information is only useful after a
+    # website has been generated.
+    def cached_items(include_default=true)
+      @cached[:node_dependencies].each_with_object({}) do |(alcn, uids), h|
+        h[alcn] = uids.sort {|a,b| a.first <=> b.first }.map do |uid|
+          next if !include_default && ((uid.first == :node_meta_info && uid.last.first == alcn )||
+                                       (uid.first == :node_content && uid.last == alcn))
+          item_tracker(uid.first).item_description(uid.last, @cached[:item_data][uid])
+        end.compact
+      end
+    end
+
     #######
     private
     #######
@@ -217,7 +244,7 @@ module Webgen
       @item_changed[uid] = if !@cached[:item_data].has_key?(uid)
                              true
                            else
-                             item_tracker(uid.first).changed?(uid.last, @cached[:item_data][uid])
+                             item_tracker(uid.first).item_changed?(uid.last, @cached[:item_data][uid])
                            end
     end
 

data/lib/webgen/item_tracker/file.rb

@@ -25,12 +25,16 @@ module Webgen
         ::File.mtime(filename)
       end
 
-      def changed?(filename, old_mtime) #:nodoc:
+      def item_changed?(filename, old_mtime) #:nodoc:
         ::File.mtime(filename) > old_mtime
       end
 
-      def node_referenced?(filename, mtime, node_alcn) #:nodoc:
-        false
+      def referenced_nodes(filename, mtime) #:nodoc:
+        []
+      end
+
+      def item_description(filename, data) #:nodoc:
+        "Content from file '#{filename}'"
       end
 
     end

data/lib/webgen/item_tracker/missing_node.rb

@@ -1,5 +1,6 @@
 # -*- encoding: utf-8 -*-
 
+require 'set'
 require 'webgen/item_tracker'
 
 module Webgen
@@ -20,9 +21,13 @@ module Webgen
         @website = website
         @at_least_one_node_created = true
         @stop_reporting = false
+        @nodes_to_ignore = Set.new
 
-        @website.blackboard.add_listener(:after_node_created, self) do
-          @at_least_one_node_created = true
+        @website.blackboard.add_listener(:reused_existing_node, self) do |node, path|
+          @nodes_to_ignore << node
+        end
+        @website.blackboard.add_listener(:after_node_created, self) do |node|
+          @at_least_one_node_created = true unless @nodes_to_ignore.include?(node)
         end
         @website.blackboard.add_listener(:after_all_nodes_written, self) do
           if @at_least_one_node_created
@@ -30,10 +35,12 @@ module Webgen
           else
             @stop_reporting = true
           end
+          @nodes_to_ignore = Set.new
         end
         @website.blackboard.add_listener(:website_generated, self) do
           @at_least_one_node_created = true
           @stop_reporting = false
+          @nodes_to_ignore = Set.new
         end
       end
 
@@ -45,14 +52,19 @@ module Webgen
         @website.tree.resolve_node(path, lang).nil?
       end
 
-      def changed?(iid, old_data) #:nodoc:
+      def item_changed?(iid, old_data) #:nodoc:
         return false if @stop_reporting
         missing = item_data(*iid)
         missing || missing != old_data
       end
 
-      def node_referenced?(iid, missing, node_alcn) #:nodoc:
-        iid.first == node_alcn
+      def referenced_nodes(iid, missing) #:nodoc:
+        [iid.first]
+      end
+
+      def item_description(iid, data) #:nodoc:
+        path, lang = *iid.last
+        "Missing acn, alcn or dest path <#{path}>" << (lang.nil? ? '' : " in language '#{lang}'")
       end
 
     end

data/lib/webgen/item_tracker/node_content.rb

@@ -26,12 +26,16 @@ module Webgen
         nil
       end
 
-      def changed?(alcn, old_data) #:nodoc:
+      def item_changed?(alcn, old_data) #:nodoc:
         @website.tree[alcn].nil? || @website.ext.item_tracker.node_changed?(@website.tree[alcn])
       end
 
-      def node_referenced?(alcn, nothing, node_alcn) #:nodoc:
-        alcn == node_alcn
+      def referenced_nodes(alcn, nothing) #:nodoc:
+        [alcn]
+      end
+
+      def item_description(alcn, data) #:nodoc:
+        "Content from node <#{alcn}>"
       end
 
     end

data/lib/webgen/item_tracker/node_meta_info.rb

@@ -38,13 +38,18 @@ module Webgen
         key.nil? ? (mi = mi.dup; mi.delete(CONTENT_MODIFICATION_KEY); mi) : mi[key].dup
       end
 
-      def changed?(iid, old_data) #:nodoc:
+      def item_changed?(iid, old_data) #:nodoc:
         alcn, key = *iid
         @website.tree[alcn].nil? || item_data(alcn, key) != old_data
       end
 
-      def node_referenced?(iid, mi, node_alcn) #:nodoc:
-        iid.first == node_alcn
+      def referenced_nodes(iid, mi) #:nodoc:
+        [iid.first]
+      end
+
+      def item_description(iid, data) #:nodoc:
+        alcn, key = *iid
+        (key.nil? ? "Any meta info from <#{alcn}>" : "Meta info key '#{key}' from <#{alcn}>")
       end
 
     end

data/lib/webgen/item_tracker/nodes.rb

@@ -47,15 +47,22 @@ module Webgen
         nodes_to_alcn(node_list(method_name, options))
       end
 
-      def changed?(iid, old_data) #:nodoc:
+      def item_changed?(iid, old_data) #:nodoc:
         method_name, options, type = *iid
         nodes = node_list(method_name, options)
         old_data != nodes_to_alcn(nodes) ||
           nodes.flatten.any? {|n| type == :content ? @website.ext.item_tracker.node_changed?(n) : @website.ext.item_tracker.item_changed?(:node_meta_info, n.alcn)}
       end
 
-      def node_referenced?(iid, alcn_list, node_alcn) #:nodoc:
-        alcn_list.flatten.any? {|alcn| alcn == node_alcn}
+      def referenced_nodes(iid, alcn_list) #:nodoc:
+        alcn_list.flatten
+      end
+
+      def item_description(iid, data) #:nodoc:
+        method, _, type = *iid
+        str = (type == :content ? "Content" : "Meta info") << " from these nodes"
+        str << " (result of #{[method].flatten.join('.')}):"
+        [str] + data.flatten
       end
 
       # Use Webgen::NodeFinder to generate a (nested) list of nodes. The options hash has to contain

data/lib/webgen/node.rb

@@ -200,16 +200,14 @@ module Webgen
     # You can optionally specify additional attributes for the HTML element in the +attr+ Hash.
     # Also, the meta information +link_attrs+ of the given +node+ is used, if available, to set
     # attributes. However, the +attr+ parameter takes precedence over the +link_attrs+ meta
-    # information. Be aware that all key-value pairs with Symbol keys are removed before the
-    # attributes are written. Therefore you always need to specify general attributes with strings!
+    # information.
     #
-    # If the special value :link_text is present in the attributes, it will be used as the link
+    # If the special value 'link_text' is present in the attributes, it will be used as the link
     # text; otherwise the title of the +node+ will be used.
     def link_to(node, lang = @lang, attr = {})
-      attr = node['link_attrs'].merge(attr) if node['link_attrs'].kind_of?(Hash)
       rnode = node.proxy_node(lang)
-      link_text = attr[:link_text] || (rnode != node && rnode['routed_title']) || node['title']
-      attr.delete_if {|k,v| k.kind_of?(Symbol)}
+      attr = (rnode['link_attrs'].kind_of?(Hash) ? rnode['link_attrs'] : {}).merge(attr)
+      link_text = attr.delete('link_text') || (rnode != node && rnode['routed_title']) || node['title']
 
       attr['href'] = self.route_to(node, lang)
       attr['hreflang'] = rnode.lang.to_s if rnode.lang
@@ -223,29 +221,6 @@ module Webgen
         each_with_object({}) {|(k, v), h| h[v['version']] = v}
     end
 
-
-    #######
-    private
-    #######
-
-    # Delegate missing methods to the associated path handler. The current node is placed into the
-    # argument array as the first argument before the method +name+ is invoked on the path handler.
-    def method_missing(name, *args, &block)
-      if node_info[:path_handler]
-        node_info[:path_handler].send(name, *([self] + args), &block)
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(symbol, include_private) #:nodoc:
-      if node_info[:path_handler]
-        node_info[:path_handler].send(:respond_to?, symbol, include_private)
-      else
-        super
-      end
-    end
-
   end
 
 end

data/lib/webgen/node_finder.rb

@@ -38,6 +38,13 @@ module Webgen
   #   Value: an integer. Specifies how many nodes from the front of the list should *not* be
   #   returned. Implies 'flatten = true'.
   #
+  # [:levels]
+  #   Value: one integer (is used as start and end level) or an array with two integers (the start
+  #   and end levels). All nodes whose hierarchy level in the returned node hierarchy is greater
+  #   than or equal to the start level and lower than or equal to the end level are used.
+  #
+  #   Only used when the node hierarchy is not flattened.
+  #
   # [:flatten]
   #   Value: anything except +nil+ or +false+. A flat list of nodes is returned if this option is
   #   set, otherwise the nodes are returned in their correct hierarchical order using nested lists.
@@ -85,10 +92,10 @@ module Webgen
   #   Value: a finder option set or an array of finder options sets (specifying option set names is
   #   also possible). Only nodes that do not appear in any specified option set are used.
   #
-  # [:levels]
+  # [:absolute_levels]
   #   Value: one integer (is used as start and end level) or an array with two integers (the start
-  #   and end levels). All nodes whose hierarchy levels are greater than or equal to the start level
-  #   and lower than or equal to the end level are used.
+  #   and end levels). All nodes whose hierarchy level in the node tree are greater than or equal to
+  #   the start level and lower than or equal to the end level are used.
   #
   # [:ancestors]
   #   Value: +true+ or +false+/+nil+. If this filter option is set to +true+, only nodes that are
@@ -131,7 +138,7 @@ module Webgen
     def initialize(website)
       @website = website
       @mapping = {
-        :alcn => :filter_alcn, :levels => :filter_levels, :lang => :filter_lang,
+        :alcn => :filter_alcn, :absolute_levels => :filter_absolute_levels, :lang => :filter_lang,
         :and => :filter_and, :or => :filter_or, :not => :filter_not,
         :ancestors => :filter_ancestors, :descendants => :filter_descendants,
         :siblings => :filter_siblings,
@@ -170,8 +177,9 @@ module Webgen
       end
       opts = prepare_options_hash(opts_or_name)
 
-      limit, offset, flatten, sort = remove_non_filter_options(opts)
+      limit, offset, flatten, sort, levels = remove_non_filter_options(opts)
       flatten = true if limit || offset
+      levels = [levels || [1, 1_000_000]].flatten.map {|i| i.to_i}
 
       nodes = filter_nodes(opts, ref_node)
 
@@ -189,10 +197,17 @@ module Webgen
           hierarchy_nodes.inject(result) {|memo, hn| memo[hn] ||= {}}
         end
 
-        reducer = lambda do |h|
-          h.map {|k,v| v.empty? ? k : [k, reducer.call(v)]}
+        reducer = lambda do |h, level|
+          if level < levels.first
+            temp = h.map {|k,v| v.empty? ? nil : reducer.call(v, level + 1)}.compact
+            temp.length == 1 && temp.first.kind_of?(Array) ? temp.first : temp
+          elsif level < levels.last
+            h.map {|k,v| v.empty? ? k : [k, reducer.call(v, level + 1)]}
+          else
+            h.map {|k,v| k}
+          end
         end
-        nodes = reducer.call(result)
+        nodes = reducer.call(result, 1)
         sort_nodes(nodes, sort, false)
       end
 
@@ -222,7 +237,7 @@ module Webgen
     end
 
     def remove_non_filter_options(opts)
-      [opts.delete(:limit), opts.delete(:offset), opts.delete(:flatten), opts.delete(:sort)]
+      [opts.delete(:limit), opts.delete(:offset), opts.delete(:flatten), opts.delete(:sort), opts.delete(:levels)]
     end
 
     def filter_nodes(opts, ref_node)
@@ -297,7 +312,7 @@ module Webgen
       nodes.keep_if {|n| alcn.any? {|a| n =~ a}}
     end
 
-    def filter_levels(nodes, ref_node, range)
+    def filter_absolute_levels(nodes, ref_node, range)
       range = [range].flatten.map {|i| i.to_i}
       nodes.keep_if {|n| n.level >= range.first && n.level <= range.last}
     end

data/lib/webgen/path.rb

@@ -314,9 +314,9 @@ module Webgen
         @basename = match_data[1]
         @ext = match_data[2]
       else
-        @meta_info['sort_info'] ||= (match_data[1].nil? ? nil : match_data[1].to_i)
+        @meta_info['sort_info'] ||= match_data[1].to_i unless match_data[1].nil?
         @basename               = match_data[2]
-        @meta_info['lang']      ||= Webgen::LanguageManager.language_for_code(match_data[3])
+        @meta_info['lang']      ||= Webgen::LanguageManager.language_for_code(match_data[3]) if match_data[3]
         @ext                    = (@meta_info['lang'].nil? && !match_data[3].nil? ? match_data[3].to_s + '.' : '') + match_data[4].to_s
       end
     end

data/lib/webgen/path_handler/base.rb

@@ -27,17 +27,24 @@ module Webgen
     #
     module Base
 
+      # This is the base Node sub class used by the Base#create_node method if a path handler class
+      # does not specify another Node class.
+      class Node < Webgen::Node
+
+        # Return the result of the #content method on the associated path handler or +nil+ if the
+        # associated path handler does not have a #content method.
+        def content
+          (@node_info[:path_handler].respond_to?(:content) ? @node_info[:path_handler].content(self) : nil)
+        end
+
+      end
+
+
       # Initialize the path handler with the given Website object.
       def initialize(website)
         @website = website
       end
 
-      # Return +nil+ as content of the given +node+.
-      #
-      # Should probably be over-written by path handler classes using this module!
-      def content(node)
-      end
-
       # Update +path.meta_info+ with meta information found in the content of the path.
       #
       # This default +parse_meta_info!+ method does nothing and should be overridden in path
@@ -50,9 +57,12 @@ module Webgen
         []
       end
 
-      # Create a node from +path+, if possible, yield the full initialized node if a block is given
+      # Create a node from +path+, if possible, yield the fully initialized node if a block is given
       # and return it.
       #
+      # The node class to be used for the created node can be specified via the +node_klass+
+      # parameter.
+      #
       # If no node can be created (e.g. when 'path.meta_info['draft']' is set), +nil+ is returned.
       #
       # The parent node under which the new node should be created can optionally be specified via
@@ -61,7 +71,7 @@ module Webgen
       #
       # On the created node, the node information +:path+ is set to the given path and
       # +:path_handler+ to the path handler instance.
-      def create_node(path)
+      def create_node(path, node_klass = Node)
         return nil if path.meta_info['draft']
         parent = parent_node(path)
         dest_path = self.dest_path(parent, path)
@@ -71,6 +81,7 @@ module Webgen
           if node_path != path
             raise Webgen::NodeCreationError.new("Another node <#{node}> with the same alcn or destination path already exists")
           elsif node_path.meta_info == path.meta_info
+            @website.blackboard.dispatch_msg(:reused_existing_node, node)
             return node
           else
             node.tree.delete_node(node)
@@ -84,7 +95,7 @@ module Webgen
           path.meta_info['modified_at'] = Time.now
         end
 
-        node = Webgen::Node.new(parent, path.cn, dest_path, path.meta_info)
+        node = node_klass.new(parent, path.cn, dest_path, path.meta_info.dup)
         node.node_info[:path] = path
         node.node_info[:path_handler] = self