codnar 0.1.64

data/lib/codnar.rb

@@ -0,0 +1,41 @@
+require "andand"
+require "base64"
+require "cgi"
+require "digest/sha2"
+require "erb"
+require "fileutils"
+require "irb"
+require "rdiscount"
+require "rdoc/markup/to_html"
+require "tempfile"
+require "yaml"
+
+require "olag/application"
+require "olag/data_files"
+require "olag/errors"
+require "olag/hash_struct"
+require "olag/string_unindent"
+
+require "codnar/version"
+
+require "codnar/hash_extensions"
+require "codnar/markdown"
+require "codnar/rdoc"
+require "codnar/string_extensions"
+
+require "codnar/application"
+require "codnar/cache"
+require "codnar/formatter"
+require "codnar/grouper"
+require "codnar/gvim"
+require "codnar/merger"
+require "codnar/split"
+require "codnar/reader"
+require "codnar/scanner"
+require "codnar/split_configurations"
+require "codnar/splitter"
+require "codnar/sunlight"
+require "codnar/weave"
+require "codnar/weave_configurations"
+require "codnar/weaver"
+require "codnar/writer"

data/lib/codnar/application.rb

@@ -0,0 +1,92 @@
+module Codnar
+
+  # Base class for Codnar applications.
+  class Application < Olag::Application
+
+    # Create a Codnar application.
+    def initialize(is_test = nil)
+      super(is_test)
+      @configuration ||= {}
+    end
+
+    # Run the Codnar application, returning its status.
+    def run(&block)
+      super(@configuration, &block)
+    end
+
+  protected
+
+    # Define Codnar application flags.
+    def define_flags
+      super
+      define_include_flag
+      define_require_flag
+      define_merge_flag
+      define_print_flag
+    end
+
+    # Return the application's version - that is, Codnar's version.
+    def version
+      return Codnar::VERSION
+    end
+
+    # Define a flag for collecting module load path directories.
+    def define_include_flag
+      @options.on("-I", "--include DIRECTORY", String, "Add directory to Ruby's load path.") do |path|
+        $LOAD_PATH.unshift(path)
+      end
+    end
+
+    # Define a flag for loading a Ruby module. This may be needed for
+    # user-specified configurations to work.
+    def define_require_flag
+      @options.on("-r", "--require MODULE", String, "Load a Ruby module for user configurations.") do |path|
+        begin
+          require(path)
+        rescue Exception => exception
+          $stderr.puts("#{$0}: #{exception}")
+          exit(1)
+        end
+      end
+    end
+
+    # Define a flag for applying (merging) a Codnar configuration.
+    def define_merge_flag
+      @options.on("-c", "--configuration NAME-or-FILE", String, "Apply a named or disk file configuration.") do |name_or_path|
+        loaded_configuration = load_configuration(name_or_path)
+        @configuration = @configuration.deep_merge(loaded_configuration)
+      end
+    end
+
+    # Define a flag for printing the (merged) Codnar configuration.
+    def define_print_flag
+      @options.on("-p", "--print", "Print the merged configuration.") do |name_or_path|
+        puts(@configuration.to_yaml)
+      end
+    end
+
+    # Load a configuration either from the available builtin data or from a
+    # disk file.
+    def load_configuration(name_or_path)
+      return YAML.load_file(name_or_path) if File.exist?(name_or_path)
+      name, *arguments = name_or_path.split(':')
+      value = configuration_value(name)
+      value = value.call(*arguments) unless Hash === value
+      return value
+    end
+
+    # Compute the value of a named built-in configuration.
+    def configuration_value(name)
+      begin
+        value = Configuration.const_get(name.upcase)
+        return value if value
+      rescue
+        value = nil
+      end
+      $stderr.puts("#{$0}: Configuration: #{name} is neither a disk file nor a known configuration")
+      exit(1)
+    end
+
+  end
+
+end

data/lib/codnar/cache.rb

