ronn-ng 0.7.4 → 0.8.0.SNAPSHOT

data/lib/ronn/roff.rb

@@ -1,15 +1,18 @@
-require 'hpricot'
+require 'nokogiri'
 require 'ronn/utils'
 
 module Ronn
+  # Filter for converting HTML to ROFF
   class RoffFilter
     include Ronn::Utils
 
     # Convert Ronn HTML to roff.
-    def initialize(html, name, section, tagline, manual=nil, version=nil, date=nil)
+    # The html input is an HTML fragment, not a complete document
+    def initialize(html_fragment, name, section, tagline, manual = nil,
+                   version = nil, date = nil)
       @buf = []
       title_heading name, section, tagline, manual, version, date
-      doc = Hpricot(html)
+      doc = Nokogiri::HTML.fragment(html_fragment)
       remove_extraneous_elements! doc
       normalize_whitespace! doc
       block_filter doc
@@ -20,36 +23,34 @@ module Ronn
       @buf.join.gsub(/[ \t]+$/, '')
     end
 
-  protected
+    protected
+
     def previous(node)
-      if node.respond_to?(:previous)
-        prev = node.previous
-        prev = prev.previous until prev.nil? || prev.elem?
-        prev
-      end
+      return unless node.respond_to?(:previous)
+      prev = node.previous
+      prev = prev.previous until prev.nil? || prev.elem?
+      prev
     end
 
-    def title_heading(name, section, tagline, manual, version, date)
+    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}"]
+      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
+      doc.traverse do |node|
+        node.parent.children.delete(node) if node.comment?
       end
     end
 
     def normalize_whitespace!(node)
-      case
-      when node.kind_of?(Array) || node.kind_of?(Hpricot::Elements)
+      if node.is_a?(Array) || node.is_a?(Nokogiri::XML::NodeSet)
         node.to_a.dup.each { |ch| normalize_whitespace! ch }
-      when node.text?
-        preceding, following = node.previous, node.next
+      elsif node.text?
+        preceding = node.previous
+        following = node.next
         content = node.content.gsub(/[\n ]+/m, ' ')
         if preceding.nil? || block_element?(preceding.name) ||
            preceding.name == 'br'
@@ -60,76 +61,91 @@ module Ronn
           content.rstrip!
         end
         if content.empty?
-          node.parent.children.delete(node)
+          node.remove
         else
           node.content = content
         end
-      when node.elem? && node.name == 'pre'
+      elsif node.elem? && node.name == 'pre'
         # stop traversing
-      when node.elem? && node.children
+      elsif node.elem? && node.children
         normalize_whitespace! node.children
-      when node.elem?
+      elsif node.elem?
         # element has no children
-      when node.doc?
+      elsif node.document? || node.fragment?
         normalize_whitespace! node.children
+      elsif node.is_a?(Nokogiri::XML::DTD) || node.is_a?(Nokogiri::XML::Comment)
+        # ignore
+        nop
       else
-        warn "unexpected node during whitespace normalization: %p", node
+        warn 'unexpected node during whitespace normalization: %p', node
       end
     end
 
     def block_filter(node)
-      if node.kind_of?(Array) || node.kind_of?(Hpricot::Elements)
+      return if node.nil?
+
+      if node.is_a?(Array) || node.is_a?(Nokogiri::XML::NodeSet)
         node.each { |ch| block_filter(ch) }
 
-      elsif node.doc?
+      elsif node.document? || node.fragment?
         block_filter(node.children)
 
       elsif node.text?
-        warn "unexpected text: %p",  node
+        # This hack is necessary to support mixed-child-type dd's
+        inline_filter(node)
 
       elsif node.elem?
         case node.name
+        when 'html', 'body'
+          block_filter(node.children)
         when 'div'
           block_filter(node.children)
         when 'h1'
           # discard
+          nop
         when 'h2'
-          macro "SH", quote(escape(node.html))
+          macro 'SH', quote(escape(node.inner_html))
         when 'h3'
-          macro "SS", quote(escape(node.html))
+          macro 'SS', quote(escape(node.inner_html))
 
         when 'p'
           prev = previous(node)
           if prev && %w[dd li blockquote].include?(node.parent.name)
