webgen 0.3.8 → 0.4.0

data/lib/webgen/plugins/tags/menu.rb

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: menu.rb 369 2005-12-24 11:37:40Z thomas $
+# $Id: menu.rb 563 2006-12-29 08:59:41Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner
@@ -21,93 +21,69 @@
 #
 
 require 'webgen/node'
-require 'webgen/plugins/tags/tags'
+load_plugin 'webgen/plugins/tags/tag_processor'
 
 module Tags
 
-  # Generates a menu. All page files for which the meta information +inMenu+ is set are displayed.
-  # If you have one page in several languages, it is sufficient to add this meta information to only
-  # one page file.
+  # Generates a menu. All page files for which the meta information +inMenu+ is set are used.
   #
   # The order in which the menu items are listed can be controlled via the meta information
-  # +orderInfo+. By default the menu items are sorted by the file names.
+  # +orderInfo+. By default the menu items are sorted by their titles.
   class MenuTag < DefaultTag
 
-    class ::Node
-
-      # Retrieves the meta information +orderInfo+.
-      def order_info
-        # be optimistic and try metainfo field first
-        node = self
-        value = node['orderInfo'].to_s.to_i unless node['orderInfo'].nil?
-
-        # get index file for directory
-        if node['int:directory?']
-          node = node['indexFile']
-          value ||= node['orderInfo'].to_s.to_i unless node.nil? || node['orderInfo'].nil?
-        end
-
-        # find the first orderInfo entry in the page files if node is a page file
-        if !node.nil? && node['int:pagename']
-          node = node.parent.find {|child| child['int:pagename'] == node['int:pagename'] && child['orderInfo'].to_s.to_i != 0}
-          value ||= node['orderInfo'].to_s.to_i unless node.nil?
-        end
-
-        # fallback value
-        value ||= 0
-
-        value
-      end
-
-      SORT_PROC = Proc.new do |a,b|
-        aoi = a.order_info
-        boi = b.order_info
-        (aoi == boi ? a['title'] <=> b['title'] : aoi <=> boi)
-      end
-
-    end
-
     # Specialised node class for the menu.
     class MenuNode < Node
 
       def initialize( parent, node )
-        super( parent )
-        self.logger.info { "Creating menu node for <#{node.recursive_value( 'src', false )}>" }
-        self['title'] = 'Menu: '+ node['title']
-        self['isMenuNode'] = true
-        self['virtual'] = true
-        self['node'] = node
+        super( parent, '' )
+        self['title'] = 'Menu: ' + node['title']
+        self.node_info[:node] = node
       end
 
 
       # Sorts recursively all children of the node depending on their order value. If two order
       # values are equal, sort the items using their title.
       def sort!
-        self.children.sort! {|a,b| SORT_PROC.call( a['node'], b['node'] ) }
-        self.children.each {|child| child.sort! if child['node']['int:directory?'] }
+        self.children.sort! {|a,b| a.node_info[:node] <=> b.node_info[:node] }
+        self.children.each {|child| child.sort! }
+      end
+
+      def inspect
+        @node_info[:node]
       end
+      alias_method :to_s, :inspect
 
     end
 
 
-    summary 'Builds a menu'
-    add_param 'menuStyle', 'vertical', 'Specifies the style of the menu.'
-    add_param 'options', {}, 'Optional options that are passed on to the plugin which is layouts the menu.'
+    infos( :name => 'Tag/Menu',
+           :author => Webgen::AUTHOR,
+           :summary => 'Builds a menu'
+           )
+
+    param 'menuStyle', nil, 'Specifies the style of the menu.'
+    param 'options', {}, 'Options that are passed on to the plugin which layouts the menu.'
+    set_mandatory 'menuStyle', true
 
-    used_meta_info 'orderInfo', 'inMenu'
+    register_tag 'menu'
 
-    tag 'menu'
+    def process_tag( tag, chain )
+      lang = chain.last['lang']
+      @menus ||= {}
+      unless @menus[lang]
+        @menus[lang] = create_menu_tree( Node.root( chain.last ), nil, lang )
+        @menus[lang].sort! if @menus[lang]
+      end
 
