webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/content_processor/scss.rb

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/content_processor/sass'
+
+module Webgen
+  class ContentProcessor
+
+    # Processes content in sassy CSS markup (used for writing CSS files) using the +sass+ library.
+    module Scss
+
+      # Convert the content in +scss+ markup to CSS.
+      def self.call(context)
+        options = Webgen::ContentProcessor::Sass.default_options(context).merge(:syntax => :scss)
+        context.content = ::Sass::Engine.new(context.content, options).render
+        context
+      rescue ::Sass::SyntaxError => e
+        raise Webgen::RenderError.new(e, self.class.name, context.dest_node, nil, (e.sass_line if e.sass_line))
+      end
+
+    end
+
+  end
+end

data/lib/webgen/content_processor/tags.rb

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/content_processor'
+
+module Webgen
+  class ContentProcessor
+
+    # Processes special webgen tags to provide dynamic content.
+    #
+    # webgen tags are an easy way to add dynamically generated content to websites, for example menus
+    # or breadcrumb trails.
+    #
+    # See Webgen::Tag and all the classes in its namespace for further information.
+    module Tags
+
+      # Replace all webgen tags in the content of +context+ with the rendered content.
+      def self.call(context)
+        context.website.ext.tag.replace_tags(context.content) do |tag, params, body|
+          context.website.logger.debug do
+            "Replacing tag #{tag} with data #{params.inspect} and body '#{body}' in <#{context.ref_node}>"
+          end
+          context.website.ext.tag.call(tag, params, body, context)
+        end
+        context
+      end
+
+    end
+
+  end
+end

data/lib/webgen/content_processor/tidy.rb

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/content_processor'
+require 'webgen/utils/external_command'
+
+module Webgen
+  class ContentProcessor
+
+    # Uses the external +tidy+ program to format the content as valid (X)HTML.
+    module Tidy
+
+      # Process the content of +context+ with the +tidy+ program.
+      def self.call(context)
+        Webgen::Utils::ExternalCommand.ensure_available!('tidy', '-v')
+
+        cmd = "tidy -q #{context.website.config['content_processor.tidy.options']}"
+        status, stdout, stderr = systemu(cmd, 'stdin' => context.content)
+        if status.exitstatus != 0
+          stderr.split(/\n/).each do |line|
+            context.website.logger.send(status.exitstatus == 1 ? :warn : :error) do
+              "Tidy reported problems for <#{context.dest_node.alcn}>: #{line}"
+            end
+          end
+        end
+        context.content = stdout
+        context
+      end
+
+    end
+
+  end
+end

data/lib/webgen/content_processor/tikz.rb

