asciidoctor 0.0.1 → 0.0.2

data/lib/asciidoctor/list_item.rb

@@ -9,6 +9,9 @@ class Asciidoctor::ListItem
   # Public: Get/Set the String list item anchor name.
   attr_accessor :anchor
 
+  # Public: Get/Set the Integer list level (for nesting list elements).
+  attr_accessor :level
+
   # Public: Initialize an Asciidoctor::ListItem object.
   #
   # content - the String content (default '')
@@ -16,4 +19,31 @@ class Asciidoctor::ListItem
     @content = content
     @blocks  = []
   end
+
+  def render
+    output = "<li><p>#{content} (HTMLIFY) "
+    output += blocks.map{|block| block.render}.join
+    output += "</p></li>"
+  end
+
+  def splain(parent_level = 0)
+    parent_level += 1
+    Asciidoctor.puts_indented(parent_level, "List Item anchor: #{anchor}") unless self.anchor.nil?
+    Asciidoctor.puts_indented(parent_level, "Content: #{content}") unless self.content.nil?
+
+    Asciidoctor.puts_indented(parent_level, "Blocks: #{@blocks.count}")
+
+    if @blocks.any?
+      Asciidoctor.puts_indented(parent_level, "Blocks content (#{@blocks.count}):")
+      @blocks.each_with_index do |block, i|
+        Asciidoctor.puts_indented(parent_level, "v" * (60 - parent_level*2))
+        Asciidoctor.puts_indented(parent_level, "Block ##{i} is a #{block.class}")
+        Asciidoctor.puts_indented(parent_level, "Name is #{block.name rescue 'n/a'}")
+        Asciidoctor.puts_indented(parent_level, "=" * 40)
+        block.splain(parent_level) if block.respond_to? :splain
+        Asciidoctor.puts_indented(parent_level, "^" * (60 - parent_level*2))
+      end
+    end
+    nil
+  end
 end

data/lib/asciidoctor/reader.rb