-    def process_tag( tag, node, refNode )
-      unless defined?( @menuTree )
-        @menuTree = create_menu_tree( Node.root( node ), nil )
-        unless @menuTree.nil?
-          Webgen::Plugin['TreeWalker'].execute( @menuTree, Webgen::Plugin['DebugTreePrinter'] )
-          @menuTree.sort!
-          Webgen::Plugin['TreeWalker'].execute( @menuTree, Webgen::Plugin['DebugTreePrinter'] )
-        end
+      style = @plugin_manager['MenuStyle/Default'].registered_handlers[param( 'menuStyle' )]
+      if style.nil?
+        log(:error) { "Invalid style specified in <#{chain.first.node_info[:src]}>" }
+        ''
+      elsif @menus[lang]
+        style.build_menu( chain.last, @menus[lang], param( 'options' ) )
+      else
+        ''
       end
-      Webgen::Plugin['DefaultMenuStyle'].get_menu_style( get_param( 'menuStyle' ) ).build_menu( node, @menuTree, get_param( 'options' ) )
     end
 
 
@@ -115,16 +91,19 @@ module Tags
     private
     #######
 
-    def create_menu_tree( node, parent )
-      menuNode = MenuNode.new( parent, node )
+    # Returns a menu tree if at least one node is in the menu or +nil+ otherwise.
+    def create_menu_tree( node, parent, lang )
+      menu_node = MenuNode.new( parent, node )
+      parent.del_child( menu_node ) if parent
 
-      node.each do |child|
-        next if menuNode.find {|n| n['node']['int:pagename'] == child['int:pagename'] && !n['node']['int:pagename'].nil? }
-        menu = create_menu_tree( child, menuNode )
-        menuNode.add_child( menu ) unless menu.nil?
-      end
+      node.select do |child|
+        child['lang'] == lang || child['lang'].nil? || child.is_directory?
+      end.each do |child|
+        sub_node = create_menu_tree( child, menu_node, lang )
+        menu_node.add_child( sub_node ) unless sub_node.nil?
+      end if node.is_directory?
 
-      return menuNode.has_children? ? menuNode : ( node['inMenu'] && !node['virtual'] ? menuNode : nil )
+      return menu_node.has_children? ? menu_node : ( node['inMenu'] ? menu_node : nil )
     end
 
   end

data/lib/webgen/plugins/tags/meta.rb

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: meta.rb 369 2005-12-24 11:37:40Z thomas $
+# $Id: meta.rb 563 2006-12-29 08:59:41Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner
@@ -20,7 +20,7 @@
 #++
 #
 
-require 'webgen/plugins/tags/tags'
+load_plugin 'webgen/plugins/tags/tag_processor'
 
 module Tags
 
@@ -31,18 +31,21 @@ module Tags
   # simple copy the values to the output file.
   class MetaTag < DefaultTag
 
-    summary "Replaces all tags without tag plugin with their respective values from the node meta data"
+    infos( :name => 'Tag/Meta',
+           :author => Webgen::AUTHOR,
+           :summary => "Replaces all tags without tag plugin with their respective values from the node meta info"
+           )
 
-    tag :default
+    register_tag :default
 
-    def process_tag( tag, node, refNode )
+    def process_tag( tag, chain )
       output = ''
-      if node[tag]
-        output = node[tag]
+      if chain.last[tag]
+        output = chain.last[tag].to_s
       else
-        self.logger.warn { "No value for tag '#{tag}' in <#{refNode.recursive_value( 'src' )}> found in <#{node.recursive_value( 'src' )}>" }
+        log(:warn) { "No value for tag '#{tag}' in <#{chain.first.node_info[:src]}> found in <#{chain.last.node_info[:src]}>" }
       end
-      return output
+      output
     end
 
   end

data/lib/webgen/plugins/tags/relocatable.rb

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: relocatable.rb 369 2005-12-24 11:37:40Z thomas $
+# $Id: relocatable.rb 563 2006-12-29 08:59:41Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner
@@ -20,7 +20,7 @@
 #++
 #
 
-require 'webgen/plugins/tags/tags'
+load_plugin 'webgen/plugins/tags/tag_processor'
 require 'uri'
 
 module Tags
