webgen 1.0.0.beta3 → 1.0.0

data/lib/webgen/path_handler/api.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'time'
+require 'ostruct'
 require 'shellwords'
 require 'webgen/path_handler/base'
 require 'webgen/path_handler/page_utils'
@@ -36,11 +37,25 @@ module Webgen
 
         dir_node = create_directory(path, Webgen::Path.new(path.parent_path + path['dir_name'] + '/'), false)
 
+        api = OpenStruct.new
+        api.directory = dir_node
+        api.class_nodes = {}
+        api.file_nodes = {}
+
         rdoc.store.all_classes_and_modules.sort.each do |klass|
           klass_node = create_page_node_for_class(path, dir_node, klass, output_flag_file)
+          api.class_nodes[klass.full_name] = klass_node
+          klass_node.node_info[:api] = api
           klass.each_method {|method| create_fragment_node_for_method(path, klass_node, method)}
         end
 
+        rdoc.store.all_files.sort.each do |file|
+          next unless file.text?
+          file_node = create_page_node_for_file(path, dir_node, file, output_flag_file)
+          api.file_nodes[file.full_name] = file_node
+          file_node.node_info[:api] = api
+        end
+
         nil
       end
 
@@ -131,11 +146,11 @@ module Webgen
         create_directory(api_path, Webgen::Path.new(File.dirname(klass_path_str) + '/'))
 
         path = Webgen::Path.new(klass_path_str, 'handler' => 'page', 'modified_at' => api_path['modified_at'],
-                                'title' => "#{klass.type} #{klass.full_name}", 'api_class' => klass.full_name,
+                                'title' => "#{klass.type} #{klass.full_name}", 'api_class_name' => klass.full_name,
                                 'api_name' => api_path['api_name'], 'template' => api_path['api_template'])
         node = @website.ext.path_handler.create_secondary_nodes(path).first
 
-        node.node_info[:api_class_object] = klass
+        node.node_info[:rdoc_object] = klass
         @website.ext.item_tracker.add(node, :file, output_flag_file)
         add_link_definition(api_path, klass.full_name, node.alcn, klass.full_name)
 
@@ -156,9 +171,27 @@ module Webgen
       end
       protected :create_fragment_node_for_method
 
+      # Create a page node for the given file and return it.
+      def create_page_node_for_file(api_path, dir_node, file, output_flag_file)
+        file_path_str = file.http_url(dir_node.alcn)
+
+        create_directory(api_path, Webgen::Path.new(File.dirname(file_path_str) + '/'))
+
+        path = Webgen::Path.new(file_path_str, 'handler' => 'page', 'modified_at' => api_path['modified_at'],
+                                'title' => "File #{file.full_name}", 'api_file_name' => file.full_name,
+                                'api_name' => api_path['api_name'], 'template' => api_path['api_template'])
+        node = @website.ext.path_handler.create_secondary_nodes(path).first
+
+        node.node_info[:rdoc_object] = file
+        @website.ext.item_tracker.add(node, :file, output_flag_file)
+
+        node
+      end
+      protected :create_page_node_for_file
+
       # Add a link definition for the given node.
       def add_link_definition(api_path, link_name, url, title)
-        link = if api_path['prefix_for_link_defs']
+        link = if api_path['prefix_link_defs']
                  "#{api_path['api_name']}:#{link_name}"
                else
                  link_name

data/lib/webgen/path_handler/base.rb

@@ -32,6 +32,15 @@ module Webgen
       # not specify another Node class.
       class Node < Webgen::Node
 
+        # Return the absolute URL of this node.
+        #
+        # This method uses the configuration option 'website.base_url' for constructing the absolute
+        # URL.
+        def url
+          node_url = Webgen::Path.url(dest_path, false)
+          node_url.absolute? ? node_url : File.join(tree.website.config['website.base_url'], dest_path)
+        end
+
         # Does exactly the same as Node#route_to but also automatically adds the necessary item
         # tracking information.
         def route_to(node, lang = @lang)
@@ -66,12 +75,19 @@ module Webgen
         []
       end
 
