codnar 0.1.68 → 0.1.73

data/lib/codnar/configuration/documentation.rb

@@ -0,0 +1,65 @@
+module Codnar
+
+  module Configuration
+
+    # Configurations for "splitting" documentation files.
+    module Documentation
+
+      # "Split" a documentation file. All lines are assumed to have the same kind
+      # +doc+ and no indentation is collected. Unless overriden by additional
+      # configuration(s), the lines are assumed to contain formatted HTML, and
+      # are passed as-is to the output.
+      #
+      # This is the default configuration as it performs the minimal amount of
+      # processing on the input. It isn't the most useful configuration.
+      SPLIT_HTML_DOCUMENTATION = {
+        "formatters" => {
+          "doc" => "Formatter.cast_lines(lines, 'html')",
+        },
+        "syntax" => {
+          "patterns" => {
+            "doc" => { "regexp" => "^(.*)$", "groups" => [ "payload" ] },
+          },
+          "states" => {
+            "start" => { "transitions" => [ { "pattern" => "doc" } ] },
+          },
+        },
+      }
+
+      # "Split" a documentation file containing arbitrary text, which is
+      # preserved by escaping it and wrapping it in an HTML pre element.
+      SPLIT_PRE_DOCUMENTATION = SPLIT_HTML_DOCUMENTATION.deep_merge(
+        "formatters" => {
+          "doc" => "Formatter.lines_to_pre_html(lines, :class => :doc)",
+        }
+      )
+
+      # "Split" a documentation file containing pure RDoc documentation.
+      SPLIT_RDOC_DOCUMENTATION = SPLIT_HTML_DOCUMENTATION.deep_merge(
+        "formatters" => {
+          "doc" => "Formatter.markup_lines_to_html(lines, Codnar::RDoc, 'rdoc')",
+          "unindented_html" => "Formatter.unindented_lines_to_html(lines)",
+        }
+      )
+
+      # "Split" a documentation file containing pure Markdown documentation.
+      SPLIT_MARKDOWN_DOCUMENTATION = SPLIT_HTML_DOCUMENTATION.deep_merge(
+        "formatters" => {
+          "doc" => "Formatter.markup_lines_to_html(lines, Codnar::Markdown, 'markdown')",
+          "unindented_html" => "Formatter.unindented_lines_to_html(lines)",
+        }
+      )
+
+      # "Split" a documentation file containing a GraphViz diagram.
+      SPLIT_GRAPHVIZ_DOCUMENTATION = SPLIT_HTML_DOCUMENTATION.deep_merge(
+        "formatters" => {
+          "doc" => "Formatter.markup_lines_to_html(lines, Codnar::GraphViz, 'graphviz')",
+          "unindented_html" => "Formatter.unindented_lines_to_html(lines)",
+        }
+      )
+
+    end
+
+  end
+
+end

data/lib/codnar/configuration/highlighting.rb