-            macro "IP"
+            macro 'IP'
           elsif prev && !%w[h1 h2 h3].include?(prev.name)
-            macro "P"
+            macro 'P'
+          elsif node.previous&.text?
+            macro 'IP'
           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
+          macro 'IP', %w["" 4] if indent
           block_filter(node.children)
-          macro "IP", %w["" 0] if indent
+          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"
+          macro 'IP', %w["" 4] if indent
+          macro 'nf'
+          # HACK: strip an initial \n to avoid extra spacing
+          if node.children && node.children[0].text?
+            text = node.children[0].to_s
+            node.children[0].replace(text[1..-1]) if text.start_with? "\n"
+          end
           inline_filter(node.children)
-          macro "fi"
-          macro "IP", %w["" 0] if indent
+          macro 'fi'
+          macro 'IP', %w["" 0] if indent
 
         when 'dl'
-          macro "TP"
+          macro 'TP'
           block_filter(node.children)
         when 'dt'
           prev = previous(node)
-          macro "TP" unless prev.nil?
+          macro 'TP' unless prev.nil?
           inline_filter(node.children)
           write "\n"
         when 'dd'
@@ -142,15 +158,17 @@ module Ronn
 
         when 'ol', 'ul'
           block_filter(node.children)
-          macro "IP", %w["" 0]
+          macro 'IP', %w["" 0]
         when 'li'
           case node.parent.name
           when 'ol'
-            macro "IP", %W["#{node.position + 1}." 4]
+            macro 'IP', %W["#{node.position + 1}." 4]
           when 'ul'
-            macro "IP", %w["\\\[ci\]" 4]
+            macro 'IP', ['"\\[ci]"', '4']
+          else
+            raise "List element found as a child of non-list parent element: #{node.inspect}"
           end
-          if node.at('p|ol|ul|dl|div')
+          if node.at('p,ol,ul,dl,div')
             block_filter(node.children)
           else
             inline_filter(node.children)
@@ -160,19 +178,68 @@ module Ronn
         when 'span', 'code', 'b', 'strong', 'kbd', 'samp', 'var', 'em', 'i',
              'u', 'br', 'a'
           inline_filter(node)
+
+        when 'table'
+          macro 'TS'
+          write "allbox;\n"
+          block_filter(node.children)
+          macro 'TE'
+        when 'thead'
+          # Convert to format section and first row
+          tr = node.children[0]
+          header_contents = []
+          cell_formats = []
+          tr.children.each do |th|
+            style = th['style']
+            cell_format = case style
+                          when 'text-align:left;'
+                            'l'
+                          when 'text-align:right;'
+                            'r'
+                          when 'text-align:center;'
+                            'c'
+                          else
+                            'l'
+                          end
+            header_contents << th.inner_html
+            cell_formats << cell_format
+          end
+          write cell_formats.join(' ') + ".\n"
+          write header_contents.join("\t") + "\n"
+        when 'th'
+          raise 'internal error: unexpected <th> element'
+        when 'tbody'
+          # Let the 'tr' handle it
+          block_filter(node.children)
+        when 'tr'
+          # Convert to a table data row
+          node.children.each do |child|
+            block_filter(child)
+            write "\t"
+          end
+          write "\n"
+        when 'td'
+          inline_filter(node.children)
+
         else
-          warn "unrecognized block tag: %p", node.name
+          warn 'unrecognized block tag: %p', node.name
         end
 
+      elsif node.is_a?(Nokogiri::XML::DTD)
+        # Ignore
+        nop
+      elsif node.is_a?(Nokogiri::XML::Comment)
+        # Ignore
+        nop
       else
-        fail "unexpected node: #{node.inspect}"
+        raise "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)
+      if node.is_a?(Array) || node.is_a?(Nokogiri::XML::NodeSet)
         node.each { |ch| inline_filter(ch) }
 
       elsif node.text?
@@ -216,7 +283,7 @@ module Ronn
             inline_filter(node.children)
             write ' '
             write '\fI'
