html-renderer 0.0.4 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef89dd4c00345deca8c54a7ac62823dd8a506a0f941186cdd6d82ebd51ae7d47
-  data.tar.gz: 4a2fd1e8b670ff87fd63b7e94a7e50af7bd66e73f94bb48b197b9f8374b8d196
+  metadata.gz: 663966745c8218ad48bbe7d05b18a2c3b28e744de5f29e1749206e636957c2e6
+  data.tar.gz: fde2480e07086d500cf4cd47fe15b3f5093d704bac2a0eca6fee2e1a47ddb77b
 SHA512:
-  metadata.gz: b0dd0122febdc3018b1d2d1f38cd6fc19c23e2495989b6b8ccca1f5e7cf096d159a38aa85fdb600f48767d75827ce6f025282a9b0a206e74aa93c60e5c02bedc
-  data.tar.gz: 8164fb8d54a3f2895bb288d32eb9e03716ff8bd3a40b68382385c499cae363c1d0ff685f77abeac96a83c0b313edfd9c9c3b013173d878ac46b155b28b84466c
+  metadata.gz: f260e527a4ea41de4c6d2a9bbef83054925c53a5d9243824fbb94f452a44ebd4a65df7df488299f38c36244a64e44654f3c64b8b2718f2461bcc45e5e3fa446e
+  data.tar.gz: e70eea4c85614825128afebd9d1cf77d9ac39d9676cc45103ee3e2bae0054f4ed261009848cda2c930a1296569225b21c2af8766fa609999c4ccd92ed2676061

data/.gemspec

@@ -13,10 +13,9 @@ Gem::Specification.new do |s|
   s.authors     = ["epitron"]
 
   s.files            = `git ls`.lines.map(&:strip)
-  s.executables      = ['html2ansi']
   s.extra_rdoc_files = ["README.md", "LICENSE"]
-  
-  s.add_dependency "oga", "~> 2"
+
+  s.add_dependency "oga", ">= 2.0"
   s.add_dependency "terminal-table", "~> 1.8"
-  # s.add_development "ansi", "~> 1"
+  s.add_dependency "term-ansicolor", "~> 1.7"
 end

data/.gitignore

@@ -0,0 +1 @@
+/pkg/

data/README.md

@@ -2,11 +2,29 @@
 
 ## Overview
 
-Allows you to subclass `HTMLRenderer::Base`, add some methods, and then parse HTML to generate custom output.
+An extensible HTML renderer.
 
