asciidoctor-asciidoc 0.0.2.dev

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5c3a7406ea5ca33ac04d2f852f99babb9288d77ad6218badf24c601ace327b10
+  data.tar.gz: cce24466950c5d6a94b796813ba43ec8781e5bcc5d2954720fb80f864d872e47
+SHA512:
+  metadata.gz: c0e08c4a75fb09c8a7be40b95f2dd44d0b8ecdca7831b5b7bccb7a39d4fda41152c82b3b91b6312648255fe1a44ed47a3eddc64aa9eb2b38e2aa6ccd8abdca3e
+  data.tar.gz: b12afcda64eaf2dc1b71e432f8df7ca2cdbb815146a598d69c5a4386313a1a4635f7279fd59a9875a99b156bed2b15299c20170b0a9985a152ff273c998d63ce

data/lib/asciidoctor-asciidoc/const.rb

@@ -0,0 +1,8 @@
+
+module AsciiDoctorAsciiDocConst
+
+  ESC = "\x00"
+  ESC_E = "x"
+
+end
+

data/lib/asciidoctor-asciidoc/conv-node.rb

@@ -0,0 +1,74 @@
+
+class AsciiDoctorAsciiDocNode
+
+  TYPE_NODE = :node
+  TYPE_TEXT = :text
+
+  attr_reader :parent
+  attr_reader :children
+  attr_reader :node
+  attr_reader :transform
+  attr_reader :text
+  attr_reader :type
+
+  attr_accessor :is_list
+  attr_accessor :is_anchor
+  attr_accessor :anchor
+
+  def initialize(parent:, node: nil, transform: nil, text: nil)
+    super()
+    @parent = parent
+    @node = node
+    @transform = transform
+    @text = text
+
+    if text.nil?
+      @children = []
+      @type = TYPE_NODE
+    else
+      @children = nil
+      @type = TYPE_TEXT
+    end
+
+  end
+  def add_child(node)
+    @children.push(node)
+  end
+
+  def parent_is_list?
+    @parent && @parent.is_list
+  end
+
+  def prev_sibling
+
+    return nil unless @parent
+
+    children = parent.children
+    prev = nil
+    children.each do |child|
+      return prev if child === self
+      prev = child
+    end
+
+    raise "I am not a child of my parent!"
+
+  end
+
+  def next_child
+
+    idx = @children.length
+    [yield, idx == @children.length ? nil : @children[idx]]
+
+  end
+
+  def add_text_child(text)
+
+    @children.push(AsciiDoctorAsciiDocNode.new(parent: self, text: text))
+
+  end
+
+  def is_text?
+    @type == TYPE_TEXT
+  end
+
+end

data/lib/asciidoctor-asciidoc/linked-list.rb

@@ -0,0 +1,126 @@
+class LinkedList
+
+  attr_reader :head
+  attr_reader :tail
+
+  def initialize(copy_from = nil, copy_fun = nil)
+    super()
+    @head = nil
+    @tail = nil
+
+    if copy_from
+      copy_from.each do |item|
+        contents = item.contents
+        contents = copy_fun.call(contents) if copy_fun
+        add(contents)
+      end
+    end
+
+  end
+
+  def add_after(el, contents)
+    add_between(el, el.next, contents)
+  end
+
+  def add_before(el, contents)
+    add_between(el.prev, el, contents)
+  end
+
+  # adds at the end
+  def add(contents)
+    add_between(@tail, nil, contents)
+  end
+
+  # adds at the beginning
+  def insert(contents)
+    add_between(nil, @head, contents)
+  end
+
+  def each
+    return unless block_given?
+    item = @head
+    until item.nil?
+      # cache next value in case the item's deleted
+      next_el = item.next
+      yield item
+      item = next_el
+    end
+  end
+
+  def delete(item)
+    if item.list
+      if @head === item
+        @head = item.next
+      else
+        item.prev.next = item.next
+      end
+      if @tail === item
+        @tail = item.prev
+      else
+        item.next.prev = item.prev
+      end
+      item.list = nil
+      item.next = nil
+      item.prev = nil
+    end
+    item.contents
+  end
+
+  private
+
+  def add_between(e_prev, e_next, contents)
+
+    if contents.is_a?(LinkedListItem)
+      item = contents
+      raise "Attempting to add a list item that is already attached to a list" if item.list
+      item.list = self
+      item.next = e_next
+      item.prev = e_prev
+    else
+      item = LinkedListItem.new(contents, self, e_next, e_prev)
+    end
+
+    if e_prev.nil?
+      @head = item
+    else
+      e_prev.next = item
+    end
+
+    if e_next.nil?
+      @tail = item
+    else
+      e_next.prev = item
+    end
+
+  end
+
+end
+
+class LinkedListItem
+
+  attr_accessor :next
+  attr_accessor :prev
+  attr_accessor :list
+  attr_accessor :contents
+
+  def initialize(contents, list, next_item, prev_item)
+    super()
+    @list = list
+    @next = next_item
+    @prev = prev_item
+    @contents = contents
+  end
+
+  def add_after(contents)
+    @list.add_after(self, contents)
+  end
+
+  def add_before(contents)
+    @list.add_before(self, contents)
+  end
+
+  def delete
+    list.delete(self)
+  end
+
+end