@@ -0,0 +1,107 @@
+module Codnar
+
+  module Configuration
+
+    # Configurations for highlighting source code lines.
+    module Highlighting
+
+      # {{{ GVim syntax highlighting formatting configurations
+
+      # Format code using GVim's syntax highlighting, using explicit HTML
+      # constructs. Assumes some previous configuration already classified the
+      # code lines.
+      FORMAT_CODE_GVIM_HTML = lambda do |syntax|
+        return Highlighting.klass_code_format('GVim', syntax, "[]")
+      end
+
+      # Format code using GVim's syntax highlighting, using CSS classes instead
+      # of explicit font and color styles. Assumes some previous configuration
+      # already classified the code lines.
+      FORMAT_CODE_GVIM_CSS = lambda do |syntax|
+        return Highlighting.klass_code_format('GVim', syntax, "[ '+:let html_use_css=1' ]")
+      end
+
+      # Return a configuration for highlighting a specific syntax using GVim.
+      def self.klass_code_format(klass, syntax, options)
+        return {
+          "formatters" => {
+            "#{syntax}_code" => "#{klass}.lines_to_html(lines, '#{syntax}', #{options})",
+          },
+        }
+      end
+
+      # }}}
+
+      # {{{ CodeRay syntax highlighting formatting configurations
+
+      # Format code using CodeRay's syntax highlighting, using explicit HTML
+      # constructs. Assumes some previous configuration already classified the
+      # code lines.
+      FORMAT_CODE_CODERAY_HTML = lambda do |syntax|
+        return Highlighting.klass_code_format('CodeRay', syntax, "{}")
+      end
+
+      # Format code using CodeRay's syntax highlighting, using CSS classes
+      # instead of explicit font and color styles. Assumes some previous
+      # configuration already classified the code lines.
+      FORMAT_CODE_CODERAY_CSS = lambda do |syntax|
+        return Highlighting.klass_code_format('CodeRay', syntax, "{ :css => :class }")
+      end
+
+      # }}}
+
+      # {{{ Sunlight syntax highlighting formatting configurations
+
+      # Format code using Sunlight's syntax highlighting. This assumes the HTML
+      # will include and invoke Sunlight's Javascript file which does the
+      # highlighting on the fly inside the DOM, instead of pre-computing it when
+      # splitting the file.
+      FORMAT_CODE_SUNLIGHT = lambda do |syntax|
+        return Highlighting.sunlight_code_format(syntax)
+      end
+
+      # Return a configuration for highlighting a specific syntax using Sunlight.
+      def self.sunlight_code_format(syntax)
+        return {
+          "formatters" => {
+            "#{syntax}_code" => "Sunlight.lines_to_html(lines, '#{syntax}')",
+          },
+        }
+      end
+
+      # }}}
+
+      # {{{ Chunk splitting configurations
+
+      # Group lines into chunks using VIM-style "{{{"/"}}}" region designations.
+      # Assumes other configurations handle the actual content lines.
+      CHUNK_BY_VIM_REGIONS = {
+        "formatters" => {
+          "begin_chunk" => "[]",
+          "end_chunk" => "[]",
+          "nested_chunk" => "Formatter.nested_chunk_lines_to_html(lines)",
+        },
+        "syntax" => {
+          "patterns" => {
+            "begin_chunk" => { "regexp" => "^(\\s*)\\W*\\{\\{\\{\\s*(.*?)\\s*$" },
+            "end_chunk" => { "regexp" => "^(\\s*)\\W*\\}\\}\\}\\s*(.*?)\\s*$" },
+          },
+          "states" => {
+            "start" => {
+              "transitions" => [
+                { "pattern" => "begin_chunk" },
+                { "pattern" => "end_chunk" },
+                [],
+              ],
+            },
+          },
+        },
+      }
+
+      # }}}
+
+    end
+
+  end
+
+end

data/lib/codnar/data/contents.js

