webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/contentprocessor/head.rb

@@ -1,128 +0,0 @@
-# -*- 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:
-
-    LINK_DOCUMENT_ATTRS = {'type' => 'text/html'} #:nodoc:
-    LINK_DOCUMENT_TYPES = %w{start next prev contents index glossary chapter section subsection appendix help} #:nodoc:
-
-    # Insert the additional header information.
-    def call(context)
-      require 'erb'
-      context.content.sub!(HTML_HEAD_END_RE) do |match|
-        result = ''
-
-        # add content set programmatically
-        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
-
-        # add links to other languages of same page
-        context.dest_node.tree.node_access[:acn][context.dest_node.acn].
-          select {|n| n.alcn != context.dest_node.alcn}.each do |node|
-          context.dest_node.node_info[:used_meta_info_nodes] << 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
-
-        link = Marshal.load(Marshal.dump(context.node['link'] || {}))
-
-        handle_files = lambda do |files|
-          [files].flatten.compact.collect do |file|
-            if !Webgen::Node.url(file, false).absolute?
-              file = context.node.resolve(file, context.dest_node.lang)
-              if file
-                context.dest_node.node_info[:used_meta_info_nodes] << file.alcn
-                file = context.dest_node.route_to(file)
-              else
-                log(:error) { "Could not resolve path '#{file}' used in 'link' meta information in <#{context.node}>" }
-                context.dest_node.flag(:dirty)
-              end
-            end
-            file
-          end.compact
-        end
-
-        # Add user defined javascript and CSS links
-        handle_files.call(link.delete('javascript')).each do |file|
-          result += "\n<script type=\"text/javascript\" src=\"#{file}\"></script>"
-        end
-        handle_files.call(link.delete('css')).each do |file|
-          result += "\n<link rel=\"stylesheet\" href=\"#{file}\" type=\"text/css\" />"
-        end
-
-        # add generic links specified via the +link+ meta information
-        link.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)
-            if href = val.delete('href')
-              href = handle_files.call(href).first
-            else
-              log(:error) { "No link target specified for link type '#{link_type}' in 'link' meta information in <#{context.node}>" }
-            end
-            if href
-              s = "\n<link href=\"#{href}\" "
-              val.sort.each {|k,v| s += "#{k}=\"#{ERB::Util.h(v)}\" "}
-              result += s + "/>"
-            end
-          end
-        end
-
-        result + match
-      end
-      context
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/kramdown.rb

@@ -1,27 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Webgen::ContentProcessor
-
-  # Processes content in kramdown format (based on Markdown) using the +kramdown+ library.
-  class Kramdown
-
-    include Webgen::Loggable
-
-    # Convert the content in +context+ to HTML.
-    def call(context)
-      require 'kramdown'
-      require 'webgen/contentprocessor/kramdown/html'
-      doc = ::Kramdown::Document.new(context.content,
-                                     context.website.config['contentprocessor.kramdown.options'].merge(context.options['contentprocessor.kramdown.options'] || {}))
-      context.content = KramdownHtmlConverter.convert(doc.root, doc.options, context)
-      doc.warnings.each do |warn|
-        log(:warn) { "Warning while parsing <#{context.ref_node}> with kramdown: #{warn}" }
-      end
-      context
-    rescue LoadError
-      raise Webgen::LoadError.new('kramdown', self.class.name, context.dest_node, 'kramdown')
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/kramdown/html.rb

@@ -1,36 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'kramdown'
-
-module Webgen::ContentProcessor
-
-  class KramdownHtmlConverter < ::Kramdown::Converter::Html
-
-    def initialize(root, options, context) #:nodoc:
-      super(root, options)
-      @context = context
-      @do_convert = if context.options.has_key?('contentprocessor.kramdown.handle_links')
-                      context.options['contentprocessor.kramdown.handle_links']
-                    else
-                      context.website.config['contentprocessor.kramdown.handle_links']
-                    end
-    end
-
-    # Convert the element tree under +root+ to HTML using the webgen +context+ object.
-    def self.convert(root, options, context)
-      new(root, options, context).convert(root)
-    end
-
-    def convert_a(el, indent)
-      el.attr['href'] = @context.tag('relocatable', {'path' => el.attr['href']}) if @do_convert
-      "<a#{html_attributes(el.attr)}>#{inner(el, indent)}</a>"
-    end
-
-    def convert_img(el, indent)
-      el.attr['src'] = @context.tag('relocatable', {'path' => el.attr['src']}) if @do_convert
-      "<img#{html_attributes(el.attr)} />"
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/less.rb