data/lib/asciidoctor-asciidoc/unescape.rb

@@ -0,0 +1,407 @@
+
+require 'asciidoctor-asciidoc/linked-list'
+require 'asciidoctor-asciidoc/const'
+
+class Unescape
+
+  include AsciiDoctorAsciiDocConst
+
+  FEED_MORE = :more
+  FEED_NO_MATCH = :no_match
+  FEED_DONE = :done
+
+  class Context
+
+    attr_accessor :last_char
+    attr_accessor :buffer_len
+    attr_accessor :buffer
+    attr_accessor :curve_quote_index
+    attr_accessor :pos
+    attr_accessor :str
+    attr_accessor :out
+    attr_reader :encode
+
+    def initialize(str, encode = false)
+      super()
+      @str = str
+      @curve_quote_index = []
+      @len = str.length
+      @pos = 0
+      @out = ''
+      @encode = encode
+      reset
+    end
+
+    def reset
+      @buffer = ''
+      @buffer_len = 0
+    end
+
+    def has_next_char?
+      @pos < @len
+    end
+
+    def next_char
+      @str[@pos]
+    end
+
+    def prev_char
+      @str[@pos-2]
+    end
+
+    def advance
+      @last_char = next_char
+      @buffer << @last_char
+      @pos+=1
+      @buffer_len += 1
+    end
+
+    def back_track(pattern)
+      @pos -= buffer_len
+      return @str[@pos..@pos + pattern.len - 1] if pattern.len > 0
+      ''
+    end
+
+    def forward(pattern)
+      @pos += pattern.len
+    end
+
+    def remainder
+      str[pos..-1]
+    end
+
+  end
+
+  class Pattern
+
+    include AsciiDoctorAsciiDocConst
+
+    attr_reader :len
+
+    def initialize(context)
+      super()
+      @ctx = context
+      reset
+    end
+
+    def reset
+      @done = false
+      @len = 0
+      self
+    end
+
+    def is_done?(ended)
+      @done
+    end
+
+    def encode(piece)
+      r = produce(piece)
+      if @ctx.encode
+        encode_bin(r)
+      else
+        r
+      end
+    end
+
+    def encode_bin(text)
+      out = "#{ESC}"
+      text.each_char do |chr|
+        chr = chr.ord
+        raise "Non-ASCII character #{chr}" if chr > 255
+        out << ("%02x" % chr)
+      end
+      out << ESC_E
+    end
+
+  end
+
+  class StringPattern < Pattern
+
+    def initialize(context, pattern, replacement)
+      super(context)
+      @pattern = pattern
+      @max_len = pattern.length
+      @replacement = replacement
+    end
+
+    def feed
+
+      return FEED_NO_MATCH if @ctx.last_char != @pattern[@len]
+      @len += 1
+      if @len == @max_len
+        @done = true
+        return FEED_DONE
+      end
+      FEED_MORE
+
+    end
+
+    def produce(piece)
+      @replacement
+    end
+
+  end
+
+  class CurveQuoteStart < StringPattern
+
+    def initialize(context)
+      super(context, "&#8216;", %('`))
+    end
+
+    def produce(piece)
+      @ctx.curve_quote_index << { :pos=>@ctx.out.length, :start=>true}
+      super
+    end
+
+  end
+
+  class CurveQuoteEnd < StringPattern
+
+    def initialize(context)
+      super(context,  "&#8217;", %(`'))
+    end
+
+    def produce(piece)
+      @ctx.curve_quote_index << { :pos=>@ctx.out.length, :start=>false}
+      super
+    end
+
+  end
+
+  class SpecialGobbler < Pattern
+
+    # these are the character that we care about escaping
+    CHAR_SET = %w[* _ ` # ~ ^].to_set
+    VOID_SET = /[[:alpha:][:digit:]:;}_]/
+
+    def initialize(context)
+      super
+    end
+
+    def feed
+
+      accept_char = CHAR_SET.include?(@ctx.last_char)
+      unless accept_char
+        return FEED_NO_MATCH unless @len > 0
+        @done = true
+        return FEED_DONE
+      end
+
+      # we don't need to escape if:
+      # - the character is singular
+      # - the character directly follows:
+      # -- a colon, semicolon, or closing curly bracket
+      # -- a letter, number, or underscore
+      # -- there is a space from this mark to the next mark.
+      # - but we need to make exceptions for first character being '*' because of lists
+
+      gobble = -> () do
+        @len+=1
+        return FEED_MORE
+      end
+
+      # if we have accumulated something already continue doing so no matter what
+      return gobble.call if @len > 0
+
+      # list exception - gobble up chars if we are consuming from the
+      # start of text
+      return gobble.call if @ctx.buffer_len == @ctx.pos
+
+      return gobble.call if @ctx.has_next_char? && @ctx.next_char == @ctx.last_char
+
+      # here we are guaranteed that there is a character before ours
+      return FEED_NO_MATCH if @ctx.prev_char.match?(VOID_SET)
+
+      # if there are no more control characters, no need to escape
+      next_char = @ctx.remainder.index(@ctx.last_char)
+      return FEED_NO_MATCH if next_char.nil?
+      next_ws = @ctx.remainder.index(/[[:space:]]/)
+      return FEED_NO_MATCH if !next_ws.nil? && next_ws < next_char
+
+      gobble.call
+
+    end
+
+    def is_done?(ended)
+      (ended && @len > 0) || super
+    end
+
+    def produce(piece)
+      %(pass:[#{piece}])
+    end
+
+  end
+
+  def self.unescape(str, encode = false)
+
+    # Note - it's generally OK for us to leave the &#xxxx; sequences in the
+    # Asciidoc, because they are re-rendered as is. We try our best to resolve
+    # these reference, but if we are unsure on how to, we can leave them in.
+
+    # $TODO I'm sure there is more to this than that.
+    # quote_release = Set[
+    #   ',', ';', '"', '.', '?', '!', ' ', '\n'
+    # ]
+
+    ctx = Context.new(str, encode)
+
+    all = LinkedList.new
+    # https://docs.asciidoctor.org/asciidoc/latest/subs/special-characters/
+    all.add(StringPattern.new(ctx, "&lt;", "<"))
+    all.add(StringPattern.new(ctx, "&gt;", ">"))
+    all.add(StringPattern.new(ctx, "&amp;", "&"))
+    # https://docs.asciidoctor.org/asciidoc/latest/subs/quotes/
+    all.add(StringPattern.new(ctx, "&#8220;", %("`)))
+    all.add(StringPattern.new(ctx, "&#8221;", %(`")))
+    all.add(CurveQuoteEnd.new(ctx))
+    all.add(CurveQuoteStart.new(ctx))
+    # https://docs.asciidoctor.org/asciidoc/latest/subs/replacements/
+    all.add(StringPattern.new(ctx, "&#169;", "(C)"))
+    all.add(StringPattern.new(ctx, "&#174;", "(R)"))
+    all.add(StringPattern.new(ctx, "&#8482;", "(TM)"))
+    all.add(StringPattern.new(ctx, "&#8212;", "--"))
+    all.add(StringPattern.new(ctx, "&#8212;&#8203;", "--"))
+    all.add(StringPattern.new(ctx, "&#8201;&#8212;&#8201;", " -- "))
+    all.add(StringPattern.new(ctx, "&#8230;", "..."))
+    all.add(StringPattern.new(ctx, "&#8230;&#8203;", "..."))
+    all.add(StringPattern.new(ctx, "&#8594;", "->"))
+    all.add(StringPattern.new(ctx, "&#8658;", "=>"))
+    all.add(StringPattern.new(ctx, "&#8592;", "<-"))
+    all.add(StringPattern.new(ctx, "&#8656;", "<="))
+
+    all.add(SpecialGobbler.new(ctx))
+
+    active = nil
+
+    reset = -> do
+      ctx.reset
+      active = LinkedList.new(all, -> (p) do
+        p.reset
+      end)
+    end
+
+    reset.call
+
+    while true do
+
+      ended = !ctx.has_next_char?
+      ctx.advance unless ended
+
+      done = nil
+      has_more = false
+
+      active.each do |item|
+
+        pattern = item.contents
+
+        record_done = Proc.new do
+          if done.nil?
+            done = item
+          else
+            if done.contents.len > item.contents.len
+              active.delete(item)
+            else
+              active.delete(done)
+              done = item
+            end
+          end
+        end
+
+        if ended
+
+          record_done.call if pattern.is_done?(true)
+
+        else
+
+          if pattern.is_done?(false)
+            record_done.call
+          else
+            feed = pattern.feed
+            if feed == FEED_NO_MATCH
+              active.delete(item)
+              next
+            end
+          end
+
+          # it's either "more" or "done" now
+          record_done.call if feed == FEED_DONE
+          has_more = true if feed == FEED_MORE
+
+        end
+
+      end
+
+      # if we found some more patterns to match
+      # we need to continue
+      next if has_more
+
+      if done.nil?
+
+        # there is nothing done, so we just flush the
+        # buffer out
+        # TODO: this should move to the next char, and not
+        # jump over the entire buffer.
+        ctx.out << ctx.buffer
+
+      else
+
+        pattern = done.contents
+        piece = ctx.back_track(pattern)
+        ctx.out << pattern.encode(piece)
+        ctx.forward(pattern)
+
+      end
+
+      reset.call
+
+      break unless ctx.has_next_char?
+
+    end
+
+    out2 = ''
+    last_pos = 0
+
+    # deal with apostrophes
+    has_start = false
+    q_len = ctx.encode ? 6 : 2
+    (0..ctx.curve_quote_index.length-1).each do |idx|
+      item = ctx.curve_quote_index[idx]
+
+      item_pos = item[:pos]
+      out2 << ctx.out[last_pos..item_pos-1] unless item_pos <= 0
+      last_pos = item_pos
+
+      if item[:start]
+        out2 << ctx.out[last_pos..last_pos + q_len - 1]
+        has_start = true
+      else
+        # ok, then this is the end quote,
+        # or it's in the middle of something
+        # or a simple one
+        # We need to replace it with the single apostrophe
+        # if we are not ending the quote. We are not ending the quote
+        # if there is an end to it later, but before any new quote starts.
+        replace = !has_start
+        unless replace
+          replace = ctx.curve_quote_index.length-1 != idx && ctx.curve_quote_index[idx+1][:start]
+        end
+
+        if replace
+          out2 << (ctx.encode ? "#{ESC}27#{ESC_E}" : "'")
+        else
+          has_start = false
+          out2 << (ctx.out[last_pos..last_pos + q_len - 1])
+        end
+
+      end
+
+      last_pos += q_len
+
+    end
+
+    return ctx.out if last_pos == 0
+    out2 << ctx.out[last_pos..-1]
+
+  end
+
+end