asciidoctor 0.1.4 → 1.5.0

data/lib/asciidoctor/helpers.rb

@@ -1,47 +1,124 @@
 module Asciidoctor
 module Helpers
-  # Internal: Prior to invoking Kernel#require, issues a warning urging a
-  # manual require if running in a threaded environment.
+  # Internal: Require the specified library using Kernel#require.
+  #
+  # Attempts to load the library specified in the first argument using the
+  # Kernel#require. Rescues the LoadError if the library is not available and
+  # passes a message to Kernel#fail to communicate to the user that processing
+  # is being aborted. If a gem_name is specified, the failure message
+  # communicates that a required gem is not installed.
   #
   # name  - the String name of the library to require.
+  # gem   - a Boolean that indicates whether this library is provided by a RubyGem,
+  #         or the String name of the RubyGem if it differs from the library name
+  #         (default: true)
   #
-  # returns false if the library is detected on the load path or the return
-  # value of delegating to Kernel#require
-  def self.require_library(name, gem_name = nil)
-    if Thread.list.size > 1
-      main_script = "#{name}.rb"
-      main_script_path_segment = "/#{name}.rb"
-      if !$LOADED_FEATURES.detect {|p| p == main_script || p.end_with?(main_script_path_segment) }.nil?
-        return false
-      else
-        warn "WARN: asciidoctor is autoloading '#{name}' in threaded environment. " +
-           "The use of an explicit require '#{name}' statement is recommended."
+  # returns the return value of Kernel#require if the library is available,
+  # otherwise Kernel#fail is called with an appropriate message.
+  def self.require_library name, gem = true
+    require name
+  rescue ::LoadError => e
+    if gem
+      fail %(asciidoctor: FAILED: required gem '#{gem == true ? name : gem}' is not installed. Processing aborted.)
+    else
+      fail %(asciidoctor: FAILED: #{e.message.chomp '.'}. Processing aborted.)
+    end
+  end
+
+  # Public: Normalize the data to prepare for parsing
+  #
+  # Delegates to Helpers#normalize_lines_from_string if data is a String.
+  # Delegates to Helpers#normalize_lines_array if data is a String Array.
+  #
+  # returns a String Array of normalized lines
+  def self.normalize_lines data
+    data.class == ::String ? (normalize_lines_from_string data) : (normalize_lines_array data)
+  end
+
+  # Public: Normalize the array of lines to prepare them for parsing
+  #
+  # Force encodes the data to UTF-8 and removes trailing whitespace from each line.
+  #
+  # If a BOM is present at the beginning of the data, a best attempt
+  # is made to encode from the specified encoding to UTF-8.
+  #
+  # data - a String Array of lines to normalize
+  #
+  # returns a String Array of normalized lines
+  def self.normalize_lines_array data
+    return [] if data.empty?
+ 
+    # NOTE if data encoding is UTF-*, we only need 0..1
+    leading_bytes = (first_line = data[0])[0..2].bytes.to_a
+    if COERCE_ENCODING
+      utf8 = ::Encoding::UTF_8
+      if (leading_2_bytes = leading_bytes[0..1]) == BOM_BYTES_UTF_16LE
+        # Ruby messes up trailing whitespace on UTF-16LE, so take a different route
+        return ((data.join.force_encoding ::Encoding::UTF_16LE)[1..-1].encode utf8).lines.map {|line| line.rstrip }
+      elsif leading_2_bytes == BOM_BYTES_UTF_16BE
+        data[0] = (first_line.force_encoding ::Encoding::UTF_16BE)[1..-1]
+        return data.map {|line| "#{((line.force_encoding ::Encoding::UTF_16BE).encode utf8).rstrip}" }
+      elsif leading_bytes[0..2] == BOM_BYTES_UTF_8
+        data[0] = (first_line.force_encoding utf8)[1..-1]
+      end
+
+      data.map {|line| line.encoding == utf8 ? line.rstrip : (line.force_encoding utf8).rstrip }
+    else
+      # Ruby 1.8 has no built-in re-encoding, so no point in removing the UTF-16 BOMs
+      if leading_bytes == BOM_BYTES_UTF_8
+        data[0] = first_line[3..-1]
       end
+      data.map {|line| line.rstrip }
     end
-    begin
-      require name
-    rescue LoadError => e
-      if gem_name
-        fail "asciidoctor: FAILED: required gem '#{gem_name === true ? name : gem_name}' is not installed. Processing aborted."
+  end
+
+  # Public: Normalize the String and split into lines to prepare them for parsing
+  #
+  # Force encodes the data to UTF-8 and removes trailing whitespace from each line.
+  # Converts the data to a String Array.
+  #
+  # If a BOM is present at the beginning of the data, a best attempt
+  # is made to encode from the specified encoding to UTF-8.
+  #
+  # data - a String of lines to normalize
+  #
+  # returns a String Array of normalized lines
+  def self.normalize_lines_from_string data 
+    return [] if data.nil_or_empty?
+
+    if COERCE_ENCODING
+      utf8 = ::Encoding::UTF_8
+      # NOTE if data encoding is UTF-*, we only need 0..1
+      leading_bytes = data[0..2].bytes.to_a
+      if (leading_2_bytes = leading_bytes[0..1]) == BOM_BYTES_UTF_16LE
+        data = (data.force_encoding ::Encoding::UTF_16LE)[1..-1].encode utf8
+      elsif leading_2_bytes == BOM_BYTES_UTF_16BE
+        data = (data.force_encoding ::Encoding::UTF_16BE)[1..-1].encode utf8
+      elsif leading_bytes[0..2] == BOM_BYTES_UTF_8
+        data = data.encoding == utf8 ? data[1..-1] : (data.force_encoding utf8)[1..-1]
       else
-        fail "asciidoctor: FAILED: #{e.chomp '.'}. Processing aborted."
+        data = data.force_encoding utf8 unless data.encoding == utf8
+      end
+    else
+      # Ruby 1.8 has no built-in re-encoding, so no point in removing the UTF-16 BOMs
+      if data[0..2].bytes.to_a == BOM_BYTES_UTF_8
+        data = data[3..-1]
       end
     end
+    data.each_line.map {|line| line.rstrip }
   end
 
+  # Matches the characters in a URI to encode
+  REGEXP_ENCODE_URI_CHARS = /[^\w\-.!~*';:@=+$,()\[\]]/
+
   # Public: Encode a string for inclusion in a URI
   #
   # str - the string to encode
   #
   # returns an encoded version of the str
   def self.encode_uri(str)
-    str.gsub(REGEXP[:uri_encode_chars]) do
-      match = $&
-      buf = ''
-      match.each_byte do |c|
-        buf << sprintf('%%%02X', c)
-      end
-      buf
+    str.gsub(REGEXP_ENCODE_URI_CHARS) do
+      $&.each_byte.map {|c| sprintf '%%%02X', c}.join
     end
   end
 
@@ -56,32 +133,18 @@ module Helpers
   #
   # Returns the String filename with the file extension removed
   def self.rootname(file_name)
-    ext = File.extname(file_name)
-    if ext.empty?
-      file_name
-    else
-      file_name[0...-ext.length]
-    end
+    # alternatively, this could be written as ::File.basename file_name, ((::File.extname file_name) || '')
+    (ext = ::File.extname(file_name)).empty? ? file_name : file_name[0...-ext.length]
   end
 
   def self.mkdir_p(dir)
-    unless File.directory? dir
-      parent_dir = File.dirname(dir)
-      if !File.directory?(parent_dir = File.dirname(dir)) && parent_dir != '.'
+    unless ::File.directory? dir
+      parent_dir = ::File.dirname(dir)
+      if !::File.directory?(parent_dir = ::File.dirname(dir)) && parent_dir != '.'
         mkdir_p(parent_dir)
       end
-      Dir.mkdir(dir)
-    end
-  end
-
-  # Public: Create a copy of options such that no references are shared
-  # returns A deep clone of the options Hash
-  def self.clone_options(opts)
-    clone = opts.dup
-    if opts.has_key? :attributes
-      clone[:attributes] = opts[:attributes].dup
+      ::Dir.mkdir(dir)
     end
-    clone
   end
 end
 end

data/lib/asciidoctor/inline.rb

@@ -1,9 +1,6 @@
 module Asciidoctor
 # Public: Methods for managing inline elements in AsciiDoc block
 class Inline < AbstractNode
-  # Public: Get/Set the String name of the render template
-  attr_accessor :template_name
-
   # Public: Get the text of this inline element
   attr_reader :text
 
@@ -15,22 +12,32 @@ class Inline < AbstractNode
 
   def initialize(parent, context, text = nil, opts = {})
     super(parent, context)
-    @template_name = "inline_#{context}"
+    @node_name = %(inline_#{context})
 
     @text = text 
 
     @id = opts[:id]
     @type = opts[:type]
     @target = opts[:target]
-    
-    if opts.has_key?(:attributes) && (attributes = opts[:attributes]).is_a?(Hash)
-      update_attributes(opts[:attributes]) unless attributes.empty?
+
+    unless (more_attributes = opts[:attributes]).nil_or_empty?
+      update_attributes more_attributes
     end
   end
 
-  def render
-    renderer.render(@template_name, self).chomp
+  def block?
+    false
   end
 
+  def inline?
+    true
+  end
+
+  def convert
+    converter.convert self
+  end
+  
+  # Alias render to convert to maintain backwards compatibility
+  alias :render :convert
 end
 end

data/lib/asciidoctor/list.rb

@@ -6,8 +6,8 @@ class List < AbstractBlock
   alias :items :blocks
   alias :items? :blocks?
 
-  def initialize(parent, context)
-    super(parent, context)
+  def initialize parent, context
+    super
   end
 
   # Public: Get the items in this list as an Array
@@ -15,10 +15,21 @@ class List < AbstractBlock
     @blocks
   end
 
-  def render
-    result = super
-    @document.callouts.next_list if @context == :colist
-    result
+  def convert
+    if @context == :colist
+      result = super
+      @document.callouts.next_list
+      result
+    else
+      super
+    end
+  end
+
+  # Alias render to convert to maintain backwards compatibility
+  alias :render :convert
+
+  def to_s
+    %(#<#{self.class}@#{object_id} {context: #{@context.inspect}, style: #{@style.inspect}, items: #{items.size}}>)
   end
 
 end
@@ -33,14 +44,14 @@ class ListItem < AbstractBlock
   #
   # parent - The parent list block for this list item
   # text - the String text (default nil)
-  def initialize(parent, text = nil)
-    super(parent, :list_item)
+  def initialize parent, text = nil
+    super parent, :list_item
     @text = text
     @level = parent.level
   end
 
   def text?
-    !@text.to_s.empty?
+    !@text.nil_or_empty?
   end
 
   def text
@@ -59,23 +70,20 @@ class ListItem < AbstractBlock
   #
   # Returns nothing
   def fold_first(continuation_connects_first_block = false, content_adjacent = false)
-    if !(first_block = @blocks.first).nil? && first_block.is_a?(Block) &&
+    if (first_block = @blocks[0]) && first_block.is_a?(Block) &&
         ((first_block.context == :paragraph && !continuation_connects_first_block) ||
         ((content_adjacent || !continuation_connects_first_block) && first_block.context == :literal &&
             first_block.option?('listparagraph')))
 
       block = blocks.shift
-      unless @text.to_s.empty?
-        block.lines.unshift("#@text\n")
-      end
-
+      block.lines.unshift @text unless @text.nil_or_empty?
       @text = block.source
     end
     nil
   end
 
   def to_s
-    "#@context [text:#@text, blocks:#{(@blocks || []).size}]"
+    %(#<#{self.class}@#{object_id} {list_context: #{parent.context.inspect}, text: #{@text.inspect}, blocks: #{(@blocks || []).size}}>)
   end
 
 end

data/lib/asciidoctor/opal_ext.rb

@@ -0,0 +1,4 @@
+require 'asciidoctor/opal_ext/comparable'
+require 'asciidoctor/opal_ext/dir'
+require 'asciidoctor/opal_ext/error'
+require 'asciidoctor/opal_ext/file'

data/lib/asciidoctor/opal_ext/comparable.rb

@@ -0,0 +1,38 @@
+# workaround for an infinite loop in Opal 0.6.2 when comparing numbers
+module Comparable
+  def == other
+    return true if equal? other
+    return false unless cmp = (self <=> other)
+    return `cmp == 0`
+  rescue StandardError
+    false
+  end
+
+  def > other
+    unless cmp = (self <=> other)
+      raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
+    end
+    `cmp > 0`
+  end
+
+  def >= other 
+    unless cmp = (self <=> other)
+      raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
+    end
+    `cmp >= 0`
+  end
+  
+  def < other
+    unless cmp = (self <=> other)
+      raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
+    end
+    `cmp < 0`
+  end
+
+  def <= other
+    unless cmp = (self <=> other)
+      raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
+    end
+    `cmp <= 0`
+  end
+end

data/lib/asciidoctor/opal_ext/dir.rb

@@ -0,0 +1,13 @@
+class Dir
+  def self.pwd
+    ENV['PWD'] || '.'
+  end
+
+  def self.getwd
+    ENV['PWD'] || '.'
+  end
+
+  def self.home
+    ENV['HOME']
+  end
+end

data/lib/asciidoctor/opal_ext/error.rb

@@ -0,0 +1,2 @@
+class SecurityError < Exception
+end

data/lib/asciidoctor/opal_ext/file.rb

@@ -0,0 +1,125 @@
+class Kernel
+  # basic implementation of open, enough to work
+  # with reading files over XmlHttpRequest
+  def open(path, *rest)
+    file = File.new(path, *rest)
+    if block_given?
+      yield file
+    else
+      file
+    end
+  end
+end
+
+class File
+  SEPARATOR = '/'
+  ALT_SEPARATOR = nil
+
+  attr_reader :eof
+  attr_reader :lineno
+  attr_reader :path
+
+  def initialize(path, mode = 'r')
+    @path = path
+    @contents = nil
+    @eof = false
+    @lineno = 0
+  end
+
+  def read
+    if @eof
+      ''
+    else
+      res = File.read(@path)
+      @eof = true
+      @lineno = res.size
+      res
+    end
+  end
+
+  def each_line(separator = $/, &block)
+    if @eof
+      return block_given? ? self : [].to_enum
+    end
+
+    if block_given?
+      lines = File.read(@path)
+      %x{
+        self.eof = false;
+        self.lineno = 0; 
+        var chomped  = #{lines.chomp},
+            trailing = lines.length != chomped.length,
+            splitted = chomped.split(separator);
+
+        for (var i = 0, length = splitted.length; i < length; i++) {
+          self.lineno += 1;
+          if (i < length - 1 || trailing) {
+            #{yield `splitted[i] + separator`};
+          }
+          else {
+            #{yield `splitted[i]`};
+          }
+        }
+        self.eof = true;
+      }
+      self
+    else
+      read.each_line
+    end
+  end
+
+  def self.expand_path(path)
+    path
+  end
+
+  def self.join(*paths)
+    paths * SEPARATOR
+  end
+
+  def self.basename(path)
+    (offset = path.rindex SEPARATOR) ? path[(offset + 1)..-1] : path
+  end
+
+  def self.dirname(path)
+    (offset = path.rindex SEPARATOR) ? path[0..(offset - 1)] : '.'
+  end
+
+  def self.extname(path)
+    return '' if path.nil_or_empty?
+    last_dot_idx = path[1..-1].rindex('.')
+    last_dot_idx.nil? ? '' : path[(last_dot_idx + 1)..-1]
+  end
+
+  # TODO use XMLHttpRequest HEAD request unless in local file mode
+  def self.file?(path)
+    true
+  end
+  
+  def self.read(path)
+    %x{
+      var data = ''
+      var status = -1;
+      try {
+        var xhr = new XMLHttpRequest();
+        xhr.open('GET', path, false);
+        xhr.addEventListener('load', function() {
+          status = this.status;
+          // status is 0 for local file mode (i.e., file://)
+          if (status == 0 || status == 200) {
+            data = this.responseText;
+          }
+        });
+        xhr.overrideMimeType('text/plain');
+        xhr.send();
+      }
+      catch (e) {
+        status = 0;
+      }
+      // assume that no data in local file mode means it doesn't exist
+      if (status == 404 || (status == 0 && data == '')) {
+        throw #{IOError.new `'No such file or directory: ' + path`};
+      }
+    }
+    `data`
+  end
+end