@@ -1,35 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Webgen::ContentProcessor
-
-  # Generates valid CSS from CSS-like input, supporting variables, nesting and mixins.
-  class Less
-
-    include Webgen::Loggable
-
-    # Convert the content in +context+ to valid CSS.
-    def call(context)
-      require 'less'
-      context.content = ::Less.parse(context.content)
-      context
-    rescue LoadError
-      raise Webgen::LoadError.new('less', self.class.name, context.dest_node, 'less')
-    rescue ::Less::SyntaxError => e
-      line = e.message.scan(/on line (\d+):/).first.first.to_i rescue nil
-      raise Webgen::RenderError.new(e, self.class.name, context.dest_node, context.ref_node, line)
-    rescue ::Less::MixedUnitsError => e
-      raise Webgen::RenderError.new("Can't mix different units together: #{e}",
-                                    self.class.name, context.dest_node, context.ref_node)
-    rescue ::Less::VariableNameError => e
-      raise Webgen::RenderError.new("Variable name is undefined: #{e}",
-                                    self.class.name, context.dest_node, context.ref_node)
-    rescue ::Less::MixinNameError => e
-      raise Webgen::RenderError.new("Mixin name is undefined: #{e}",
-                                    self.class.name, context.dest_node, context.ref_node)
-    rescue ::Less::ImportError => e
-      raise Webgen::RenderError.new(e, self.class.name, context.dest_node, context.ref_node)
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/maruku.rb

@@ -1,36 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'rexml/parsers/baseparser'
-
-class REXML::Parsers::BaseParser
-
-  alias :"old_stream=" :"stream="
-
-  def stream=(source)
-    self.old_stream=(source)
-    @nsstack << Set.new(['webgen'])
-  end
-
-end
-
-
-module Webgen::ContentProcessor
-
-  # Processes content in Markdown format using the +maruku+ library.
-  class Maruku
-
-    # Convert the content in +context+ to HTML.
-    def call(context)
-      require 'maruku'
-      $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, 'maruku')
-    rescue Exception => e
-      raise Webgen::RenderError.new(e, self.class.name, context.dest_node, context.ref_node)
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/rdiscount.rb

@@ -1,19 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Webgen::ContentProcessor
-
-  # Processes content in Markdown markup with the fast +rdiscount+ library.
-  class RDiscount
-
-    # Convert the content in +context+ to HTML.
-    def call(context)
-      require 'rdiscount'
-      context.content = ::RDiscount.new(context.content).to_html
-      context
-    rescue LoadError
-      raise Webgen::LoadError.new('rdiscount', self.class.name, context.dest_node, 'rdiscount')
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/rdoc.rb

@@ -1,20 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Webgen::ContentProcessor
-
-  # Converts content in RDoc markup (the native Ruby documentation format) to HTML. Needs the newer
-  # RDoc implementation provided as +rdoc+ gem!
-  class RDoc
-
-    # Convert the content in RDoc markup to HTML.
-    def call(context)
-      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, 'rdoc')
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/redcloth.rb

@@ -1,21 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Webgen::ContentProcessor
-
-  # Processes content in Textile format using the +redcloth+ library.
-  class RedCloth
-
-    # Convert the content in +context+ to HTML.
-    def call(context)
-      require 'redcloth'
-      doc = ::RedCloth.new(context.content)
-      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, 'RedCloth')
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/sass.rb

@@ -1,22 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Webgen::ContentProcessor
-
-  # Processes content in Sass markup (used for writing CSS files) using the +haml+ library.
-  class Sass
-
-    # Convert the content in +sass+ markup to CSS.
-    def call(context)
-      require 'sass'
-
-      context.content = ::Sass::Engine.new(context.content, :filename => context.ref_node.alcn).render
-      context
-    rescue LoadError
-      raise Webgen::LoadError.new('sass', self.class.name, context.dest_node, 'haml')
-    rescue ::Sass::SyntaxError => e
-      raise Webgen::RenderError.new(e, self.class.name, context.dest_node, context.ref_node, (e.sass_line if e.sass_line))
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/scss.rb

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

data/lib/webgen/contentprocessor/tags.rb

