ron 0.3 → 0.4

data/bin/ron

@@ -1,130 +0,0 @@
-#!/usr/bin/env ruby
-## Usage: ron [ OPTIONS ] [ FILE ]
-##        ron --build FILE ...
-##        ron --install FILE ...
-##        ron --man FILE ...
-## Convert ron FILE to roff man page or HTML and write to standard
-## output. With no FILE, ron reads from standard input. The build,
-## install, and man forms accept multiple FILE arguments.
-##
-## Modes:
-##       --pipe                write to standard output (default behavior)
-##   -b, --build               write to files instead of standard output
-##   -i, --install             write to file in MAN_HOME or system man path
-##   -m, --man                 open man page like man(1)
-##
-## Formats:
-##   -r, --roff                generate roff/man text; this is the default behavior
-##   -5, --html                generate entire HTML page with layout
-##   -f, --fragment            generate HTML fragment instead of entire HTML page
-##
-## Document attributes:
-##       --date=DATE           published date in YYYY-MM-DD format;
-##                             displayed bottom-center in footer
-##       --manual=NAME         name of the manual this document belongs to;
-##                             displayed top-center in header
-##       --organization=NAME   publishing group, organization, or individual;
-##                             displayed bottom-left in footer
-##
-##       --help                show this help message
-##
-require 'date'
-require 'optparse'
-
-formats = []
-options = {}
-build = false
-install = false
-man = false
-groff = "groff -Wall -mtty-char -mandoc -Tascii"
-pager = ENV['MANPAGER'] || ENV['PAGER'] || 'more'
-
-def info(message, *args)
-  STDERR.puts message % args
-end
-
-def usage
-  puts File.read(__FILE__).
-    grep(/^##.*/).
-    map { |line| line.chomp[3..-1] }.
-    join("\n")
-end
-
-# parse command line options
-ARGV.options do |option|
-  # modes
-  option.on("--pipe") { }
-  option.on("-b", "--build") { build = true }
-  option.on("-i", "--install") { install = true }
-  option.on("-m", "--man") { man = true }
-
-  # format options
-  option.on("-r", "--roff") { formats << 'roff' }
-  option.on("-5", "--html") { formats << 'html' }
-  option.on("-f", "--fragment") { formats << 'html_fragment' }
-
-  # manual attribute options
-  [:name, :section, :manual, :organization, :date].each do |option_attr|
-    option.on("--#{option_attr}=VALUE") { |val| options[option_attr] = val }
-  end
-
-  option.on_tail("--help") { usage ; exit }
-  option.parse!
-end
-
-if ARGV.empty? && STDIN.tty?
-  usage
-  exit
-elsif ARGV.empty?
-  ARGV.push '-'
-end
-
-# turn the --date arg into a real date object
-options[:date] &&= Date.strptime(options[:date], '%Y-%m-%d')
-
-formats = ['roff'] if formats.empty?
-formats.delete('html') if formats.include?('html_fragment')
-pid = nil
-
-begin
-  require 'ron'
-rescue LoadError
-  $:.unshift File.dirname(__FILE__) + "../lib"
-  require 'ron'
-end
-
-wr = STDOUT
-ARGV.each do |file|
-  doc = Ron.new(file, options) { file == '-' ? STDIN.read : File.read(file) }
-
-  # setup the man pipeline if the --man option was specified
-  if man && !build
-    rd, wr = IO.pipe
-    if pid = fork
-      rd.close
-    else
-      wr.close
-      STDIN.reopen rd
-      exec "#{groff} | #{pager}"
-    end
-  end
-
-  # write output for each format
-  formats.each do |format|
-    if build
-      path = doc.path_for(format)
-      info "building: #{path}" if build
-      output = doc.convert(format)
-      File.open(path, 'wb') { |f| f.puts(output) }
-      system "man #{path}" if man && format == 'roff'
-    else
-      output = doc.convert(format)
-      wr.puts(output)
-    end
-  end
-
-  if pid
-    wr.close
-    Process.wait
-  end
-end

data/lib/ron.rb

@@ -1,16 +0,0 @@
-# Ron is a humane text format and toolchain for authoring manpages (and
-# things that appear as manpages from a distance). Use it to build /
-# install standard UNIX roff(7) formatted manpages or to generate
-# beautiful HTML manpages.
-module Ron
-  VERSION = '0.3'
-
-  require 'ron/document'
-  require 'ron/roff'
-
-  # Create a new Ron::Document for the given ron file. See
-  # Ron::Document.new for usage information.
-  def self.new(filename, attributes={}, &block)
-    Document.new(filename, attributes, &block)
-  end
-end

data/lib/ron/document.rb

@@ -1,289 +0,0 @@
-require 'set'
-require 'nokogiri'
-require 'rdiscount'
-require 'ron/roff'
-
-module Ron
-  # The Document class can be used to load and inspect a ron document
-  # and to convert a ron document into other formats, like roff or
-  # HTML.
-  #
-  # Ron files may optionally follow the naming convention:
-  # "<name>.<section>.ron". The <name> and <section> are used in
-  # generated documentation unless overridden by the information
-  # extracted from the document's name section.
-  class Document
-    attr_reader :path, :data
-
-    # The man pages name: usually a single word name of
-    # a program or filename; displayed along with the section in
-    # the left and right portions of the header as well as the bottom
-    # right section of the footer.
-    attr_accessor :name
-
-    # The man page's section: a string whose first character
-    # is numeric; displayed in parenthesis along with the name.
-    attr_accessor :section
-
-    # Single sentence description of the thing being described
-    # by this man page; displayed in the NAME section.
-    attr_accessor :tagline
-
-    # The manual this document belongs to; center displayed in
-    # the header.
-    attr_accessor :manual
-
-    # The name of the group, organization, or individual responsible
-    # for this document; displayed in the left portion of the footer.
-    attr_accessor :organization
-
-    # The date the document was published; center displayed in
-    # the document footer.
-    attr_accessor :date
-
-    # Create a Ron::Document given a path or with the data returned by
-    # calling the block. The document is loaded and preprocessed before
-    # the intialize method returns. The attributes hash may contain values
-    # for any writeable attributes defined on this class.
-    def initialize(path=nil, attributes={}, &block)
-      @path = path
-      @basename = path.to_s =~ /^-?$/ ? nil : File.basename(path)
-      @reader = block || Proc.new { |f| File.read(f) }
-      @data = @reader.call(path)
-      @name, @section, @tagline = nil
-      @manual, @organization, @date = nil
-      @fragment = preprocess
-      attributes.each { |attr_name,value| send("#{attr_name}=", value) }
-    end
-
-    # Generate a file basename of the form "<name>.<section>.<type>"
-    # for the given file extension. Uses the name and section from
-    # the source file path but falls back on the name and section
-    # defined in the document.
-    def basename(type=nil)
-      type = nil if ['', 'roff'].include?(type.to_s)
-      [path_name || @name, path_section || @section, type].
-      compact.join('.')
-    end
-
-    # Construct a path for a file near the source file. Uses the
-    # Document#basename method to generate the basename part and
-    # appends it to the dirname of the source document.
-    def path_for(type=nil)
-      if @basename
-        File.join(File.dirname(path), basename(type))
-      else
-        basename(type)
-      end
-    end
-
-    # Returns the <name> part of the path, or nil when no path is
-    # available. This is used as the manual page name when the
-    # file contents do not include a name section.
-    def path_name
-      @basename[/^[^.]+/] if @basename
-    end
-
-    # Returns the <section> part of the path, or nil when
-    # no path is available.
-    def path_section
-      $1 if @basename.to_s =~ /\.(\d\w*)\./
-    end
-
-    # Returns the manual page name based first on the document's
-    # contents and then on the path name.
-    def name
-      @name || path_name
-    end
-
-    # Truthful when the name was extracted from the name section
-    # of the document.
-    def name?
-      !name.nil?
-    end
-
-    # Returns the manual page section based first on the document's
-    # contents and then on the path name.
-    def section
-      @section || path_section
-    end
-
-    # True when the section number was extracted from the name
-    # section of the document.
-    def section?
-      !section.nil?
-    end
-
-    # The date the man page was published. If not set explicitly,
-    # this is the file's modified time or, if no file is given,
-    # the current time.
-    def date
-      return @date if @date
-      return File.mtime(path) if File.exist?(path)
-      Time.now
-    end
-
-    # Convert the document to :roff, :html, or :html_fragment and
-    # return the result as a string.
-    def convert(format)
-      send "to_#{format}"
-    end
-
-    # Convert the document to roff and return the result as a string.
-    def to_roff
-      RoffFilter.new(
-        to_html_fragment,
-        name,
-        section,
-        tagline,
-        manual,
-        organization,
-        date
-      ).to_s
-    end
-
-    # Convert the document to HTML and return the result as a string.
-    def to_html
-      layout_filter(to_html_fragment)
-    end
-
-    # Convert the document to HTML and return the result
-    # as a string. The HTML does not include <html>, <head>,
-    # or <style> tags.
-    def to_html_fragment
-      buf = []
-      if name? && section?
-        buf << "<h2 id='NAME'>NAME</h2>"
-        buf << "<p><code>#{name}</code> -- #{tagline}</p>"
-      elsif tagline
-        buf << "<h1>#{[name, tagline].compact.join(' -- ')}</h1>"
-      end
-      buf << @fragment.to_s
-      buf.join("\n")
-    end
-
-  protected
-    # Parse the document and extract the name, section, and tagline
-    # from its contents. This is called while the object is being
-    # initialized.
-    def preprocess
-      [
-        :angle_quote_pre_filter,
-        :markdown_filter,
-        :angle_quote_post_filter,
-        :definition_list_filter
-      ].inject(data) { |res,filter| send(filter, res) }
-    end
-
-    # Apply the standard HTML layout template.
-    def layout_filter(html)
-      template_file = File.dirname(__FILE__) + "/layout.html"
-      template = File.read(template_file)
-      eval("%Q{#{template}}", binding, template_file)
-    end
-
-    # Convert special format unordered lists to definition lists.
-    def definition_list_filter(html)
-      doc = parse_html(html)
-      # process all unordered lists depth-first
-      doc.search('ul').to_a.reverse.each do |ul|
-        items = ul.search('li')
-        next if items.any? { |item| item.text.split("\n", 2).first !~ /:$/ }
-
-        ul.name = 'dl'
-        items.each do |item|
-          if item.child.name == 'p'
-            wrap = '<p></p>'
-            container = item.child
-          else
-            wrap = '<dd></dd>'
-            container = item
-          end
-          term, definition = container.inner_html.split(":\n", 2)
-
-          dt = item.before("<dt>#{term}</dt>").previous_sibling
-          dt['class'] = 'flush' if dt.content.length <= 7
-
-          item.name = 'dd'
-          container.swap(wrap.sub(/></, ">#{definition}<"))
-        end
-      end
-      doc
-    end
-
-    # Perform angle quote (<THESE>) post filtering.
-    def angle_quote_post_filter(html)
-      doc = parse_html(html)
-      # convert all angle quote vars nested in code blocks
-      # back to the original text
-      doc.search('code text()').each do |node|
-        next unless node.to_s.include?('var&gt;')
-        new = node.document.create_text_node(
-          node.to_s.
-            gsub('&lt;var&gt;', '<').
-            gsub("&lt;/var&gt;", '>')
-        )
-        node.replace(new)
-      end
-      doc
-    end
-
-    # Run markdown on the data and extract name, section, and
-    # tagline.
-    def markdown_filter(data)
-      html = Markdown.new(data).to_html
-      @tagline, html = html.split("</h1>\n", 2)
-      if html.nil?
-        html = @tagline
-        @tagline = nil
-      else
-        # grab name and section from title
-        @tagline.sub!('<h1>', '')
-        if @tagline =~ /([\w_.\[\]~+=@:-]+)\s*\((\d\w*)\)\s*--?\s*(.*)/
-          @name = $1
-          @section = $2
-          @tagline = $3
-        elsif @tagline =~ /([\w_.\[\]~+=@:-]+)\s+--\s+(.*)/
-          @name = $1
-          @tagline = $2
-        end
-      end
-
-      html.to_s
-    end
-
-    # Convert all <WORD> to <var>WORD</var> but only if WORD
-    # isn't an HTML tag.
-    def angle_quote_pre_filter(data)
-      data.gsub(/\<([^:.\/]+?)\>/) do |match|
-        contents = $1
-        tag, attrs = contents.split(' ', 2)
-        if attrs =~ /\/=/ ||
-           HTML.include?(tag.sub(/^\//, '')) ||
-           data.include?("</#{tag}>")
-          match.to_s
-        else
-          "<var>#{contents}</var>"
-        end
-      end
-    end
-
-    HTML = %w[
-      a abbr acronym b bdo big br cite code dfn
-      em i img input kbd label q samp select
-      small span strong sub sup textarea tt var
-      address blockquote div dl fieldset form
-      h1 h2 h3 h4 h5 h6 hr noscript ol p pre
-      table ul
-    ].to_set
-
-  private
-    def parse_html(html)
-      if html.kind_of?(Nokogiri::HTML::DocumentFragment)
-        html
-      else
-        Nokogiri::HTML.fragment(html.to_s)
-      end
-    end
-  end
-end

data/lib/ron/layout.html

@@ -1,75 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <meta http-equiv='content-type' value='text/html;charset=utf8'>
-  <meta name='generator' value='Ron/v#{Ron::VERSION}'>
-  <title>#{name}(#{section})#{tagline ? " -- " + tagline : ''}</title>
-  <style type='text/css'>
-    body {margin:0}
-    #man, #man code, #man pre, #man tt, #man kbd, #man samp {
-      font-family:consolas,monospace;
-      font-size:16px;
-      line-height:1.3;
-      color:#343331;
-      background:#fff; }
-    #man { max-width:89ex; text-align:justify; margin:0 25px 25px 25px }
-    #man h1, #man h2, #man h3 { color:#232221;clear:left }
-    #man h1 { font-size:28px; margin:15px 0 30px 0; text-align:center }
-    #man h2 { font-size:18px; margin-bottom:0; margin-top:10px; line-height:1.3; }
-    #man h3 { font-size:16px; margin:0 0 0 4ex; }
-    #man p, #man ul, #man ol, #man dl, #man pre { margin:0 0 18px 0; }
-    #man pre {
-      color:#333231;
-      background:#edeceb;
-      padding:5px 7px;
-      margin:0px 0 20px 0;
-      border-left:2ex solid #ddd}
-    #man pre + h2, #man pre + h3 {
-      margin-top:22px;
-    }
-    #man h2 + pre, #man h3 + pre {
-      margin-top:5px;
-    }
-    #man > p, #man > ul, #man > ol, #man > dl, #man > pre { margin-left:8ex; }
-    #man dt { margin:0; clear:left }
-    #man dt.flush { float:left; width:8ex }
-    #man dd { margin:0 0 0 9ex }
-    #man code, #man strong, #man b { font-weight:bold; color:#131211; }
-    #man pre code { font-weight:normal; color:#232221; background:inherit }
-    #man em, var, u {
-      font-style:normal; color:#333231; border-bottom:1px solid #999; }
-    #man h1.man-title { display:none; }
-    #man ol.man, #man ol.man li { margin:2px 0 10px 0; padding:0;
-      float:left; width:33%; list-style-type:none;
-      text-transform:uppercase; font-size:18px; color:#999;
-      letter-spacing:1px;}
-    #man ol.man { width:100%; }
-    #man ol.man li.tl { text-align:left }
-    #man ol.man li.tc { text-align:center;letter-spacing:4px }
-    #man ol.man li.tr { text-align:right }
-    #man ol.man a { color:#999 }
-    #man ol.man a:hover { color:#333231 }
-  </style>
-</head>
-<body>
-<div id='man'>
-
-<h1 class='man-title'>#{name}(#{section})</h1>
-
-<ol class='head man'>
-  <li class='tl'>#{name if section}#{"("+section+")" if name and section}</li>
-  <li class='tc'>#{manual}</li>
-  <li class='tr'>#{name if section}#{"("+section+")" if name and section}</li>
-</ol>
-
-#{html}
-
-<ol class='foot man'>
-  <li class='tl'>#{organization}</li>
-  <li class='tc'>#{date.strftime('%B %Y')}</li>
-  <li class='tr'>#{name if section}#{"("+section+")" if name and section}</li>
-</ol>
-
-</div>
-</body>
-</html>