conversio 0.1.1

data/HISTORY.md

@@ -0,0 +1,8 @@
+## 0.1.1
+
+* finishing Kramdown support
+* adding a couple of templates shipped with the gem
+
+## 0.1.0
+
+* First release

data/README.md

@@ -0,0 +1,43 @@
+Conversio by Jörg Behrendt and Victor Penso
+
+# Description
+
+Renders plain text files with [Markdown][1] syntax to XHTML pages. 
+User can define their own Ruby ERB templates to customize the 
+XHTML page generation. Also the creation of a table of content 
+using the HTML header elements (like `<h1>`) and the syntax
+high-lighting of code snippets is supported.
+
+## Installation 
+
+Conversio RubyGem: 
+
+    gem install conversio
+
+Syntax high-lighting is done with Pyhton [Pygments][2]:
+
+    easy_install pygments
+
+## Usage Examples
+
+Take a look to the help text:
+
+    conversio -h
+
+Convert all files called `*.markdown` inside a defined directory 
+and all sub-directories into HTML and store the in the destination
+directory.
+
+    conversio ~/docs/path/to/files ~/public/path
+
+Create a single `readme.html` file including a table of content by 
+using the 'dark' template:
+
+    conversio -t -p dark readme.markdown
+
+## License
+
+GPLv3 - see the COPYING file.
+
+[1]: http://daringfireball.net/projects/markdown/
+[2]: http://pygments.org/

data/bin/conversio