@@ -1,170 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'yaml'
-require 'strscan'
-require 'webgen/tag'
-
-module Webgen::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.
-  class Tags
-
-    include Webgen::WebsiteAccess
-    include Webgen::Loggable
-
-    def initialize #:nodoc:
-      @start_re = /(\\*)\{#{website.config['contentprocessor.tags.prefix']}(\w+)(::?)/
-      @end_re = /(\\*)\{#{website.config['contentprocessor.tags.prefix']}(\w+)\}/
-    end
-
-    # Replace all webgen tags in the content of +context+ with the rendered content.
-    def call(context)
-      replace_tags(context) do |tag, param_string, body|
-        log(:debug) { "Replacing tag #{tag} with data '#{param_string}' and body '#{body}' in <#{context.ref_node}>" }
-        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, context.ref_node)
-      end
-      result
-    end
-
-
-    #######
-    private
-    #######
-
-    BRACKETS_RE = /([{}])/
-    ProcessingStruct = Struct.new(:state, :tag, :simple_tag, :backslashes, :brackets, :start_pos, :end_pos,
-                                  :params_start_pos, :params_end_pos, :body_end_pos)
-
-    # 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
-        when :before_tag
-          if scanner.skip_until(@start_re)
-            data.state = :in_start_tag
-            data.backslashes = scanner[1].length
-            data.brackets = 1
-            data.tag = scanner[2]
-            data.simple_tag = (scanner[3] == ':')
-            data.params_start_pos = scanner.pos
-            data.start_pos = scanner.pos - scanner.matched.length
-          else
-            data.state = :done
-          end
-
-        when :in_start_tag
-          data.brackets += (scanner[1] == '{' ? 1 : -1) while data.brackets != 0 && scanner.skip_until(BRACKETS_RE)
-          if data.brackets != 0
-            raise Webgen::RenderError.new("Unbalanced curly brackets for tag '#{data.tag}'", self.class.name,
-                                          context.dest_node, context.ref_node)
-          else
-            data.params_end_pos = data.body_end_pos = data.end_pos = scanner.pos - 1
-            data.state = (data.simple_tag ? :process : :in_body)
-          end
-
-        when :process
-          if RUBY_VERSION >= '1.9'
-            begin
-              enc = scanner.string.encoding
-              scanner.string.force_encoding('ASCII-8BIT')
-              if data.backslashes % 2 == 0
-                result = yield(data.tag, scanner.string[data.params_start_pos...data.params_end_pos].force_encoding(enc),
-                               scanner.string[(data.params_end_pos+1)...data.body_end_pos].to_s.force_encoding(enc)).to_s
-                scanner.string[data.start_pos..data.end_pos] = "\\" * (data.backslashes / 2) + result.force_encoding('ASCII-8BIT')
-                scanner.pos = data.start_pos + result.length
-              else
-                scanner.string[data.start_pos, 1 + data.backslashes / 2] = ''
-                scanner.pos -= 1 + data.backslashes / 2
-              end
-            ensure
-              scanner.string.force_encoding(enc) if RUBY_VERSION >= '1.9'
-            end
-          else
-            if data.backslashes % 2 == 0
-              result = yield(data.tag, scanner.string[data.params_start_pos...data.params_end_pos],
-                             scanner.string[(data.params_end_pos+1)...data.body_end_pos]).to_s
-              scanner.string[data.start_pos..data.end_pos] = "\\" * (data.backslashes / 2) + result
-              scanner.pos = data.start_pos + result.length
-            else
-              scanner.string[data.start_pos, 1 + data.backslashes / 2] = ''
-              scanner.pos -= 1 + data.backslashes / 2
-            end
-          end
-          data.state = :before_tag
-
-        when :in_body
-          while (result = scanner.skip_until(@end_re))
-            next unless scanner[2] == data.tag
-            if scanner[1].length % 2 == 1
-              scanner.string[(scanner.pos - scanner.matched.length), 1 + scanner[1].length / 2] = ''
-              scanner.pos -= 1 + scanner[1].length / 2
-            else
-              break
-            end
-          end
-          if result
-            data.state = :process
-            data.end_pos = scanner.pos - 1
-            data.body_end_pos = scanner.pos - scanner.matched.length + scanner[1].length / 2
-          else
-            raise Webgen::RenderError.new("Invalid body part - no end tag found for '#{data.tag}'", self.class.name,
-                                          context.dest_node, context.ref_node)
-          end
-
-        when :done
-          break
-        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.
-    def processor_for_tag(tag)
-      map = website.config['contentprocessor.tags.map']
-      klass = if map.has_key?(tag)
-                map[tag]
-              elsif map.has_key?(:default)
-                map[:default]
-              else
-                nil
-              end
-      klass.nil? ? nil : website.cache.instance(klass)
-    end
-
-  end
-
-end