@@ -0,0 +1,116 @@
+# -*- encoding: utf-8 -*-
+
+require 'erb'
+require 'tempfile'
+require 'fileutils'
+require 'webgen/content_processor'
+require 'webgen/utils/external_command'
+
+Webgen::Utils::ExternalCommand.ensure_available!('pdflatex', '-v')
+Webgen::Utils::ExternalCommand.ensure_available!('pdfcrop', '--version')
+Webgen::Utils::ExternalCommand.ensure_available!('gs', '-v')
+Webgen::Utils::ExternalCommand.ensure_available!('convert', '-version')
+Webgen::Utils::ExternalCommand.ensure_available!('identify', '-version')
+
+module Webgen
+  class ContentProcessor
+
+    # Uses LaTeX and the TikZ library for creating images from LaTeX code.
+    module Tikz
+
+      LATEX_TEMPLATE = <<EOF
+\\nonstopmode \\documentclass{article} \\usepackage{tikz} \\pagestyle{empty}
+<% if context['content_processor.tikz.libraries'] %>
+\\usetikzlibrary{<%= context['content_processor.tikz.libraries'].join(',') %>}
+<% end %>
+\\begin{document}
+\\begin{tikzpicture}[<%= context['content_processor.tikz.opts'] %>]
+<%= context.content %>
+\\end{tikzpicture}
+\\end{document}
+EOF
+
+      # Process the content with LaTeX to generate a TikZ image.
+      def self.call(context)
+        prepare_options(context)
+        context.content = ERB.new(LATEX_TEMPLATE).result(binding)
+        context.content = File.binread(compile(context))
+        context
+      end
+
+      # Collect the necessary options and save them in the context object.
+      def self.prepare_options(context)
+        %w[content_processor.tikz.resolution content_processor.tikz.transparent
+           content_processor.tikz.libraries content_processor.tikz.opts].each do |opt|
+          context[opt] = context.content_node[opt] || context.website.config[opt]
+        end
+      end
+      private_class_method :prepare_options
+
+      # Compile the LaTeX document stored in the Context and convert the resulting PDF to the
+      # correct output image format specified by context[:ext] (the extension needs to include the
+      # dot).
+      #
+      # Returns the path to the created image.
+      def self.compile(context)
+        cwd = context.website.tmpdir('content_processor.tikz')
+        FileUtils.mkdir_p(cwd)
+        tempfile = Tempfile.open(['webgen-tikz', '.tex'], cwd)
+        tempfile.write(context.content)
+        tempfile.close
+
+        file = File.basename(tempfile.path, '.tex')
+        ext = File.extname(context.dest_node.dest_path)
+        render_res, output_res = context['content_processor.tikz.resolution'].split(' ')
+
+        execute("pdflatex --shell-escape -interaction=batchmode #{file}.tex", cwd, context) do |status, stdout, stderr|
+          errors = stderr.scan(/^!(.*\n.*)/).join("\n")
+          raise Webgen::RenderError.new("Error while parsing TikZ picture commands with PDFLaTeX: #{errors}",
+                                        self.name, context.dest_node, context.ref_node)
+        end
+
+        execute("pdfcrop #{file}.pdf #{file}.pdf", cwd, context)
+
+        if context['content_processor.tikz.transparent'] && ext =~ /\.png/i
+          cmd = "gs -dSAFER -dBATCH -dNOPAUSE -r#{render_res} -sDEVICE=pngalpha -dGraphicsAlphaBits=4 " +
+            "-dTextAlphaBits=4 -sOutputFile=#{file}#{ext} #{file}.pdf"
+        else
+          cmd = "convert -density #{render_res} #{file}.pdf #{file}#{ext}"
+        end
+        execute(cmd, cwd, context)
+
+        if render_res != output_res
+          status, stdout, stderr = execute("identify #{file}#{ext}", cwd, context)
+          width, height = stdout.scan(/\s\d+x\d+\s/).first.strip.split('x').collect do |s|
+            s.to_f * output_res.to_f / render_res.to_f
+          end
+          execute("convert -resize #{width}x#{height} #{file}#{ext} #{file}#{ext}", cwd, context)
+        end
+        File.join(cwd, file + ext)
+      end
+      private_class_method :compile
+
+      # Execute the command +cmd+ in the working directory +cwd+.
+      #
+      # If the exit status is not zero, yields to the given block if one is given, or raises an error
+      # otherwise.
+      #
+      # Returns [status, stdout, stderr]
+      def self.execute(cmd, cwd, context)
+        status, stdout, stderr = systemu(cmd, :cwd => cwd)
+        if status.exitstatus != 0
+          if block_given?
+            yield(status, stdout, stderr)
+          else
+            raise Webgen::RenderError.new("Error while running a command for a TikZ picture: #{stdout + "\n" + stderr}",
+                                          self.name, context.dest_node, context.ref_node)
+          end
+        end
+        [status, stdout, stderr]
+      end
+      private_class_method :execute
+
+    end
+
+  end
+end

data/lib/webgen/content_processor/xmllint.rb

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/content_processor'
+require 'webgen/utils/external_command'
+
+module Webgen
+  class ContentProcessor
+
+    # Uses the external +xmllint+ program to check if the content is valid (X)HTML.
+    module Xmllint
+
+      # Checks the content of +context+ with the +xmllint+ program for validness.
+      def self.call(context)
+        Webgen::Utils::ExternalCommand.ensure_available!('xmllint', '--version')
+
+        cmd = "xmllint #{context.website.config['content_processor.xmllint.options']} -"
+        status, stdout, stderr = systemu(cmd, 'stdin' => context.content)
+        if status.exitstatus != 0
+          stderr.scan(/^-:(\d+):(.*?\n)(.*?\n)/).each do |line, error_msg, line_context|
+            context.website.logger.warn do
+              "xmllint reported problems for <#{context.dest_node.alcn}:~#{line}>: #{error_msg.strip} (context: #{line_context.strip})"
+            end
+          end
+        end
+        context
+      end
+
+    end
+
+  end
+end