@@ -0,0 +1,61 @@
+module Codnar
+
+  # Cache long computations in disk files.
+  class Cache
+
+    # Whether to recompute values even if they are cached.
+    attr_accessor :force_recompute
+  
+    # Connect to an existing disk cache. The cache is expected to be stored in
+    # a directory of the specified name, which is either in the current working
+    # directory or in one of its parent directories.
+    def initialize(directory, &block)
+      @force_recompute = false
+      @computation = block
+      @directory = find_directory(Dir.pwd, directory)
+      if @directory
+        class <<self; alias [] :cached_computation; end
+      else
+        class <<self; alias [] :uncached_computation; end
+        $stderr.puts("#{$0}: Could not find cache directory: #{directory}.")
+      end
+    end
+
+    # Access the results of the computation for the specified input. Fetch the
+    # result from the cache if it is there, otherwise invoke the computation
+    # and store the result in the cache for the next time.
+    def cached_computation(input)
+      file = cache_file(input)
+      return YAML.load_file(file) if File.exists?(file) and not @force_recompute
+      result = @computation.call(input)
+      File.open(file, "w") { |file| file.write(result.to_yaml) }
+      return result
+    end
+
+    # Return the file expected to cache the computed results for a given input,
+    def cache_file(input)
+      key = Digest.hexencode(Digest::SHA2.digest(input.to_yaml))
+      return @directory + "/" + key + ".yaml"
+    end
+
+    # Access the results of a computation for the specified input, in case we
+    # do not have a cache directory to look for and store the results in.
+    def uncached_computation(input)
+      return @computation.call(input)
+    end
+
+  protected
+
+    # Find the path of the cache directory, search from the given working
+    # directory upward until finding a match.
+    def find_directory(working_directory, cache_directory)
+      directory = working_directory + "/" + cache_directory
+      return directory if File.exists?(directory)
+      parent_directory = File.dirname(working_directory)
+      return nil if parent_directory == working_directory
+      return find_directory(parent_directory, cache_directory)
+    end
+
+  end
+
+end

data/lib/codnar/data/contents.js

@@ -0,0 +1,113 @@
+/*
+ * Quick-and-dirty JS for inserting a table of content inside a DIV with the id
+ * "contents". The table of content is a series of nested UL and LI elements,
+ * prefixed with an H1 containing the text "0 Contents". This H1 comes in
+ * addition to the single static H1 expected by HTML best practices. It looks
+ * "right" and should not confuse search engines etc. since they do not execute
+ * Javascript code.
+ */
+function inject_contents() {
+  var contents = document.getElementById("contents");
+  var lists = contents_lists();
+  contents.appendChild(contents_header()); // TRICKY: Must be done after contents_lists().
+  contents.appendChild(lists);
+}
+
+/*
+ * Create a table of contents H1.
+ */
+function contents_header() {
+  var h = document.createElement("h1");
+  var text = document.createTextNode("Contents");
+  h.appendChild(text);
+  return h;
+}
+
+/*
+ * Create nested UL/LI lists for the table of content.
+ */
+function contents_lists() {
+  var container;
+  var indices = [];
+  var h_elements = all_h_elements();
+  for (var e in h_elements) {
+    h = h_elements[e];
+    var level = h.tagName.substring(1, 2) - 1;
+    container = pop_container(container, indices, level);
+    container = push_container(container, indices, level);
+    var id = indices.join(".");
+    container.appendChild(list_element(id, h));
+    h.insertBefore(header_anchor(id), h.firstChild);
+  }
+  return pop_container(container, indices, 1);
+}
+
+/*
+ * Get a list of all H elements in the DOM. We skip the single H1 element;
+ * otherwise it would just have the index "1" which would be prefixed to all
+ * other headers.
+ */
+function all_h_elements() {
+  var elements = document.getElementsByTagName("*");
+  var h_elements = [];
+  for (var e in elements) {
+    var h = elements[e];
+    if (/^h[2-9]$/i.test(h.tagName)) h_elements.push(h);
+  }
+  return h_elements;
+}
+
+/*
+ * Pop indices (and UL containers) until reaching up to a given level.
+ */
+function pop_container(container, indices, level) {
+  while (indices.length > level) {
+    container = container.parentNode;
+    indices.pop();
+  }
+  return container;
+}
+
+/*
+ * Push indices (and UL containers) until reaching doen to a given level.
+ */
+function push_container(container, indices, level) {
+  while (indices.length < level) {
+    // TRICKY: push a 0 for the very last new level, so the ++ at the end
+    // will turn it into a 1.
+    indices.push(indices.level < level - 1);
+    var ul = document.createElement("ul");
+    if (container) {
+      container.appendChild(ul);
+    }
+    container = ul;
+  }
+  indices[indices.length - 1]++;
+  return container;
+}
+
+/*
+ * Create a LI for an H element with some id.
+ */
+function list_element(id, h) {
+  var a = document.createElement("a");
+  a.href = "#" + id;
+  a.innerHTML = id + "&nbsp;" + h.innerHTML;
+  var li = document.createElement("li");
+  li.appendChild(a);
+  return li;
+}
+
+/*
+ * Create an anchor for an H element with some id.
+ */
+function header_anchor(id) {
+  var text = document.createTextNode(id + " ");
+  var a = document.createElement("a");
+  a.id = id;
+  a.appendChild(text);
+  return a;
+}
+
+/* Only invoke it after all helper functions are defined. */
+inject_contents();