@@ -35,14 +35,20 @@ module Tags
   # Tag parameter: the name of the file which should be relocated
   class RelocatableTag < DefaultTag
 
-    summary 'Adds a relative path to the specified name if necessary'
-    add_param 'item', nil, 'The item which should be relocatable'
-    set_mandatory 'item', true
+    infos( :name => 'Tag/Relocatable',
+           :author => Webgen::AUTHOR,
+           :summary => 'Adds a relative path to the specified name if necessary'
+           )
 
-    tag 'relocatable'
+    param 'path', nil, 'The path which should be relocatable'
+    param 'resolveFragment', true, 'Specifies if the fragment part (#something) in the path should also be resolved'
+    set_mandatory 'path', true
 
-    def process_tag( tag, node, refNode )
-      uri_string = get_param( 'item' )
+    register_tag 'relocatable'
+
+
+    def process_tag( tag, chain )
+      uri_string = param( 'path' )
       result = ''
       unless uri_string.nil?
         begin
@@ -50,15 +56,37 @@ module Tags
           if uri.absolute?
             result = uri_string
           else
-            destNode = refNode.node_for_string( uri.path )
-            qf = (uri.query.nil? ? '' : '?'+ uri.query ) + (uri.fragment.nil? ? '' : '#' + uri.fragment)
-            result = ( destNode.nil? ? '' :  node.relpath_to_node( destNode['processor'].get_node_for_lang( destNode, node['lang'] ) ) + qf )
+            result = resolve_path( uri, chain )
           end
+          log(:error) { "Could not resolve path '#{uri_string}' in <#{chain.first.node_info[:src]}>" } if result.empty?
         rescue URI::InvalidURIError => e
-          logger.error { "Error while parsing URI for relocatable tag: #{e.message}" }
+          log(:error) { "Error while parsing path for tag relocatable in <#{chain.first.node_info[:src]}>: #{e.message}" }
         end
       end
-      return result
+      result
+    end
+
+    #######
+    private
+    #######
+
+    def query_fragment( uri )
+      (uri.query.nil? ? '' : '?'+ uri.query ) + (uri.fragment.nil? ? '' : '#' + uri.fragment)
+    end
+
+    def resolve_path( uri, chain )
+      dest_node = chain.first.resolve_node( uri.path )
+      if !dest_node.nil? && (File.basename( uri.path ) == dest_node.node_info[:pagename] || dest_node.is_directory?)
+        dest_node = dest_node.node_for_lang( chain.last['lang'] )
+      end
+      if !dest_node.nil? && !uri.fragment.nil? && param( 'resolveFragment' )
+        dest_node = dest_node.resolve_node( '#' + uri.fragment )
+      end
+      if dest_node.nil?
+        ''
+      else
+        chain.last.route_to( dest_node.is_fragment? ? dest_node.parent : dest_node ) + query_fragment( uri )
+      end
     end
 
   end

data/lib/webgen/plugins/tags/sitemap.rb

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: sitemap.rb 369 2005-12-24 11:37:40Z thomas $
+# $Id: sitemap.rb 563 2006-12-29 08:59:41Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner
@@ -20,55 +20,59 @@
 #++
 #
 
-require 'webgen/plugins/tags/tags'
+load_plugin 'webgen/plugins/tags/tag_processor'
+load_plugin 'webgen/plugins/filehandlers/page'
 
 module Tags
 
   # Generates a sitemap. The sitemap contains the hierarchy of all pages on the web site.
   class SitemapTag < DefaultTag
 
-    summary 'Shows all pages of the website'
-    add_param 'levelTag', 'ul', 'The tag used for creating a new hierarchy level.'
-    add_param 'itemTag', 'li', 'The tag used for pages.'
-    add_param 'honorInMenu', true, 'Only pages for which the \'inMenu\' meta information is set are shown in ' \
-    'the sitemap if true'
+    infos( :name => 'Tag/Sitemap',
+           :author => Webgen::AUTHOR,
+           :summary => 'Shows all page files of the website'
+           )
 
