webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/content_processor/html_head.rb

@@ -0,0 +1,157 @@
+# -*- encoding: utf-8 -*-
+
+require 'erb'
+
+module Webgen
+  class ContentProcessor
+
+    # == General information
+    #
+    # 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.
+    #
+    # Use the methods defined on the special Context#html_head object to provide values.
+    #
+    # == Internal details
+    #
+    # The key ':cp_html_head' of 'context.persistent' is used (the normal 'context.options' 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 'meta' tags are generated. The keys and the
+    #         values will be properly escaped before insertion. The entries in the meta information
+    #         'meta' 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.
+    #
+    module HtmlHead
+
+      HTML_HEAD_END_RE = /<\/head\s*>/i #:nodoc:
+
+      # Insert the additional header information.
+      def self.call(context)
+        context.content.sub!(HTML_HEAD_END_RE) do |match|
+          result = ''
+          result << tags_from_context_data(context)
+          result << links_to_translations(context)
+          result << links_from_link_meta_info(context)
+          result << match
+        end
+        context
+      end
+
+      # Return a string containing the HTML tags corresponding to the information set in the given
+      # Context object and the values of the meta info key +meta+ of the content node.
+      def self.tags_from_context_data(context)
+        result = ''
+        if context.persistent[:cp_html_head].kind_of?(Hash)
+          process_data_array(context, :js_file) do |js_file|
+            result += "\n<script type=\"text/javascript\" src=\"#{js_file}\"></script>"
+          end
+
+          process_data_array(context, :js_inline) do |content|
+            result += "\n<script type=\"text/javascript\">//<![CDATA[\n#{content}\n//]]></script>"
+          end
+
+          process_data_array(context, :css_file) do |css_file|
+            result += "\n<link rel=\"stylesheet\" href=\"#{css_file}\" type=\"text/css\"/>"
+          end
+
+          process_data_array(context, :css_inline) do |content|
+            result += "\n<style type=\"text/css\">/*<![CDATA[/*/\n#{content}\n/*]]>*/</style>"
+          end
+
+          (context.persistent[:cp_html_head][:meta] || {}).merge(context.content_node['meta'] || {}).each do |name, content|
+            result += "\n<meta name=\"#{ERB::Util.h(name)}\" content=\"#{ERB::Util.h(content)}\" />"
+          end
+        end
+        result
+      end
+
+      # Yield the values of the specified array.
+      def self.process_data_array(context, array_name, &block)
+        (context.persistent[:cp_html_head][array_name] || []).uniq.each(&block)
+      end
+
+      # Return a string containing HTML link tags to translations of the destination node.
+      def self.links_to_translations(context)
+        context.website.tree.translations(context.dest_node).map do |node|
+          next '' if node.alcn == context.dest_node.alcn
+          context.website.ext.item_tracker.add(context.dest_node, :node_meta_info, node.alcn)
+
+          result = "\n<link type=\"text/html\" rel=\"alternate\" hreflang=\"#{node.lang}\" "
+          result << "href=\"#{context.dest_node.route_to(node)}\" "
+          if node['title'] && !node['title'].empty?
+            result << "lang=\"#{node.lang}\" title=\"#{ERB::Util.h(node['title'])}\" "
+          end
+          result << "/>"
+        end.join('')
+      end
+
+      # Given an array of path names, add tracker information for the resolved nodes (reference node
+      # is the content node) and return the relative paths to them.
+      def self.resolve_paths(context, paths)
+        [paths].flatten.compact.collect do |path|
+          next path if Webgen::Path.url(path, false).absolute?
+          node = context.content_node.resolve(path, context.dest_node.lang, true)
+          if node
+            context.website.ext.item_tracker.add(context.dest_node, :node_meta_info, node.alcn)
+            context.dest_node.route_to(node)
+          else
+            nil
+          end
+        end.compact
+      end
+
+      LINK_DOCUMENT_ATTRS = {'type' => 'text/html'} #:nodoc:
+      LINK_DOCUMENT_TYPES = %w{start next prev contents index glossary chapter section subsection appendix help} #:nodoc:
+
+      # Return a string containing HTML link tags to the links from the 'link' meta information.
+      def self.links_from_link_meta_info(context)
+        link_mi = Marshal.load(Marshal.dump(context.content_node['link'] || {}))
+        result = ''
+
+        # Add user defined javascript and CSS links
+        resolve_paths(context, link_mi.delete('javascript')).each do |file|
+          result += "\n<script type=\"text/javascript\" src=\"#{file}\"></script>"
+        end
+        resolve_paths(context, link_mi.delete('css')).each do |file|
+          result += "\n<link rel=\"stylesheet\" href=\"#{file}\" type=\"text/css\" />"
+        end
+
+        # add generic links
+        link_mi.sort.each do |link_type, vals|
+          link_type = link_type.downcase
+          [vals].flatten.each do |val|
+            val = {'href' => val} if val.kind_of?(String)
+            val['rel'] ||= link_type
+            val = LINK_DOCUMENT_ATTRS.merge(val) if LINK_DOCUMENT_TYPES.include?(link_type)
+            href = val.delete('href')
+            href = resolve_paths(context, href).first if href
+            if href
+              result << "\n<link href=\"#{href}\" "
+              val.sort.each {|k,v| result << "#{k}=\"#{ERB::Util.h(v)}\" "}
+              result << "/>"
+            else
+              context.website.logger.error do
+                "No link target specified for link type '#{link_type}' in 'link' meta information in <#{context.content_node}>"
+              end
+            end
+          end
+        end
+
+        result
+      end
+
+    end
+
+  end
+end