-      # Create a node from +path+, if possible, yield the fully initialized node if a block is given
-      # and return it.
+      # Create a node from +path+, if possible, and yield the fully initialized node if a block is
+      # given as well as return it.
+      #
+      # Note that the block should be used when the newly created node need to be modified because
+      # the returned node can also be a reused node (in case the information in the supplied path
+      # applies uniquely to an already existing node)!
       #
       # The node class to be used for the to-be-created node can be specified via
-      # `path.meta_info['node_class']`. If this node processing information is not set, the
-      # Base::Node class is used.
+      # `path.meta_info['node_class']`. This is normally used by specific path handlers to provide
+      # custom node classes.
+      #
+      # The default base node class can be changed by setting `path.meta_info['base_node_class']`.
+      # Note that the `node_class` key takes precedence over this key!
       #
       # The parent node under which the new node should be created can optionally be specified via
       # 'path.meta_info['parent_alcn']'. This node processing information has to be set to the alcn

data/lib/webgen/path_handler/feed.rb

@@ -34,7 +34,7 @@ module Webgen
 
         # Return the feed link URL for this feed node.
         def feed_link
-          Webgen::Path.url(File.join(self['site_url'], tree[self['link']].dest_path), false)
+          tree[self['link']].url
         end
 
         # Return the content of an +entry+ (a Node object) of this feed node.
@@ -52,7 +52,7 @@ module Webgen
 
 
       # The mandatory keys that need to be set in a feed file.
-      MANDATORY_INFOS = %W[site_url author entries]
+      MANDATORY_INFOS = %W[author entries]
 
       # Create the feed nodes.
       def create_nodes(path, blocks)
@@ -60,6 +60,10 @@ module Webgen
           raise Webgen::NodeCreationError.new("At least one of #{MANDATORY_INFOS.join('/')} is missing",
                                               "path_handler.feed", path)
         end
+        if @website.config['website.base_url'].empty?
+          raise Webgen::NodeCreationError.new("The configuration option 'website.base_url' needs to be set",
+                                              "path_handler.feed", path)
+        end
         if !['atom', 'rss'].include?(path['version'])
           raise Webgen::NodeCreationError.new("Invalid version '#{path['version']}' for feed path specified, only atom and rss allowed",
                                               "path_handler.feed", path)

data/lib/webgen/path_handler/meta_info.rb

@@ -19,8 +19,10 @@ module Webgen
       # :after_node_created hooks so that it can apply the meta information.
       def initialize(website)
         super
-        @website.blackboard.add_listener(:apply_meta_info_to_path, &method(:apply_meta_info_to_path))
-        @website.blackboard.add_listener(:after_node_created, &method(:after_node_created))
+        @website.blackboard.add_listener(:apply_meta_info_to_path, 'path_handler.meta_info',
+                                         &method(:apply_meta_info_to_path))
+        @website.blackboard.add_listener(:after_node_created, 'path_handler.meta_info',
+                                         :before => 'item_tracker.node_meta_info', &method(:after_node_created))
         @paths = []
         @alcns = []
       end

data/lib/webgen/path_handler/page.rb

@@ -21,13 +21,11 @@ module Webgen
         end
       end
 
-      # Render the block +block_name+ of the given +node+.
-      #
-      # If the parameter +chain+ (an array of template nodes) is not set, the default template chain
-      # for the given +node+ is used.
-      def content(node, block_name = 'content', chain = node.template_chain)
-        chain << node
-        chain.first.render_block(block_name, Webgen::Context.new(@website, :chain => chain)).content
+      # Render the content of the given page +node+.
+      def content(node)
+        @website.ext.item_tracker.add(node, :template_chain, node)
+        chain = node.template_chain << node
+        chain.first.render_block('content', Webgen::Context.new(@website, :chain => chain)).content
       end
 
     end

data/lib/webgen/path_handler/sitemap.rb

@@ -28,7 +28,7 @@ module Webgen
 
 
       # The mandatory keys that need to be set in a sitemap file.
-      MANDATORY_INFOS = %W[site_url entries]
+      MANDATORY_INFOS = %W[entries]
 
       # Create an XML sitemap from +path+.
       def create_nodes(path, blocks)