-    used_meta_info 'orderInfo'
+    param 'levelTag', 'ul', 'The tag used for creating a new hierarchy level.'
+    param 'itemTag', 'li', 'The tag used for hierarchy items.'
+    param 'honorInMenu', true, 'Only pages for which the \'inMenu\' meta information is set are shown in ' +
+      'the sitemap if true'
 
-    tag 'sitemap'
+    register_tag 'sitemap'
 
-    def process_tag( tag, srcNode, refNode )
-      root = Node.root( srcNode )
-      output_node( root, srcNode )
+
+    def process_tag( tag, chain )
+      root = Node.root( chain.last )
+      output_node( root, chain.last )
     end
 
     #######
     private
     #######
 
-    def output_node( node, srcNode )
-      return '' if not node.find {|c| c['int:directory?'] || c['int:pagename'] }
+    def output_node( node, src_node )
+      nodes = node.select do |child|
+        child.is_directory? || (child.kind_of?( FileHandlers::PageHandler::PageNode ) && child['lang'] == src_node['lang'])
+      end
+      return '' if nodes.empty?
 
-      processed_pagenodes = []
-      out = "<#{get_param( 'levelTag' )}>"
+      out = "<#{param( 'levelTag' )}>"
       temp = ''
-      node.sort( &Node::SORT_PROC ).each do |child|
-        next unless (child['int:directory?'] || (child['int:pagename'] && (!get_param( 'honorInMenu' ) || child['inMenu']))) && !processed_pagenodes.include?( child['int:pagename'] )
-        processed_pagenodes << child['int:pagename'] if child['int:pagename']
-
-        next if !node['indexFile'].nil? && node['indexFile']['int:pagename'] == child['int:pagename']
+      nodes.sort.each do |child|
+        next if !child.is_directory? &&
+          ((param( 'honorInMenu' ) && !child['inMenu']) ||
+           (!node['indexFile'].nil? && node['indexFile'].node_info[:pagename] == child.node_info[:pagename] && !node.parent.nil?))
 
-        isDir = child['int:directory?']
-        subout = output_node( child, srcNode )
-        link = child['processor'].get_html_link( child, srcNode ) if subout != '' || !isDir
+        subout = output_node( child, src_node )
+        link = child.link_from( src_node ) if !child.is_directory? || subout != ''
 
-        temp += "<#{get_param( 'itemTag' )}>#{link}" if !isDir || subout != ''
-        temp += subout if isDir
-        temp += "</#{get_param( 'itemTag' )}>" if !isDir || subout != ''
+        temp += "<#{param( 'itemTag' )}>#{link}" if !child.is_directory? || subout != ''
+        temp += subout if child.is_directory?
+        temp += "</#{param( 'itemTag' )}>" if !child.is_directory? || subout != ''
       end
 
       out += temp
-      out += "</#{get_param( 'levelTag' )}>"
+      out += "</#{param( 'levelTag' )}>"
 
       (temp == '' ? temp : out)
     end

data/lib/webgen/plugins/tags/tag_processor.rb