data/lib/webgen/content_processor/kramdown.rb

@@ -0,0 +1,49 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/content_processor'
+webgen_require 'kramdown'
+
+module Webgen
+  class ContentProcessor
+
+    # Processes content in kramdown format (based on Markdown) using the +kramdown+ library.
+    module Kramdown
+
+      class CustomHtmlConverter < ::Kramdown::Converter::Html #:nodoc:
+        public_class_method(:new)
+
+        def initialize(root, options, context)
+          super(root, options)
+          @context = context
+          @do_convert = context.website.config['content_processor.kramdown.handle_links']
+          @ignore_fragments = context.website.config['content_processor.kramdown.ignore_unknown_fragments']
+        end
+
+        def convert_a(el, indent)
+          el.attr['href'] = @context.tag('relocatable', {'path' => el.attr['href'],
+                                           'ignore_unknown_fragment' => @ignore_fragments}) if @do_convert
+          super
+        end
+
+        def convert_img(el, indent)
+          el.attr['src'] = @context.tag('relocatable', {'path' => el.attr['src'],
+                                          'ignore_unknown_fragment' => @ignore_fragments}) if @do_convert
+          super
+        end
+
+      end
+
+      # Convert the content in +context+ to HTML.
+      def self.call(context)
+        doc = ::Kramdown::Document.new(context.content, context.website.config['content_processor.kramdown.options'])
+        context.content = CustomHtmlConverter.new(doc.root, doc.options, context).convert(doc.root)
+        doc.warnings.each do |warn|
+          context.website.logger.warn { "kramdown warning while parsing <#{context.ref_node}>: #{warn}" }
+        end
+        context
+      end
+
+    end
+
+  end
+end

data/lib/webgen/content_processor/maruku.rb

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/content_processor'
+require 'rexml/parsers/baseparser'
+webgen_require 'maruku'
+
+
+# :stopdoc:
+# Fixes a problem when parsing Markdown with <webgen>-tags in Maruku.
+class REXML::Parsers::BaseParser
+
+  alias_method :"old_stream=", :"stream="
+
+  def stream=(source)
+    self.old_stream = source
+    @nsstack << Set.new(['webgen'])
+  end
+
+end
+# :startdoc:
+
+
+module Webgen
+  class ContentProcessor
+
+    # Processes content in Markdown format using the +maruku+ library.
+    module Maruku
+
+      # Convert the content in +context+ to HTML.
+      def self.call(context)
+        $uid = 0 # fix for invalid fragment IDs on second run
+        context.content = ::Maruku.new(context.content, :on_error => :raise).to_html
+        context
+      end
+
+    end
+
+  end
+end

data/lib/webgen/content_processor/r_discount.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/content_processor'
+webgen_require 'rdiscount'
+
+module Webgen
+  class ContentProcessor
+
+    # Processes content in Markdown markup with the fast +rdiscount+ library.
+    module RDiscount
+
+      # Convert the content in +context+ to HTML.
+      def self.call(context)
+        context.content = ::RDiscount.new(context.content).to_html
+        context
+      end
+
+    end
+
+  end
+end

data/lib/webgen/content_processor/rdoc.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/content_processor'
+webgen_require 'rdoc/markup/to_html', 'rdoc'
+
+module Webgen
+  class ContentProcessor
+
+    # Converts content in RDoc markup (the native Ruby documentation format) to HTML. Needs the newer
+    # RDoc implementation (version >= 2.4.x).
+    module RDoc
+
+      # Convert the content in RDoc markup to HTML.
+      def self.call(context)
+        context.content = ::RDoc::Markup::ToHtml.new.convert(context.content)
+        context
+      end
+
+    end
+
+  end
+end

data/lib/webgen/content_processor/redcloth.rb

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/content_processor'
+webgen_require 'redcloth', 'RedCloth'
+
+module Webgen
+  class ContentProcessor
+
+    # Processes content in Textile format using the +redcloth+ library.
+    module RedCloth
+
+      # Convert the content in +context+ to HTML.
+      def self.call(context)
+        doc = ::RedCloth.new(context.content)
+        doc.hard_breaks = context.website.config['content_processor.redcloth.hard_breaks']
+        context.content = doc.to_html
+        context
+      end
+
+    end
+
+  end
+end