@@ -0,0 +1,247 @@
+#!/usr/bin/env ruby 
+
+$DEBUG = false
+
+require 'rubygems'
+require 'erb'
+require 'yaml'
+require 'fileutils'
+require 'pathname'
+require 'getoptlong'
+require 'ostruct'
+require 'conversio'
+
+include Conversio
+
+help = <<EOF
+Synopsis
+--------
+
+  #{File.split(__FILE__)[-1]}: Renders Markdown plain text files to HTML 
+
+Purpose
+-------
+
+Uses Ruby ERB Templates to generate XHTML documents rendered from Markdown
+plain text files.
+
+Usage
+-----
+
+#{File.split(__FILE__)[-1]} [OPTIONS] SRC [DST]
+
+SRC: File or directory containing the Markdown formated plain text
+DST: Target directory for the XHTML output.
+
+Options
+-------
+
+--config:
+
+  Creates a personal configuration file in ~/.conversiorc
+
+-c, --colorize:
+
+  Enable syntax high-lighting for marked code blocks.
+
+-e, --engine:
+
+  Select the Markdown parser to be used:
+  * 'bluecloth' (default)
+  * 'kramdown'
+
+-f, --template-file FILE:
+
+  FILE containing an ERB template with:
+  * '<%= content %>' to mark the postion inside the body tag
+    to place the passed in content.
+  * '<%= style %>' to mark the position for placing CSS.
+
+-h, --help:
+
+  Show this help documentation.
+
+-i, --ignore-config:
+
+  Don't read the configuration from ~/.conversiorc
+
+-l, --list-templates:
+
+  Show a list of all available templates.
+
+-t, --table-of-content:
+
+  Enables the creation of a table of content.
+
+-p, --template NAME:
+
+  Select a specific template to be used.
+
+-v, --verbose:
+
+  Print more verbose output.
+EOF
+
+config = <<EOF
+colorize: true
+table_of_content: true
+template_file:
+engine: 
+EOF
+
+# -------------------------------------------------------------
+# helper functions
+# -------------------------------------------------------------
+
+def ask?(*question)
+  print question.join(' '), '? (y/n) > '
+  return true if STDIN.gets.chomp.downcase.eql?('y')
+  return false
+end
+
+def overwrite?(*str)
+  return ask?('Overwrite',str)
+end
+
+
+# -------------------------------------------------------------
+# class extensions
+# -------------------------------------------------------------
+
+class Array
+  def resolv_path
+    Hash[ *self.collect { |e| [e,e.gsub(/.markdown/,'.html') ] }.flatten ]
+  end
+end
+
+# -------------------------------------------------------------
+# main program
+# -------------------------------------------------------------
+begin
+
+  user_config = "#{ENV['HOME']}/.conversiorc"
+
+
+  # defaults for program arguments
+  options = OpenStruct.new
+  options.ignore_config = false
+  options.colorize = false
+  options.engine = nil
+  options.template_file = nil
+  options.table_of_content = false
+  options.verbose = false
+  options.template = 'default'
+
+  # list of user options
+  opts = GetoptLong.new(
+    [ '--colorize', '-c', GetoptLong::NO_ARGUMENT],
+    [ '--config', GetoptLong::NO_ARGUMENT],
+    [ '--engine', '-e', GetoptLong::OPTIONAL_ARGUMENT],
+    [ '--ignore-config', '-i', GetoptLong::NO_ARGUMENT],
+    [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
+    [ '--list-templates', '-l', GetoptLong::NO_ARGUMENT ],
+    [ '--table-of-content', '-t', GetoptLong::NO_ARGUMENT],
+    [ '--template-file', '-f', GetoptLong::OPTIONAL_ARGUMENT ],
+    [ '--template', '-p', GetoptLong::OPTIONAL_ARGUMENT ],
+    [ '--verbose', '-v', GetoptLong::NO_ARGUMENT]
+  )
+
+  # parse the options from the command line
+  opts.each do |opt, arg|
+    case opt
+    when '--colorize'
+      options.colorize = true
+    when '--config'
+      open(user_config,'w') { |f| f.write config } if overwrite? user_config 
+      exit 0
+    when '--engine'
+      options.engine = arg
+    when '--ignore-config'
+      options.ignore_config = true
+    when '--help' 
+      puts help
+      exit 0
+    when '--list-templates'
+      Template.constants.each { |tpl| puts tpl.downcase }
+      exit 0
+    when '--table-of-content'
+      options.table_of_content = true
+    when '--template-file'
+      options.template_file = arg
+    when '--template' 
+      options.template = arg
+    when '--verbose'
+      options.verbose = true
+    end
+  end
+
+
+  # get the input source
+  src = ARGV[0] || raise("no input defined")
+  dst = ARGV[1] # optional parameter!
+
+  # read the default configuration of the user  
+  if not options.ignore_config and  File.exists? user_config then
+    STDERR.puts "Reading configuration file: #{user_config}" if options.verbose
+    defaults = YAML.load_file user_config
+    # command-line arguments have precedents before the suer configuration
+    options.colorize = defaults['colorize']
+    options.engine = defaults['engine'] if options.engine.nil?
+    options.table_of_content = defaults['table_of_content']
+    options.template_file = defaults['template_file'] if options.template_file.nil?
+  end
+
+  STDERR.print 'Configuration: ', options, "\n" if options.verbose 
+  
+  template = String.new
+  # user the default ERB template if the user hasn't defined its own
+  if options.template_file.nil? then
+    STDERR.print 'Using ERB template: ', options.template, "\n" if options.verbose
+    template = Template.const_get(options.template.upcase)
+  else
+    STDERR.print 'Using ERB template: ', options.template_file, "\n" if options.verbose
+    options.template_file = File.expand_path(options.template_file)
+    if File.exists? options.template_file
+      template = File.read options.template_file
+    else
+      raise("The specified ERB templates is not existing!")
+    end
+  end
+
+  # setup the converter object
+  converter = Converter.new(template)
+  converter.load_parser(options.engine) unless options.engine.nil?
+  converter.color = true if options.colorize 
+  converter.table_of_content = true if options.table_of_content
+  
+  # get all the input files
+  input_files = Array.new
+  if File.directory?(src) then
+    input_files = Dir["#{src}/**/*.markdown"]
+  else
+    file = File.expand_path(src)
+    input_files << file
+    src = File.dirname(file) 
+  end
+  src_dst_pairs = input_files.resolv_path
+  # fix the destination path if needed
+  unless dst.nil? then
+    src_dst_pairs.each_pair do |src_path,dst_path|
+      src_dst_pairs[src_path] = dst_path.gsub(/#{src}/,dst)      
+    end
+  end
+  # render the XHTML docs
+  STDERR.puts 'Created files:' if options.verbose
+  src_dst_pairs.each_pair do |s,d| 
+    converter.markdown_to_xhtml(s,d)
+    STDERR.print '  ', d, "\n" if options.verbose
+  end
+
+  exit 0
+
+rescue => exc
+  STDERR.puts "ERROR: #{exc.message}"
+  STDERR.puts "  use -h for detailed instructions"
+  exit 1
+end
+

data/conversio.gemspec

@@ -0,0 +1,56 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  
+s.name = %q{conversio}
+s.version = "0.1.1"
+
+s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+s.authors = ["Jörg Behrendt","Victor Penso"]
+s.date = %q{2010-11-19}
+s.default_executable = %q{conversio}
+s.homepage = 'https://github.com/vpenso/conversio'
+
+s.description = <<-EOF 
+Renders plain text files with Markdown syntax to XHTML pages. 
+User can define their own Ruby ERB templates to customize the 
+XHTML page generation. Also the creation of a table of content 
+using the HTML header elements (like `<h1>`) and the syntax
+high-lighting of code snippets is supported.
+EOF
+
+s.email = %q{v.penso@gsi.de}
+s.executables = ["conversio"]
+s.extra_rdoc_files = [
+  "bin/conversio", 
+  "lib/conversio.rb", 
+  "lib/conversio/converter.rb", 
+  "lib/conversio/htmltoc.rb", 
+  "lib/conversio/pygmentizer.rb"
+]
+s.files = [
+  "README.md", 
+  "HISTORY.md", 
+  "bin/conversio", 
+  "conversio.gemspec", 
+  "lib/conversio.rb", 
+  "lib/conversio/converter.rb", 
+  "lib/conversio/htmltoc.rb", 
+  "lib/conversio/pygmentizer.rb",
+  "templates/default.erb",
+  "templates/no_css.erb",
+  "templates/dark.erb",
+  "templates/light.erb"
+]
+s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Conversio"]
+s.require_paths = ["lib"]
+s.rubyforge_project = %q{conversio}
+s.rubygems_version = %q{1.3.6}
+s.summary = %q{Renders Markdown plain text files to HTML}
+
+s.add_dependency('bluecloth', '>= 2.0.9')
+s.add_dependency('kramdown')
+s.requirements << 'Pygments  (http://pygments.org/)'
+s.licenses = 'GPLv3'
+
+end

data/lib/conversio/converter.rb

@@ -0,0 +1,141 @@
+require 'fileutils'
+
+module Conversio
+
+class Hash
+
+ def deep_merge(hash)
+    target = dup
+    
+    hash.keys.each do |key|
+      if hash[key].is_a? Hash and self[key].is_a? Hash
+        target[key] = target[key].deep_merge(hash[key])
+        next
+      end
+      
+      target[key] = hash[key]
+    end
+    
+    target
+  end
+
+
+  def deep_merge!(second)
+    second.each_pair do |k,v|
+      if self[k].is_a?(Hash) and second[k].is_a?(Hash)
+        self[k].deep_merge!(second[k])
+      else
+        self[k] = second[k]
+      end
+    end
+  end
+end
+
+
+class Converter
+
+  attr_accessor :table_of_content, :color
+
+  def initialize(template)
+    @template = template
+    @table_of_content = false
+    @color = false
+    #user_config = "#{ENV['HOME']}/.conversiorc"
+    #if File.exists?(user_config)
+      # overwrite defaults
+      #@meta_data = @meta_data.deep_merge(YAML.load_file(user_config))
+    #end
+    # Holds the input Markdown plain text
+    @source = nil
+    # Hold Markdown rendered to HTML
+    @content = nil
+    # Hold the finished XHTML document
+    @result = nil
+    # load the default parser
+    @parser = 'bluecloth'
+    load_parser(@parser)
+  end
+
+  def markdown_to_xhtml(src,dst)
+    @source = open(src).readlines.join
+    colorize() if @color 
+    parse()    
+    generate_table_of_content() if @table_of_content
+    render()
+    # write the HTML file
+    FileUtils::mkdir_p(File.dirname(dst)) unless File.exists?(File.dirname(dst))
+    open(dst,'w') { |f| f.write @result }
+  end
+
+  def load_parser(parser)
+    begin
+      case parser
+      when 'bluecloth'
+        require 'bluecloth'
+      when 'kramdown'
+        require 'kramdown'
+      else
+        raise "Parser '#{parser}' is not a known Markdown library"
+      end
+    rescue LoadError
+      raise "Couldn't load #{parser}."
+    end
+    @parser = parser
+  end
+
+  private
+
+  def configure()
+    config = nil
+    # read the header of the source file
+    start = @source.index("|--")
+    ende = @source.index("--|")
+    #if start != nil and ende != nil then
+    if false
+      STDERR.puts 'Meta data found in file!' if $DEBUG
+      yamlheader = @source[start+3,ende-start-3]
+      # overwrite defaults
+      config = @meta_data.deep_merge(YAML.load(yamlheader))
+      splitted =  @source.split('--|',2)
+      @source = splitted[1]
+    else
+      config = @meta_data
+    end
+    return config
+  end
+
+  def load_template(tpl)
+    puts "Loading template : "+tpl.to_s
+    raise "Couldn't open ERB template: #{tpl}" unless File.exists?(File.expand_path(tpl))
+    return open(File.expand_path(tpl)).readlines.join
+  end
+
+  def parse
+    raise "Define source before rendering!" if @source == nil
+    case @parser
+    when 'bluecloth'
+      @content = BlueCloth::new(@source).to_html
+    when 'kramdown'
+      @content = Kramdown::Document.new(@source).to_html
+    else 
+      puts "Markdown parser #{@parser} not supported yet"
+    end
+  end
+
+  def colorize 
+     @source = Pygmentizer.new.transform_code_blocks(@source)
+  end
+
+  def generate_table_of_content #füge zum geparsten Text ein Inhaltsverzeichnis hinzu -> davor parsen
+    raise "No content to generate table of content - Run the parser first!" if @content == nil
+    @content = HTMLTableOfContent.new(@content).get_html()
+  end
+
+  def render(values = {})
+    values.store(:content, @content)
+    @result = ERB.new(@template).result(binding)
+  end
+
+end
+
+end

data/lib/conversio/htmltoc.rb

@@ -0,0 +1,115 @@
+module Conversio
+
+class HTMLTableOfContent
+  
+  attr_accessor :numbering, :table_of_content_div_class
+  
+  def initialize(html_input)
+    @numbering = true
+    @table_of_content_div_class = 'toc'
+    # Variables
+    @html_input = Array.new
+    @heading_elements = Array.new
+    html_input.split("\n").each { |l| @html_input << l }
+    scan_for_heading_elements()
+    numbers()
+  end
+
+  def get_html_with_anchors()
+    inject_anchors()
+    return @html_input.join("\n")
+  end
+
+  def get_html_table_of_content()
+    output = String.new
+    @heading_elements.each do |heading|  
+      index, level, content, anchor, number = heading
+      level = level.to_i
+      next if level > 3 # only h1,h2, and h3 tags are used
+      space = '&nbsp;&nbsp;'
+      case level
+      when 2 then output << space
+      when 3 then output << space << space
+      end
+      content = "#{number}&nbsp;#{content}" if numbering?
+      output << %{<a href="##{anchor}">#{content}</a><br/>\n}
+    end
+    return %{<div class="#{@table_of_content_div_class}">\n#{output}</div>\n}
+  end
+
+  def get_html()
+    return get_html_table_of_content() << "\n" << get_html_with_anchors
+  end
+
+  protected
+  
+  def numbering?
+    return @numbering
+  end
+
+  def scan_for_heading_elements()
+    @html_input.each_index do |index|
+      if @html_input[index] =~ %r{<h(\d)(.*?)>(.*?)</h\1>$}m then
+        # Pattern match values:
+        #  $1 -- header tag level, e.g. <h2>...</h2> will be 2
+        #  $3 -- content between the tags
+        @heading_elements << [index, $1, $3, anchor($3)]
+      end
+    end
+  end
+
+  # Transforms the input string into a valid XHTML anchor (ID attribute).
+  # 
+  #   anchor("Text with spaces")                   # textwithspaces
+  #   anchor("step 1 step 2 step: 3")              # step1step2step3
+  def anchor(string)
+    alnum = String.new
+    string.gsub(/[[:alnum:]]/) { |c| alnum << c }
+    return alnum.downcase
+  end
+
+  def numbers()
+    chapters = 0
+    sections = 0
+    subsections = 0
+    @heading_elements.each_index do |index|
+      level = @heading_elements[index][1].to_i
+      case level
+      when 1
+        chapters = chapters.next
+        @heading_elements[index] << "#{chapters}"
+        sections = 0
+        subsections = 0
+      when 2
+        sections = sections.next
+        @heading_elements[index] << "#{chapters}.#{sections}"
+        subsections = 0
+      when 3
+        subsections = subsections.next
+        @heading_elements[index] << "#{chapters}.#{sections}.#{subsections}"
+      end
+    end
+  end
+
+  def inject_anchors()
+    @heading_elements.each do |heading|
+      line = String.new
+      index = heading[0]
+      level = heading[1].to_i
+      content = heading[2]
+      anchor = heading[3]
+      next if level > 3 # only h1,h2, and h3 tags are used 
+      if numbering? then 
+        number = heading[4] 
+        line = %{<h#{level}><a name="#{anchor}"></a>#{number}&nbsp;#{content}</h#{level}>}
+      else
+        line = %{<h#{level}><a name="#{anchor}"></a>#{content}</h#{level}>}
+      end
+      @html_input[index] = line
+    end
+  end
+
+end
+
+end
+

data/lib/conversio/pygmentizer.rb

@@ -0,0 +1,82 @@
+module Conversio
+
+
+class Pygmentizer
+
+  def self.respond_to?( command )
+   return true if `which #{command}`.empty?
+   return false
+ end
+  
+  def self.run(command, input='')
+   puts command if $DEBUG
+   IO.popen(command, 'r+') do |io|
+     io.puts input
+     io.close_write
+     return io.read
+   end
+  end
+
+
+
+  def output(string)
+    @output << "#{string}\n"
+  end
+
+  def transform_code_blocks(text)
+    raise RuntimeError, "pygmentize not in path" if 
+    Pygmentizer::respond_to?("pygmentize")
+    @input_by_line = Array.new 
+    text.each_line { |line| @input_by_line << line.chop }
+    @output = String.new
+    buffer = Array.new
+    rec = false
+    @input_by_line.each do |line|
+      # true if a Markdown code block is found
+      rec = true if !rec and line =~ /^    /
+      # store the code block into buffer
+      if rec and line =~ /^    / then
+        # remove the leading 4 spaces
+        line = line.gsub(/^    /,'')
+        buffer << line
+      # End of code block
+      elsif rec 
+        block_to_html(buffer)
+        # Wipe the buffer
+        buffer.clear
+        rec = false
+      # Anyting beside code blocks will be output
+      else 
+        output(line)
+      end
+    end
+    return @output
+  end
+  
+
+  def block_to_html(block)
+    style = get_style(block[0])
+    unless style.empty? then
+      # remove the style information from the code block
+      block.slice!(0)
+      output(highlight(block.join("\n"),style))
+    else
+      # Code blocks without style information will be
+      # put to output includeing the 4 leading spaces
+      block.each {|line| output("    #{line}") }
+      output("")
+    end
+  end
+
+
+  def get_style(string)
+    return string.gsub(/--/,'').strip if string =~ /^--[a-z]* */
+    return ""
+  end
+  
+  def highlight(string, style)
+    return Pygmentizer::run("pygmentize -f html -l #{style}", string) << "\n"
+  end
+end
+
+end

data/lib/conversio.rb

@@ -0,0 +1,19 @@
+require 'conversio/converter'
+require 'conversio/pygmentizer'
+require 'conversio/htmltoc'
+
+module Conversio
+  class Template
+  end
+end
+
+# find the template directory
+templates = File.join(File.dirname(File.expand_path(__FILE__)),'..','templates')
+# find the ERB templates 
+Dir.glob("#{templates}/*.erb") do |template|
+  # add the template as constant to the class Templates
+  Conversio::Template.const_set(
+    File.basename(template,".erb").upcase, 
+    File.read(template))
+end
+