@@ -0,0 +1,279 @@
+#
+#--
+#
+# $Id: tag_processor.rb 572 2006-12-31 08:19:56Z thomas $
+#
+# webgen: template based static website generator
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+#
+
+require 'yaml'
+
+module Tags
+
+  # This class is used for processing tags. When a content string is parsed and a tag is
+  # encountered, the registered plugin for the tag is called. If no plugin for a tag is registered
+  # but a default plugin is, the default plugin is called. Otherwise an error is raised.
+  #
+  # The default plugin can be defined by using the special key <tt>:default</tt>.
+  class TagProcessor < Webgen::Plugin
+
+    infos( :name => 'Core/TagProcessor',
+           :author => Webgen::AUTHOR,
+           :summary => "Plugin for processing tags"
+           )
+
+    # Processes the given +content+ using the nodes in +chain+ which should be an array of nodes.
+    # The first node is the main template (from which the +content+ was retrieved, the +ref_node+),
+    # then comes the sub template, the sub sub template and so on until the last node which is the
+    # current node (the +node+) that is the reason for the whole processing.
+    #
+    # After having processed all nodes, the method returns the result as string, ie. the rendered
+    # content.
+    def process( content, chain )
+      if !content.kind_of?( String )
+        log(:warn) { "The content in <#{chain.first.node_info[:src]}> is not a string, but a #{content.class.name}" }
+        content = content.to_s
+      end
+
+      return replace_tags( content, chain.first ) do |tag, tag_data|
+        log(:debug) { "Replacing tag #{tag} with data '#{tag_data}' in <#{chain.first.full_path}>" }
+
+        result = ''
+        processor = processor_for_tag( tag )
+        if !processor.nil?
+          begin
+            processor.set_tag_config( YAML::load( "--- #{tag_data}" ), chain.first )
+          rescue ArgumentError => e
+            log(:error) { "Could not parse the data '#{tag_data}' for tag #{tag} in <#{node.nod_info[:src]}>: #{e.message}" }
+          end
+          result, tag_chain = processor.process_tag( tag, chain )
+          processor.reset_tag_config
+
+          result = process( result, tag_chain || chain ) if processor.process_output?
+        end
+
+        result
+      end
+    end
+
+    #######
+    private
+    #######
+
+    # Scans the +content+ for tags. If a tag is found, the block is called which needs to return the
+    # value for the given tag. The changed content is returned.
+    def replace_tags( content, node ) # :yields: tag, data
+      offset = 0;
+      content = content.dup
+      while index = content.index( /(\\*)\{(\w+):/, offset )
+        bracketCount = 1;
+        length = $1.length + 1;
+        tag = $2
+        content[(index + length)..-1].each_byte do |char|
+          length += 1
+          bracketCount += 1 if char == ?{
+          bracketCount -= 1 if char == ?}
+          break if bracketCount == 0
+        end
+
+        if bracketCount > 0
+          log(:error) { "Unbalanced curly brackets in <#{node.node_info[:src]}>!!!" }
+          newContent = content[index, length]
+        else
+          newContent = "\\"* ( $1.length / 2 )
+          if $1.length % 2 == 1
+            newContent += content[index + $1.length, length - $1.length]
+          else
+            tagHeaderLength = $1.length + tag.length + 2
+            realContent = content[index + tagHeaderLength, length - tagHeaderLength - 1].lstrip
+            newContent += yield( tag, realContent ).to_s
+          end
+          content[index, length] = newContent
+        end
+        offset = index + newContent.length
+      end
+      content
+    end
+
+
+    # Returns the tag processor for +tag+ or +nil+ if +tag+ is unknown.
+    def processor_for_tag( tag )
+      tags = registered_tags
+      if tags.has_key?( tag )
+        tags[tag]
+      elsif tags.has_key?( :default )
+        tags[:default]
+      else
+        log(:error) { "No tag processor for tag '#{tag}' found" }
+      end
+    end
+
+    # Returns a hash of the registered tag plugins with the tag name as key.
+    def registered_tags
+      if !defined?( @registered_tags_cache ) || @cached_plugins_hash != @plugin_manager.plugins.keys.hash
+        @registered_tags_cache = {}
+        @plugin_manager.plugins.each do |name, plugin|
+          if plugin.kind_of?( DefaultTag )
+            #TOOD write log message if duplicate tag name
+            plugin.tags.each {|tag| @registered_tags_cache[tag] = plugin }
+          end
+        end
+        @cached_plugins_hash = @plugin_manager.plugins.keys.hash
+      end
+      @registered_tags_cache
+    end
+
+  end
+
+
+  # Base class for all tag plugins. The base class provides a default mechanism for retrieving
+  # configuration data from either the configuration file or the tag itself.
+  class DefaultTag < Webgen::Plugin
+
+    infos( :name => 'Tag/Default',
+           :summary => "Base plugin for all tag plugins",
+           :author => Webgen::AUTHOR,
+           :instantiate => false
+           )
+
+    def initialize( plugin_manager )
+      super
+      @process_output = true
+      @cur_config = {}
+      @tags = []
+    end
+
+    # Returns +true+ if the output should be processed again
+    def process_output?
+      @process_output
+    end
+
+    # Set the parameter +param+ as mandatory. The parameter +default+ specifies, if this parameter
+    # should be the default mandatory parameter. If only a String is supplied in a tag, its value
+    # will be assigned to the default mandatory parameter. There *should* be only one default
+    # mandatory parameter.
+    def self.set_mandatory( param, default = false )
+      if self.config.params.nil? || !self.config.params.has_key?( param )
+        $stderr.puts( "Cannot set parameter #{param} as mandatory as this parameter does not exist for #{self.name}" ) if $VERBOSE
+      else
+        self.config.params[param].mandatory = true
+        self.config.params[param].mandatory_default = default
+      end
+    end
+
+    # Register +tag+ so that it gets processed by the current class.
+    def self.register_tag( tag )
+      (self.config.infos[:tags] ||= [] ) << tag
+    end
+
+    # See DefaultTag.register_tag
+    def register_tag( tag )
+      @tags << tag
+    end
+
+    # Returns all registered tags for the plugin.
+    def tags
+      (self.class.config.infos[:tags] || []) + @tags
+    end
+
+    # Set the configuration parameters for the next #process_tag call. The configuration, if
+    # specified, is taken from the tag itself.
+    def set_tag_config( config, node )
+      @cur_config = {}
+      case config
+      when Hash
+        set_cur_config( config, node )
+
+      when String
+        set_default_mandatory_param( config, node )
+
+      when NilClass
+
+      else
+        log(:error) { "Invalid parameter type (#{config.class}) for tag '#{self.class.plugin_name}' in <#{node.node_info[:src]}>" }
+      end
+
+      unless all_mandatory_params_set?
+        log(:error) { "Not all mandatory parameters for tag '#{self.class.plugin_name}' in <#{node.node_info[:src]}> set" }
+      end
+    end
+
+    # Resets the tag configuration data.
+    def reset_tag_config
+      @cur_config = {}
+    end
+
+    # Retrieves the parameter value for +name+. The value is taken from the current tag if the
+    # parameter is specified there or the default value set in #register_config_value is used.
+    def param( name, plugin = nil )
+      if @cur_config.has_key?( name ) && plugin.nil?
+        return @cur_config[name]
+      else
+        super( name, plugin )
+      end
+    end
+
+    # Default implementation for processing a tag. The parameter +tag+ specifies the name of the tag
+    # which should be processed (useful for tag plugins which process different tags).
+    #
+    # The +node_chain+ parameter holds all relevant nodes. The first node in the chain is always the
+    # node in which the tag was found (a template )and the last node is the current node, i.e. the
+    # page node which triggered all this. The nodes between are other template nodes.
+    #
+    # The method has to return the result of the tag processing and, optionally, a modified chain
+    # (as second result). The second value is currently only returned by the block tag.
+    #
+    # Has to be overridden by subclasses!!!
+    def process_tag( tag, node_chain )
+      raise NotImplementedError
+    end
+
+    #######
+    private
+    #######
+
+    # Set the current configuration taking values from +config+ which has to be a Hash.
+    def set_cur_config( config, node )
+      config.each do |key, value|
+        if self.class.config.params.has_key?( key )
+          @cur_config[key] = value
+          log(:debug) { "Setting parameter '#{key}' to '#{value}' for tag '#{self.class.plugin_name}' in <#{node.node_info[:src]}>" }
+        else
+          log(:warn) { "Invalid parameter '#{key}' for tag '#{self.class.plugin_name}' in <#{node.node_info[:src]}>" }
+        end
+      end
+    end
+
+    # Set the default mandatory parameter.
+    def set_default_mandatory_param( value, node )
+      param_name, param_value = self.class.config.params.find {|k,v| v.mandatory_default} unless self.class.config.params.nil?
+      if param_name.nil?
+        log(:error) { "No default mandatory parameter specified for tag '#{self.class.plugin_name}' but set in <#{node.node_info[:src]}>"}
+      else
+        @cur_config[param_name] = value
+      end
+    end
+
+    # Check if all mandatory parameters have been set
+    def all_mandatory_params_set?
+      params = self.class.config.params
+      ( params.nil? ? true : params.all? { |k,v| !v.mandatory || @cur_config.has_key?( k ) || !v.default.nil? } )
+    end
+
+  end
+
+end