data/lib/codnar/data/control_chunks.js

@@ -0,0 +1,44 @@
+/*
+ * Quick-and-dirty JS for inserting a "+"/"-" control for chunk visibility next
+ * to each chunk's name. By default, all chunks are hidden.
+ */
+function inject_chunk_controls() {
+  var name_div;
+  foreach_chunk_elements(function(div) {
+    name_div = div;
+  }, function(html_div) {
+    var control_span = document.createElement("span");
+    var hide = function() {
+      control_span.innerHTML = "+";
+      html_div.style.display = "none";
+    }
+    var show = function() {
+      control_span.innerHTML = "–"; // Vertical bar.
+      html_div.style.display = "block";
+    }
+    name_div.onclick = function() {
+      html_div.style.display == "block" ? hide() : show();
+    }
+    hide(); // Initializes html_div.style.display
+    control_span.className = "control chunk";
+    name_div.insertBefore(control_span, name_div.firstChild);
+  })
+}
+
+/*
+ * Loop on all DIV elements that contain a chunk name, or that contain chunk
+ * HTML. Assumes that they come in pairs - name first, HTML second.
+ */
+function foreach_chunk_elements(name_lambda, html_lambda) {
+  var div_elements = document.getElementsByTagName("div");
+  for (var e in div_elements) {
+    var div = div_elements[e];
+    classes = " " + div.className + " ";
+    if (!/ chunk /.test(classes)) continue;
+    if (/ name /.test(classes)) name_lambda(div);
+    if (/ html /.test(classes)) html_lambda(div);
+  }
+}
+
+/* Only invoke it after all helper functions are defined. */
+inject_chunk_controls();

data/lib/codnar/data/style.css

@@ -0,0 +1,95 @@
+/* Margin & Padding */
+
+div.chunk.name,
+div.chunk.html,
+div.chunk.containers,
+div.chunk table,
+div.chunk td,
+div.chunk pre {
+  margin: 0;
+  padding: 0;
+}
+div.chunk *:last-child {
+  margin-bottom: 0;
+}
+h4, h5, h6,
+div.chunk,
+div.comment pre {
+  margin: 1em 0;
+}
+pre,
+div.comment,
+div.chunk.html {
+  padding: 0.33em;
+}
+
+span.control.chunk {
+  padding-left: 0.25em;
+  padding-right: 0.25em;
+}
+
+/* Table of content */
+
+div#contents ul {
+  margin-top: 0;
+  margin-bottom: 0;
+  padding: 0;
+}
+
+div#contents li {
+  list-style-type: none;
+}
+
+/* Lists */
+
+ul.chunk.containers {
+  padding: 0;
+  margin: 0;
+  display: inline;
+}
+ul.chunk.containers li {
+  display: inline;
+  list-style-type: none;
+}
+
+/* Borders */
+
+pre,
+span.control.chunk,
+div.chunk.html {
+  border: 1px solid #000;
+}
+
+table.layout td.indentation,
+div.chunk pre {
+  border: none;
+}
+
+/* Colors */
+
+span.control.chunk,
+table.layout td.html {
+  background-color: Beige;
+}
+
+/* Colors for GVim classes */
+
+span.Constant   { color: Crimson; }
+span.Identifier { color: Teal; }
+span.PreProc    { color: Indigo; }
+span.Special    { color: Navy; }
+span.Statement  { color: Maroon; }
+span.Type       { color: Green; }
+span.Comment    { color: Purple; }
+
+/* Fonts */
+
+body {
+  font-family: Sans-Serif;
+}
+pre {
+  font-family: Consolas, Inconsolata, Monaco, "Courier New", Monospace;
+}
+div.chunk.name {
+  font-weight: bold;
+}