@@ -0,0 +1,236 @@
+# Public: Methods for retrieving lines from Asciidoc documents
+class Asciidoctor::Reader
+
+  include Asciidoctor
+
+  # Public: Get the String document source.
+  attr_reader :source
+
+  # Public: Get the Hash of defines
+  attr_reader :defines
+
+  attr_reader :references
+
+  # Public: Convert a string to a legal attribute name.
+  #
+  # name  - The String holding the Asciidoc attribute name.
+  #
+  # Returns a String with the legal name.
+  #
+  # Examples
+  #
+  #   sanitize_attribute_name('Foo Bar')
+  #   => 'foobar'
+  #
+  #   sanitize_attribute_name('foo')
+  #   => 'foo'
+  #
+  #   sanitize_attribute_name('Foo 3 #-Billy')
+  #   => 'foo3-billy'
+  def sanitize_attribute_name(name)
+    name.gsub(/[^\w\-_]/, '').downcase
+  end
+
+  # Public: Initialize the Reader object.
+  #
+  # data  - The Array of Strings holding the Asciidoc source document.
+  # block - A block that can be used to retrieve external Asciidoc
+  #         data to include in this document.
+  #
+  # Examples
+  #
+  #   data   = File.readlines(filename)
+  #   reader = Asciidoctor::Reader.new(data)
+  def initialize(data = [], &block)
+    raw_source = []
+    @defines = {}
+    @references = {}
+
+    include_regexp = /^include::([^\[]+)\[\]\s*\n?\z/
+
+    data.each do |line|
+      if inc = line.match(include_regexp)
+        if block_given?
+          raw_source << yield(inc[1])
+        else
+          raw_source.concat(File.readlines(inc[1]))
+        end
+      else
+        raw_source << line
+      end
+    end
+
+    ifdef_regexp = /^(ifdef|ifndef)::([^\[]+)\[\]/
+    endif_regexp = /^endif::/
+    defattr_regexp = /^:([^:!]+):\s*(.*)\s*$/
+    delete_attr_regexp = /^:([^:]+)!:\s*$/
+    conditional_regexp = /^\s*\{([^\?]+)\?\s*([^\}]+)\s*\}/
+
+    skip_to = nil
+    continuing_value = nil
+    continuing_key = nil
+    @lines = []
+    raw_source.each do |line|
+      if skip_to
+        skip_to = nil if line.match(skip_to)
+      elsif continuing_value
+        close_continue = false
+        # Lines that start with whitespace and end with a '+' are
+        # a continuation, so gobble them up into `value`
+        if match = line.match(/\s+(.+)\s+\+\s*$/)
+          continuing_value += match[1]
+        elsif match = line.match(/\s+(.+)/)
+          # If this continued line doesn't end with a +, then this
+          # is the end of the continuation, no matter what the next
+          # line does.
+          continuing_value += match[1]
+          close_continue = true
+        else
+          # If this line doesn't start with whitespace, then it's
+          # not a valid continuation line, so push it back for processing
+          close_continue = true
+          raw_source.unshift(line)
+        end
+        if close_continue
+          @defines[continuing_key] = continuing_value
+          continuing_key = nil
+          continuing_value = nil
+        end
+      elsif match = line.match(ifdef_regexp)
+        attr = match[2]
+        skip = case match[1]
+               when 'ifdef';  !@defines.has_key?(attr)
+               when 'ifndef'; @defines.has_key?(attr)
+               end
+        skip_to = /^endif::#{attr}\[\]\s*\n/ if skip
+      elsif match = line.match(defattr_regexp)
+        key = sanitize_attribute_name(match[1])
+        value = match[2]
+        if match = value.match(Asciidoctor::REGEXP[:attr_continue])
+          # attribute value continuation line; grab lines until we run out
+          # of continuation lines
+          continuing_key = key
+          continuing_value = match[1]  # strip off the spaces and +
+          Asciidoctor.debug "continuing key: #{continuing_key} with partial value: '#{continuing_value}'"
+        else
+          @defines[key] = value
+          Asciidoctor.debug "Defines[#{key}] is '#{value}'"
+        end
+      elsif match = line.match(delete_attr_regexp)
+        key = sanitize_attribute_name(match[1])
+        @defines.delete(key)
+      elsif !line.match(endif_regexp)
+        while match = line.match(conditional_regexp)
+          value = @defines.has_key?(match[1]) ? match[2] : ''
+          line.sub!(conditional_regexp, value)
+        end
+        @lines << line unless line.match(REGEXP[:comment])
+      end
+    end
+
+    # Process bibliography references, so they're available when text
+    # before the reference is being rendered.
+    @lines.each do |line|
+      if biblio = line.match(REGEXP[:biblio])
+        @references[biblio[1]] = "[#{biblio[1]}]"
+      end
+    end
+
+    Asciidoctor.debug "About to leave Reader#init, and references is #{@references.inspect}"
+    @source = @lines.join
+    Asciidoctor.debug "Leaving Reader#init, and I have #{@lines.count} lines"
+    Asciidoctor.debug "Also, has_lines? is #{self.has_lines?}"
+  end
+
+  # Public: Check whether there are any lines left to read.
+  #
+  # Returns true if @lines.any? is true, or false otherwise.
+  def has_lines?
+    @lines.any?
+  end
+
+  # Private: Strip off leading blank lines in the Array of lines.
+  #
+  # Returns nil.
+  #
+  # Examples
+  #
+  #   @lines
+  #   => ["\n", "\t\n", "Foo\n", "Bar\n", "\n"]
+  #
+  #   skip_blank
+  #   => nil
+  #
+  #   @lines
+  #   => ["Foo\n", "Bar\n"]
+  def skip_blank
+    while @lines.any? && @lines.first.strip.empty?
+      @lines.shift
+    end
+
+    nil
+  end
+
+  # Public: Get the next line of source data. Consumes the line returned.
+  #
+  # Returns the String of the next line of the source data if data is present.
+  # Returns nil if there is no more data.
+  def get_line
+    @lines.shift
+  end
+
+  # Public: Get the next line of source data. Does not consume the line returned.
+  #
+  # Returns a String dup of the next line of the source data if data is present.
+  # Returns nil if there is no more data.
+  def peek_line
+    @lines.first.dup if @lines.first
+  end
+
+  # Public: Push String `line` onto queue of source data lines, unless `line` is nil.
+  #
+  # Returns nil
+  def unshift(line)
+    @lines.unshift(line) if line
+    nil
+  end
+
+  # Public: Return all the lines from `@lines` until we (1) run out them,
+  #   (2) find a blank line with :break_on_blank_lines => true, or (3) find
+  #   a line for which the given block evals to true.
+  #
+  # options - an optional Hash of processing options:
+  #           * :break_on_blank_lines may be used to specify to break on
+  #               blank lines
+  #           * :preserve_last_line may be used to specify that the String
+  #               causing the method to stop processing lines should be
+  #               pushed back onto the `lines` Array.
+  #
+  # Returns the Array of lines forming the next segment.
+  #
+  # Examples
+  #
+  #   reader = Reader.new ["First paragraph\n", "Second paragraph\n",
+  #                        "Open block\n", "\n", "Can have blank lines\n",
+  #                        "--\n", "\n", "In a different segment\n"]
+  #
+  #   reader.grab_lines_until
+  #   => ["First paragraph\n", "Second paragraph\n", "Open block\n"]
+  def grab_lines_until(options = {}, &block)
+    buffer = []
+
+    while (this_line = self.get_line)
+      Asciidoctor.debug "Processing line: '#{this_line}'"
+      finis ||= true if options[:break_on_blank_lines] && this_line.strip.empty?
+      finis ||= true if block && value = yield(this_line)
+      if finis
+        self.unshift(this_line) if options[:preserve_last_line]
+        break
+      end
+
+      buffer << this_line
+    end
+    buffer
+  end
+
+end

data/lib/asciidoctor/render_templates.rb

@@ -164,9 +164,9 @@ class SectionUlistTemplate < BaseTemplate
     @template ||= ERB.new <<-EOF
       <div class='ulist'>
         <ul>
-          <% content.each do |li| %>
-            <li><p><%= li %></p></li>
-          <% end %>
+        <% content.each do |li| %>
+          <%= li %>
+        <% end %>
         </ul>
       </div>
     EOF

data/lib/asciidoctor/renderer.rb

@@ -14,6 +14,26 @@ class Asciidoctor::Renderer
       @views[view] = tc.new
     end
 
+    # If user passed in a template dir, let them override our base templates
+    if template_dir = options.delete(:template_dir)
+      Asciidoctor.debug "Views going in are like so:"
+      @views.each_pair do |k, v|
+        Asciidoctor.debug "#{k}: #{v}"
+      end
+      Asciidoctor.debug "="*60
+      # Grab the files in the top level of the directory (we're not traversing)
+      files = Dir.glob(File.join(template_dir, '*')).select{|f| File.stat(f).file?}
+      files.inject(@views) do |view_hash, view|
+        name = File.basename(view).split('.').first
+        view_hash.merge!(name => Tilt.new(view, nil, :trim => '<>'))
+      end
+      Asciidoctor.debug "Views are now like so:"
+      @views.each_pair do |k, v|
+        Asciidoctor.debug "#{k}: #{v}"
+      end
+      Asciidoctor.debug "="*60
+    end
+
     @render_stack = []
   end
 
@@ -37,8 +57,8 @@ class Asciidoctor::Renderer
       STDERR.puts "Rendering:"
       @render_stack.each do |stack_view, stack_obj|
         obj_info = case stack_obj
-                   when Section; "SECTION #{stack_obj.name}"
-                   when Block;
+                   when Asciidoctor::Section; "SECTION #{stack_obj.name}"
+                   when Asciidoctor::Block;
                      if stack_obj.context == :dlist
                        dt_list = stack_obj.buffer.map{|dt,dd| dt.content.strip}.join(', ')
                        "BLOCK :dlist (#{dt_list})"

data/lib/asciidoctor/version.rb

@@ -1,3 +1,3 @@
 module Asciidoctor
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/attributes_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+
+context "Attributes" do
+  test "creates an attribute" do
+    doc = document_from_string(":frog: Tanglefoot")
+    assert_equal doc.defines['frog'], 'Tanglefoot'
+  end
+
+  test "deletes an attribute" do
+    doc = document_from_string(":frog: Tanglefoot\n:frog!:")
+    assert_equal nil, doc.defines['frog']
+  end
+
+  test "doesn't choke when deleting a non-existing attribute" do
+    doc = document_from_string(":frog!:")
+    assert_equal nil, doc.defines['frog']
+  end
+
+  test "render properly with simple names" do
+    html = render_string(":frog: Tanglefoot\nYo, {frog}!")
+    result = Nokogiri::HTML(html)
+    assert_equal 'Yo, Tanglefoot!', result.css("p").first.content.strip
+  end
+
+  test "convert multi-word names and render" do
+    html = render_string("Main Header\n===========\n:My frog: Tanglefoot\nYo, {myfrog}!")
+    result = Nokogiri::HTML(html)
+    assert_equal 'Yo, Tanglefoot!', result.css("p").first.content.strip
+  end
+
+  test "ignores lines with bad attributes" do
+    html = render_string("This is\nblah blah {foobarbaz}\nall there is.")
+    result = Nokogiri::HTML(html)
+    assert_no_match /blah blah/m, result.css("p").first.content.strip
+  end
+
+  # See above - AsciiDoc says we're supposed to delete lines with bad
+  # attribute refs in them. AsciiDoc is strange.
+  #
+  # test "Unknowns" do
+  #   html = render_string("Look, a {gobbledygook}")
+  #   result = Nokogiri::HTML(html)
+  #   assert_equal("Look, a {gobbledygook}", result.css("p").first.content.strip)
+  # end
+
+  test "substitutes inside unordered list items" do
+    html = render_string(":foo: bar\n* snort at the {foo}\n* yawn")
+    result = Nokogiri::HTML(html)
+    assert_match /snort at the bar/, result.css("li").first.content.strip
+  end
+
+  test "renders attribute until it's deleted" do
+    pending "Not working yet (will require adding element-specific attributes or early attr substitution during parsing)"
+    # html = render_string(":foo: bar\nCrossing the {foo}\n\n:foo!:\nBelly up to the {foo}")
+    # result = Nokogiri::HTML(html)
+    # assert_match /Crossing the bar/, result.css("p").first.content.strip
+    # assert_no_match /Belly up to the bar/, result.css("p").last.content.strip
+  end
+
+  test "doesn't disturb attribute-looking things escaped with backslash" do
+    html = render_string(":foo: bar\nThis is a \\{foo} day.")
+    result = Nokogiri::HTML(html)
+    assert_equal 'This is a {foo} day.', result.css('p').first.content.strip
+  end
+
+  test "doesn't disturb attribute-looking things escaped with literals" do
+    html = render_string(":foo: bar\nThis is a +++{foo}+++ day.")
+    result = Nokogiri::HTML(html)
+    assert_equal 'This is a {foo} day.', result.css('p').first.content.strip
+  end
+
+  test "doesn't substitute attributes inside code blocks" do
+    pending "whut?"
+  end
+
+  test "doesn't substitute attributes inside literal blocks" do
+    pending "whut?"
+  end
+
+  test "Intrinsics" do
+    Asciidoctor::INTRINSICS.each_pair do |key, value|
+      html = render_string("Look, a {#{key}} is here")
+      result = Nokogiri::HTML(html)
+      assert_equal("Look, a #{value} is here", result.css("p").first.content.strip)
+    end
+  end
+
+end

data/test/document_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 class DocumentTest < Test::Unit::TestCase
   # setup for test
   def setup
-    @doc = Asciidoctor::Document.new(File.readlines(sample_doc_path(:asciidoc_index)))
+    @doc = example_document(:asciidoc_index)
   end
 
   def test_title
@@ -11,13 +11,7 @@ class DocumentTest < Test::Unit::TestCase
   end
 
   def test_with_no_title
-    d = Asciidoctor::Document.new("Snorf")
+    d = Asciidoctor::Document.new(["Snorf"])
     assert_nil d.title
   end
-
-  def test_is_section_heading
-    assert @doc.send(:is_section_heading?, "AsciiDoc Home Page", "==================")
-    assert @doc.send(:is_section_heading?, "=== AsciiDoc Home Page")
-  end
-
 end