ronn-ng 0.7.4

data/lib/ronn/index.rb

@@ -0,0 +1,183 @@
+require 'ronn'
+
+module Ronn
+
+  # Maintains a list of links / references to manuals and other resources.
+  class Index
+    include Enumerable
+
+    attr_reader :path
+    attr_reader :references
+
+    # Retrieve an Index for <path>, where <path> is a directory or normal
+    # file. The index is loaded from the corresponding index.txt file if
+    # one exists.
+    def self.[](path)
+      (@indexes ||= {})[index_path_for_file(path)] ||=
+        Index.new(index_path_for_file(path))
+    end
+
+    def self.index_path_for_file(file)
+      File.expand_path(
+        if File.directory?(file)
+          File.join(file, 'index.txt')
+        else
+          File.join(File.dirname(file), 'index.txt')
+        end
+      )
+    end
+
+    def initialize(path, &bk)
+      @path = path
+      @references = []
+      @manuals    = {}
+
+      if block_given?
+        read! yield
+      elsif exist?
+        read! File.read(path)
+      end
+    end
+
+    # Determine whether the index file exists.
+    def exist?
+      File.exist?(path)
+    end
+
+    # Load index data from a string.
+    def read!(data)
+      data.each_line do |line|
+        line = line.strip.gsub(/\s*#.*$/, '')
+        if !line.empty?
+          name, url = line.split(/\s+/, 2)
+          @references << reference(name, url)
+        end
+      end
+    end
+
+    ##
+    # Enumerable and friends
+
+    def each(&bk)
+      references.each(&bk)
+    end
+
+    def size
+      references.size
+    end
+
+    def first
+      references.first
+    end
+
+    def last
+      references.last
+    end
+
+    def empty?
+      references.empty?
+    end
+
+    def [](name)
+      references.find { |ref| ref.name == name }
+    end
+
+    def reference(name, path)
+      Reference.new(self, name, path)
+    end
+
+    def <<(path)
+      raise ArgumentError, "local paths only" if path =~ /(https?|mailto):/
+      return self if any? { |ref| ref.path == File.expand_path(path) }
+      relative_path = relative_to_index(path)
+      @references << \
+        if path =~ /\.ronn?$/
+          reference manual(path).reference_name, relative_path
+        else
+          reference File.basename(path), relative_path
+        end
+      self
+    end
+
+    def add_manual(manual)
+      @manuals[File.expand_path(manual.path)] = manual
+      self << manual.path
+    end
+
+    def manual(path)
+      @manuals[File.expand_path(path)] ||= Document.new(path)
+    end
+
+    def manuals
+      select { |ref| ref.relative? && ref.ronn? }.
+      map    { |ref| manual(ref.path) }
+    end
+
+    ##
+    # Converting
+
+    def to_text
+      map { |ref| [ref.name, ref.location].join(' ') }.join("\n")
+    end
+
+    def to_a
+      references
+    end
+
+    def to_h
+      to_a.map { |doc| doc.to_hash }
+    end
+
+    def relative_to_index(path)
+      path = File.expand_path(path)
+      index_dir = File.dirname(File.expand_path(self.path))
+      path.sub(/^#{index_dir}\//, '')
+    end
+  end
+
+  # An individual index reference. A reference can point to one of a few types
+  # of locations:
+  #
+  #   - URLs: "http://man.cx/crontab(5)"
+  #   - Relative paths to ronn manuals: "crontab.5.ronn"
+  #
+  # The #url method should be used to obtain the href value for HTML.
+  class Reference
+    attr_reader :name
+    attr_reader :location
+
+    def initialize(index, name, location)
+      @index = index
+      @name = name
+      @location = location
+    end
+
+    def manual?
+      name =~ /\([0-9]\w*\)$/
+    end
+
+    def ronn?
+      location =~ /\.ronn?$/
+    end
+
+    def remote?
+      location =~ /^(?:https?|mailto):/
+    end
+
+    def relative?
+      !remote?
+    end
+
+    def url
+      if remote?
+        location
+      else
+        location.chomp('.ronn') + '.html'
+      end
+    end
+
+    def path
+      File.expand_path(location, File.dirname(@index.path)) if relative?
+    end
+  end
+end

data/lib/ronn/roff.rb

@@ -0,0 +1,302 @@
+require 'hpricot'
+require 'ronn/utils'
+
+module Ronn
+  class RoffFilter
+    include Ronn::Utils
+
+    # Convert Ronn HTML to roff.
+    def initialize(html, name, section, tagline, manual=nil, version=nil, date=nil)
+      @buf = []
+      title_heading name, section, tagline, manual, version, date
+      doc = Hpricot(html)
+      remove_extraneous_elements! doc
+      normalize_whitespace! doc
+      block_filter doc
+      write "\n"
+    end
+
+    def to_s
+      @buf.join.gsub(/[ \t]+$/, '')
+    end
+
+  protected
+    def previous(node)
+      if node.respond_to?(:previous)
+        prev = node.previous
+        prev = prev.previous until prev.nil? || prev.elem?
+        prev
+      end
+    end
+
+    def title_heading(name, section, tagline, manual, version, date)
+      comment "generated with Ronn-NG/v#{Ronn.version}"
+      comment "http://github.com/apjanke/ronn-ng/tree/#{Ronn.revision}"
+      return if name.nil?
+      macro "TH", %["#{escape(name.upcase)}" "#{section}" "#{date.strftime('%B %Y')}" "#{version}" "#{manual}"]
+    end
+
+    def remove_extraneous_elements!(doc)
+      doc.traverse_all_element do |node|
+        if node.comment? || node.procins? || node.doctype? || node.xmldecl?
+          node.parent.children.delete(node)
+        end
+      end
+    end
+
+    def normalize_whitespace!(node)
+      case
+      when node.kind_of?(Array) || node.kind_of?(Hpricot::Elements)
+        node.to_a.dup.each { |ch| normalize_whitespace! ch }
+      when node.text?
+        preceding, following = node.previous, node.next
+        content = node.content.gsub(/[\n ]+/m, ' ')
+        if preceding.nil? || block_element?(preceding.name) ||
+           preceding.name == 'br'
+          content.lstrip!
+        end
+        if following.nil? || block_element?(following.name) ||
+           following.name == 'br'
+          content.rstrip!
+        end
+        if content.empty?
+          node.parent.children.delete(node)
+        else
+          node.content = content
+        end
+      when node.elem? && node.name == 'pre'
+        # stop traversing
+      when node.elem? && node.children
+        normalize_whitespace! node.children
+      when node.elem?
+        # element has no children
+      when node.doc?
+        normalize_whitespace! node.children
+      else
+        warn "unexpected node during whitespace normalization: %p", node
+      end
+    end
+
+    def block_filter(node)
+      if node.kind_of?(Array) || node.kind_of?(Hpricot::Elements)
+        node.each { |ch| block_filter(ch) }
+
+      elsif node.doc?
+        block_filter(node.children)
+
+      elsif node.text?
+        warn "unexpected text: %p",  node
+
+      elsif node.elem?
+        case node.name
+        when 'div'
+          block_filter(node.children)
+        when 'h1'
+          # discard
+        when 'h2'
+          macro "SH", quote(escape(node.html))
+        when 'h3'
+          macro "SS", quote(escape(node.html))
+
+        when 'p'
+          prev = previous(node)
+          if prev && %w[dd li blockquote].include?(node.parent.name)
+            macro "IP"
+          elsif prev && !%w[h1 h2 h3].include?(prev.name)
+            macro "P"
+          end
+          inline_filter(node.children)
+
+        when 'blockquote'
+          prev = previous(node)
+          indent = prev.nil? || !%w[h1 h2 h3].include?(prev.name)
+          macro "IP", %w["" 4] if indent
+          block_filter(node.children)
+          macro "IP", %w["" 0] if indent
+
+        when 'pre'
+          prev = previous(node)
+          indent = prev.nil? || !%w[h1 h2 h3].include?(prev.name)
+          macro "IP", %w["" 4] if indent
+          macro "nf"
+          write "\n"
+          inline_filter(node.children)
+          macro "fi"
+          macro "IP", %w["" 0] if indent
+
+        when 'dl'
+          macro "TP"
+          block_filter(node.children)
+        when 'dt'
+          prev = previous(node)
+          macro "TP" unless prev.nil?
+          inline_filter(node.children)
+          write "\n"
+        when 'dd'
+          if node.at('p')
+            block_filter(node.children)
+          else
+            inline_filter(node.children)
+          end
+          write "\n"
+
+        when 'ol', 'ul'
+          block_filter(node.children)
+          macro "IP", %w["" 0]
+        when 'li'
+          case node.parent.name
+          when 'ol'
+            macro "IP", %W["#{node.position + 1}." 4]
+          when 'ul'
+            macro "IP", %w["\\\[ci\]" 4]
+          end
+          if node.at('p|ol|ul|dl|div')
+            block_filter(node.children)
+          else
+            inline_filter(node.children)
+          end
+          write "\n"
+
+        when 'span', 'code', 'b', 'strong', 'kbd', 'samp', 'var', 'em', 'i',
+             'u', 'br', 'a'
+          inline_filter(node)
+        else
+          warn "unrecognized block tag: %p", node.name
+        end
+
+      else
+        fail "unexpected node: #{node.inspect}"
+      end
+    end
+
+    def inline_filter(node)
+      return unless node # is an empty node
+
+      if node.kind_of?(Array) || node.kind_of?(Hpricot::Elements)
+        node.each { |ch| inline_filter(ch) }
+
+      elsif node.text?
+        text = node.to_html.dup
+        write escape(text)
+
+      elsif node.elem?
+        case node.name
+        when 'span'
+          inline_filter(node.children)
+        when 'code'
+          if child_of?(node, 'pre')
+            inline_filter(node.children)
+          else
+            write '\fB'
+            inline_filter(node.children)
+            write '\fR'
+          end
+
+        when 'b', 'strong', 'kbd', 'samp'
+          write '\fB'
+          inline_filter(node.children)
+          write '\fR'
+
+        when 'var', 'em', 'i', 'u'
+          write '\fI'
+          inline_filter(node.children)
+          write '\fR'
+
+        when 'br'
+          macro 'br'
+
+        when 'a'
+          if node.classes.include?('man-ref')
+            inline_filter(node.children)
+          elsif node.has_attribute?('data-bare-link')
+            write '\fI'
+            inline_filter(node.children)
+            write '\fR'
+          else
+            inline_filter(node.children)
+            write ' '
+            write '\fI'
+            write escape(node.attributes['href'])
+            write '\fR'
+          end
+
+        when 'sup'
+          # This superscript equivalent is a big ugly hack.
+          write '^('
+          inline_filter(node.children)
+          write ')'
+
+        else
+          warn "unrecognized inline tag: %p", node.name
+        end
+
+      else
+        fail "unexpected node: #{node.inspect}"
+      end
+    end
+
+    def macro(name, value=nil)
+      writeln ".\n.#{[name, value].compact.join(' ')}"
+    end
+
+    HTML_ROFF_ENTITIES = {
+      '•'  => '\[ci]',
+      '&lt;'    => '<',
+      '&gt;'    => '>',
+      '&nbsp;'  => '\~',
+      '&copy;'  => '\(co',
+      '&rdquo;' => '\(rs',
+      '&mdash;' => '\(em',
+      '&reg;'   => '\(rg',
+      '&sec;'   => '\(sc',
+      '&ge;'    => '\(>=',
+      '&le;'    => '\(<=',
+      '&ne;'    => '\(!=',
+      '&equiv;' => '\(=='
+    }
+
+    def escape(text)
+      return text.to_s if text.nil? || text.empty?
+      ent = HTML_ROFF_ENTITIES
+      text = text.dup
+      text.gsub!(/&#x([0-9A-Fa-f]+);/) { $1.to_i(16).chr }  # hex entities
+      text.gsub!(/&#(\d+);/) { $1.to_i.chr }                # dec entities
+      text.gsub!('\\', '\e')                                # backslash
+      text.gsub!('...', '\|.\|.\|.')                        # ellipses
+      text.gsub!(/['.-]/) { |m| "\\#{m}" }                  # control chars
+      text.gsub!(/(&[A-Za-z]+;)/) { ent[$1] || $1 }         # named entities
+      text.gsub!('&amp;',  '&')                             # amps
+      text
+    end
+
+    def quote(text)
+      "\"#{text.gsub(/"/, '\\"')}\""
+    end
+
+    # write text to output buffer
+    def write(text)
+      return if text.nil? || text.empty?
+      # lines cannot start with a '.'. insert zero-width character before.
+      if text[0,2] == '\.' &&
+        (@buf.last && @buf.last[-1] == ?\n)
+        @buf << '\&'
+      end
+      @buf << text
+    end
+
+    # write text to output buffer on a new line.
+    def writeln(text)
+      write "\n" if @buf.last && @buf.last[-1] != ?\n
+      write text
+      write "\n"
+    end
+
+    def comment(text)
+      writeln %[.\\" #{text}]
+    end
+
+    def warn(text, *args)
+      $stderr.puts "warn: #{text}" % args
+    end
+  end
+end