asciidoctor-pdf 1.5.0.alpha.1

data/lib/asciidoctor-pdf/prawn_ext/formatted_text/parser.treetop

@@ -0,0 +1,115 @@
+module Asciidoctor
+module Prawn
+grammar FormattedText
+  rule text
+    complex
+  end
+
+  rule complex
+    (cdata / element / entity)* {
+      def content
+        elements.map {|e| e.content }
+      end
+    }
+  end
+
+  rule element
+    # strict tag matching (costs a minor toll)
+    # empty_element / start_tag complex end_tag &{|seq| seq[0].name == seq[2].name } {
+
+    empty_element / start_tag complex end_tag {
+      # NOTE content only applies to non-empty element
+      def content
+        { type: :element, name: (tag_element = elements[0]).name.to_sym, attributes: tag_element.attributes, pcdata: elements[1].content }
+      end
+    }
+  end
+
+  rule empty_element
+    '<br' (spaces? '/')? '>' {
+      def content
+        { type: :element, name: :br, attributes: {} }
+      end
+    }
+  end
+
+  rule start_tag
+    '<' tag_name attributes '>' {
+      def name
+        elements[1].text_value
+      end
+
+      def attributes
+        elements[2].content
+      end
+    }
+  end
+
+  rule tag_name
+    # QUESTION faster to do regex?
+    'a' / 'b' / 'code' / 'color' / 'del' / 'em' / 'font' / 'i' / 'link' / 'span' / 'strikethrough' / 'strong' / 'sub' / 'sup' / 'u'
+  end
+
+  rule attributes
+    attribute* {
+      def content
+        attrs = {}
+        elements.each {|e|
+          attr_name, attr_val = e.content
+          attrs[attr_name.to_sym] = attr_val
+        }
+        attrs
+      end
+    }
+  end
+
+  rule attribute
+    spaces [a-z_]+ '=' '"' [^"]* '"' {
+      def content
+        [elements[1].text_value, elements[4].text_value]
+      end
+    }
+  end
+
+  rule end_tag
+    '</' tag_name '>' {
+      def name
+        elements[1].text_value
+      end
+    }
+  end
+
+  rule cdata
+    [^<&]+ {
+      def content
+        { type: :text, value: text_value }
+      end
+    }
+  end
+
+  rule entity
+    '&' ('#' entity_number / entity_name) ';' {
+      def content
+        if (entity_value = elements[1]).terminal?
+          { type: :entity, name: entity_value.text_value.to_sym }
+        else
+          { type: :entity, number: entity_value.elements[1].text_value.to_i }
+        end
+      end
+    }
+  end
+
+  rule entity_number
+    [0-9] 2..4
+  end
+
+  rule entity_name
+    'amp' / 'apos' / 'gt' / 'lt' / 'quot'
+  end
+
+  rule spaces
+    ' '+
+  end
+end
+end
+end

data/lib/asciidoctor-pdf/prawn_ext/formatted_text/transform.rb

