webgen 0.5.8 → 0.5.9

data/lib/webgen/context.rb

@@ -1,5 +1,7 @@
 # -*- encoding: utf-8 -*-
 require 'webgen/context/nodes'
+require 'webgen/context/tags'
+require 'webgen/context/render'
 
 module Webgen
 
@@ -13,17 +15,23 @@ module Webgen
   #   The content string that should be processed.
   #
   # [<tt>:processors</tt>]
-  #   Normally an AccessHash object providing access to all available content processors.
+  #   Normally an ContentProcessor::AccessHash object providing access to all available content
+  #   processors.
   #
   # [<tt>:chain</tt>]
   #   The chain of nodes that is processed. There are some utiltity methods for getting
   #   special nodes of the chain (see #ref_node, #content_node and #dest_node).
+  #
+  # The +persistent+ options hash is shared by all cloned Context objects.
   class Context
 
     include Webgen::WebsiteAccess
     public :website
 
-    # Processing options
+    # The persistent options. Once initialized, all cloned objects refer to the same hash.
+    attr_reader :persistent
+
+    # Processing options.
     attr_accessor :options
 
     # Create a new Context object. You can use the +options+ hash to set needed options.
@@ -35,17 +43,18 @@ module Webgen
     #
     # [<tt>:processors</tt>]
     #   Is set to a new AccessHash.
-    def initialize(options = {})
+    def initialize(options = {}, persistent = {})
       @options = {
         :content => '',
         :processors => Webgen::ContentProcessor::AccessHash.new
       }.merge(options)
+      @persistent = persistent
     end
 
     # Create a copy of the current object. You can use the +options+ parameter to override options
     # of the current Context object in the newly created Context object.
     def clone(options = {})
-      self.class.new(@options.merge(options))
+      self.class.new(@options.merge(options), @persistent)
     end
 
     # Return the value of the option +name+.

data/lib/webgen/context/render.rb

@@ -0,0 +1,32 @@
+module Webgen
+
+  class Context
+
+    # Render the named block and return the result.
+    #
+    # call-seq:
+    #   context.render_block(block_name)<br />
+    #   context.render_block(:name => block_name, :option => value, ...)
+    #
+    # This method uses the functionality of the content processor +blocks+ for doing the actual
+    # work, so you may also want to look at Webgen::ContentProcessor::Blocks#render_block. You can
+    # call this method in two ways:
+    #
+    # [<tt>#render_block(block_name)</tt>]
+    #   Renders the block named +block_name+ of the next node in the current node chain. This is the
+    #   version that most want to use since it is equivalent to the use of <tt><webgen:block
+    #   name="block_name" /></tt>. It is equivalent to <tt>#render_block(:name =>
+    #   block_name)</tt>.
+    #
+    # [<tt>#render_block(opts_hash)</tt>]
+    #   This version allows the same level of control over the output as the blocks content
+    #   processor. For a list of valid options have a look at the documentation of the
+    #   Webgen::ContentProcessor::Blocks#render_block method!
+    def render_block(name_or_hash)
+      name_or_hash = {:name => name_or_hash} if name_or_hash.kind_of?(String)
+      website.cache.instance('Webgen::ContentProcessor::Blocks').render_block(self, name_or_hash)
+    end
+
+  end
+
+end

data/lib/webgen/context/tags.rb

@@ -0,0 +1,20 @@
+module Webgen
+
+  class Context
+
+    # Returns the result of evaluating the webgen tag +name+ with the tag parameters +params+ and
+    # the +body+ in the current context.
+    #
+    # Have a look at Webgen::Tag::Base for more information about webgen tags!
+    #
+    # This method is useful when you want to have the functionality of webgen tags available but you
+    # don't want to use the content processor for them. Or, for example, if the used markup language
+    # uses a similar markup as webgen tags do and therefore you can't use the normal webgen tags
+    # content processor.
+    def tag(name, params = {}, body = '')
+      website.cache.instance('Webgen::ContentProcessor::Tags').process_tag(name, params, body, self)
+    end
+
+  end
+
+end

data/lib/webgen/default_config.rb

@@ -43,6 +43,7 @@ end
 
 # All things regarding sources
 config.sources [['/', "Webgen::Source::FileSystem", 'src']], :doc => 'One or more sources from which files are read, relative to website directory'