@@ -37,6 +37,11 @@ module Webgen
                                               "path_handler.sitemap", path)
         end
 
+        if @website.config['website.base_url'].empty?
+          raise Webgen::NodeCreationError.new("The configuration option 'website.base_url' needs to be set",
+                                              "path_handler.sitemap", path)
+        end
+
         path.ext = 'xml'
         path['node_class'] = Node.to_s
         create_node(path) do |node|

data/lib/webgen/path_handler/virtual.rb

@@ -20,9 +20,8 @@ module Webgen
 
       # Create all virtual nodes which are specified in +path+.
       def create_nodes(path, blocks)
-        nodes = []
         if path.meta_info.delete(:virtual)
-          nodes << create_node(path)
+          create_node(path)
         else
           read_entries(blocks) do |key, meta_info|
             meta_info['modified_at'] = path.meta_info['modified_at']
@@ -44,16 +43,15 @@ module Webgen
 
             if key =~ /\/$/
               entry_path['handler'] = 'directory'
-              nodes << @website.ext.path_handler.create_secondary_nodes(entry_path)
+              @website.ext.path_handler.create_secondary_nodes(entry_path)
             else
               entry_path[:virtual] = true
               entry_path['handler'] = 'virtual'
-              nodes << @website.ext.path_handler.create_secondary_nodes(entry_path)
+              @website.ext.path_handler.create_secondary_nodes(entry_path)
             end
           end
-        end
-        nodes.flatten.compact.each do |node|
-          node.node_info[:path] = path
+
+          nil
         end
       end
 
@@ -67,7 +65,7 @@ module Webgen
         blocks.each do |name, content|
           begin
             data = YAML::load(content)
-          rescue RuntimeError, ArgumentError, SyntaxError => e
+          rescue RuntimeError, ArgumentError, SyntaxError, YAML::SyntaxError => e
             raise RuntimeError, "Problem parsing block '#{name}' (it needs to contain a YAML hash): #{e.message}", e.backtrace
           end
           raise "Structure of block '#{name}' is invalid, it has to be a Hash" unless data.kind_of?(Hash)

data/lib/webgen/source/file_system.rb

@@ -20,7 +20,7 @@ module Webgen
 
       # Create a new file system source for the root path +root+ using the provided +glob+. If
       # +root+ is not an absolute path, the website directory will be prepended.
-      def initialize(website, root, glob = '**/*')
+      def initialize(website, root, glob = '{*,**/*}')
         @root = File.absolute_path(root, website.directory)
         @glob = glob
       end
@@ -28,7 +28,7 @@ module Webgen
       # Return all paths under the root path which match the glob.
       def paths
         @paths ||= Dir.glob(File.join(@root, @glob), File::FNM_DOTMATCH|File::FNM_CASEFOLD).collect do |f|
