webgen 0.5.8 → 0.5.9

data/lib/webgen/contentprocessor/blocks.rb

@@ -10,49 +10,80 @@ module Webgen::ContentProcessor
     BLOCK_RE = /<webgen:block\s*?((?:\s\w+=('|")[^'"]+\2)+)\s*\/>/
     BLOCK_ATTR_RE = /(\w+)=('|")([^'"]+)\2/
 
-    # Replace that webgen:block xml tags with the rendered content of a node.
+    # Replace the webgen:block xml tags with the rendered content of the specified node.
     def call(context)
-      chain = context[:chain]
-      new_chain = (chain.length > 1 ? chain[1..-1] : chain)
-
       context.content.gsub!(BLOCK_RE) do |match|
         attr = {}
-        match.scan(BLOCK_ATTR_RE) {|name, sep, content| attr[name] = content}
-        if attr['chain'].nil?
-          used_chain = new_chain.dup
-        else
-          paths = attr['chain'].split(';')
-          used_chain = paths.collect do |path|
-            temp_node = context.ref_node.resolve(path.strip, context.dest_node.lang)
-            log(:error) { "Could not resolve <#{path.strip}> in <#{context.ref_node.absolute_lcn}> in '#{match.to_s}'" } if temp_node.nil?
-            temp_node
-          end.compact
-          next match if used_chain.length != paths.length
-          dest_node = context.content_node
-        end
+        match_object = $~
+        attr[:line_nr_proc] = lambda { match_object.pre_match.scan("\n").size + 1 }
+        match.scan(BLOCK_ATTR_RE) {|name, sep, content| attr[name.to_sym] = content}
+        render_block(context, attr)
+      end
+      context
+    end
 
-        if attr['node'] == 'first'
-          used_chain.shift while used_chain.length > 0 && !used_chain.first.node_info[:page].blocks.has_key?(attr['name'])
-        elsif attr['node'] == 'current'
-          used_chain = context[:chain].dup
-        end
-        block_node = used_chain.first
-
-        if !block_node || !block_node.node_info[:page].blocks.has_key?(attr['name'])
-          if attr['notfound'] == 'ignore'
-            next ''
-          elsif block_node
-            raise "Node <#{block_node.absolute_lcn}> has no block named '#{attr['name']}'"
-          else
-            raise "No node in the chain has a block named '#{attr['name']}'"
+    # Render a block of a page node and return the result.
+    #
+    # The Webgen::Context object +context+ is used as the render context and the +options+ hash
+    # needs to hold all relevant information, that is:
+    #
+    # [<tt>:name</tt> (mandatory)]
+    #   The name of the block that should be used.
+    # [<tt>:chain</tt>]
+    #   The node chain used for rendering. If this is not specified, the node chain from the context
+    #   is used. It needs to be a String in the format <tt>(A)LCN;(A)LCN;...</tt> or an array of
+    #   nodes.
+    # [<tt>:node</tt>]
+    #   Defines which node in the node chain should be used. Valid values are +next+ (= default
+    #   value; the next node in the node chain), +first+ (the first node in the node chain with a
+    #   block called +name+) or +current+ (the currently rendered node, ignores the +chain+ option).
+    # [<tt>:notfound</tt>]
+    #   If this property is set to +ignore+, a missing block will not raise an error. It is unset by
+    #   default, so missing blocks will raise errors.
+    def render_block(context, options)
+      if options[:chain].nil?
+        used_chain = (context[:chain].length > 1 ? context[:chain][1..-1] : context[:chain]).dup
+      elsif options[:chain].kind_of?(Array)
+        used_chain = options[:chain]
+      else
+        paths = options[:chain].split(';')
+        used_chain = paths.collect do |path|
+          temp_node = context.ref_node.resolve(path.strip, context.dest_node.lang)
+          if temp_node.nil?
+            raise Webgen::RenderError.new("Could not resolve <#{path.strip}>",
+                                          self.class.name, context.dest_node.alcn,
+                                          context.ref_node.alcn, (options[:line_nr_proc].call if options[:line_nr_proc]))
           end
-        end
+          temp_node
+        end.compact
+        return '' if used_chain.length != paths.length
+        dest_node = context.content_node
+      end
 
-        context.dest_node.node_info[:used_nodes] << block_node.absolute_lcn
-        tmp_context = block_node.node_info[:page].blocks[attr['name']].render(context.clone(:chain => used_chain, :dest_node => dest_node))
-        tmp_context.content
+      if options[:node] == 'first'
+        used_chain.shift while used_chain.length > 0 && !used_chain.first.node_info[:page].blocks.has_key?(options[:name])
+      elsif options[:node] == 'current'
+        used_chain = context[:chain].dup
       end
-      context
+      block_node = used_chain.first
+
+      if !block_node || !block_node.node_info[:page].blocks.has_key?(options[:name])
+        if options[:notfound] == 'ignore'
+          return ''
+        elsif block_node
+          raise Webgen::RenderError.new("No block named '#{options[:name]}' found in <#{block_node.alcn}>",
+                                        self.class.name, context.dest_node.alcn,
+                                        context.ref_node.alcn, (options[:line_nr_proc].call if options[:line_nr_proc]))
+        else
+          raise Webgen::RenderError.new("No node in the render chain has a block named '#{options[:name]}'",
+                                        self.class.name, context.dest_node.alcn,
+                                        context.ref_node.alcn, (options[:line_nr_proc].call if options[:line_nr_proc]))
+        end
+      end
+
+      context.dest_node.node_info[:used_nodes] << block_node.alcn
+      tmp_context = block_node.node_info[:page].blocks[options[:name]].render(context.clone(:chain => used_chain, :dest_node => dest_node))
+      tmp_context.content
     end
 
   end

data/lib/webgen/contentprocessor/builder.rb

@@ -19,11 +19,14 @@ module Webgen::ContentProcessor
       dest_node = deprecate('dest_node', 'context.dest_node', context.dest_node)
 
       xml = ::Builder::XmlMarkup.new(:indent => 2)
-      eval(context.content, binding, context.ref_node.absolute_lcn)
+      eval(context.content, binding, context.ref_node.alcn)
       context.content = xml.target!
       context
+    rescue LoadError
+      raise Webgen::LoadError.new('builder', self.class.name, context.dest_node.alcn, 'builder')
     rescue Exception => e
-      raise RuntimeError, "Error using Builder in <#{context.ref_node.absolute_lcn}> to generate XML: #{e.message}", e.backtrace
+      line = (e.is_a?(::SyntaxError) ? e.message : e.backtrace[0]).scan(/:(\d+)/).first.first.to_i rescue nil
+      raise Webgen::RenderError.new(e, self.class.name, context.dest_node.alcn, context.ref_node.alcn, line)
     end
 
   end

data/lib/webgen/contentprocessor/erb.rb

@@ -10,6 +10,7 @@ module Webgen::ContentProcessor
     # Process the Ruby statements embedded in the content of +context+.
     def call(context)
       require 'erb'
+      extend(ERB::Util)
 
       website = deprecate('website', 'context.website', context.website)
       node = deprecate('node', 'context.node', context.content_node)
@@ -17,11 +18,12 @@ module Webgen::ContentProcessor
       dest_node = deprecate('dest_node', 'context.dest_node', context.dest_node)
 
       erb = ERB.new(context.content)
-      erb.filename = context.ref_node.absolute_lcn
+      erb.filename = context.ref_node.alcn
       context.content = erb.result(binding)
       context
     rescue Exception => e
-      raise RuntimeError, "Erb processing failed in <#{context.ref_node.absolute_lcn}>: #{e.message}", e.backtrace
+      line = (e.is_a?(::SyntaxError) ? e.message : e.backtrace[0]).scan(/:(\d+)/).first.first.to_i rescue nil
+      raise Webgen::RenderError.new(e, self.class.name, context.dest_node.alcn, context.ref_node.alcn, line)
     end
 
   end

data/lib/webgen/contentprocessor/erubis.rb

@@ -29,11 +29,14 @@ module Webgen::ContentProcessor
                   else
                     ::Erubis::Eruby.new(context.content, options)
                   end
-      erubis.filename = context.ref_node.absolute_lcn
+      erubis.filename = context.ref_node.alcn
       context.content = erubis.result(binding)
       context
+    rescue LoadError
+      raise Webgen::LoadError.new('erubis', self.class.name, context.dest_node.alcn, 'erubis')
     rescue Exception => e
-      raise RuntimeError, "Erubis processing failed in <#{context.ref_node.absolute_lcn}>: #{e.message}", e.backtrace
+      line = (e.is_a?(::SyntaxError) ? e.message : e.backtrace[0]).scan(/:(\d+)/).first.first.to_i rescue nil
+      raise Webgen::RenderError.new(e, self.class.name, context.dest_node.alcn, context.ref_node.alcn, line)
     end
 
   end

data/lib/webgen/contentprocessor/haml.rb

@@ -18,11 +18,15 @@ module Webgen::ContentProcessor
         :ref_node => deprecate('ref_node', 'context.ref_node', context.ref_node),
         :dest_node => deprecate('dest_node', 'context.dest_node', context.dest_node)
       }
-      context.content = ::Haml::Engine.new(context.content, :filename => context.ref_node.absolute_lcn).
+      context.content = ::Haml::Engine.new(context.content, :filename => context.ref_node.alcn).
         render(Object.new, locals)
       context
+    rescue LoadError
+      raise Webgen::LoadError.new('haml', self.class.name, context.dest_node.alcn, 'haml')
+    rescue ::Haml::Error => e
+      raise Webgen::RenderError.new(e, self.class.name, context.dest_node.alcn, context.ref_node.alcn, (e.line + 1 if e.line))
     rescue Exception => e
-      raise RuntimeError, "Error converting Haml markup to HTML in <#{context.ref_node.absolute_lcn}>: #{e.message}", e.backtrace
+      raise Webgen::RenderError.new(e, self.class.name, context.dest_node.alcn, context.ref_node.alcn)
     end
 
   end

data/lib/webgen/contentprocessor/head.rb

@@ -0,0 +1,64 @@
+# -*- encoding: utf-8 -*-
+
+module Webgen::ContentProcessor
+
+  # Inserts additional links to CSS/JS files and other HTML head meta info directly before the HTML
+  # head end tag.
+  #
+  # The data used by this content processor is taken from the Context object. Therefore this
+  # processor should be the last in the processing pipeline so that all other processors have been
+  # able to set the data.
+  #
+  # The key <tt>:cp_head</tt> of <tt>context.persistent</tt> is used (the normal
+  # <tt>context.options</tt> won't do because the data needs to be shared 'backwards' during the
+  # rendering) and it has to be a Hash with the following values:
+  #
+  # [:js_file] An array of already resolved relative or absolute paths to Javascript files.
+  # [:js_inline] An array of Javascript fragments to be inserted directly into the head section.
+  # [:css_file] An array of already resolved relative or absolute paths to CSS files.
+  # [:css_inline] An array of CSS fragments to be inserted directly into the head section.
+  # [:meta] A hash with key-value pairs from which <tt>meta</tt> tags are generated. The keys and
+  #         the values will be properly escaped before insertion. The entries in the meta
+  #         information <tt>meta</tt> of the content node are also used and take precedence over
+  #         these entries.
+  #
+  # Duplicate values will be removed from the above mentioned arrays before generating the output.
+  class Head
+
+    include Webgen::Loggable
+
+    HTML_HEAD_END_RE = /<\/head\s*>/i #:nodoc:
+
+    # Insert the additional header information.
+    def call(context)
+      require 'erb'
+      context.content.sub!(HTML_HEAD_END_RE) do |match|
+        result = ''
+        if context.persistent[:cp_head].kind_of?(Hash)
+          context.persistent[:cp_head][:js_file].uniq.each do |js_file|
+            result += "\n<script type=\"text/javascript\" src=\"#{js_file}\"></script>"
+          end if context.persistent[:cp_head][:js_file].kind_of?(Array)
+
+          context.persistent[:cp_head][:js_inline].uniq.each do |content|
+            result += "\n<script type=\"text/javascript\">\n#{content}\n</script>"
+          end if context.persistent[:cp_head][:js_inline].kind_of?(Array)
+
+          context.persistent[:cp_head][:css_file].uniq.each do |css_file|
+            result += "\n<link rel=\"stylesheet\" href=\"#{css_file}\" type=\"text/css\"/>"
+          end if context.persistent[:cp_head][:css_file].kind_of?(Array)
+
+          context.persistent[:cp_head][:css_inline].uniq.each do |content|
+            result += "\n<style type=\"text/css\"><![CDATA[/\n#{content}\n]]></style>"
+          end if context.persistent[:cp_head][:css_inline].kind_of?(Array)
+        end
+        ((context.persistent[:cp_head] || {})[:meta] || {}).merge(context.node['meta'] || {}).each do |name, content|
+          result += "\n<meta name=\"#{ERB::Util.h(name)}\" content=\"#{ERB::Util.h(content)}\" />"
+        end
+        result + match
+      end
+      context
+    end
+
+  end
+
+end

data/lib/webgen/contentprocessor/maruku.rb

@@ -11,8 +11,10 @@ module Webgen::ContentProcessor
       $uid = 0 #fix for invalid fragment ids on second run
       context.content = ::Maruku.new(context.content, :on_error => :raise).to_html
       context
+    rescue LoadError
+      raise Webgen::LoadError.new('maruku', self.class.name, context.dest_node.alcn, 'maruku')
     rescue Exception => e
-      raise RuntimeError, "Maruku to HTML conversion failed for <#{context.ref_node.absolute_lcn}>: #{e.message}", e.backtrace
+      raise Webgen::RenderError.new(e, self.class.name, context.dest_node.alcn, context.ref_node.alcn)
     end
 
   end

data/lib/webgen/contentprocessor/rdiscount.rb

@@ -10,6 +10,8 @@ module Webgen::ContentProcessor
       require 'rdiscount'
       context.content = ::RDiscount.new(context.content).to_html
       context
+    rescue LoadError
+      raise Webgen::LoadError.new('rdiscount', self.class.name, context.dest_node.alcn, 'rdiscount')
     end
 
   end

data/lib/webgen/contentprocessor/rdoc.rb

@@ -11,6 +11,8 @@ module Webgen::ContentProcessor
       require 'rdoc/markup/to_html'
       context.content = ::RDoc::Markup::ToHtml.new.convert(context.content)
       context
+    rescue LoadError
+      raise Webgen::LoadError.new('rdoc/markup/to_html', self.class.name, context.dest_node.alcn, 'rdoc')
     end
 
   end

data/lib/webgen/contentprocessor/redcloth.rb

@@ -12,6 +12,8 @@ module Webgen::ContentProcessor
       doc.hard_breaks = context.website.config['contentprocessor.redcloth.hard_breaks']
       context.content = doc.to_html
       context
+    rescue LoadError
+      raise Webgen::LoadError.new('redcloth', self.class.name, context.dest_node.alcn, 'RedCloth')
     end
 
   end

data/lib/webgen/contentprocessor/sass.rb

@@ -9,10 +9,12 @@ module Webgen::ContentProcessor
     def call(context)
       require 'sass'
 
-      context.content = ::Sass::Engine.new(context.content, :filename => context.ref_node.absolute_lcn).render
+      context.content = ::Sass::Engine.new(context.content, :filename => context.ref_node.alcn).render
       context
-    rescue Exception => e
-      raise RuntimeError, "Error converting Sass markup to CSS in <#{context.ref_node.absolute_lcn}>: #{e.message}", e.backtrace
+    rescue LoadError
+      raise Webgen::LoadError.new('sass', self.class.name, context.dest_node.alcn, 'haml')
+    rescue ::Sass::SyntaxError => e
+      raise Webgen::RenderError.new(e, self.class.name, context.dest_node.alcn, context.ref_node.alcn, (e.sass_line if e.sass_line))
     end
 
   end

data/lib/webgen/contentprocessor/tags.rb

@@ -22,24 +22,38 @@ module Webgen::ContentProcessor
 
     # Replace all webgen tags in the content of +context+ with the rendered content.
     def call(context)
-      replace_tags(context.content, context.ref_node) do |tag, param_string, body|
-        log(:debug) { "Replacing tag #{tag} with data '#{param_string}' and body '#{body}' in <#{context.ref_node.absolute_lcn}>" }
-
-        result = ''
-        processor = processor_for_tag(tag)
-        if !processor.nil?
-          processor.set_params(processor.create_tag_params(param_string, context.ref_node))
-          result, process_output = processor.call(tag, body, context)
-          processor.set_params(nil)
-
-          result = call(context.clone(:content => result)).content if process_output
-        end
-
-        result
+      replace_tags(context) do |tag, param_string, body|
+        log(:debug) { "Replacing tag #{tag} with data '#{param_string}' and body '#{body}' in <#{context.ref_node.alcn}>" }
+        process_tag(tag, param_string, body, context)
       end
       context
     end
 
+    # Process the +tag+ and return the result. The parameter +params+ needs to be a Hash holding all
+    # needed and optional parameters for the tag or a parameter String in YAML format and +body+ is
+    # the optional body for the tag. +context+ needs to be a valid Webgen::Context object.
+    def process_tag(tag, params, body, context)
+      result = ''
+      processor = processor_for_tag(tag)
+      if !processor.nil?
+        params = if params.kind_of?(String)
+                   processor.create_tag_params(params, context.ref_node)
+                 else
+                   processor.create_params_hash(params, context.ref_node)
+                 end
+
+        processor.set_params(params)
+        result, process_output = processor.call(tag, body, context)
+        processor.set_params(nil)
+        result = call(context.clone(:content => result)).content if process_output
+      else
+        raise Webgen::RenderError.new("No tag processor for '#{tag}' found", self.class.name,
+                                      context.dest_node.alcn, context.ref_node.alcn)
+      end
+      result
+    end
+
+
     #######
     private
     #######
@@ -48,11 +62,11 @@ module Webgen::ContentProcessor
     ProcessingStruct = Struct.new(:state, :tag, :simple_tag, :backslashes, :brackets, :start_pos, :end_pos,
                                   :params_start_pos, :params_end_pos, :body_end_pos)
 
-    # Return the +content+ provided by +node+ with all webgen tags replaced. When a webgen tag is
-    # encountered by the parser, the method yields all found information and substitutes the
-    # returned string for the tag.
-    def replace_tags(content, node) #:yields: tag_name, param_string, body
-      scanner = StringScanner.new(content)
+    # Return the <tt>context.content</tt> provided by <tt>context.ref_node</tt> with all webgen tags
+    # replaced. When a webgen tag is encountered by the parser, the method yields all found
+    # information and substitutes the returned string for the tag.
+    def replace_tags(context) #:yields: tag_name, param_string, body
+      scanner = StringScanner.new(context.content)
       data = ProcessingStruct.new(:before_tag)
       while true
         case data.state
@@ -72,8 +86,8 @@ module Webgen::ContentProcessor
         when :in_start_tag
           data.brackets += (scanner[1] == '{' ? 1 : -1) while data.brackets != 0 && scanner.skip_until(BRACKETS_RE)
           if data.brackets != 0
-            log(:error) { "Unbalanced curly brackets in <#{node.absolute_lcn}>!" }
-            data.state = :done
+            raise Webgen::RenderError.new("Unbalanced curly brackets for tag '#{data.tag}'", self.class.name,
+                                          context.dest_node.alcn, context.ref_node.alcn)
           else
             data.params_end_pos = data.body_end_pos = data.end_pos = scanner.pos - 1
             data.state = (data.simple_tag ? :process : :in_body)
@@ -106,8 +120,8 @@ module Webgen::ContentProcessor
             data.end_pos = scanner.pos - 1
             data.body_end_pos = scanner.pos - scanner.matched.length + scanner[1].length / 2
           else
-            log(:error) { "Invalid body part in <#{node.absolute_lcn}>!" }
-            data.state = :done
+            raise Webgen::RenderError.new("Invalid body part - no end tag found for '#{data.tag}'", self.class.name,
+                                          context.dest_node.alcn, context.ref_node.alcn)
           end
 
         when :done
@@ -115,6 +129,9 @@ module Webgen::ContentProcessor
         end
       end
       scanner.string
+    rescue Webgen::RenderError => e
+      e.line = scanner.string[0...scanner.pos].scan("\n").size + 1 unless e.line
+      raise
     end
 
     # Return the tag processor for +tag+ or +nil+ if +tag+ is unknown.
@@ -125,7 +142,6 @@ module Webgen::ContentProcessor
               elsif map.has_key?(:default)
                 map[:default]
               else
-                log(:error) { "No tag processor for tag #{tag.inspect} found" }
                 nil
               end
       klass.nil? ? nil : website.cache.instance(klass)

data/lib/webgen/contentprocessor/tidy.rb

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+require 'tempfile'
+
+module Webgen::ContentProcessor
+
+  # Uses the external +tidy+ program to format the content as valid (X)HTML.
+  class Tidy
+
+    include Webgen::Loggable
+
+    # Process the content of +context+ with the +tidy+ program.
+    def call(context)
+      error_file = Tempfile.new('webgen-tidy')
+      error_file.close
+
+      `tidy -v 2>&1`
+      if $?.exitstatus != 0
+        raise Webgen::CommandNotFoundError.new('tidy', self.class.name, context.dest_node.alcn)
+      end
+
+      cmd = "tidy -q -f #{error_file.path} #{context.website.config['contentprocessor.tidy.options']}"
+      result = IO.popen(cmd, 'r+') do |io|
+        io.write(context.content)
+        io.close_write
+        io.read
+      end
+      if $?.exitstatus != 0
+        File.readlines(error_file.path).each do |line|
+          log($?.exitstatus == 1 ? :warn : :error) { "Tidy reported problems for <#{context.dest_node.alcn}>: #{line}" }
+        end
+      end
+      context.content = result
+      context
+    end
+
+  end
+
+end