@@ -30,7 +30,8 @@ function contents_lists() {
   var container;
   var indices = [];
   var h_elements = all_h_elements();
-  for (var e in h_elements) {
+  /* Using "for (var e in h_elements)" is too sensitive to other libraries */
+  for (var e = 0; e < h_elements.length; e++) {
     h = h_elements[e];
     var level = h.tagName.substring(1, 2) - 1;
     container = pop_container(container, indices, level);

data/lib/codnar/haddock.rb

@@ -0,0 +1,72 @@
+module Codnar
+
+  # Convert Haddoc to HTML.
+  class Haddock
+
+    # Process a Haddock String and return the resulting HTML.
+    def self.to_html(haddock)
+      with_temporary_directory do |path|
+        write_temporary_file(path, haddock)
+        run_haddock(path)
+        html = read_html_file(path)
+        clean_html(html)
+      end
+    end
+
+  protected
+
+    # Run a block using a temporary directory, that is then removed. TODO: This
+    # should be in some more generic place.
+    def self.with_temporary_directory
+      path = create_temporary_directory
+      result = yield path
+      FileUtils.rm_rf(path)
+      return result
+    end
+
+    # Create a temporary directory to run Haddock in.
+    def self.create_temporary_directory
+      file = Tempfile.open("dir", ".")
+      path = file.path
+      File.delete(path)
+      Dir.mkdir(path)
+      return path
+    end
+
+    # Minimal header to insert before the Haddock String to trick Haddock into
+    # generating HTML from it.
+    HADDOCK_HEADER = <<-EOF.unindent
+      module Wrapper where
+      -- $doc
+    EOF
+
+    # Write the Haddock String into a wrapper Haskell file so we'll be able to
+    # run Haddock to generate HTML from it.
+    def self.write_temporary_file(path, haddock)
+      File.open(path + "/wrapper.hs", "w") do |file|
+        file.write(HADDOCK_HEADER)
+        file.write("-- " + haddock.gsub("\n", "\n-- "))
+      end
+    end
+
+    # Run Haddock to convert the wrapper Haskell file into HTML documentation.
+    def self.run_haddock(path)
+      system("cd #{path} && haddock --html wrapper.hs > haddock.out 2>&1")
+    end
+
+    # Read the HTML generated by Haddock.
+    def self.read_html_file(path)
+      return File.read(path + "/Wrapper.html")
+    end
+
+    # Extract the clean generated HTML from Haddock's output.
+    def self.clean_html(html)
+      html.gsub!("\r\n", "\n")
+      html.sub!(/.*<div class="doc">/m, '')
+      html.sub!(/<\/div><\/div><\/div><div id="footer">.*/m, "\n")
+      return html
+    end
+
+  end
+
+end

data/lib/codnar/rake/split_task.rb

@@ -57,6 +57,12 @@ module Codnar
         ::Rake::Task.define_task(:clean => "clean_codnar")
       end
 
+      # For some reason, <tt>include ::Rake::DSL</tt> doesn't give us this and
+      # life is too short...
+      def self.desc(description)
+        ::Rake.application.last_description = description
+      end
+
       # Connect the task for splitting a single source file to the common task
       # of splitting all source files.
       def self.connect_common_tasks(output)

data/lib/codnar/scanner.rb

@@ -34,7 +34,9 @@ module Codnar
     # - The pattern groups field can be ommitted or contain +nil+ if it is
     #   equal to [ "indentation", "payload" ].
     # - The kind field of a transition can be ommitted; by default it is
-    #   assumed to be identical to the pattern kind.
+    #   assumed to be identical to the pattern kind. If it ends up +nil+, this
+    #   indicates that there's no kind assigned by the pattern, and the current
+    #   line should be classified again by the next state.
     # - The next state of a transition can be ommitted; by default it is
     #   assumed to be identical to the containing state.
     # - The start state can be ommitted; by default it is assumed to be named
@@ -113,11 +115,21 @@ module Codnar
 
     # {{{ Scanner state shorthands
 
+    # A pattern that matches any line and extracts no data; is meant to be used
+    # for catch-all transitions that transfer the scanning to a different
+    # state. It is used if no explicit pattern is specified in a transition
+    # (that is, you can think of this as the +nil+ pattern).
+    CATCH_ALL_PATTERN = {
+      "kind" => nil,
+      "groups" => [],
+      "regexp" => //
+    }
+
     # Expand all the shorthands used in the state.
     def expand_state_shorthands(name, state)
       fill_name(name, state, "State")
       state.transitions.each do |transition|
-        pattern = transition.pattern = lookup(@syntax.patterns, "pattern", transition.pattern)
+        pattern = transition.pattern = lookup(@syntax.patterns, "pattern", transition.pattern || CATCH_ALL_PATTERN)
         transition.kind ||= pattern.andand.kind
         transition.next_state = lookup(@syntax.states, "state", transition.next_state || state)
       end
@@ -146,10 +158,21 @@ module Codnar
 
     # Scan the next file line.
     def scan_line(line)
+      until state_classified_line(line)
+        # Do nothing
+      end
+    end
+
+    # Scan the current line using the current state transitions. Return true if
+    # the line was classified, of false if we need to try and classify it again
+    # using the updated (next) state.
+    def state_classified_line(line)
       @state.transitions.each do |transition|
-        return if transition.pattern && transition.next_state && classify_matching_line(line, transition)
+        match = transition.pattern.andand.regexp.andand.match(line) if transition.next_state
+        return classify_matching_line(line, transition, match) if match
       end
-      unclassified_line(line, @state.name)
+      classify_error_line(line, @state.name)
+      return true
     end
 
     # }}}
@@ -157,15 +180,15 @@ module Codnar
     # {{{ Scanner line processing
 
     # Handle a file line, only if it matches the pattern.
-    def classify_matching_line(line, transition)
-      match = (pattern = transition.pattern).regexp.match(line)
-      return false unless match
-      @lines << Scanner.extracted_groups(match, pattern.groups).update({
+    def classify_matching_line(line, transition, match)
+      @state = transition.next_state
+      kind = transition.kind
+      return false unless kind # A +nil+ kind indicates the next state will classify the line.
+      @lines << Scanner.extracted_groups(match, transition.pattern.groups || []).update({
         "line" => line,
-        "kind" => transition.kind,
+        "kind" => kind,
         "number" => @errors.line_number
       })
-      @state = transition.next_state
       return true
     end
 
@@ -181,7 +204,7 @@ module Codnar
     end
 
     # Handle a file line that couldn't be classified.
-    def unclassified_line(line, state_name)
+    def classify_error_line(line, state_name)
       @lines << {
         "line" => line,
         "indentation" => line.indentation,

data/lib/codnar/split_configurations.rb

@@ -5,388 +5,10 @@ module Codnar
   # Application.
   module Configuration
 
-    # {{{ Documentation "splitting" configurations
-
-    # "Split" a documentation file. All lines are assumed to have the same kind
-    # +doc+ and no indentation is collected. Unless overriden by additional
-    # configuration(s), the lines are assumed to contain formatted HTML, and
-    # are passed as-is to the output.
-    #
-    # This is the default configuration as it performs the minimal amount of
-    # processing on the input. It isn't the most useful configuration.
-    SPLIT_HTML_DOCUMENTATION = {
-      "formatters" => {
-        "doc" => "Formatter.cast_lines(lines, 'html')",
-      },
-      "syntax" => {
-        "patterns" => {
-          "doc" => { "regexp" => "^(.*)$", "groups" => [ "payload" ] },
-        },
-        "states" => {
-          "start" => { "transitions" => [ { "pattern" => "doc" } ] },
-        },
-      },
-    }
-
-    # "Split" a documentation file containing arbitrary text, which is
-    # preserved by escaping it and wrapping it in an HTML pre element.
-    SPLIT_PRE_DOCUMENTATION = SPLIT_HTML_DOCUMENTATION.deep_merge(
-      "formatters" => {
-        "doc" => "Formatter.lines_to_pre_html(lines, :class => :doc)",
-      }
-    )
-
-    # "Split" a documentation file containing pure RDoc documentation.
-    SPLIT_RDOC_DOCUMENTATION = SPLIT_HTML_DOCUMENTATION.deep_merge(
-      "formatters" => {
-        "doc" => "Formatter.markup_lines_to_html(lines, Codnar::RDoc, 'rdoc')",
-        "unindented_html" => "Formatter.unindented_lines_to_html(lines)",
-      }
-    )
-
-    # "Split" a documentation file containing pure Markdown documentation.
-    SPLIT_MARKDOWN_DOCUMENTATION = SPLIT_HTML_DOCUMENTATION.deep_merge(
-      "formatters" => {
-        "doc" => "Formatter.markup_lines_to_html(lines, Codnar::Markdown, 'markdown')",
-        "unindented_html" => "Formatter.unindented_lines_to_html(lines)",
-      }
-    )
-
-    # "Split" a documentation file containing a GraphViz diagram.
-    SPLIT_GRAPHVIZ_DOCUMENTATION = SPLIT_HTML_DOCUMENTATION.deep_merge(
-      "formatters" => {
-        "doc" => "Formatter.markup_lines_to_html(lines, Codnar::GraphViz, 'graphviz')",
-        "unindented_html" => "Formatter.unindented_lines_to_html(lines)",
-      }
-    )
-
-    # }}}
-
-    # {{{ Source code lines classification configurations
-
-    # Classify all lines as source code of some syntax (kind). This doesn't
-    # distinguish between comment and code lines; to do that, you need to
-    # combine this with comment classification configuration(s). Also, it just
-    # formats the lines in an HTML +pre+ element, without any syntax
-    # highlighting; to do that, you need to combine this with syntax
-    # highlighting formatting configuration(s).
-    CLASSIFY_SOURCE_CODE = lambda do |syntax|
-      return {
-        "formatters" => {
-          "#{syntax}_code" => "Formatter.lines_to_pre_html(lines, :class => :code)",
-        },
-        "syntax" => {
-          "patterns" => {
-            "#{syntax}_code" => { "regexp" => "^(\\s*)(.*)$" },
-          },
-          "states" => {
-            "start" => {
-              "transitions" => [
-                { "pattern" => "#{syntax}_code" },
-              ],
-            },
-          },
-        },
-      }
-    end
-
-    # }}}
-
-    # {{{ Nested foreign syntax code islands configurations
-
-    # Allow for comments containing "((( <syntax>" and "))) <syntax>" to
-    # designate nested islands of foreign syntax inside the normal code. The
-    # designator comment lines are always treated as part of the surrounding
-    # code, not as part of the nested foreign syntax code. There is no further
-    # classification of the nested foreign syntax code. Therefore, the nested
-    # code is not examined for begin/end chunk markers. Likewise, the nested
-    # code may not contain deeper nested code using a third syntax.
-    CLASSIFY_NESTED_CODE = lambda do |outer_syntax, inner_syntax|
-      {
-        "syntax" => {
-          "patterns" => {
-            "start_#{inner_syntax}_in_#{outer_syntax}" =>
-              { "regexp" => "^(\\s*)(.*\\(\\(\\(\\s*#{inner_syntax}.*)$" },
-            "end_#{inner_syntax}_in_#{outer_syntax}" => 
-              { "regexp" => "^(\\s*)(.*\\)\\)\\)\\s*#{inner_syntax}.*)$" },
-            "#{inner_syntax}_in_#{outer_syntax}" =>
-              { "regexp" => "^(\\s*)(.*)$" },
-          },
-          "states" => {
-            "start" => {
-              "transitions" => [
-                { "pattern" => "start_#{inner_syntax}_in_#{outer_syntax}",
-                  "kind" => "#{outer_syntax}_code",
-                  "next_state" => "#{inner_syntax}_in_#{outer_syntax}" },
-                [],
-              ],
-            },
-            "#{inner_syntax}_in_#{outer_syntax}" => {
-              "transitions" => [
-                { "pattern" => "end_#{inner_syntax}_in_#{outer_syntax}",
-                  "kind" => "#{outer_syntax}_code",
-                  "next_state" => "start" },
-                { "pattern" => "#{inner_syntax}_in_#{outer_syntax}",
-                  "kind" => "#{inner_syntax}_code" },
-              ],
-            },
-          },
-        },
-      }
-    end
-
-    # }}}
-
-    # {{{ Simple comment classification configurations
-
-    # Classify simple comment lines. It accepts a restricted format: each
-    # comment is expected to start with some exact prefix (e.g. "#" for shell
-    # style comments or "//" for C++ style comments). The following space, if
-    # any, is stripped from the payload. As a convenience, comment that starts
-    # with "!" is not taken to start a comment. This both protects the 1st line
-    # of shell scripts ("#!"), and also any other line you wish to avoid being
-    # treated as a comment.
-    #
-    # This configuration is typically complemented by an additional one
-    # specifying how to format the (stripped!) comments; by default they are
-    # just displayed as-is using an HTML +pre+ element, which isn't very
-    # useful.
-    CLASSIFY_SIMPLE_COMMENTS = lambda do |prefix|
-      return Configuration.simple_comments(prefix)
-    end
-
-    # Classify simple shell ("#") comment lines.
-    CLASSIFY_SHELL_COMMENTS = lambda do
-      return Configuration.simple_comments("#")
-    end
-
-    # Classify simple C++ ("//") comment lines.
-    CLASSIFY_CPP_COMMENTS = lambda do
-      return Configuration.simple_comments("//")
-    end
-
-    # Configuration for classifying lines to comments and code based on a
-    # simple prefix (e.g. "#" for shell style comments or "//" for C++ style
-    # comments).
-    def self.simple_comments(prefix)
-      return {
-        "syntax" => {
-          "patterns" => {
-            "comment_#{prefix}" => { "regexp" => "^(\\s*)#{prefix}(?!!)\\s?(.*)$" },
-          },
-          "states" => {
-            "start" => {
-              "transitions" => [
-                { "pattern" => "comment_#{prefix}", "kind" => "comment" },
-                []
-              ],
-            },
-          },
-        },
-      }
-    end
-
-    # }}}
-
-    # {{{ Complex comment classification configurations
-
-    # Classify complex comment lines. It accepts a restricted format: each
-    # comment is expected to start with some exact prefix (e.g. "/*" for C
-    # style comments or "<!--" for HTML style comments). The following space,
-    # if any, is stripped from the payload. Following lines are also considered
-    # comments; a leading inner line prefix (e.g., " *" for C style comments or
-    # " -" for HTML style comments) with an optional following space are
-    # stripped from the payload. Finally, a line containing some exact suffix
-    # (e.g. "*/" for C style comments, or "-->" for HTML style comments) ends
-    # the comment. A one line comment format is also supported containing the
-    # prefix, the payload, and the suffix. As a convenience, comment that
-    # starts with "!" is not taken to start a comment. This allows protecting
-    # comment block you wish to avoid being classified as a comment.
-    #
-    # This configuration is typically complemented by an additional one
-    # specifying how to format the (stripped!) comments; by default they are
-    # just displayed as-is using an HTML +pre+ element, which isn't very
-    # useful.
-    CLASSIFY_COMPLEX_COMMENTS = lambda do |prefix, inner, suffix|
-      return Configuration.complex_comments(prefix, inner, suffix)
-    end
-
-    # Classify complex C ("/*", " *", " */") style comments.
-    CLASSIFY_C_COMMENTS = lambda do
-      # Since the prefix/inner/suffix passed to the configuration are regexps,
-      # we need to escape special characters such as "*".
-      return Configuration.complex_comments("/\\*", " \\*", " \\*/")
-    end
-
-    # Classify complex HTML ("<!--", " -", "-->") style comments.
-    CLASSIFY_HTML_COMMENTS = lambda do
-      return Configuration.complex_comments("<!--", " -", "-->")
-    end
-
-    # Configuration for classifying lines to comments and code based on a
-    # complex start prefix, inner line prefix and final suffix (e.g., "/*", "
-    # *", " */" for C-style comments or "<!--", " -", "-->" for HTML style
-    # comments).
-    def self.complex_comments(prefix, inner, suffix)
-      return {
-        "syntax" => {
-          "patterns" => {
-            "comment_prefix_#{prefix}" => { "regexp" => "^(\\s*)#{prefix}(?!!)\\s?(.*)$" },
-            "comment_inner_#{inner}" => { "regexp" => "^(\\s*)#{inner}\\s?(.*)$" },
-            "comment_suffix_#{suffix}" => { "regexp" => "^(\\s*)#{suffix}\\s*$" },
-            "comment_line_#{prefix}_#{suffix}" => { "regexp" => "^(\\s*)#{prefix}(?!!)\s?(.*?)\s*#{suffix}\\s*$" },
-          },
-          "states" => {
-            "start" => {
-              "transitions" => [
-                { "pattern" => "comment_line_#{prefix}_#{suffix}",
-                  "kind" => "comment" },
-                { "pattern" => "comment_prefix_#{prefix}",
-                  "kind" => "comment",
-                  "next_state" => "comment_#{prefix}" },
-                [],
-              ],
-            },
-            "comment_#{prefix}" => {
-              "transitions" => [
-                { "pattern" => "comment_suffix_#{suffix}",
-                  "kind" => "comment",
-                  "next_state" => "start" },
-                { "pattern" => "comment_inner_#{inner}",
-                  "kind" => "comment" },
-              ],
-            },
-          },
-        },
-      }
-    end
-
-    # }}}
-
-    # {{{ Comment formatting configurations
-
-    # Format comments as HTML pre elements. Is used to complement a
-    # configuration that classifies some lines as +comment+.
-    FORMAT_PRE_COMMENTS = {
-      "formatters" => {
-        "comment" => "Formatter.lines_to_pre_html(lines, :class => :comment)",
-      },
-    }
-
-    # Format comments that use the RDoc notation. Is used to complement a
-    # configuration that classifies some lines as +comment+.
-    FORMAT_RDOC_COMMENTS = {
-      "formatters" => {
-        "comment" => "Formatter.markup_lines_to_html(lines, Codnar::RDoc, 'rdoc')",
-        "unindented_html" => "Formatter.unindented_lines_to_html(lines)",
-      },
-    }
-
-    # Format comments that use the Markdown notation. Is used to complement a
-    # configuration that classifies some lines as +comment+.
-    FORMAT_MARKDOWN_COMMENTS = {
-      "formatters" => {
-        "comment" => "Formatter.markup_lines_to_html(lines, Markdown, 'markdown')",
-        "unindented_html" => "Formatter.unindented_lines_to_html(lines)",
-      },
-    }
-
-    # }}}
-    
-    # {{{ GVim syntax highlighting formatting configurations
-
-    # Format code using GVim's syntax highlighting, using explicit HTML
-    # constructs. Assumes some previous configuration already classified the
-    # code lines.
-    FORMAT_CODE_GVIM_HTML = lambda do |syntax|
-      return Configuration.klass_code_format('GVim', syntax, "[]")
-    end
-
-    # Format code using GVim's syntax highlighting, using CSS classes instead
-    # of explicit font and color styles. Assumes some previous configuration
-    # already classified the code lines.
-    FORMAT_CODE_GVIM_CSS = lambda do |syntax|
-      return Configuration.klass_code_format('GVim', syntax, "[ '+:let html_use_css=1' ]")
-    end
-
-    # Return a configuration for highlighting a specific syntax using GVim.
-    def self.klass_code_format(klass, syntax, options)
-      return {
-        "formatters" => {
-          "#{syntax}_code" => "#{klass}.lines_to_html(lines, '#{syntax}', #{options})",
-        },
-      }
-    end
-
-    # }}}
-
-    # {{{ CodeRay syntax highlighting formatting configurations
-
-    # Format code using CodeRay's syntax highlighting, using explicit HTML
-    # constructs. Assumes some previous configuration already classified the
-    # code lines.
-    FORMAT_CODE_CODERAY_HTML = lambda do |syntax|
-      return Configuration.klass_code_format('CodeRay', syntax, "{}")
-    end
-
-    # Format code using CodeRay's syntax highlighting, using CSS classes
-    # instead of explicit font and color styles. Assumes some previous
-    # configuration already classified the code lines.
-    FORMAT_CODE_CODERAY_CSS = lambda do |syntax|
-      return Configuration.klass_code_format('CodeRay', syntax, "{ :css => :class }")
-    end
-
-    # }}}
-
-    # {{{ Sunlight syntax highlighting formatting configurations
-
-    # Format code using Sunlight's syntax highlighting. This assumes the HTML
-    # will include and invoke Sunlight's Javascript file which does the
-    # highlighting on the fly inside the DOM, instead of pre-computing it when
-    # splitting the file.
-    FORMAT_CODE_SUNLIGHT = lambda do |syntax|
-      return Configuration.sunlight_code_format(syntax)
-    end
-
-    # Return a configuration for highlighting a specific syntax using Sunlight.
-    def self.sunlight_code_format(syntax)
-      return {
-        "formatters" => {
-          "#{syntax}_code" => "Sunlight.lines_to_html(lines, '#{syntax}')",
-        },
-      }
-    end
-
-    # }}}
-
-    # {{{ Chunk splitting configurations
-
-    # Group lines into chunks using VIM-style "{{{"/"}}}" region designations.
-    # Assumes other configurations handle the actual content lines.
-    CHUNK_BY_VIM_REGIONS = {
-      "formatters" => {
-        "begin_chunk" => "[]",
-        "end_chunk" => "[]",
-        "nested_chunk" => "Formatter.nested_chunk_lines_to_html(lines)",
-      },
-      "syntax" => {
-        "patterns" => {
-          "begin_chunk" => { "regexp" => "^(\\s*)\\W*\\{\\{\\{\\s*(.*?)\\s*$" },
-          "end_chunk" => { "regexp" => "^(\\s*)\\W*\\}\\}\\}\\s*(.*?)\\s*$" },
-        },
-        "states" => {
-          "start" => {
-            "transitions" => [
-              { "pattern" => "begin_chunk" },
-              { "pattern" => "end_chunk" },
-              [],
-            ],
-          },
-        },
-      },
-    }
-
-    # }}}
+    include Documentation
+    include Code
+    include Comments
+    include Highlighting
 
   end