-          next unless File.exists?(f) # handle invalid links
+          next unless File.exists?(f) && f !~ /\/\.\.$/ # handle invalid links
           temp = Pathname.new(f.sub(/^#{Regexp.escape(@root)}\/?/, '/')).cleanpath.to_s
           temp += '/' if File.directory?(f) && temp[-1] != ?/
           Path.new(temp, 'modified_at' => File.mtime(f)) {|mode| File.open(f, mode)}

data/lib/webgen/tag.rb

@@ -18,16 +18,16 @@ module Webgen
   #
   # A tag object only needs to respond to the method +call+ which needs to accept three parameters:
   #
-  # [tag]: The name of the tag which should be processed (useful for tag objects which can process
-  #        different tags).
+  # [tag] The name of the tag which should be processed (useful for tag objects which can process
+  #       different tags).
   #
-  # [body]: Holds the body value for the tag if any.
+  # [body] Holds the body value for the tag if any.
   #
-  # [context]: Holds all relevant information for processing -- have a look at the Webgen::Context
-  #            class to see what is available. The special key :config is set to an
-  #            Webgen::Configuration object that should be used to retrieve configuration option
-  #            values because the values might be changed due to options set directly via the tag
-  #            syntax.
+  # [context] Holds all relevant information for processing -- have a look at the Webgen::Context
+  #           class to see what is available. The special key :config is set to an
+  #           Webgen::Configuration object that should be used to retrieve configuration option
+  #           values because the values might be changed due to options set directly via the tag
+  #           syntax.
   #
   # The method has to return the result of the processing and, optionally, a boolean value
   # specifying if the result should further be processed (ie. webgen tags replaced).
@@ -76,11 +76,12 @@ module Webgen
     # If the template node cannot be found, an empty string is returned.
     def self.render_tag_template(context, tag)
       path = context[:config]["tag.#{tag}.template"]
-      template_node = context.ref_node.resolve(path, context.dest_node.lang, true)
-      if template_node
+      if path && template_node = context.ref_node.resolve(path, context.dest_node.lang, true)
+        context.website.ext.item_tracker.add(context.dest_node, :template_chain, template_node)
         context.render_block(:name => "tag.#{tag}", :node => 'first',
                              :chain => [*template_node.template_chain, template_node, context.content_node])
       else
+        context.website.logger.warn { "Template node '#{path}' for tag '#{tag}' not found" }
         ''
       end
     end
@@ -88,7 +89,7 @@ module Webgen
 
     def initialize(website) # :nodoc:
       super()
-      website.blackboard.add_listener(:website_initialized, self) do
+      website.blackboard.add_listener(:website_initialized, 'tag') do
         @parser = Webgen::Utils::TagParser.new(website.config['tag.prefix'])
       end
     end
@@ -156,9 +157,12 @@ module Webgen
       result = ''
       tdata = tag_data(tag, context)
       if !tdata.nil?
-        context[:config] = create_config(tag, params, tdata, context)
+        context = context.clone(:config => create_config(tag, params, tdata, context))
         result, process_output = tdata.object.call(tag, body, context)
-        result = context.website.ext.content_processor.call('tags', context.clone(:content => result)).content if process_output
+        if process_output
+          context.content = result
+          result = context.website.ext.content_processor.call('tags', context).content
+        end
       else
         raise Webgen::RenderError.new("No tag processor for '#{tag}' found", 'tag',
                                       context.dest_node, context.ref_node)
@@ -186,7 +190,7 @@ module Webgen
     def create_config(tag, params, tdata, context)
       values = case params
                when Hash then values_from_hash(tag, params, tdata, context)
-               when String then values_from_string(tag, params, tdata, context)
+               when String, Array then values_for_default_mandatory(tag, params, tdata, context)
                when NilClass then {}
                else
                  raise Webgen::RenderError.new("Invalid parameter type (#{params.class})",
@@ -221,16 +225,16 @@ module Webgen
     end
 
     # Return a hash containing valid configuration options by setting the default mandatory
-    # parameter for +tag+ to +str+.
-    def values_from_string(tag, str, tdata, context)
+    # parameter for +tag+ to +value+.
+    def values_for_default_mandatory(tag, value, tdata, context)
       if tdata.mandatory.first.nil?
         context.website.logger.error do
           ["No default mandatory option specified for tag '#{tag}' but set in <#{context.ref_node}>",
-           "Use the {key: value} syntax for assigning the value '#{str}' to the intended tag option!"]
+           "Use the {key: value} syntax for assigning the value '#{value}' to the intended tag option!"]
         end
         {}
       else
-        {tdata.mandatory.first => str}
+        {tdata.mandatory.first => value}
       end
     end
 

data/lib/webgen/tag/menu.rb

@@ -27,11 +27,11 @@ module Webgen
       # Return style information (node is selected, ...) and a link from +dest_node+ to +node+.
       #
       # This method can be used in a menu template.
-      def self.menu_item_details(dest_node, node, lang, level, has_submenu)
-        styles = ['webgen-menu-level' + level.to_s]
-        styles << 'webgen-menu-submenu' if has_submenu
-        styles << 'webgen-menu-submenu-inhierarchy' if node.is_ancestor_of?(dest_node)
-        styles << 'webgen-menu-item-selected' if node == dest_node
+      def self.menu_item_details(dest_node, node, lang, level, has_submenu, config)
+        styles = [config['tag.menu.item_level_class'] + level.to_s]
+        styles << config['tag.menu.item_submenu_class'] if has_submenu
+        styles << config['tag.menu.item_submenu_inhierarchy_class'] if node.is_ancestor_of?(dest_node)
+        styles << config['tag.menu.item_selected_class'] if node == dest_node
         style = "class=\"#{styles.join(' ')}\"" if styles.length > 0
 
         link = dest_node.link_to(node, lang)

data/lib/webgen/test_helper.rb

@@ -129,30 +129,30 @@ module Webgen
     #   /dir2/                   'dir2' proxy_path='index.html'
     #   /dir2/index.en.html      'index en' routed_title='routed en' link_attrs={'class' => 'help'}
     #   /dir2/index.de.html      'index de' routed_title='routed de'
-    def setup_default_nodes(tree)
-      root = Webgen::Node.new(tree.dummy_root, '/', '/')
+    def setup_default_nodes(tree, klass = Webgen::Node)
+      root = klass.new(tree.dummy_root, '/', '/')
 
-      file_en = Webgen::Node.new(root, 'file.html', '/file.en.html', {'lang' => 'en', 'title' => 'file en', 'sort_info' => 3})
-      frag_en = Webgen::Node.new(file_en, '#frag', '/file.en.html#frag', {'title' => 'frag'})
-      Webgen::Node.new(frag_en, '#nested', '/file.en.html#nested', {'title' => 'fragnested', 'routing_path' => '/routed.html'})
-      file_de = Webgen::Node.new(root, 'file.html', '/file.de.html', {'lang' => 'de', 'title' => 'file de', 'sort_info' => 5})
-      Webgen::Node.new(file_de, '#frag', '/file.de.html#frag', {'title' => 'frag'})
+      file_en = klass.new(root, 'file.html', '/file.en.html', {'lang' => 'en', 'title' => 'file en', 'sort_info' => 3})
+      frag_en = klass.new(file_en, '#frag', '/file.en.html#frag', {'title' => 'frag'})
+      klass.new(frag_en, '#nested', '/file.en.html#nested', {'title' => 'fragnested', 'routing_path' => '/routed.html'})
+      file_de = klass.new(root, 'file.html', '/file.de.html', {'lang' => 'de', 'title' => 'file de', 'sort_info' => 5})
+      klass.new(file_de, '#frag', '/file.de.html#frag', {'title' => 'frag'})
 
-      Webgen::Node.new(root, 'other.html', '/other.html', {'title' => 'other'})
-      Webgen::Node.new(root, 'other.html', '/other.en.html', {'lang' => 'en', 'title' => 'other en'})
+      klass.new(root, 'other.html', '/other.html', {'title' => 'other'})
+      klass.new(root, 'other.html', '/other.en.html', {'lang' => 'en', 'title' => 'other en'})
 
-      Webgen::Node.new(root, 'german.html', '/german.other.html', {'title' => 'german', 'lang' => 'de'})
+      klass.new(root, 'german.html', '/german.other.html', {'title' => 'german', 'lang' => 'de'})
 
-      dir = Webgen::Node.new(root, 'dir/', '/dir/', {'title' => 'dir'})
-      dir_file = Webgen::Node.new(dir, 'subfile.html', '/dir/subfile.html', {'title' => 'subfile'})
-      Webgen::Node.new(dir_file, '#frag', '/dir/subfile.html#frag', {'title' => 'frag'})
-      dir_dir = Webgen::Node.new(dir, 'dir/' , '/dir/dir/', {'title' => 'dir'})
-      Webgen::Node.new(dir_dir, 'file.html', '/dir/dir/file.html', {'title' => 'file'})
+      dir = klass.new(root, 'dir/', '/dir/', {'title' => 'dir'})
+      dir_file = klass.new(dir, 'subfile.html', '/dir/subfile.html', {'title' => 'subfile'})
+      klass.new(dir_file, '#frag', '/dir/subfile.html#frag', {'title' => 'frag'})
+      dir_dir = klass.new(dir, 'dir/' , '/dir/dir/', {'title' => 'dir'})
+      klass.new(dir_dir, 'file.html', '/dir/dir/file.html', {'title' => 'file'})
 
-      dir2 = Webgen::Node.new(root, 'dir2/', '/dir2/', {'proxy_path' => 'index.html', 'title' => 'dir2'})
-      Webgen::Node.new(dir2, 'index.html', '/dir2/index.en.html',
+      dir2 = klass.new(root, 'dir2/', '/dir2/', {'proxy_path' => 'index.html', 'title' => 'dir2'})
+      klass.new(dir2, 'index.html', '/dir2/index.en.html',
                        {'lang' => 'en', 'routed_title' => 'routed', 'title' => 'index en', 'link_attrs' => {'class'=>'help'}})
-      Webgen::Node.new(dir2, 'index.html', '/dir2/index.de.html',
+      klass.new(dir2, 'index.html', '/dir2/index.de.html',
                        {'lang' => 'de', 'routed_title' => 'routed de', 'title' => 'index de'})
     end
 

data/lib/webgen/utils/external_command.rb

@@ -13,7 +13,7 @@ module Webgen
       #
       # This just checks if the exit status is zero.
       def self.ensure_available!(cmd, *args)
-        status = systemu([cmd, *args], 'stdout' => '')
+        status = systemu([cmd, *args], 'stdout' => '', 'stdin' => '')
         raise Webgen::CommandNotFoundError.new(cmd) if status.exitstatus != 0
       end
 

data/lib/webgen/utils/tag_parser.rb

@@ -114,7 +114,7 @@ module Webgen
       # Parse the parameter string and return the result.
       def parse_params(param_string, tag)
         YAML::load("--- #{param_string}")
-      rescue ArgumentError, SyntaxError => e
+      rescue ArgumentError, SyntaxError, YAML::SyntaxError => e
         raise Error.new("Could not parse parameter string '#{param_string}' for tag '#{tag}': #{e.message}")
       end
 

data/lib/webgen/vendor/rainpress.rb

@@ -0,0 +1,168 @@
+# == Information
+#
+# This is the main class of Rainpress, create an instance of it to compress
+# your CSS-styles.
+#
+# Author:: Uwe L. Korn <uwelk@xhochy.org>
+#
+# <b>Options:</b>
+#
+# * <tt>:comments</tt> - if set to false, comments will not be removed
+# * <tt>:newlines</tt> - if set to false, newlines will not be removed
+# * <tt>:spaces</tt> - if set to false, spaces will not be removed
+# * <tt>:colors</tt> - if set to false, colors will not be modified
+# * <tt>:misc</tt> - if set to false, miscellaneous compression parts will be skipped
+class Rainpress
+  # Quick-compress the styles.
+  # This eliminates the need to create an instance of the class
+  def self.compress(style, options = {})
+    self.new(style, options).compress!
+  end
+
+  def initialize(style, opts = {})
+    @style = style
+    @opts = {
+      :comments => true,
+      :newlines => true,
+      :spaces   => true,
+      :colors   => true,
+      :misc     => true
+    }
+    @opts.merge! opts
+  end
+
+  # Run the compressions and return the newly compressed text
+  def compress!
+    remove_comments!  if @opts[:comments]
+    remove_newlines!  if @opts[:newlines]
+    remove_spaces!    if @opts[:spaces]
+    shorten_colors!   if @opts[:colors]
+    do_misc!          if @opts[:misc]
+    @style
+  end
+
+  # Remove all comments out of the CSS-Document
+  #
+  # Only /* text */ comments are supported.
+  # Attention: If you are doing css hacks for IE using the comment tricks,
+  # they will be removed using this function. Please consider for IE css style
+  # corrections the usage of conditionals comments in your (X)HTML document.
+	def remove_comments!
+    input = @style
+    @style = ''
+
+    while input.length > 0 do
+      pos = input.index("/*");
+
+      # No more comments
+      if pos == nil
+        @style += input
+        input = '';
+      else # Comment beginning at pos
+        @style += input[0..(pos-1)] if pos > 0 # only append text if there is some
+        input = input[(pos+2)..-1]
+        # Comment ending at pos
+        pos = input.index("*/")
+        input = input[(pos+2)..-1]
+      end
+    end
+	end
+
+  # Remove all newline characters
+  #
+  # We take care of Windows(\r\n), Unix(\n) and Mac(\r) newlines.
+	def remove_newlines!
+		@style.gsub! /\n|\r/, ''
+	end
+
+	# Remove unneeded spaces
+	#
+  # 1. Turn mutiple spaces into a single
+  # 2. Remove spaces around ;:{},
+  # 3. Remove tabs
+  def remove_spaces!
+    @style.gsub! /\s*(\s|;|:|\}|\{|,)\s*/, '\1'
+    @style.gsub! "\t", ''
+	end
+
+	# Replace color values with their shorter equivalent
+	#
+	# 1. Turn rgb(,,)-colors into #-values
+	# 2. Shorten #AABBCC down to #ABC
+	# 3. Replace names with their shorter hex-equivalent
+	#    * white -> #fff
+ 	#    * black -> #000
+	# 4. Replace #-values with their shorter name
+	#    * #f00 -> red
+	def shorten_colors!
+	  # rgb(50,101,152) to #326598
+    @style.gsub! /rgb\s*\(\s*([0-9,\s]+)\s*\)/ do |match|
+      out = '#'
+      $1.split(',').each do |num|
+        out += '0' if num.to_i < 16
+        out += num.to_i.to_s(16) # convert to hex
+      end
+      out
+    end
+    # Convert #AABBCC to #ABC, keep if preceed by a '='
+    @style.gsub! /([^\"'=\s])(\s*)#([\da-f])\3([\da-f])\4([\da-f])\5/i, '\1#\3\4\5'
+
+    # At the moment we assume that colours only appear before ';' or '}' and
+    # after a ':', if there could be an occurence of a color before or after
+    # an other character, submit either a bug report or, better, a patch that
+    # enables Rainpress to take care of this.
+
+    # shorten several names to numbers
+    ## shorten white -> #fff
+    @style.gsub! /:\s*white\s*(;|\})/, ':#fff\1'
+
+    ## shorten black -> #000
+    @style.gsub! /:\s*black\s*(;|\})/, ':#000\1'
+
+    # shotern several numbers to names
+    ## shorten #f00 or #ff0000 -> red
+    @style.gsub! /:\s*#f{1,2}0{2,4}(;|\})/i, ':red\1'
+  end
+
+  # Do miscellaneous compression methods on the style.
+  def do_misc!
+    # Replace 0(pt,px,em,%) with 0 but only when preceded by : or a white-space
+    @style.gsub! /([\s:]+)(0)(px|em|%|in|cm|mm|pc|pt|ex)/i, '\1\2'
+
+    # Replace :0 0 0 0(;|}) with :0(;|})
+    @style.gsub! /:0 0 0 0(;|\})/, ':0\1'
+
+    # Replace :0 0 0(;|}) with :0(;|})
+    @style.gsub! /:0 0 0(;|\})/, ':0\1'
+
+    # Replace :0 0(;|}) with :0(;|})
+    @style.gsub! /:0 0(;|\})/, ':0\1'
+
+    # Replace background-position:0; with background-position:0 0;
+    @style.gsub! 'background-position:0;', 'background-position:0 0;'
+
+    # Replace 0.6 to .6, but only when preceded by : or a white-space
+    @style.gsub! /[:\s]0+\.(\d+)/ do |match|
+      match.sub '0', '' # only first '0' !!
+    end
+
+    # Replace multiple ';' with a single ';'
+    @style.gsub! /[;]+/, ';'
+
+    # Replace ;} with }
+    @style.gsub! ';}', '}'
+
+    # Replace font-weight:normal; with 400
+    @style.gsub! /font-weight[\s]*:[\s]*normal[\s]*(;|\})/i,'font-weight:400\1'
+    @style.gsub! /font[\s]*:[\s]*normal[\s;\}]*/ do |match|
+      match.sub 'normal', '400'
+    end
+
+    # Replace font-weight:bold; with 700
+    @style.gsub! /font-weight[\s]*:[\s]*bold[\s]*(;|\})/,'font-weight:700\1'
+    @style.gsub! /font[\s]*:[\s]*bold[\s;\}]*/ do |match|
+      match.sub 'bold', '700'
+    end
+  end
+
+end