data/lib/webgen/content_processor/ruby.rb

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/content_processor'
+
+module Webgen
+  class ContentProcessor
+
+    # Processes the content that is valid Ruby to generate new content.
+    module Ruby
+
+      # Process the content of +context+ which needs to be valid Ruby code.
+      def self.call(context)
+        eval(context.content, binding, context.ref_node.alcn)
+        context
+      end
+
+    end
+
+  end
+end

data/lib/webgen/content_processor/sass.rb

@@ -0,0 +1,145 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/content_processor'
+require 'webgen/path'
+webgen_require 'sass'
+
+module Webgen
+  class ContentProcessor
+
+    # Processes content in Sass markup (used for writing CSS files).
+    module Sass
+
+      # Custom importer for Sass to load files from the file system but resolves absolute paths from
+      # the given root directory and not from the filesystem root!
+      class FileSystemImporter < ::Sass::Importers::Filesystem
+
+        def find_real_file(dir, name, options = {}) #:nodoc:
+          for (f,s) in possible_files(remove_root(name))
+            if full_path = Dir["#{dir}/#{f}"].first
+              full_path.gsub!(REDUNDANT_DIRECTORY,File::SEPARATOR)
+              return full_path, s
+            end
+          end
+          nil
+        end
+
+      end
+
+      # Custom importer for Sass to load files by resolving them in the node tree.
+      class NodeTreeImporter < ::Sass::Importers::Base
+
+        # Creates a new importer that imports files from the node tree relative to the given node alcn.
+        def initialize(website, alcn)
+          @website = website
+          @alcn = alcn
+        end
+
+        # @see Base#find_relative
+        def find_relative(name, base, options)
+          _find(base, name, options)
+        end
+
+        # @see Base#find
+        def find(name, options)
+          _find(@alcn, name, options)
+        end
+
+        def mtime(name, options) #:nodoc:
+          node = resolve_node(@alcn, name)
+          node['modified_at'] if node
+        end
+
+        def key(name, options) #:nodoc:
+          ["webgen:", name]
+        end
+
+        def to_s #:nodoc:
+          "webgen: #{@alcn}"
+        end
+
+        #######
+        private
+        #######
+
+        # Find the @import-ed name under the given base filename.
+        #
+        # Returns a Sass::Engine object if found or +nil+ otherwise.
+        def _find(base, name, options)
+          node, syntax = resolve_node(base, name)
+          return unless node
+
+          options[:syntax] = syntax
+          options[:filename] = node.alcn
+          options[:importer] = self
+          ::Sass::Engine.new(node.node_info[:path].data, options)
+        end
+
+        # Resolve the path using the given base filename.
+        #
+        # Returns [node, syntax] if a node was found or nil otherwise
+        def resolve_node(base, path)
+          possible_filenames(path).each do |filename, syntax|
+            node = @website.tree.resolve_node(Webgen::Path.append(base, filename), nil)
+            return [node, syntax] if node
+          end
+          nil
+        end
+
+        # Return an array of all possible (filename, syntax) pairs for the given path.
+        def possible_filenames(path)
+          dirname, basename = File.split(path)
+          basename, ext = basename.scan(/^(.*?)(?:\.(sass|scss))?$/).first
+          (ext.nil? ? %w{sass scss} : [ext]).map do |ext|
+            [["#{dirname}/_#{basename}.#{ext}", ext.to_sym], ["#{dirname}/#{basename}.#{ext}", ext.to_sym]]
+          end.flatten(1)
+        end
+
+      end
+
+      module ::Sass::Script::Functions
+
+        # Return the correct relative path for the given path.
+        def relocatable(path)
+          assert_type(path, :String)
+          context = options[:webgen_context]
+          path = path.value
+
+          dest_node = context.website.tree[options[:filename]].resolve(path, context.dest_node.lang, true)
+          if dest_node
+            context.website.ext.item_tracker.add(context.dest_node, :node_meta_info, dest_node.alcn)
+            result = context.dest_node.route_to(dest_node)
+          else
+            result = path
+          end
+          ::Sass::Script::String.new("url(\"#{result}\")")
+        end
+        declare :relocatable, [:string]
+
+      end
+
+      # Convert the content in +sass+ markup to CSS.
+      def self.call(context)
+        context.content = ::Sass::Engine.new(context.content, default_options(context)).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
+
+      def self.default_options(context) # :nodoc:
+        opts = context.website.config['content_processor.sass.options']
+        load_paths = context.website.ext.sass_load_paths + [NodeTreeImporter.new(context.website, '/')]
+        opts.merge({
+                     :filename => context.ref_node.alcn,
+                     :syntax => :sass,
+                     :cache_store => ::Sass::CacheStores::Filesystem.new(context.website.tmpdir('sass')),
+                     :filesystem_importer => FileSystemImporter,
+                     :load_paths => load_paths,
+                     :webgen_context => context
+                   })
+      end
+
+    end
+
+  end
+end