data/lib/webgen/context.rb

@@ -1,60 +1,88 @@
 # -*- encoding: utf-8 -*-
-require 'webgen/context/nodes'
-require 'webgen/context/tags'
-require 'webgen/context/render'
 
 module Webgen
 
   # This class represents the context object that is passed, for example, to the +call+ method of a
   # content processor.
   #
-  # The needed context variables are stored in the +options+ hash. You can set any options you like,
-  # however, there are three noteworthy options:
+  # == About
   #
-  # [<tt>:content</tt>]
-  #   The content string that should be processed.
+  # A context object provides information about the render context as well as access to the website
+  # that is rendered. The needed context variables are stored in the +options+ hash. You can set any
+  # options you like, however, there are two noteworthy options:
   #
-  # [<tt>:processors</tt>]
-  #   Normally an ContentProcessor::AccessHash object providing access to all available content
-  #   processors.
+  # [:content]
+  #   The content string that should be processed. This option is always set.
   #
-  # [<tt>:chain</tt>]
+  # [:chain]
   #   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).
+  #   special nodes of the chain (see Nodes#ref_node, Nodes#content_node and Nodes#dest_node).
   #
   # The +persistent+ options hash is shared by all cloned Context objects.
+  #
+  # == Adding custom methods
+  #
+  # If you want to add custom methods to each context object of your website that is created, you
+  # just need to define one or more modules in which your custom methods are defined and then add
+  # the modules to the 'website.ext.context_modules' array.
+  #
+  # Here is a simple example:
+  #
+  #   module MyContextMethods
+  #
+  #     def my_method
+  #       # do something useful here
+  #     end
+  #
+  #   end
+  #
+  #   website.ext.context_modules << MyContextMethods
+  #
   class Context
 
-    include Webgen::WebsiteAccess
-    public :website
+    require 'webgen/context/nodes'
+    require 'webgen/context/webgen_tags'
+    require 'webgen/context/rendering'
+    require 'webgen/context/html_head'
+
+    include Nodes
+    include WebgenTags
+    include Rendering
+    include HtmlHead
+
 
     # The persistent options. Once initialized, all cloned objects refer to the same hash.
     attr_reader :persistent
 
     # Processing options.
-    attr_accessor :options
+    attr_reader :options
 
-    # Create a new Context object. You can use the +options+ hash to set needed options.
+    # The website object to which the render context belongs.
+    attr_reader :website
+
+    # Create a new Context object belonging to the website object +website+.
+    #
+    # All modules listed in the array 'website.ext.context_modules' are automatically used to extend
+    # the Context object.
     #
     # The following options are set by default and can be overridden via the +options+ hash:
     #
-    # [<tt>:content</tt>]
+    # [:content]
     #   Is set to an empty string.
     #
-    # [<tt>:processors</tt>]
-    #   Is set to a new AccessHash.
-    def initialize(options = {}, persistent = {})
-      @options = {
-        :content => '',
-        :processors => Webgen::ContentProcessor::AccessHash.new
-      }.merge(options)
+    def initialize(website, options = {}, persistent = {})
+      @website = website
+      (website.ext.context_modules || []).each {|m| self.extend(m)}
+      @options = {:content => ''}.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.
+    # 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), @persistent)
+      self.class.new(@website, @options.merge(options), @persistent)
     end
 
     # Return the value of the option +name+.
@@ -67,12 +95,12 @@ module Webgen
       @options[name] = value
     end
 
-    # Return the <tt>:content</tt> option.
+    # Return the :content option.
     def content
       @options[:content]
     end
 
-    # Set the <tt>:content</tt> option to the given +value+.
+    # Set the :content option to the given +value+.
     def content=(value)
       @options[:content] = value
     end

data/lib/webgen/context/html_head.rb