+config.passive_sources([['/', "Webgen::Source::Resource", "webgen-passive-sources"]], :doc => 'One or more sources for delayed node creation on node resolution')
 
 # All things regarding source handler
 config.sourcehandler.patterns({
@@ -70,7 +71,7 @@ config.sourcehandler.default_lang_in_output_path(false, :doc => 'Specifies wheth
 config.sourcehandler.default_meta_info({
                                          :all => {
                                            'output_path' => 'standard',
-                                           'output_path_style' => [:parent, :cnbase, ['.', :lang], :ext]
+                                           'output_path_style' => [:parent, :basename, ['.', :lang], :ext]
                                          },
                                          'Webgen::SourceHandler::Copy' => {
                                            'kind' => 'asset'
@@ -88,19 +89,21 @@ config.sourcehandler.default_meta_info({
                                            'kind' => 'fragment'
                                          },
                                          'Webgen::SourceHandler::Template' => {
-                                           'blocks' => {'default' => {'pipeline' => 'erb,tags,blocks'}}
+                                           'blocks' => {'default' => {'pipeline' => 'erb,tags,blocks,head'}}
                                          },
                                          'Webgen::SourceHandler::Metainfo' => {
                                            'blocks' => {1 => {'name' => 'paths'}, 2 => {'name' => 'alcn'}}
                                          },
                                          'Webgen::SourceHandler::Feed' => {
                                            'rss' => true,
-                                           'atom' => true
+                                           'atom' => true,
+                                           'blocks' => {'default' => {'pipeline' => 'erb'}}
                                          },
                                          'Webgen::SourceHandler::Sitemap' => {
                                            'default_priority' => 0.5,
                                            'default_change_freq' => 'weekly',
-                                           'common.sitemap.any_lang' => true
+                                           'common.sitemap.any_lang' => true,
+                                           'blocks' => {'default' => {'pipeline' => 'erb'}}
                                          }
                                        }, :doc => "Default meta information for all nodes and for nodes belonging to a specific source handler")
 
@@ -114,6 +117,8 @@ website.autoload_service(:parse_html_headers, 'Webgen::SourceHandler::Fragment')
 
 # All things regarding output
 config.output ["Webgen::Output::FileSystem", 'out'], :doc => 'The class which is used to output the generated paths.'
+config.output.do_deletion(false, :doc => 'Specifies whether the generated output paths should be deleted once the sources are deleted')
+
 
 Webgen::WebsiteAccess.website.blackboard.add_service(:output_instance, Webgen::Output.method(:instance))
 
@@ -134,10 +139,13 @@ config.contentprocessor.map({
                               'erubis' => 'Webgen::ContentProcessor::Erubis',
                               'rdiscount' => 'Webgen::ContentProcessor::RDiscount',
                               'fragments' => 'Webgen::ContentProcessor::Fragments',
+                              'head' => 'Webgen::ContentProcessor::Head',
+                              'tidy' => 'Webgen::ContentProcessor::Tidy'
                             }, :doc => 'Content processor name to class map')
 
 Webgen::WebsiteAccess.website.blackboard.add_service(:content_processor_names, Webgen::ContentProcessor.method(:list))
 Webgen::WebsiteAccess.website.blackboard.add_service(:content_processor, Webgen::ContentProcessor.method(:for_name))
+Webgen::WebsiteAccess.website.blackboard.add_service(:content_processor_binary?, Webgen::ContentProcessor.method(:is_binary?))
 
 # All things regarding tags
 config.contentprocessor.tags.prefix('', :doc => 'The prefix used for tag names to avoid name clashes when another content processor uses similar markup.')
@@ -161,6 +169,8 @@ config.contentprocessor.erubis.options({}, :doc => 'A hash of additional options
 
 config.contentprocessor.redcloth.hard_breaks(false, :doc => 'Specifies whether new lines are turned into hard breaks')
 
+config.contentprocessor.tidy.options("-raw", :doc => "The options passed to the tidy command")
+
 config.tag.relocatable.path(nil, :doc => 'The path which should be made relocatable', :mandatory => 'default')
 
 config.tag.menu.start_level(1, :doc => 'The level at which the menu starts.')
@@ -196,6 +206,7 @@ config.tag.coderay.line_numbers(true, :doc => 'Show line numbers')
 config.tag.coderay.line_number_start(1, :doc => 'Line number of first line')
 config.tag.coderay.bold_every(10, :doc => 'The interval at which the line number appears bold')
 config.tag.coderay.tab_width(8, :doc => 'Number of spaces used for a tabulator')
+config.tag.coderay.css(:style, :doc => 'Specifies how the highlighted code should be styled')
 
 config.tag.date.format('%Y-%m-%d %H:%M:%S', :doc => 'The format of the date (same options as Ruby\'s Time#strftime)')
 

data/lib/webgen/deprecated.rb

@@ -3,18 +3,42 @@ module Webgen
   class Node
 
     def flagged(key)
-      warn("Deprecation warning: this method will be removed in one of the next releases - use Node#flagged? instead!")
+      warn("Deprecation warning (~ #{caller.first}): this method will be removed in one of the next releases - use Node#flagged? instead!")
       flagged?(key)
     end
 
+    def absolute_cn
+      warn("Deprecation warning (~ #{caller.first}): this method will be removed in one of the next releases - use Node#acn instead!")
+      acn
+    end
+
+    def absolute_lcn
+      warn("Deprecation warning (~ #{caller.first}): this method will be removed in one of the next releases - use Node#alcn instead!")
+      alcn
+    end
+
+  end
+
+  class Path
+
+    def cnbase
+      warn("Deprecation warning (~ #{caller.first}): this method will be removed in one of the next releases - use Path#basename instead!")
+      @basename
+    end
+
+    def cnbase=(value)
+      warn("Deprecation warning (~ #{caller.first}): this method will be removed in one of the next releases - use Path#basename= instead!")
+      basename = value
+    end
+
   end
 
   def self.const_missing(const)
     if const.to_s == 'Block'
-      warn("Deprecation warning: Webgen::Block name will be removed in one of the next releases - use Webgen::Page::Block instead!")
+      warn("Deprecation warning (~ #{caller.first}): Webgen::Block name will be removed in one of the next releases - use Webgen::Page::Block instead!")
       Webgen::Page::Block
     elsif const.to_s == "WebgenPageFormatError"
-      warn("Deprecation warning: Webgen::WebgenPageFormatError name will be removed in one of the next releases - use Webgen::Page::FormatError instead!")
+      warn("Deprecation warning (~ #{caller.first}): Webgen::WebgenPageFormatError name will be removed in one of the next releases - use Webgen::Page::FormatError instead!")
       Webgen::Page::FormatError
     else
       super
@@ -25,7 +49,7 @@ module Webgen
 
     def self.const_missing(const)
       if const.to_s == 'Context'
-        warn("Deprecation warning: Webgen::ContentProcessor::Context is now named Webgen::Context! This alias will be removed in one of the next releases.")
+        warn("Deprecation warning (~ #{caller.first}): Webgen::ContentProcessor::Context is now named Webgen::Context! This alias will be removed in one of the next releases.")
         Webgen::Context
       else
         super
@@ -39,6 +63,7 @@ module Webgen
         klass.instance_methods.select {|m| m.to_s !~ /^(__|instance_eval|object_id)/}.each {|m| klass.__send__(:undef_method, m)}
         result = klass.new
         result.instance_eval { @old, @new, @obj = old, new, obj }
+        def result.inspect; end
         def result.method_missing(sym, *args, &block)
           Kernel::warn("Deprecation warning (~ #{caller.first}): The alias '#{@old}' will be removed in one of the next releases - use '#{@new}' instead!")
           @obj.send(sym, *args, &block)
@@ -50,4 +75,13 @@ module Webgen
 
   end
 
+  module Common
+
+    def self.absolute_path(path, base)
+      warn("Deprecation warning (~ #{caller.first}): this method will be removed in one of the next releases - use Webgen::Path.make_absolute(base, path) instead!")
+      Path.make_absolute(base, path)
+    end
+
+  end
+
 end

data/lib/webgen/error.rb

@@ -0,0 +1,135 @@
+# -*- encoding: utf-8 -*-
+
+module Webgen
+
+  # Custom webgen error.
+  class Error < StandardError
+
+    # The name of the class where the error happened.
+    attr_reader :class_name
+
+    # This is either the source path or the node alcn which is responsible for the error.
+    attr_accessor :alcn
+
+    # The plain error message.
+    attr_reader :plain_message
+
+    # Create a new Error using the provided values.
+    #
+    # If +msg_or_error+ is a String, it is treated as the error message. If it is an exception, the
+    # exception is wrapped.
+    def initialize(msg_or_error, class_name = nil, alcn = nil)
+      if msg_or_error.kind_of?(String)
+        super(msg_or_error)
+        @plain_message = msg_or_error
+      else
+        super(msg_or_error.message)
+        set_backtrace(msg_or_error.backtrace)
+        @plain_message = msg_or_error.message
+      end
+      @class_name, @alcn = class_name, alcn
+    end
+
+    def message # :nodoc:
+      msg = 'Error while working'
+      msg += (@alcn ? " on <#{@alcn}>" : '')
+      msg += " with #{@class_name}" if @class_name
+      msg + ":\n    " + plain_message
+    end
+
+  end
+
+  # This error is raised when an error condition occurs during the creation of a node.
+  class NodeCreationError < Error
+
+    def message # :nodoc:
+      msg = 'Error while creating a node'
+      msg += (@alcn ? " from <#{@alcn}>" : '')
+      msg += " with #{@class_name}" if @class_name
+      msg + ":\n    " + plain_message
+    end
+
+  end
+
+
+  # This error is raised when an error condition occurs during rendering of a node.
+  class RenderError < Error
+
+    # The alcn of the file where the error happened. This can be different from #alcn (e.g. a page
+    # file is rendered but the error happens in a used template).
+    attr_accessor :error_alcn
+
+    # The line number in the +error_alcn+ where the errror happened.
+    attr_accessor :line
+
+    # Create a new RenderError using the provided values.
+    #
+    # If +msg_or_error+ is a String, it is treated as the error message. If it is an exception, the
+    # exception is wrapped.
+    def initialize(msg_or_error, class_name = nil, alcn = nil, error_alcn = nil, line = nil)
+      super(msg_or_error, class_name, alcn)
+      @error_alcn, @line = error_alcn, line
+    end
+
+    def message # :nodoc:
+      msg = 'Error '
+      if @error_alcn
+        msg += "in <#{@error_alcn}"
+        msg += ":~#{@line}" if @line
+        msg += "> "
+      end
+      msg += 'while rendering '
+      msg += (@alcn ? "<#{@alcn}>" : 'the website')
+      msg += " with #{@class_name}" if @class_name
+      msg + ":\n    " + plain_message
+    end
+
+  end
+
+
+  # This error is raised when a needed library is not found.
+  class LoadError < Error
+
+    # The name of the library that is missing.
+    attr_reader :library
+
+    # The name of the Rubygem that provides the missing library.
+    attr_reader :gem
+
+    # Create a new LoadError using the provided values.
+    #
+    # If +library_or_error+ is a String, it is treated as the missing library name and an approriate
+    # error message is created. If it is an exception, the exception is wrapped.
+    def initialize(library_or_error, class_name = nil, alcn = nil, gem = nil)
+      if library_or_error.kind_of?(String)
+        msg = "The needed library '#{library_or_error}' is missing."
+        msg += " You can install it via rubygems with 'gem install #{gem}'!" if gem
+        super(msg, class_name, alcn)
+        @library = library_or_error
+      else
+        super(library_or_error, class_name, alcn)
+        @library = nil
+      end
+      @gem = gem
+    end
+
+  end
+
+
+  # This error is raised when a needed external command is not found.
+  class CommandNotFoundError < Error
+
+    # The command that is missing.
+    attr_reader :cmd
+
+    # Create a new CommandNotFoundError using the provided values.
+    #
+    # The parameter +cmd+ specifies the command that is missing.
+    def initialize(cmd, class_name = nil, alcn = nil)
+      super("The needed command '#{cmd}' is missing!", class_name, alcn)
+      @cmd = cmd
+    end
+
+  end
+
+end

data/lib/webgen/node.rb

@@ -22,10 +22,11 @@ module Webgen
     include WebsiteAccess
     include Loggable
 
-    # The parent node.
+    # The parent node. This is in all but one case a Node object. The one exception is that the
+    # parent of the Tree#dummy_node is a Tree object.
     attr_reader :parent
 
-    # The children of this node.
+    # The child nodes of this node.
     attr_reader :children
 
     # The full output path of this node.
@@ -38,13 +39,13 @@ module Webgen
     attr_reader :cn
 
     # The absolute canonical name of this node.
-    attr_reader :absolute_cn
+    attr_reader :acn
 
     # The localized canonical name of this node.
     attr_reader :lcn
 
     # The absolute localized canonical name of this node.
-    attr_reader :absolute_lcn
+    attr_reader :alcn
 
     # The level of the node. The level specifies how deep the node is in the hierarchy.
     attr_reader :level
@@ -76,7 +77,7 @@ module Webgen
     # found, the node is language neutral.
     def initialize(parent, path, cn, meta_info = {})
       @parent = parent
-      @cn = cn.chomp('/').freeze
+      @cn = cn.freeze
       @children = []
       reinit(path, meta_info)
       init_rest
@@ -111,11 +112,11 @@ module Webgen
 
     # Return the node information hash which contains information for processing the node.
     def node_info
-      tree.node_info[@absolute_lcn] ||= {}
+      tree.node_info[@alcn] ||= {}
     end
 
     # Check if the node is a directory.
-    def is_directory?; @path[-1] == ?/; end
+    def is_directory?; @path[-1] == ?/ && !is_fragment?; end
 
     # Check if the node is a file.
     def is_file?; !is_directory? && !is_fragment?; end
@@ -160,14 +161,23 @@ module Webgen
     # thinks it is dirty.
     def changed?
       if_not_checked(:node) do
-        flag(:dirty) if meta_info_changed? ||
-          node_info[:used_nodes].any? {|n| n != @absolute_lcn && (!tree[n] || tree[n].changed?)} ||
-          node_info[:used_meta_info_nodes].any? {|n| n != @absolute_lcn && (!tree[n] || tree[n].meta_info_changed?)}
+        flag(:dirty) if meta_info_changed? || user_nodes_changed? ||
+          node_info[:used_nodes].any? {|n| n != @alcn && (!tree[n] || tree[n].changed?)} ||
+          node_info[:used_meta_info_nodes].any? {|n| n != @alcn && (!tree[n] || tree[n].meta_info_changed?)}
         website.blackboard.dispatch_msg(:node_changed?, self) unless flagged?(:dirty)
       end
       flagged?(:dirty)
     end
 
+    # Return +true+ if any node matching a pattern from the meta information +used_nodes+ has changed.
+    def user_nodes_changed?
+      pattern = [@meta_info['used_nodes']].flatten.compact.collect {|pat| Webgen::Path.make_absolute(parent.alcn, pat)}
+      tree.node_access[:alcn].any? do |path, n|
+        pattern.any? {|pat| n =~ pat && n.changed?}
+      end if pattern.length > 0
+    end
+    private :user_nodes_changed?
+
     # Return +true+ if the meta information of the node has changed.
     #
     # Sends the message <tt>:node_meta_info_changed?</tt> with +self+ as argument unless the meta
@@ -183,12 +193,12 @@ module Webgen
 
     # Return an informative representation of the node.
     def inspect
-      "<##{self.class.name}: alcn=#{@absolute_lcn}>"
+      "<##{self.class.name}: alcn=#{@alcn}>"
     end
 
     # Return +true+ if the alcn matches the pattern. See File.fnmatch for useable patterns.
     def =~(pattern)
-      File.fnmatch(pattern, @absolute_lcn, File::FNM_DOTMATCH|File::FNM_CASEFOLD|File::FNM_PATHNAME)
+      File.fnmatch(pattern, @alcn, File::FNM_DOTMATCH|File::FNM_CASEFOLD|File::FNM_PATHNAME)
     end
 
     # Sort nodes by using the meta info +sort_info+ (or +title+ if +sort_info+ is not set) of both
@@ -203,22 +213,16 @@ module Webgen
       self_so <=> other_so
     end
 
-    # Construct the absolute (localized) canonical name by using the +parent+ node and +name+ (which
-    # can be a cn or an lcn). The +type+ can be either <tt>:alcn</tt> or <tt>:acn</tt>.
-    def self.absolute_name(parent, name, type)
-      if parent.kind_of?(Tree)
-        ''
-      else
-        parent = parent.parent while parent.is_fragment? # Handle fragment nodes specially in case they are nested
-        parent_name = (type == :alcn ? parent.absolute_lcn : parent.absolute_cn)
-        parent_name + (parent_name !~ /\/$/ && (parent.is_directory? || parent == parent.tree.dummy_root) ? '/' : '') + name
-      end
-    end
+    # This pattern is the the same as URI::UNSAFE except that the hash character (#) is also
+    # not escaped. This is needed sothat paths with fragments work correctly.
+    URL_UNSAFE_PATTERN = Regexp.new("[^#{URI::PATTERN::UNRESERVED}#{URI::PATTERN::RESERVED}#]") # :nodoc:
 
-    # Construct an internal URL for the given +name+ which can be a acn/alcn/path.
-    def self.url(name)
-      url = URI::parse(name)
-      url = URI::parse('webgen://webgen.localhost/') + url unless url.absolute?
+    # Construct an internal URL for the given +name+ which can be an acn/alcn/path. If the parameter
+    # +make_absolute+ is +true+, then a relative URL will be made absolute by prepending the special
+    # URL <tt>webgen:://webgen.localhost/</tt>.
+    def self.url(name, make_absolute = true)
+      url = URI::parse(URI::escape(name, URL_UNSAFE_PATTERN))
+      url = URI::parse('webgen://webgen.localhost/') + url unless url.absolute? || !make_absolute
       url
     end
 
@@ -235,7 +239,7 @@ module Webgen
     # exists, an unlocalized version of the node. If no such node is found either, +nil+ is
     # returned.
     def in_lang(lang)
-      avail = @tree.node_access[:acn][@absolute_cn]
+      avail = @tree.node_access[:acn][@acn]
       avail.find do |n|
         n = n.parent while n.is_fragment?
         n.lang == lang
@@ -252,19 +256,23 @@ module Webgen
     # If the +path+ is an alcn and a node is found, it is returned. If the +path+ is an acn, the
     # correct localized node according to +lang+ is returned or if no such node exists but an
     # unlocalized version does, the unlocalized node is returned.
-    def resolve(path, lang = nil)
-      url = self.class.url(self.is_directory? ? File.join(@absolute_lcn, '/') : @absolute_lcn) + path
+    def resolve(path, lang = nil, use_passive_sources = true)
+      orig_path = path
+      url = self.class.url(@alcn) + self.class.url(path, false)
 
       path = url.path + (url.fragment.nil? ? '' : '#' + url.fragment)
-      path.chomp!('/') unless path == '/'
       return nil if path =~ /^\/\.\./
 
       node = @tree[path, :alcn]
-      if node && node.absolute_cn != path
-        node
-      else
-        (node = @tree[path, :acn]) && node.in_lang(lang)
+      if !node || node.acn == path
+        (node = (@tree[path, :acn] || @tree[path + '/', :acn])) && (node = node.in_lang(lang))
+      end
+      if !node && use_passive_sources && !website.config['passive_sources'].empty?
+        nodes = website.blackboard.invoke(:create_nodes_from_paths, [path])
+        node = resolve(orig_path, lang, false)
+        node.node_info[:used_meta_info_nodes] += nodes.collect {|n| n.alcn} if node
       end
+      node
     end
 
     # Return the relative path to the given path +other+. The parameter +other+ can be a Node or a
@@ -295,7 +303,7 @@ module Webgen
       if !is_directory?
         self
       else
-        key = [absolute_lcn, :index_node, lang]
+        key = [alcn, :index_node, lang]
         vcache = website.cache.volatile
         return vcache[key] if vcache.has_key?(key)
 
@@ -306,10 +314,10 @@ module Webgen
           index_node = resolve(index_path, lang)
           if index_node
             vcache[key] = index_node
-            log(:info) { "Directory index path for <#{absolute_lcn}> => <#{index_node.absolute_lcn}>" }
+            log(:info) { "Directory index path for <#{alcn}> => <#{index_node.alcn}>" }
           elsif log_warning
             vcache[key] = self
-            log(:warn) { "No directory index path found for directory <#{absolute_lcn}>" }
+            log(:warn) { "No directory index path found for directory <#{alcn}>" }
           end
         end
         vcache[key] || self
@@ -351,8 +359,8 @@ module Webgen
     # Do the rest of the initialization.
     def init_rest
       @lcn = Path.lcn(@cn, @lang)
-      @absolute_cn = self.class.absolute_name(@parent, @cn, :acn)
-      @absolute_lcn = self.class.absolute_name(@parent, @lcn, :alcn)
+      @acn = (@parent.kind_of?(Tree) ? '' : @parent.acn.sub(/#.*$/, '') + @cn)
+      @alcn = (@parent.kind_of?(Tree) ? '' : @parent.alcn.sub(/#.*$/, '') + @lcn)
 
       @level = -1
       @tree = @parent