asciidoctor 0.1.4 → 1.5.0

data/lib/asciidoctor/attribute_list.rb

@@ -10,7 +10,7 @@ module Asciidoctor
 #    attrlist = Asciidoctor::AttributeList.new('astyle')
 #
 #    attrlist.parse
-#    => {0 => 'astyle'} 
+#    => {0 => 'astyle'}
 #
 #    attrlist.rekey(['style'])
 #    => {'style' => 'astyle'}
@@ -18,55 +18,58 @@ module Asciidoctor
 #    attrlist = Asciidoctor::AttributeList.new('quote, Famous Person, Famous Book (2001)')
 #
 #    attrlist.parse(['style', 'attribution', 'citetitle'])
-#    => {'style' => 'quote', 'attribution' => 'Famous Person', 'citetitle' => 'Famous Book (2001)'} 
+#    => {'style' => 'quote', 'attribution' => 'Famous Person', 'citetitle' => 'Famous Book (2001)'}
 #
 class AttributeList
 
   # Public: Regular expressions for detecting the boundary of a value
-  BOUNDARY_PATTERNS = {
+  BoundaryRxs = {
     '"' => /.*?[^\\](?=")/,
     '\'' => /.*?[^\\](?=')/,
     ',' => /.*?(?=[ \t]*(,|$))/
   }
 
   # Public: Regular expressions for unescaping quoted characters
-  UNESCAPE_PATTERNS = {
-    '\\"' => /\\"/,
-    '\\\'' => /\\'/ 
+  EscapedQuoteRxs = {
+    '"' => /\\"/,
+    '\'' => /\\'/
   }
 
+  # Public: A regular expression for an attribute name
+  # TODO named attributes cannot contain dash characters
+  NameRx = /[A-Za-z:_][A-Za-z:_\-.]*/
+
+  BlankRx = /[ \t]+/
+
   # Public: Regular expressions for skipping blanks and delimiters
-  SKIP_PATTERNS = {
-    :blank => /[ \t]+/,
+  SkipRxs = {
+    :blank => BlankRx,
     ',' => /[ \t]*(,|$)/
   }
 
-  # Public: A regular expression for an attribute name
-  # TODO named attributes cannot contain dash characters
-  NAME_PATTERN = /[A-Za-z:_][A-Za-z:_\-\.]*/
-
-  def initialize(source, block = nil, quotes = ['\'', '"'], delimiter = ',', escape_char = '\\')
+  def initialize source, block = nil, delimiter = ','
     @scanner = ::StringScanner.new source
     @block = block
-    @quotes = quotes
-    @escape_char = escape_char
     @delimiter = delimiter
+    @delimiter_skip_pattern = SkipRxs[delimiter]
+    @delimiter_boundary_pattern = BoundaryRxs[delimiter]
     @attributes = nil
   end
 
-  def parse_into(attributes, posattrs = [])
-    attributes.update(parse(posattrs))
+  def parse_into attributes, posattrs = []
+    attributes.update(parse posattrs)
   end
 
-  def parse(posattrs = [])
-    return @attributes unless @attributes.nil?
+  def parse posattrs = []
+    # return if already parsed
+    return @attributes if @attributes
 
     @attributes = {}
-    # not sure if I want this assignment or not
+    # QUESTION do we want to store the attribute list as the zero-index attribute?
     #attributes[0] = @scanner.string
     index = 0
 
-    while parse_attribute(index, posattrs)
+    while parse_attribute index, posattrs
       break if @scanner.eos?
       skip_delimiter
       index += 1
@@ -75,144 +78,136 @@ class AttributeList
     @attributes
   end
 
-  def rekey(posattrs)
-    AttributeList.rekey(@attributes, posattrs)
+  def rekey posattrs
+    AttributeList.rekey @attributes, posattrs
   end
 
-  def self.rekey(attributes, pos_attrs)
+  def self.rekey attributes, pos_attrs
     pos_attrs.each_with_index do |key, index|
-      next if key.nil?
+      next unless key
       pos = index + 1
-      unless (val = attributes[pos]).nil?
+      if (val = attributes[pos])
+        # QUESTION should we delete the positional key?
         attributes[key] = val
-        #QUESTION should we delete the positional key?
-        #attributes.delete pos
       end
     end
 
     attributes
   end
 
-  def parse_attribute(index = 0, pos_attrs = [])
+  def parse_attribute index = 0, pos_attrs = []
     single_quoted_value = false
     skip_blank
-    first = @scanner.peek(1)
-    # example: "quote" || 'quote'
-    if @quotes.include? first
+    # example: "quote"
+    if (first = @scanner.peek(1)) == '"'
+      name = parse_attribute_value @scanner.get_byte
       value = nil
+    # example: 'quote'
+    elsif first == '\''
       name = parse_attribute_value @scanner.get_byte
-      if first == '\''
-        single_quoted_value = true
-      end
+      value = nil
+      single_quoted_value = true
     else
       name = scan_name
 
       skipped = 0
       c = nil
       if @scanner.eos?
-        if name.nil?
-          return false
-        end
+        return false unless name
       else
         skipped = skip_blank || 0
         c = @scanner.get_byte
       end
 
       # example: quote
-      if c.nil? || c == @delimiter
+      if !c || c == @delimiter
         value = nil
       # example: Sherlock Holmes || =foo=
-      elsif c != '=' || name.nil?
-        remainder = scan_to_delimiter
-        name = '' if name.nil?
-        name += ' ' * skipped + c
-        name += remainder unless remainder.nil?
+      elsif c != '=' || !name
+        name = %(#{name}#{' ' * skipped}#{c}#{scan_to_delimiter})
         value = nil
       else
         skip_blank
-        # example: foo=,
-        if @scanner.peek(1) == @delimiter
-          value = nil
-        else
-          c = @scanner.get_byte
-
-          # example: foo="bar" || foo='bar' || foo="ba\"zaar" || foo='ba\'zaar' || foo='ba"zaar' (all spaces ignored)
-          if @quotes.include? c
+        if @scanner.peek(1)
+          # example: foo="bar" || foo="ba\"zaar"
+          if (c = @scanner.get_byte) == '"'
             value = parse_attribute_value c
-            if c == '\''
-              single_quoted_value = true
-            end
+          # example: foo='bar' || foo='ba\'zaar' || foo='ba"zaar'
+          elsif c == '\''
+            value = parse_attribute_value c
+            single_quoted_value = true
+          # example: foo=,
+          elsif c == @delimiter
+            value = nil
           # example: foo=bar (all spaces ignored)
-          elsif !c.nil?
-            value = c + scan_to_delimiter
+          else
+            value = %(#{c}#{scan_to_delimiter})
+            return true if value == 'None'
           end
         end
       end
     end
 
-    if value.nil?
-      resolved_name = single_quoted_value && !@block.nil? ? @block.apply_normal_subs(name) : name
-      if !(pos_name = pos_attrs[index]).nil?
-        @attributes[pos_name] = resolved_name
-      else
-        #@attributes[index + 1] = resolved_name
-      end
-      # not sure if we want to always assign the positional key
-      @attributes[index + 1] = resolved_name
-      # not sure if I want this assignment or not
-      #@attributes[resolved_name] = nil
-    else
-      resolved_value = value
+    if value
       # example: options="opt1,opt2,opt3"
       # opts is an alias for options
-      if name == 'options' || name == 'opts'
+      case name
+      when 'options', 'opts'
         name = 'options'
-        resolved_value.split(',').each do |o|
-          @attributes["#{o.strip}-option"] = ''
-        end
-      elsif single_quoted_value && !@block.nil?
-        resolved_value = @block.apply_normal_subs(value)
+        value.split(',').each {|o| @attributes[%(#{o.strip}-option)] = '' }
+        @attributes[name] = value
+      when 'title'
+        @attributes[name] = value
+      else
+        @attributes[name] = single_quoted_value && !value.empty? && @block ? (@block.apply_normal_subs value) : value
+      end
+    else
+      resolved_name = single_quoted_value && !name.empty? && @block ? (@block.apply_normal_subs name) : name
+      if (pos_name = pos_attrs[index])
+        @attributes[pos_name] = resolved_name
       end
-      @attributes[name] = resolved_value
+      # QUESTION should we always assign the positional key?
+      @attributes[index + 1] = resolved_name
+      # QUESTION should we assign the resolved name as an attribute?
+      #@attributes[resolved_name] = nil
     end
 
     true
   end
 
-  def parse_attribute_value(quote)
+  def parse_attribute_value quote
     # empty quoted value
     if @scanner.peek(1) == quote
-      @scanner.get_byte 
+      @scanner.get_byte
       return ''
     end
 
-    value = scan_to_quote quote
-    if value.nil?
-      quote + scan_to_delimiter
-    else
+    if (value = scan_to_quote quote)
       @scanner.get_byte
-      value.gsub(UNESCAPE_PATTERNS[@escape_char + quote], quote)
+      value.gsub EscapedQuoteRxs[quote], quote
+    else
+      %(#{quote}#{scan_to_delimiter})
     end
   end
 
   def skip_blank
-    @scanner.skip SKIP_PATTERNS[:blank]
+    @scanner.skip BlankRx
   end
 
   def skip_delimiter
-    @scanner.skip SKIP_PATTERNS[@delimiter]
+    @scanner.skip @delimiter_skip_pattern
   end
 
   def scan_name
-    @scanner.scan NAME_PATTERN
+    @scanner.scan NameRx
   end
 
   def scan_to_delimiter
-    @scanner.scan BOUNDARY_PATTERNS[@delimiter]
+    @scanner.scan @delimiter_boundary_pattern
   end
 
-  def scan_to_quote(quote)
-    @scanner.scan BOUNDARY_PATTERNS[quote]
+  def scan_to_quote quote
+    @scanner.scan BoundaryRxs[quote]
   end
 
 end

data/lib/asciidoctor/block.rb

@@ -8,6 +8,20 @@ module Asciidoctor
 #   => "<em>This</em> is a &lt;test&gt;"
 class Block < AbstractBlock
 
+  DEFAULT_CONTENT_MODEL = ::Hash.new(:simple).merge({
+    # TODO should probably fill in all known blocks
+    :audio => :empty,
+    :image => :empty,
+    :listing => :verbatim,
+    :literal => :verbatim,
+    :stem => :raw,
+    :open => :compound,
+    :page_break => :empty,
+    :pass => :raw,
+    :thematic_break => :empty,
+    :video => :empty
+  })
+
   # Public: Create alias for context to be consistent w/ AsciiDoc
   alias :blockname :context
 
@@ -25,31 +39,31 @@ class Block < AbstractBlock
   #                 * :source a String or Array of raw source for this Block. (default: nil)
   #--
   # QUESTION should we store source_data as lines for blocks that have compound content models?
-  def initialize(parent, context, opts = {})
-    super(parent, context)
-    @content_model = opts.fetch(:content_model, nil) || :simple
-    @attributes = opts.fetch(:attributes, nil) || {}
-    @subs = opts[:subs] if opts.has_key? :subs
-    raw_source = opts.fetch(:source, nil) || nil
-    if raw_source.nil?
-      @lines = []
-    elsif raw_source.class == String
-      # FIXME make line normalization a utility method since it's used multiple times in code base!!
-      if ::Asciidoctor::FORCE_ENCODING
-        @lines = raw_source.lines.map {|line| "#{line.rstrip.force_encoding(::Encoding::UTF_8)}\n" }
+  def initialize parent, context, opts = {}
+    super
+    @content_model = opts[:content_model] || DEFAULT_CONTENT_MODEL[context]
+    if opts.has_key? :subs
+      # FIXME this is a bit funky
+      # we have to be defensive to avoid lock_in_subs wiping out the override
+      if !(subs = opts[:subs]) || (subs.is_a? ::Array)
+        @subs = subs || []
+        @default_subs = @subs.dup
+        @attributes.delete('subs')
       else
-        @lines = raw_source.lines.map {|line| "#{line.rstrip}\n" }
-      end
-      if (last = @lines.pop)
-        @lines.push last.chomp
+        @attributes['subs'] = %(#{subs})
       end
+    end
+    if !(raw_source = opts[:source])
+      @lines = []
+    elsif raw_source.is_a? ::String
+      @lines = Helpers.normalize_lines_from_string raw_source
     else
       @lines = raw_source.dup
     end
   end
 
-  # Public: Get an rendered version of the block content, performing
-  # any substitutions on the content.
+  # Public: Get the converted result of the child blocks by converting the
+  # children appropriate to content model that this block supports.
   #
   # Examples
   #
@@ -62,10 +76,23 @@ class Block < AbstractBlock
     case @content_model
     when :compound
       super
-    when :simple, :verbatim, :raw
-      apply_subs @lines.join, @subs
+    when :simple
+      apply_subs(@lines * EOL, @subs)
+    when :verbatim, :raw
+      #((apply_subs @lines.join(EOL), @subs).sub StripLineWiseRx, '\1')
+
+      # QUESTION could we use strip here instead of popping empty lines?
+      # maybe apply_subs can know how to strip whitespace?
+      result = apply_subs @lines, @subs
+      if result.size < 2
+        result[0]
+      else
+        result.shift while (first = result[0]) && first.rstrip.empty?
+        result.pop while (last = result[-1]) && last.rstrip.empty?
+        result * EOL
+      end
     else
-      warn "Unknown content model '#@content_model' for block: #{to_s}" unless @content_model == :empty
+      warn %(Unknown content model '#{@content_model}' for block: #{to_s}) unless @content_model == :empty
       nil
     end
   end
@@ -75,12 +102,12 @@ class Block < AbstractBlock
   # Returns the a String containing the lines joined together or nil if there
   # are no lines
   def source
-    @lines.join
+    @lines * EOL
   end
 
   def to_s
-    content_summary = @content_model == :compound ? %(# of blocks = #{@blocks.size}) : %(# of lines = #{@lines.size})
-    %(Block[@context: :#@context, @content_model: :#@content_model, #{content_summary}])
+    content_summary = @content_model == :compound ? %(blocks: #{@blocks.size}) : %(lines: #{@lines.size})
+    %(#<#{self.class}@#{object_id} {context: #{@context.inspect}, content_model: #{@content_model.inspect}, style: #{@style.inspect}, #{content_summary}}>)
   end
 end
 end

data/lib/asciidoctor/callouts.rb

@@ -36,8 +36,8 @@ class Callouts
   # Public: Get the next callout index in the document
   #
   # Reads the next callout index in the document and advances the pointer.
-  # This method is used during rendering to retrieve the unique id of the
-  # callout that was generated during lexing.
+  # This method is used during conversion to retrieve the unique id of the
+  # callout that was generated during parsing.
   #
   # Returns The unique String id of the next callout in the document
   def read_next_id
@@ -60,10 +60,7 @@ class Callouts
   #
   # Returns A space-separated String of callout ids associated with the specified list item
   def callout_ids(li_ordinal)
-    current_list.inject([]) {|collector, element|
-      collector << element[:id] if element[:ordinal] == li_ordinal
-      collector
-    } * ' '
+    current_list.map {|element| element[:ordinal] == li_ordinal ? %(#{element[:id]} ) : nil }.join.chop
   end
 
   # Public: The current list for which callouts are being collected
@@ -89,7 +86,7 @@ class Callouts
   end
 
   # Public: Rewind the list index pointer, intended to be used when switching
-  # from the parsing to rendering phase.
+  # from the parsing to conversion phase.
   #
   # Returns nothing
   def rewind

data/lib/asciidoctor/cli.rb

@@ -0,0 +1,3 @@
+require 'optparse'
+require 'asciidoctor/cli/options'
+require 'asciidoctor/cli/invoker'

data/lib/asciidoctor/cli/invoker.rb

@@ -12,100 +12,110 @@ module Asciidoctor
         @err = nil
         @code = 0
         options = options.flatten
-        if !options.empty? && options.first.is_a?(Cli::Options)
-          @options = options.first
-        elsif options.first.is_a? Hash
+        if (first_option = options[0]).is_a?(Cli::Options)
+          @options = first_option
+        elsif first_option.is_a?(::Hash)
           @options = Cli::Options.new(options)
         else
-          @options = Cli::Options.parse!(options)
-          # hmmm
-          if @options.is_a?(Integer)
-            @code = @options
+          if (result = Cli::Options.parse! options).is_a? ::Integer
+            @code = result
             @options = nil
+          else
+            @options = result
           end
         end
       end
 
       def invoke!
-        return if @options.nil?
-
-        begin
-          opts = {}
-          profile = false
-          infiles = []
-          outfile = nil
-          tofile = nil
-          @options.map {|k, v|
-            case k
-            when :input_files
-              infiles = v
-            when :output_file
-              outfile = v
-            when :destination_dir
-              #opts[:to_dir] = File.expand_path(v) unless v.nil?
-              opts[:to_dir] = v unless v.nil?
-            when :attributes
-              opts[:attributes] = v.dup
-            when :verbose
-              profile = true if v
-            when :trace
-              # currently, nothing
-            else
-              opts[k] = v unless v.nil?
-            end
-          }
+        old_verbose = -1
+        return unless @options
 
-          if infiles.size == 1 && infiles.first == '-'
-             # allows use of block to supply stdin, particularly useful for tests
-             inputs = [block_given? ? yield : STDIN]
-          else
-             inputs = infiles.map {|infile| File.new infile}
-          end
+        old_verbose = $VERBOSE
+        case @options[:verbose]
+        when 0
+          $VERBOSE = nil
+        when 1
+          $VERBOSE = false
+        when 2
+          $VERBOSE = true
+        end
 
-          # NOTE: if infile is stdin, default to outfile as stout
-          if outfile == '-' || (infiles.size == 1 && infiles.first == '-' && outfile.to_s.empty?)
-            tofile = (@out || $stdout)
-          elsif !outfile.nil?
-            tofile = outfile
-            opts[:mkdirs] = true
+        opts = {}
+        infiles = []
+        outfile = nil
+        tofile = nil
+        @options.map do |key, val|
+          case key
+          when :input_files
+            infiles = val
+          when :output_file
+            outfile = val
+          when :destination_dir
+            opts[:to_dir] = val if val
+          when :attributes
+            # NOTE processor will dup attributes internally
+            opts[:attributes] = val
+          when :trace
+            # currently, nothing
           else
-            tofile = nil
-            # automatically calculate outfile based on infile
-            opts[:in_place] = true unless opts.has_key? :to_dir
-            opts[:mkdirs] = true
+            opts[key] = val unless val.nil?
           end
+        end
 
-          original_opts = opts
-          inputs.each do |input|
-            
-            opts = Helpers.clone_options(original_opts) if inputs.size > 1
-            opts[:to_file] = tofile unless tofile.nil?
-            opts[:monitor] = {} if profile
+        if infiles.size == 1 && infiles[0] == '-'
+          # allows use of block to supply stdin, particularly useful for tests
+          inputs = [block_given? ? yield : STDIN]
+        else
+          inputs = infiles.map {|infile| ::File.new infile, 'r'}
+        end
 
-            @documents ||= []
-            @documents.push Asciidoctor.render(input, opts)
+        # NOTE if infile is stdin, default to outfile as stout
+        if outfile == '-' || (!outfile && infiles.size == 1 && infiles[0] == '-')
+          tofile = (@out || $stdout)
+        elsif outfile
+          tofile = outfile
+          opts[:mkdirs] = true
+        else
+          # automatically calculate outfile based on infile unless to_dir is set
+          tofile = nil
+          opts[:mkdirs] = true
+        end
 
-            if profile
-              monitor = opts[:monitor]
-              err = (@err || $stderr)
-              err.puts "Input file: #{input.respond_to?(:path) ? input.path : '-'}"
-              err.puts "  Time to read and parse source: #{'%05.5f' % monitor[:parse]}"
-              err.puts "  Time to render document: #{monitor.has_key?(:render) ? '%05.5f' % monitor[:render] : 'n/a'}"
-              err.puts "  Total time to read, parse and render: #{'%05.5f' % (monitor[:load_render] || monitor[:parse])}"
-            end
+        show_timings = @options[:timings]
+        inputs.each do |input|
+          # NOTE processor will dup options and attributes internally
+          input_opts = tofile.nil? ? opts : opts.merge(:to_file => tofile)
+          if show_timings
+            timings = Timings.new
+            @documents << ::Asciidoctor.convert(input, input_opts.merge(:timings => timings))
+            timings.print_report((@err || $stderr), ((input.respond_to? :path) ? input.path : '-'))
+          else
+            @documents << ::Asciidoctor.convert(input, input_opts)
+          end
+        end
+      rescue ::Exception => e
+        if ::SignalException === e
+          @code = e.signo
+          # add extra endline if Ctrl+C is used
+          (@err || $stderr).puts if ::Interrupt === e
+        else
+          @code = (e.respond_to? :status) ? e.status : 1
+          if @options[:trace]
+            raise e
+          else
+            err = (@err || $stderr)
+            err.print %(#{e.class}: ) if ::RuntimeError === e
+            err.puts e.message
+            err.puts '  Use --trace for backtrace'
           end
-        rescue Exception => e
-          raise e if @options[:trace] || SystemExit === e
-          err = (@err || $stderr)
-          err.print "#{e.class}: " if e.class != RuntimeError
-          err.puts e.message
-          err.puts '  Use --trace for backtrace'
-          @code = 1
         end
+        nil
+      ensure
+        $VERBOSE = old_verbose unless old_verbose == -1
       end
 
       def document
-        @documents.size > 0 ? @documents.first : nil
+        @documents[0]
       end
 
       def redirect_streams(out, err = nil)
@@ -114,11 +124,11 @@ module Asciidoctor
       end
 
       def read_output
-        !@out.nil? ? @out.string : ''
+        @out ? @out.string : ''
       end
 
       def read_error
-        !@err.nil? ? @err.string : ''
+        @err ? @err.string : ''
       end
 
       def reset_streams