@@ -0,0 +1,178 @@
+module Asciidoctor
+module Prawn
+class FormattedTextTransform
+  def initialize(options = {})
+    @merge_adjacent_text_nodes = options.fetch(:merge_adjacent_text_nodes, false)
+    if (theme = options[:theme])
+      @link_font_color = theme.link_font_color
+      @monospaced_font_color = theme.literal_font_color
+      @monospaced_font_family = theme.literal_font_family
+      @monospaced_font_size = theme.literal_font_size
+      #@monospaced_letter_spacing = theme.literal_letter_spacing
+    else
+      @link_font_color = '0000FF'
+      @monospaced_font_color = nil
+      @monospaced_font_family = 'Courier'
+      @monospaced_font_size = 0.9
+      #@monospaced_letter_spacing = -0.1
+    end
+  end
+
+  # FIXME might want to pass styles downwards rather than decorating on way up
+  def apply(parsed)
+    fragments = []
+    previous_fragment_is_text = false
+    # NOTE using inject is slower than a manual loop
+    parsed.each {|node|
+      case (node_type = node[:type])
+      when :element
+        if (tag_name = node[:name]) == :br
+          if @merge_adjacent_text_nodes && previous_fragment_is_text
+            fragments << { text: %(#{fragments.pop[:text]}\n) }
+          else
+            fragments << { text: "\n" }
+          end
+          previous_fragment_is_text = true
+        else
+          pcdata = node[:pcdata] || []
+          attributes = node[:attributes]
+          fragments << apply(pcdata).map {|fragment|
+            # decorate child fragments with styles from this element
+            build_fragment(fragment, tag_name, attributes)
+          } unless pcdata.size == 0
+          previous_fragment_is_text = false
+        end
+      when :text, :entity
+        node_text = if node_type == :text
+          node[:value]
+        elsif node_type == :entity
+          if (entity_name = node[:name])
+            case entity_name
+            when :lt
+              '<'
+            when :gt
+              '>'
+            when :amp
+              '&'
+            when :quot
+              '"'
+            when :apos
+              '\''
+            end
+          else
+            [node[:number]].pack('U*')
+            # afm fonts do not include a thin space glyph
+            # set fallback_fonts to allow glyph to be resolved
+            #if (node_number = node[:number]) == 8201
+            #  ' '
+            #else
+            #  [node_number].pack('U*')
+            #end
+          end
+        end
+        if @merge_adjacent_text_nodes && previous_fragment_is_text
+          fragments << { text: %(#{fragments.pop[:text]}#{node_text}) }
+        else
+          fragments << { text: node_text }
+        end
+        previous_fragment_is_text = true
+      end
+    }
+    fragments.flatten
+  end
+
+  def build_fragment(fragment, tag_name = nil, attrs = {})
+    #return { text: fragment } if tag_name.nil?
+    styles = (fragment[:styles] ||= ::Set.new)
+    case tag_name
+    when :b, :strong
+      styles << :bold
+    when :i, :em
+      styles << :italic
+    when :code
+      fragment[:font] ||= @monospaced_font_family
+      if @monospaced_font_size
+        fragment[:size] ||= @monospaced_font_size
+      end
+      #if @monospaced_letter_spacing
+      #  fragment[:character_spacing] ||= @monospaced_letter_spacing
+      #end
+      if @monospaced_font_color
+        fragment[:color] ||= @monospaced_font_color
+      end
+    when :color
+      if !fragment[:color]
+        if (rgb = attrs[:rgb])
+          if rgb[0] == '#'
+            rgb = rgb[1..-1]
+          end
+          fragment[:color] = rgb
+        elsif (r = attrs[:r]) && (g = attrs[:g]) && (b = attrs[:b])
+          fragment[:color] = [r, g, b].map {|e| '%02x' % e.to_i }.join
+        elsif (c = attrs[:c]) && (m = attrs[:m]) && (y = attrs[:y]) && (k = attrs[:k])
+          fragment[:color] = [c.to_i, m.to_i, y.to_i, k.to_i]
+        end
+      end
+    when :font
+      if !fragment[:font] && (value = attrs[:name])
+        fragment[:font] = value
+      end
+      if !fragment[:size] && (value = attrs[:size])
+        fragment[:size] = value.to_f
+      end
+      #if !fragment[:character_spacing] && (value = attrs[:character_spacing])
+      #  fragment[:character_spacing] = value.to_f
+      #end
+    when :a, :link
+      if !fragment[:anchor] && (value = attrs[:anchor])
+        fragment[:anchor] = value
+      end
+      if !fragment[:link] && (value = attrs[:href])
+        fragment[:link] = value
+      end
+      if !fragment[:local] && (value = attrs[:local])
+        fragment[:local] = value
+      end
+      fragment[:color] ||= @link_font_color
+    when :sub
+      styles << :subscript
+    when :sup
+      styles << :superscript
+    when :u
+      styles << :underline
+    when :del, :strikethrough
+      styles << :strikethrough
+    when :span
+      # span logic with normal style parsing
+      if (inline_styles = attrs[:style])
+        inline_styles.rstrip.chomp(';').split(';').each do |style|
+          pname, pvalue = style.split(':', 2)
+          case pname
+          when 'color'
+            fragment[:color] = pvalue.tr(' #', '') unless fragment[:color]
+          when 'font-weight'
+            if pvalue.lstrip == 'bold'
+              styles << :bold
+            end
+          when 'font-style'
+            if pvalue.lstrip == 'italic'
+              styles << :italic
+            end
+          end
+        end
+      end
+
+      # quicker span logic that only honors font color
+      #if !fragment[:color] && (value = attrs[:style]) && value.start_with?('color:')
+      #  if value.include?(';')
+      #    value = value.split(';').first
+      #  end
+      #  fragment[:color] = value[6..-1].tr(' #', '')
+      #end
+    end
+    #fragment.delete(:styles) if styles.empty?
+    fragment
+  end
+end
+end
+end

data/lib/asciidoctor-pdf/roman_numeral.rb

@@ -0,0 +1,107 @@
+########################################################################
+#
+# This file was copied from roman-numerals and modified for use with
+# Asciidoctor PDF.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Copyright (c) 2011 Andrew Vos
+# Copyright (c) 2014 OpenDevice, Inc.
+#
+########################################################################
+
+module Asciidoctor
+module Pdf
+class RomanNumeral
+  BaseDigits = {
+    1    => 'I',
+    4    => 'IV',
+    5    => 'V',
+    9    => 'IX',
+    10   => 'X',
+    40   => 'XL',
+    50   => 'L',
+    90   => 'XC',
+    100  => 'C',
+    400  => 'CD',
+    500  => 'D',
+    900  => 'CM',
+    1000 => 'M'
+  }
+
+  def initialize initial_value, letter_case = nil
+    initial_value ||= 1
+    if initial_value.is_a? ::Integer
+      @integer_value = initial_value
+    else
+      @integer_value = RomanNumeral.roman_to_int initial_value
+      letter_case = :lower if letter_case.nil? && initial_value.upcase != initial_value
+    end
+    @letter_case = letter_case.nil? ? :upper : letter_case
+  end
+
+  def to_s
+    to_r
+  end
+
+  def to_r
+    roman = RomanNumeral.int_to_roman @integer_value
+    @letter_case == :lower ? roman.downcase : roman
+  end
+
+  def to_i
+    @integer_value
+  end
+
+  def next
+    RomanNumeral.new @integer_value + 1, @letter_case
+  end
+
+  def next!
+    @integer_value += 1
+    self
+  end
+
+  def self.int_to_roman value
+    result = ''
+    BaseDigits.keys.reverse.each do |ival|
+      while value >= ival
+        value -= ival 
+        result += BaseDigits[ival]
+      end
+    end
+    result
+  end
+
+  def self.roman_to_int value
+    value = value.upcase
+    result = 0
+    BaseDigits.values.reverse.each do |rval|
+      while value.start_with? rval
+        offset = rval.length
+        value = value[offset..offset]
+        result += BaseDigits.key rval
+      end
+    end
+    result
+  end
+end
+end
+end

data/lib/asciidoctor-pdf/theme_loader.rb

@@ -0,0 +1,103 @@
+require 'yaml'
+require 'ostruct'
+require_relative 'core_ext/ostruct'
+
+module Asciidoctor
+module Pdf
+class ThemeLoader
+  DataDir = ::File.expand_path ::File.join(::File.dirname(__FILE__), '..', '..', 'data')
+  ThemesDir = ::File.join DataDir, 'themes'
+  FontsDir = ::File.join DataDir, 'fonts'
+
+  def self.resolve_theme_file theme_name = nil, theme_path = nil
+    theme_name ||= 'default'
+    # if .yml extension is given, assume it's a full file name
+    if theme_name.end_with? '.yml'
+      # FIXME restrict to jail!
+      theme_path ? (::File.join theme_path, theme_name) : theme_name
+    else
+      # QUESTION should we append '-theme.yml' or just '.yml'?
+      ::File.expand_path %(#{theme_name}-theme.yml), (theme_path || ThemesDir)
+    end
+  end
+
+  def self.load_theme theme_name = nil, theme_path = nil
+    load_file (resolve_theme_file theme_name, theme_path)
+  end
+
+  def self.load_file filename
+    theme_hash = YAML.load_file filename
+    self.new.load theme_hash
+  end
+
+  def load hash
+    hash.inject(OpenStruct.new) do |s, (k, v)|
+      if v.kind_of? Hash
+        v.each do |k2, v2|
+          s[%(#{k}_#{k2})] = (k2.end_with? '_color') ? evaluate(v2, s).to_s : evaluate(v2, s)
+        end
+      else
+        s[k] = (k.end_with? '_color') ? evaluate(v, s).to_s : evaluate(v, s)
+      end
+      s
+    end
+  end
+
+  private
+
+  def evaluate expr, vars
+    case expr
+    when String
+      evaluate_math(expand_vars(expr, vars))
+    when Array
+      expr.map {|e| evaluate(e, vars) }
+    else
+      expr
+    end
+  end
+  
+  def expand_vars expr, vars
+    if expr.include? '$'
+      if (expr.start_with? '$') && (expr.match /^\$([a-z0-9_]+)$/)
+        vars[$1]
+      else
+        expr.gsub(/\$([a-z0-9_]+)/) { vars[$1] }
+      end
+    else
+      expr
+    end
+  end
+  
+  def evaluate_math expr
+    return expr unless expr.kind_of? String
+    original = expr
+    while true
+      result = expr.gsub(/(-?\d+(?:\.\d+)?) *([*\/]) *(-?\d+(?:\.\d+)?)/) { $1.to_f.send($2.to_sym, $3.to_f) }
+      unchanged = (result == expr)
+      expr = result
+      break if unchanged
+    end
+    while true
+      result = expr.gsub(/(-?\d+(?:\.\d+)?) *([+\-]) *(-?\d+(?:\.\d+)?)/) { $1.to_f.send($2.to_sym, $3.to_f) }
+      unchanged = (result == expr)
+      expr = result
+      break if unchanged
+    end
+    if (expr.end_with? ')') && (expr.match /^(round|floor|ceil)\(/)
+      op = $1
+      offset = op.length + 1
+      expr = expr[offset...-1].to_f.send(op.to_sym)
+    end
+    if original == expr
+      expr
+    else
+      if ((int_val = expr.to_i) == (float_val = expr.to_f))
+        int_val
+      else
+        float_val
+      end
+    end
+  end
+end
+end
+end