@@ -0,0 +1,60 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/error'
+
+module Webgen
+  class Context
+
+    # Provides methods for adding data for Webgen::ContentProcessor::HtmlHead.
+    module HtmlHead
+
+      # Proxy object for working with the data structure needed by
+      # Webgen::ContentProcessor::HtmlHead.
+      class Proxy
+
+        def initialize(context) #:nodoc:
+          @context = context
+        end
+
+        # Add a link to the given file in the HTML head section.
+        #
+        # The type can either be :css for CSS files or :js for javascript files. The path to the
+        # file is resolved using the "relocatable" tag (see Webgen::Tag::Relocatable).
+        def link_file(type, file)
+          type_check!(type)
+          (cp_hash["#{type}_file".intern] ||= []) << @context.tag('relocatable', file)
+        end
+
+        # Add inline CSS or JS fragments to the HTML head section.
+        #
+        # The type can either be :css for a CSS fragment or :js for a javascript fragment.
+        def inline_fragment(type, content)
+          type_check!(type)
+          (cp_hash["#{type}_inline".intern] ||= []) << content
+        end
+
+        def type_check!(type) #:nodoc:
+          if ![:css, :js].include?(type)
+            raise Webgen::RenderError.new("Type must either be :css or :js, not #{type}",
+                                          self.class.name, @context.dest_node, @context.ref_node)
+          end
+        end
+        private :type_check!
+
+        def cp_hash #:nodoc:
+          @context.persistent[:cp_html_head] ||= {}
+        end
+        private :cp_hash
+
+      end
+
+      # Return the Proxy object for adding data to the context for
+      # Webgen::ContentProcessor::HtmlHead.
+      def html_head
+        Proxy.new(self)
+      end
+
+    end
+
+  end
+end

data/lib/webgen/context/nodes.rb

@@ -1,36 +1,41 @@
-module Webgen
+# -*- encoding: utf-8 -*-
 
+module Webgen
   class Context
 
-    # Return the node which represents the file into which everything gets rendered. This is normally
-    # the same node as <tt>#content_node</tt> but can differ in special cases. For example, when
-    # rendering the content of node called <tt>my.page</tt> into the output of the node
-    # <tt>this.page</tt>, <tt>this.page</tt> would be the +dest_node+ and <tt>my.page</tt> would be
-    # the +content_node+.
-    #
-    # The +dest_node+ is not included in the chain but can be set via the option <tt>:dest_node</tt>!
-    #
-    # The returned node should be used as source node for calculating relative paths to other nodes.
-    def dest_node
-      @options[:dest_node] || self.content_node
-    end
+    # Provides quick access to special nodes of the node chain of a context object.
+    module Nodes
 
-    # Return the reference node, ie. the node which provided the original content for this context
-    # object.
-    #
-    # The returned node should be used, for example, for resolving relative paths.
-    def ref_node
-      @options[:chain] && @options[:chain].first
-    end
+      # Return the node which represents the file into which everything gets rendered.
+      #
+      # This is normally the same node as #content_node but can differ in special cases. For
+      # example, when rendering the content of node called 'my.page' into the output of the node
+      # 'this.page', 'this.page' would be the #dest_node and 'my.page' would be the #content_node.
+      #
+      # The #dest_node is not included in the chain but can be set via the option +:dest_node+!
+      #
+      # The returned node should be used as source node for calculating relative paths to other nodes.
+      def dest_node
+        @options[:dest_node] || self.content_node
+      end
+
+      # Return the reference node, ie. the node which provided the original content for this context
+      # object.
+      #
+      # The returned node should be used, for example, for resolving relative paths.
+      def ref_node
+        @options[:chain] && @options[:chain].first
+      end
+
+      # Return the node that is ultimately rendered.
+      #
+      # This node should be used, for example, for retrieving meta information.
+      def content_node
+        @options[:chain] && @options[:chain].last
+      end
+      alias :node :content_node
 
-    # Return the node that is ultimately rendered.
-    #
-    # This node should be used, for example, for retrieving meta information.
-    def content_node
-      @options[:chain] && @options[:chain].last
     end
-    alias :node :content_node
 
   end
-
 end