-(Uses a similar API to the [RedCarpet](https://github.com/vmg/redcarpet) gem.)
+Comes with two built-in renderers:
+* `HTMLRenderer::ANSI` (outputs colored text to the termnial)
+* `HTMLRenderer::Text` (outputs plain text)
 
-## Examples
+## Usage
 
-* [HTML to Plain Text Renderer](https://github.com/epitron/html-renderer/blob/master/examples/plain_text_renderer.rb)
-* [HTML to ANSI Renderer](https://github.com/epitron/html-renderer/blob/master/examples/ansi_renderer.rb)
+Render to ANSI:
+```
+ansi_text = HTMLRenderer::ANSI.render("<b>hello html</b>")
+ansi_text = HTMLRenderer::ANSI.render(open("file.html"))
+```
+
+Render to plain text:
+```
+plain_text = HTMLRenderer::Text.render(open("file.html"))
+```
+
+## Extending it
+
+The API design uses the same philosophy as [RedCarpet](https://github.com/vmg/redcarpet).
+
+To create a new renderer, subclass `HTMLRenderer::Base`, then add a method to handle each type of element. Whatever the method returns is output by the renderer.
+
+Example renderer: [HTMLRenderer::ANSI](https://github.com/epitron/html-renderer/blob/master/lib/html-renderer/ansi.rb)

data/Rakefile

@@ -1,14 +1,13 @@
-pkgname = "html-renderer"
-gem_version = File.read("VERSION").strip
+gem = eval(File.read '.gemspec')
 
-gemfile = "#{pkgname}-#{gem_version}.gem"
+gemfile = "#{gem.name}-#{gem.version}.gem"
 
 task :build do
   system "gem build .gemspec"
   system "mkdir pkg/" unless File.directory? "pkg"
   system "mv #{gemfile} pkg/"
 end
- 
+
 task :release => :build do
   system "gem push pkg/#{gemfile}"
 end
@@ -18,3 +17,9 @@ task :gem => :build
 task :install => :build do
   system "gem install pkg/#{gemfile}"
 end
+
+task :test do
+  Dir.chdir "test"
+  $: << "../lib"
+  load "test.rb"
+end

data/TODO.md

@@ -0,0 +1,14 @@
+# TODO list
+
+## Base class
+
+! add HTMLRenderer.reflow_paragraph
+* #render takes options (and passes them to subclasses)
+* :debug option (hide parse errors unless 'true')
+
+## ANSI renderer
+
+* use HTMLRenderer.reflow_paragraph
+* :wrap option (with optional terminal width)
+* Better table renderer (with line-drawing)
+* Follow `<table>` style attributes when drawing tables (eg: borders)

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.1.4

data/{examples/ansi_renderer.rb → lib/html-renderer/ansi.rb}

@@ -1,16 +1,24 @@
 require 'html-renderer'
 require 'ansi/mixin'
 require 'terminal-table'
-require 'coderay'
 
-class String
-  include ANSI::Mixin
+###########################################################################
 
-  def grey; self.black.bold; end
+module ANSI::Mixin
+  def grey; ANSI::Code.bold { ANSI::Code.black { to_s } }; end
 end
 
+module HTMLRenderer::ANSIStrings
+  refine String do
+    include ANSI::Mixin
+  end
+end
+
+###########################################################################
+
+class HTMLRenderer::ANSI < HTMLRenderer::Base
 
-class ANSIRenderer < HTMLRenderer::Base
+  using HTMLRenderer::ANSIStrings
 
 private
 
@@ -32,6 +40,9 @@ private
     s&.downcase&.scan(/\w+/)&.join
   end
 
+  def subscript(s)
+    "[#{s}]"
+  end
 
 public
 
@@ -78,13 +89,7 @@ public
   end
 
   def block_code(code, language)
-    language ||= :ruby
-
-    language = language[1..-1] if language[0] == "."  # strip leading "."
-    language = :cpp if language == "C++"
-
-    require 'coderay'
-    "#{indent CodeRay.scan(code, language).term, 4}\n"
+    code.bold.cyan + "\n"
   end
 
   def block_quote(text)
@@ -174,7 +179,8 @@ public
 
 end
 
+###########################################################################
 
 if __FILE__ == $0
-  puts ANSIRenderer.render(open(ARGV.first || "test.html"))
+  puts HTMLRenderer::ANSI.render(open(ARGV.first || "test.html"))
 end

data/lib/html-renderer/base.rb

@@ -1,30 +1,25 @@
 ######################################################################################
 require 'oga'
 ######################################################################################
-#
-# TODOs:
-# - Streaming output (yield every paragraph/div/header)
-# - Embed into 'c' tool (for rendering raw HTML blocks)
-#
-######################################################################################
-
-class String
 
-  def tighten
-    gsub(/\s+/, ' ').strip
-  end
+module HTMLRenderer
 
-  def blank?; !!self[/[^\s]/]; end
+  module STDLIBRefinements
+    refine String do
+      def tighten
+        gsub(/\s+/, ' ').strip
+      end
 
-end
+      def blank?; !!self[/[^\s]/]; end
+    end
 
-class NilClass
-  def blank?; true; end
-end
+    refine NilClass do
+      def blank?; true; end
+    end
+  end
 
-######################################################################################
+  using STDLIBRefinements
 
-module HTMLRenderer
 
   class State
     attr_accessor :list_order
@@ -65,14 +60,16 @@ private
           content.blank? ? normal_text(content) : nil
 
         when Oga::XML::Element
-          case node.name
+          case node.name.downcase
           when "a"
             url     = node["href"]
             title   = node["title"]
             name    = node["name"]
             content = render_children(node, state)
 
-            if name and not url
+            if title.blank? and url.blank? and name.blank?
+              content
+            elsif name and not url
               anchor(name, title, content)
             else
               link(url, title, content)
@@ -151,23 +148,25 @@ private
             table(header, rows)
 
           when "html", "body", "nav", "span", "form", "label", "input", "button", "section", "fieldset",
-               "menu", "article", "header", "time", "aside", "footer", "nobr", "wbr",
+               "pre", "menu", "article", "header", "time", "aside", "footer", "nobr", "wbr",
                "table", "tr", "td", "th", "tt", "thead", "tbody", "noscript", "select",
                "address", "center", "small"
             render_children(node, state)
 
           when "head", "script", "link", "style"
-            # skip it
-
+            #
+            # don't render anything
+            #
           else
             # raise "Unrecognized HTML tag: #{node.name} -> #{node.inspect}"
-            $stderr.puts "Unrecognized HTML tag: #{node.name} -> #{node.inspect}"
+            $stderr.puts "Unrecognized HTML tag: #{node.name} -> #{node.inspect}" if $VERBOSE
             render_children(node, state)
           end
 
-        when Oga::XML::Comment
-          # skip it
-
+        when Oga::XML::Comment, Oga::XML::Cdata, Oga::XML::ProcessingInstruction
+          #
+          # i'm not sure why you'd care about these, but here's a place to, if you do
+          #
         else
           raise "Unhandled Oga node type: #{node.class}"
         end

data/lib/html-renderer/debug.rb

@@ -0,0 +1,9 @@
+require 'html-renderer'
+
+class HTMLRenderer::DebugRenderer < HTMLRenderer::Base
+
+  def method_missing(meth, *args)
+    "#{meth}(#{args})"
+  end
+
+end

data/lib/html-renderer/html_parser.rb

@@ -102,4 +102,4 @@ html = File.read(file)
 r = HTMLParser.new(html)
 r.each_tag{|t| p t}
 
-# puts r.as_tree
+# puts r.as_tree

data/{examples/plain_text_renderer.rb → lib/html-renderer/text.rb}

@@ -1,9 +1,10 @@
 require 'html-renderer'
 
 #
-# Everything-stripping renderer.
+# Strips out everything but the plain text.
 #
-class PlainTextRenderer < HTMLRenderer::Base
+class HTMLRenderer::Text < HTMLRenderer::Base
+
   # Methods where the first argument is the text content
   [
     # block-level calls
@@ -65,8 +66,3 @@ class PlainTextRenderer < HTMLRenderer::Base
     content + "\t"
   end
 end
-
-
-if __FILE__ == $0
-  puts PlainTextRenderer.render(open("test.html"))
-end

data/lib/html-renderer.rb

@@ -1 +1,6 @@
 require 'html-renderer/base'
+
+module HTMLRenderer
+  autoload :ANSI, 'html-renderer/ansi'
+  autoload :Text, 'html-renderer/text'
+end

data/test/test.rb

@@ -0,0 +1,15 @@
+require 'html-renderer'
+require 'html-renderer/debug'
+
+[
+  HTMLRenderer::ANSI,
+  HTMLRenderer::Text,
+  HTMLRenderer::DebugRenderer,
+].each do |renderer|
+  puts
+  puts "=== #{renderer} =============================="
+  puts
+  puts renderer.render(open("test.html"))
+  puts
+  puts
+end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: html-renderer
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.4
 platform: ruby
 authors:
 - epitron
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-11-05 00:00:00.000000000 Z
+date: 2021-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oga
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: terminal-table
   requirement: !ruby/object:Gem::Requirement
@@ -38,35 +38,50 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: term-ansicolor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
 description: Easily implement an HTML renderer by creating a subclass and adding some
   methods, similar to RedCarpet. (Examples are included for rendering HTML to ANSI
   and plain text.)
 email: chris@ill-logic.com
-executables:
-- html2ansi
+executables: []
 extensions: []
 extra_rdoc_files:
 - README.md
 - LICENSE
 files:
 - ".gemspec"
+- ".gitignore"
 - LICENSE
 - README.md
 - Rakefile
+- TODO.md
 - VERSION
-- bin/html2ansi
-- examples/ansi_renderer.rb
-- examples/debug_renderer.rb
-- examples/plain_text_renderer.rb
-- examples/test.html
 - lib/html-renderer.rb
+- lib/html-renderer/ansi.rb
 - lib/html-renderer/base.rb
+- lib/html-renderer/debug.rb
 - lib/html-renderer/html_parser.rb
+- lib/html-renderer/text.rb
+- test/test.html
+- test/test.rb
 homepage: http://github.com/epitron/html-renderer/
 licenses:
 - WTFPL
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -81,9 +96,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
-signing_key: 
+rubygems_version: 3.2.21
+signing_key:
 specification_version: 4
 summary: HTML Renderer
 test_files: []

data/bin/html2ansi

@@ -1,248 +0,0 @@
-#!/usr/bin/env ruby
-#######################################################################################
-require 'html-renderer'
-require 'terminal-table'
-require 'term/ansicolor'
-require 'coderay'
-#######################################################################################
-
-class String
-  # include ANSI::Mixin
-  include Term::ANSIColor
-
-  def grey; self.black.bold; end
-end
-
-#######################################################################################
-
-def lesspipe(*args)
-  if args.any? and args.last.is_a?(Hash)
-    options = args.pop
-  else
-    options = {}
-  end
-
-  output = args.first if args.any?
-
-  params = []
-  params << "-R" unless options[:color] == false
-  params << "-S" unless options[:wrap] == true
-  params << "-F" unless options[:always] == true
-  if options[:tail] == true
-    params << "+\\>"
-    $stderr.puts "Seeking to end of stream..."
-  end
-  params << "-X"
-
-  IO.popen("less #{params * ' '}", "w") do |less|
-    if output
-      less.puts output
-    else
-      yield less
-    end
-  end
-rescue Errno::EPIPE, Interrupt
-  # less just quit -- eat the exception.
-end
-
-#######################################################################################
-
-class ANSIRenderer < HTMLRenderer::Base
-
-private
-
-  def indented?(text)
-    indent_sizes = text.lines.map{ |line| if line =~ /^(\s+)/ then $1 else '' end }.map(&:size)
-    indent_sizes.all? {|dent| dent > 0 }
-  end
-
-  def unwrap(text)
-    return text unless indented? text
-    text.lines.to_a.map(&:strip).join ' '
-  end
-
-  def indent(text,amount=2)
-    text.lines.map{|line| " "*amount + line }.join
-  end
-
-  def smash(s)
-    s&.downcase&.scan(/\w+/)&.join
-  end
-
-  def subscript(s)
-    "[#{s}]"
-  end
-
-public
-
-  def normal_text(text)
-    text
-  end
-
-  def underline(content)
-    content.magenta.bold
-  end
-
-  def superscript(content)
-    "^(#{content})"
-  end
-
-  def link(link, title, content)
-    unless content&.[] /^Back /
-      str = ""
-      # str += "<15>#{content}</15>" if content
-      str += content.white.bold if content
-      if smash(link) != smash(content)
-        # str += " <8>(</8><11>#{link}</11><8>)</8>"
-        str += " #{"(".grey}#{link&.cyan&.bold}#{")".grey}"
-      end
-
-      str
-    end
-  end
-
-  def anchor(name, title=nil, content=nil)
-    result = "Anchor: ##{name}"
-    result << " (#{title})" if title
-    result << "\n"
-    result << "#{content}\n" if content
-    result
-  end
-
-  def image(link, title, content)
-    link(link, nil, title)
-  end
-
-  def italic(text)
-    text.yellow.bold
-  end
-
-  def block_code(code, language)
-    language ||= :ruby
-
-    language = language[1..-1] if language[0] == "."  # strip leading "."
-    language = :cpp if language == "C++"
-
-    require 'coderay'
-    "#{indent CodeRay.scan(code, language).term, 4}\n"
-  end
-
-  def block_quote(text)
-    indent paragraph(text)
-  end
-
-  def codespan(code)
-    code.cyan
-  end
-
-  def header(title, level, anchor=nil)
-    bar = ("-"*(title.size+4)).grey
-
-    title = case level
-      when 1 then title.bold.yellow
-      when 2 then title.bold.cyan
-      when 3 then title.bold.blue
-      else title.magenta
-    end
-
-    "#{bar}\n  #{title}\n#{bar}\n\n"
-  end
-
-  def double_emphasis(text)
-    text.bold.green
-  end
-
-  def emphasis(text)
-    text.green
-  end
-
-  def linebreak
-    "\n"
-  end
-
-  def paragraph(text)
-    div(text) + "\n"
-  end
-
-  def div(text)
-    "#{indented?(text) ? text : unwrap(text)}\n"
-  end
-
-  def list(content, list_type)
-    case list_type
-    when :ordered
-      @counter = 0
-      "#{content}\n"
-    when :unordered
-      "#{content}\n"
-    end
-  end
-
-  def list_item(content, list_type)
-    case list_type
-    when :ordered
-      @counter ||= 0
-      @counter += 1
-      # "  <8>#{@counter}.</8> #{content.strip}\n".colorize
-      "  #{@counter.to_s.grey}. #{content.strip}\n"
-    when :unordered
-      # "  <8>*</8> #{content.strip}\n".colorize
-      "  #{"*".grey} #{content.strip}\n"
-    end
-  end
-
-  def definition_list(defs)
-    defs.each do |dt, dd|
-      puts "<15>#{dt}<7>:".colorize
-      puts "  #{dd}"
-      puts
-    end
-  end
-
-  def table(header, rows)
-    if header
-      table = Terminal::Table.new(headings: header, rows: rows)
-    else
-      table = Terminal::Table.new(rows: rows)
-    end
-    "#{table}\n\n"
-  end
-
-  def separator
-    "_____________________________\n\n"
-  end
-
-end
-
-#######################################################################################
-
-def render(stream, paged=false)
-  output = ANSIRenderer.render(stream)
-  if paged
-    lesspipe { |less| less.puts output }
-  else
-    puts output
-  end
-end
-
-#######################################################################################
-
-opts, args = ARGV.partition { |arg| arg[/^--?\w/] }
-
-if opts.include?("-h") or opts.include?("--help")
-  puts "usage:"
-  puts "  html2ansi [options] <file.html>"
-  puts "    or"
-  puts "  curl http://host/path.html | html2ansi [options]"
-  puts
-  puts "options:"
-  puts "    -p    Paged (redirect output to less)"
-  puts
-else
-  paged = opts.include?("-p") or opts.include?("--paged")
-  if args.empty?
-    render($stdin, paged)
-  else
-    args.each { |arg| render(open(arg), paged) }
-  end
-end

data/examples/debug_renderer.rb

@@ -1,14 +0,0 @@
-require 'html-renderer'
-
-class DebugRenderer < HTMLRenderer::Base
- 
-  def method_missing(meth, *args)
-    "#{meth}(#{args})"
-  end
-
-end
-
-
-if __FILE__ == $0
-  puts DebugRenderer.render(open("test.html"))
-end