-            write escape(node.attributes['href'])
+            write escape(node.attributes['href'].content)
             write '\fR'
           end
 
@@ -227,33 +294,38 @@ module Ronn
           write ')'
 
         else
-          warn "unrecognized inline tag: %p", node.name
+          warn 'unrecognized inline tag: %p', node.name
         end
 
       else
-        fail "unexpected node: #{node.inspect}"
+        raise "unexpected node: #{node.inspect}"
       end
     end
 
-    def macro(name, value=nil)
-      writeln ".\n.#{[name, value].compact.join(' ')}"
+    def maybe_new_line
+      write "\n" if @buf.last && @buf.last[-1] != "\n"
+    end
+
+    def macro(name, value = nil)
+      maybe_new_line
+      writeln ".#{[name, value].compact.join(' ')}"
     end
 
     HTML_ROFF_ENTITIES = {
-      '&bull;'  => '\[ci]',
-      '&lt;'    => '<',
-      '&gt;'    => '>',
-      '&nbsp;'  => '\~',
-      '&copy;'  => '\(co',
-      '&rdquo;' => '\(rs',
-      '&mdash;' => '\(em',
-      '&reg;'   => '\(rg',
-      '&sec;'   => '\(sc',
-      '&ge;'    => '\(>=',
-      '&le;'    => '\(<=',
-      '&ne;'    => '\(!=',
-      '&equiv;' => '\(=='
-    }
+      '•' => '\[ci]',
+      '&lt;' => '<',
+      '&gt;' => '>',
+      ' ' => '\~', # That's a literal non-breaking space character there
+      '©' => '\(co',
+      '”' => '\(rs',
+      '—' => '\(em',
+      '®' => '\(rg',
+      '§' => '\(sc',
+      '≥' => '\(>=',
+      '≤' => '\(<=',
+      '≠' => '\(!=',
+      '≡' => '\(=='
+    }.freeze
 
     def escape(text)
       return text.to_s if text.nil? || text.empty?
@@ -264,8 +336,10 @@ module Ronn
       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
+      ent.each do |key, val|
+        text.gsub!(key, val)
+      end
+      text.gsub!('&amp;', '&')                              # amps
       text
     end
 
@@ -277,26 +351,29 @@ module Ronn
     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
+      text = text.gsub(/\n\\\./s, "\n\\\\&\\.")
+      buf_ends_in_newline = @buf.last && @buf.last[-1] == "\n"
+      @buf << '\&' if text[0, 2] == '\.' && buf_ends_in_newline
       @buf << text
     end
 
     # write text to output buffer on a new line.
     def writeln(text)
-      write "\n" if @buf.last && @buf.last[-1] != ?\n
+      maybe_new_line
       write text
       write "\n"
     end
 
     def comment(text)
-      writeln %[.\\" #{text}]
+      writeln %(.\\" #{text})
     end
 
     def warn(text, *args)
-      $stderr.puts "warn: #{text}" % args
+      Kernel.warn format("warn: #{text}", args)
+    end
+
+    def nop
+      # Do nothing
     end
   end
 end

data/lib/ronn/server.rb

@@ -3,21 +3,20 @@ require 'rack'
 require 'sinatra/base'
 
 module Ronn
-
   # Ronn HTTP server. Serves a list of .ronn files as HTML. The options Hash is
   # passed to Ronn::Document.new on each invocation.
   #
   # Use Ronn::Server.new to create a Rack app. See the config.ru file in the
   # root of the Ronn distribution for example usage.
   #
-  # Ronn::Server.run starts a server on port 
+  # Ronn::Server.run starts a server on port 1207.
   module Server
-    def self.new(files, options={})
+    def self.new(files, options = {})
       files = Dir[files] if files.respond_to?(:to_str)
-      raise ArgumentError, "no files" if files.empty?
+      raise ArgumentError, 'no files' if files.empty?
       Sinatra.new do
         set :show_exceptions, true
-        set :public, File.expand_path(__FILE__, '../templates')
+        set :public_dir, File.expand_path(__FILE__, '../templates')
         set :static, false
         set :views, File.expand_path(__FILE__, '../templates')
 
@@ -28,25 +27,22 @@ module Ronn
           end
         end
 
-        def styles
-          params[:styles] ||= params[:style]
-          case
-          when params[:styles].respond_to?(:to_ary)
-            params[:styles]
-          when params[:styles]
-            params[:styles].split(/[, ]+/)
-          else
-            []
-          end
-        end
+        options[:styles] ||= options[:style]
+        my_styles = if options[:styles].respond_to?(:to_ary)
+                      options[:styles]
+                    elsif options[:styles]
+                      options[:styles].split(/[, ]+/)
+                    else
+                      []
+                    end
 
         files.each do |file|
           basename = File.basename(file, '.ronn')
 
           get "/#{basename}.html" do
-            options = options.merge(:styles => styles)
+            options = options.merge(styles: my_styles)
             %w[date manual organization].each do |attribute|
-              next if !params[attribute]
+              next unless params[attribute]
               options[attribute] = params[attribute]
             end
             Ronn::Document.new(file, options).to_html
@@ -59,11 +55,12 @@ module Ronn
       end
     end
 
-    def self.run(files, options={})
+    def self.run(files, options = {})
+      port_number = options['port'] || 1207
       new(files, options).run!(
-        :server  => %w[mongrel thin webrick],
-        :port    => 1207,
-        :logging => true
+        server:  %w[mongrel thin webrick],
+        port:    port_number,
+        logging: true
       )
     end
   end

data/lib/ronn/template.rb

@@ -1,17 +1,18 @@
 require 'mustache'
 
 module Ronn
+  # A Mustache Template for HTML formatting.
   class Template < Mustache
     self.template_path = File.dirname(__FILE__) + '/template'
     self.template_extension = 'html'
 
-    def initialize(document, style_path=ENV['RONN_STYLE'].to_s.split(':'))
+    def initialize(document, style_path = ENV['RONN_STYLE'].to_s.split(':'))
       @document = document
       @style_path = style_path + [Template.template_path]
     end
 
-    def render(template='default')
-      super template[0,1] == '/' ? File.read(template) : partial(template)
+    def render(template = 'default')
+      super template[0, 1] == '/' ? File.read(template) : partial(template)
     end
 
     ##
@@ -80,8 +81,8 @@ module Ronn
     def section_heads
       @document.section_heads.map do |id, text|
         {
-          :id   => id,
-          :text => text
+          id:   id,
+          text: text
         }
       end
     end
@@ -98,21 +99,21 @@ module Ronn
     def stylesheets
       styles.zip(style_files).map do |name, path|
         base = File.basename(path, '.css')
-        fail "style not found: #{style.inspect}" if path.nil?
+        raise "style not found: #{style.inspect}" if path.nil?
         {
-          :name  => name,
-          :path  => path,
-          :base  => File.basename(path, '.css'),
-          :media => (base =~ /(print|screen)$/) ? $1 : 'all'
+          name:  name,
+          path:  path,
+          base:  File.basename(path, '.css'),
+          media: base =~ /(print|screen)$/ ? $1 : 'all'
         }
       end
     end
 
     # All embedded stylesheets.
     def stylesheet_tags
-      stylesheets.
-        map { |style| inline_stylesheet(style[:path], style[:media]) }.
-        join("\n  ")
+      stylesheets
+        .map { |style| inline_stylesheet(style[:path], style[:media]) }
+        .join("\n  ")
     end
 
     attr_accessor :style_path
@@ -123,27 +124,27 @@ module Ronn
     def style_files
       styles.map do |name|
         next name if name.include?('/')
-        style_path.
-          reject  { |p| p.strip.empty? }.
-          map     { |p| File.join(p, "#{name}.css") }.
-          detect  { |file| File.exist?(file) }
+        style_path
+          .reject     { |p| p.strip.empty? }
+          .map     { |p| File.join(p, "#{name}.css") }
+          .detect  { |file| File.exist?(file) }
       end
     end
 
     # Array of style names for which no file could be found.
     def missing_styles
-      style_files.
-        zip(files).
-        select { |style, file| file.nil? }.
-        map    { |style, file| style }
+      style_files
+        .zip(files)
+        .select { |_style, file| file.nil? }
+        .map    { |style, _file| style }
     end
 
     ##
     # TEMPLATE CSS LOADING
 
-    def inline_stylesheet(path, media='all')
+    def inline_stylesheet(path, media = 'all')
       data = File.read(path)
-      data.gsub!(%r|/\*.+?\*/|m, '')   # comments
+      data.gsub!(%r{/\*.+?\*/}m, '')   # comments
       data.gsub!(/([;{,]) *\n/m, '\1') # end-of-line whitespace
       data.gsub!(/\n{2,}/m, "\n")      # collapse lines
       data.gsub!(/[; ]+\}/, '}')       # superfluous trailing semi-colons
@@ -155,16 +156,16 @@ module Ronn
         "<style type='text/css' media='#{media}'>",
         "/* style: #{File.basename(path, '.css')} */",
         data,
-        "</style>"
+        '</style>'
       ].join("\n  ")
     end
 
-    def remote_stylesheet(name, media='all')
+    def remote_stylesheet(name, media = 'all')
       path = File.expand_path("../template/#{name}.css", __FILE__)
       "<link rel='stylesheet' type='text/css' media='#{media}' href='#{path}'>"
     end
 
-    def stylesheet(path, media='all')
+    def stylesheet(_path, media = 'all')
       inline_stylesheet(name, media)
     end
   end

data/lib/ronn/utils.rb

@@ -2,16 +2,17 @@ require 'set'
 require 'cgi'
 
 module Ronn
+  # Miscellaneous utilities.
   module Utils
-
     # All HTML 4 elements and some that are in common use.
     HTML = %w[
-      a abbr acronym address applet area b base basefont bdo big blockquote body br
-      button caption center cite code col colgroup dd del dfn dir div dl dt em
-      fieldset font form frame frameset h1 h2 h3 h4 h5 h6 head hr html i iframe img
-      input ins isindex kbd label legend li link map menu meta noframes noscript
-      object ol optgroup option p param pre q s samp script select small span strike
-      strong style sub sup table tbody td textarea tfoot th thead title tr tt u ul var
+      a abbr acronym address applet area b base basefont bdo big blockquote body
+      br button caption center cite code col colgroup dd del dfn dir div dl dt
+      em fieldset font form frame frameset h1 h2 h3 h4 h5 h6 head hr html i
+      iframe img input ins isindex kbd label legend li link map menu meta
+      noframes noscript object ol optgroup option p param pre q s samp script
+      select small span strike strong style sub sup table tbody td textarea
+      tfoot th thead title tr tt u ul var
     ].to_set
 
     # Block elements.
@@ -47,6 +48,7 @@ module Ronn
     def child_of?(node, tag)
       while node
         return true if node.name && node.name.downcase == tag
+        return false if node.document?
         node = node.parent
       end
       false

data/lib/ronn.rb

@@ -11,7 +11,7 @@ module Ronn
 
   # Create a new Ronn::Document for the given ronn file. See
   # Ronn::Document.new for usage information.
-  def self.new(filename, attributes={}, &block)
+  def self.new(filename, attributes = {}, &block)
     Document.new(filename, attributes, &block)
   end
 
@@ -26,7 +26,7 @@ module Ronn
   # of the version is incremented by the commit offset, such that version
   # 0.6.6-5-gdacd74b => 0.6.11
   def self.version
-    ver = revision[/^[0-9.-]+/].split(/[.-]/).map { |p| p.to_i }
+    ver = revision[/^[0-9.-]+/].split(/[.-]/).map(&:to_i)
     ver[2] += ver.pop while ver.size > 3
     ver.join('.')
   end
@@ -45,6 +45,8 @@ module Ronn
   end
 
   # value generated by: rake rev
-  REV = '0.7.4'
+  # or edit manually; I'm not sure of how rake rev interacts with git
+  # tags -apjanke
+  REV = '0.8.0.SNAPSHOT'.freeze
   VERSION = version
 end