asciidoctor-pdf 1.5.0.alpha.16 → 1.5.0

data/lib/asciidoctor/pdf/roman_numeral.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+########################################################################
+#
+# 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 OpenDevise, 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 ::Integer === initial_value
+          @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
+        if (int = @integer_value) < 1
+          return int.to_s
+        end
+        roman = RomanNumeral.int_to_roman int
+        @letter_case == :lower ? roman.downcase : roman
+      end
+
+      def to_i
+        @integer_value
+      end
+
+      def odd?
+        to_i.odd?
+      end
+
+      def even?
+        to_i.even?
+      end
+
+      def next
+        RomanNumeral.new @integer_value + 1, @letter_case
+      end
+
+      def next!
+        @integer_value += 1
+        self
+      end
+
+      def pred
+        RomanNumeral.new @integer_value - 1, @letter_case
+      end
+
+      def empty?
+        false
+      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.join
+      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/sanitizer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Asciidoctor
+  module PDF
+    module Sanitizer
+      XMLSpecialChars = {
+        '&lt;' => ?<,
+        '&gt;' => ?>,
+        '&amp;' => ?&,
+      }
+      XMLSpecialCharsRx = /(?:#{XMLSpecialChars.keys.join ?|})/
+      InverseXMLSpecialChars = XMLSpecialChars.invert
+      InverseXMLSpecialCharsRx = /[#{InverseXMLSpecialChars.keys.join}]/
+      (BuiltInNamedEntities = {
+        'amp' => ?&,
+        'apos' => ?',
+        'gt' => ?>,
+        'lt' => ?<,
+        'nbsp' => ' ',
+        'quot' => ?",
+      }).default = ??
+      SanitizeXMLRx = /<[^>]+>/
+      CharRefRx = /&(?:([a-z][a-z]+\d{0,2})|#(?:(\d\d\d{0,4})|x([a-f\d][a-f\d][a-f\d]{0,3})));/
+
+      # Strip leading, trailing and repeating whitespace, remove XML tags and
+      # resolve all entities in the specified string.
+      #
+      # FIXME move to a module so we can mix it in elsewhere
+      # FIXME add option to control escaping entities, or a filter mechanism in general
+      def sanitize string
+        string = string.gsub SanitizeXMLRx, '' if string.include? '<'
+        string = string.gsub(CharRefRx) { $1 ? BuiltInNamedEntities[$1] : ([$2 ? $2.to_i : ($3.to_i 16)].pack 'U1') } if string.include? '&'
+        string.strip.tr_s ' ', ' '
+      end
+
+      def escape_xml string
+        string.gsub InverseXMLSpecialCharsRx, InverseXMLSpecialChars
+      end
+
+      def encode_quotes string
+        (string.include? ?") ? (string.gsub ?", '&quot;') : string
+      end
+    end
+  end
+end

data/lib/asciidoctor/pdf/text_transformer.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+unless RUBY_VERSION >= '2.4'
+  begin
+    require 'unicode' unless defined? Unicode::VERSION
+  rescue LoadError
+    begin
+      require 'active_support/multibyte' unless defined? ActiveSupport::Multibyte
+    rescue LoadError; end
+  end
+end
+
+module Asciidoctor
+  module PDF
+    module TextTransformer
+      XMLMarkupRx = /&#?[a-z\d]+;|</
+      PCDATAFilterRx = /(&#?[a-z\d]+;|<[^>]+>)|([^&<]+)/
+      TagFilterRx = /(<[^>]+>)|([^<]+)/
+      WordRx = /\S+/
+      SoftHyphen = ?\u00ad
+
+      def capitalize_words_pcdata string
+        if XMLMarkupRx.match? string
+          string.gsub(PCDATAFilterRx) { $2 ? (capitalize_words_mb $2) : $1 }
+        else
+          capitalize_words_mb string
+        end
+      end
+
+      def capitalize_words_mb string
+        string.gsub(WordRx) { capitalize_mb $& }
+      end
+
+      def hyphenate_words_pcdata string, hyphenator
+        if XMLMarkupRx.match? string
+          string.gsub(PCDATAFilterRx) { $2 ? (hyphenate_words $2, hyphenator) : $1 }
+        else
+          hyphenate_words string, hyphenator
+        end
+      end
+
+      def hyphenate_words string, hyphenator
+        string.gsub(WordRx) { hyphenator.visualize $&, SoftHyphen }
+      end
+
+      def lowercase_pcdata string
+        if string.include? '<'
+          string.gsub(TagFilterRx) { $2 ? (lowercase_mb $2) : $1 }
+        else
+          lowercase_mb string
+        end
+      end
+
+      def uppercase_pcdata string
+        if XMLMarkupRx.match? string
+          string.gsub(PCDATAFilterRx) { $2 ? (uppercase_mb $2) : $1 }
+        else
+          uppercase_mb string
+        end
+      end
+
+      if RUBY_VERSION >= '2.4'
+        def capitalize_mb string
+          string.capitalize
+        end
+
+        def lowercase_mb string
+          string.downcase
+        end
+
+        def uppercase_mb string
+          string.upcase
+        end
+      # NOTE Unicode library is 4x as fast as ActiveSupport::MultiByte::Chars
+      elsif defined? ::Unicode
+        def capitalize_mb string
+          string.ascii_only? ? string.capitalize : (::Unicode.capitalize string)
+        end
+
+        def lowercase_mb string
+          string.ascii_only? ? string.downcase : (::Unicode.downcase string)
+        end
+
+        def uppercase_mb string
+          string.ascii_only? ? string.upcase : (::Unicode.upcase string)
+        end
+      elsif defined? ::ActiveSupport::Multibyte
+        MultibyteChars = ::ActiveSupport::Multibyte::Chars
+
+        def capitalize_mb string
+          string.ascii_only? ? string.capitalize : (MultibyteChars.new string).capitalize.to_s
+        end
+
+        def lowercase_mb string
+          string.ascii_only? ? string.downcase : (MultibyteChars.new string).downcase.to_s
+        end
+
+        def uppercase_mb string
+          string.ascii_only? ? string.upcase : (MultibyteChars.new string).upcase.to_s
+        end
+      else
+        def capitalize_mb string
+          string.capitalize
+        end
+
+        def lowercase_mb string
+          string.downcase
+        end
+
+        def uppercase_mb string
+          string.upcase
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/pdf/theme_loader.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require 'safe_yaml/load'
+require 'ostruct'
+require_relative 'measurements'
+
+module Asciidoctor
+  module PDF
+    class ThemeLoader
+      include ::Asciidoctor::PDF::Measurements
+      include ::Asciidoctor::Logging
+
+      DataDir = ::File.absolute_path %(#{__dir__}/../../../data)
+      ThemesDir = ::File.join DataDir, 'themes'
+      FontsDir = ::File.join DataDir, 'fonts'
+      BaseThemePath = ::File.join ThemesDir, 'base-theme.yml'
+
+      VariableRx = /\$([a-z0-9_-]+)/
+      LoneVariableRx = /^\$([a-z0-9_-]+)$/
+      HexColorEntryRx = /^(?<k> *\p{Graph}+): +(?!null$)(?<q>["']?)(?<h>#)?(?<v>[a-fA-F0-9]{3,6})\k<q> *(?:#.*)?$/
+      MultiplyDivideOpRx = /(-?\d+(?:\.\d+)?) +([*\/]) +(-?\d+(?:\.\d+)?)/
+      AddSubtractOpRx = /(-?\d+(?:\.\d+)?) +([+\-]) +(-?\d+(?:\.\d+)?)/
+      PrecisionFuncRx = /^(round|floor|ceil)\(/
+
+      # TODO: implement white? & black? methods
+      module ColorValue; end
+
+      class HexColorValue < String
+        include ColorValue
+      end
+
+      # A marker module for a normalized CMYK array
+      # Prevents normalizing CMYK value more than once
+      module CMYKColorValue
+        include ColorValue
+        def to_s
+          %([#{join ', '}])
+        end
+      end
+
+      def self.resolve_theme_file theme_name = nil, theme_dir = nil
+        # NOTE if .yml extension is given, assume it's a path (don't append -theme.yml)
+        if theme_name && (theme_name.end_with? '.yml')
+          # FIXME: restrict to jail!
+          if theme_dir
+            theme_path = ::File.absolute_path theme_name, (theme_dir = ::File.expand_path theme_dir)
+          else
+            theme_path = ::File.expand_path theme_name
+            theme_dir = ::File.dirname theme_path
+          end
+        else
+          theme_dir = theme_dir ? (::File.expand_path theme_dir) : ThemesDir
+          theme_path = ::File.absolute_path ::File.join theme_dir, %(#{theme_name || 'default'}-theme.yml)
+        end
+        [theme_path, theme_dir]
+      end
+
+      def self.resolve_theme_asset asset_path, theme_dir = nil
+        ::File.absolute_path asset_path, (theme_dir || ThemesDir)
+      end
+
+      # NOTE base theme is loaded "as is" (no post-processing)
+      def self.load_base_theme
+        (::OpenStruct.new ::SafeYAML.load_file BaseThemePath).tap {|theme| theme.__dir__ = ThemesDir }
+      end
+
+      def self.load_theme theme_name = nil, theme_dir = nil
+        theme_path, theme_dir = resolve_theme_file theme_name, theme_dir
+        if theme_path == BaseThemePath
+          load_base_theme
+        else
+          theme_data = load_file theme_path, nil, theme_dir
+          unless (::File.dirname theme_path) == ThemesDir
+            theme_data.base_align ||= 'left'
+            theme_data.base_line_height ||= 1
+            theme_data.base_font_color ||= '000000'
+            theme_data.code_font_family ||= (theme_data.literal_font_family || 'Courier')
+            theme_data.conum_font_family ||= (theme_data.literal_font_family || 'Courier')
+            if (heading_font_family = theme_data.heading_font_family)
+              theme_data.abstract_title_font_family ||= heading_font_family
+              theme_data.sidebar_title_font_family ||= heading_font_family
+            end
+          end
+          theme_data.__dir__ = theme_dir
+          theme_data
+        end
+      end
+
+      def self.load_file filename, theme_data = nil, theme_dir = nil
+        data = ::File.read filename, mode: 'r:UTF-8', newline: :universal
+        data = data.each_line.map {|line|
+          line.sub(HexColorEntryRx) { %(#{(m = $~)[:k]}: #{m[:h] || (m[:k].end_with? 'color') ? "'#{m[:v]}'" : m[:v]}) }
+        }.join unless (::File.dirname filename) == ThemesDir
+        yaml_data = ::SafeYAML.load data, filename
+        if ::Hash === yaml_data && (yaml_data.key? 'extends')
+          if (extends = yaml_data.delete 'extends')
+            [*extends].each do |extend_path|
+              if extend_path == 'base'
+                theme_data = theme_data ? (::OpenStruct.new theme_data.to_h.merge load_base_theme.to_h) : load_base_theme
+                next
+              elsif extend_path == 'default' || extend_path == 'default-with-fallback-font'
+                extend_path, extend_theme_dir = resolve_theme_file extend_path, ThemesDir
+              elsif extend_path.start_with? './'
+                extend_path, extend_theme_dir = resolve_theme_file extend_path, (::File.dirname filename)
+              else
+                extend_path, extend_theme_dir = resolve_theme_file extend_path, theme_dir
+              end
+              theme_data = load_file extend_path, theme_data, extend_theme_dir
+            end
+          end
+        else
+          theme_data ||= ((::File.dirname filename) == ThemesDir ? nil : load_base_theme)
+        end
+        new.load yaml_data, theme_data
+      end
+
+      def load hash, theme_data = nil
+        ::Hash === hash ? hash.reduce(theme_data || ::OpenStruct.new) {|data, (key, val)| process_entry key, val, data, true } : (theme_data || ::OpenStruct.new)
+      end
+
+      private
+
+      def process_entry key, val, data, normalize_key = false
+        key = key.tr '-', '_' if normalize_key && (key.include? '-')
+        if key == 'font'
+          val.each do |subkey, subval|
+            process_entry %(#{key}_#{subkey}), subval, data if subkey == 'catalog' || subkey == 'fallbacks'
+          end if ::Hash === val
+        elsif key == 'font_catalog'
+          data[key] = ::Hash === val ? (val.reduce (val.delete 'merge') ? data[key] || {} : {} do |accum, (name, styles)| # rubocop:disable Style/EachWithObject
+            styles = %w(normal bold italic bold_italic).map {|style| [style, styles] }.to_h if ::String === styles
+            accum[name] = styles.reduce({}) do |subaccum, (style, path)| # rubocop:disable Style/EachWithObject
+              if (path.start_with? 'GEM_FONTS_DIR') && (sep = path[13])
+                path = %(#{FontsDir}#{sep}#{path.slice 14, path.length})
+              end
+              subaccum[style == 'regular' ? 'normal' : style] = expand_vars path, data
+              subaccum
+            end if ::Hash === styles
+            accum
+          end) : {}
+        elsif key == 'font_fallbacks'
+          data[key] = ::Array === val ? val.map {|name| expand_vars name.to_s, data } : []
+        elsif key.start_with? 'admonition_icon_'
+          data[key] = val ? val.map {|(key2, val2)|
+            key2 = key2.tr '-', '_' if key2.include? '-'
+            [key2.to_sym, (key2.end_with? '_color') ? (to_color evaluate val2, data) : (evaluate val2, data)]
+          }.to_h : {}
+        elsif ::Hash === val
+          val.each do |subkey, subval|
+            process_entry %(#{key}_#{key == 'role' || !(subkey.include? '-') ? subkey : (subkey.tr '-', '_')}), subval, data
+          end
+        elsif key.end_with? '_color'
+          # QUESTION do we really need to evaluate_math in this case?
+          data[key] = to_color evaluate val, data
+        elsif key.end_with? '_content'
+          data[key] = (expand_vars val.to_s, data).to_s
+        else
+          data[key] = evaluate val, data
+        end
+        data
+      end
+
+      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
+
+      # NOTE we assume expr is a String
+      def expand_vars expr, vars
+        if (idx = (expr.index '$'))
+          if idx == 0 && expr =~ LoneVariableRx
+            if (key = $1).include? '-'
+              key = key.tr '-', '_'
+            end
+            if vars.respond_to? key
+              vars[key]
+            else
+              logger.warn %(unknown variable reference in PDF theme: $#{$1})
+              expr
+            end
+          else
+            expr.gsub VariableRx do
+              if (key = $1).include? '-'
+                key = key.tr '-', '_'
+              end
+              if vars.respond_to? key
+                vars[key]
+              else
+                logger.warn %(unknown variable reference in PDF theme: $#{$1})
+                $&
+              end
+            end
+          end
+        else
+          expr
+        end
+      end
+
+      def evaluate_math expr
+        return expr if !(::String === expr) || ColorValue === expr
+        # resolve measurement values (e.g., 0.5in => 36)
+        # QUESTION should we round the value? perhaps leave that to the precision functions
+        # NOTE leave % as a string; handled by converter for now
+        original, expr = expr, (resolve_measurement_values expr)
+        loop do
+          if (expr.count '*/') > 0
+            result = expr.gsub(MultiplyDivideOpRx) { $1.to_f.send $2.to_sym, $3.to_f }
+            unchanged = (result == expr)
+            expr = result
+            break if unchanged
+          else
+            break
+          end
+        end
+        loop do
+          if (expr.count '+-') > 0
+            result = expr.gsub(AddSubtractOpRx) { $1.to_f.send $2.to_sym, $3.to_f }
+            unchanged = (result == expr)
+            expr = result
+            break if unchanged
+          else
+            break
+          end
+        end
+        if (expr.end_with? ')') && expr =~ PrecisionFuncRx
+          op = $1
+          offset = op.length + 1
+          expr = expr[offset...-1].to_f.send op.to_sym
+        end
+        if expr == original
+          original
+        else
+          (int_val = expr.to_i) == (flt_val = expr.to_f) ? int_val : flt_val
+        end
+      end
+
+      def to_color value
+        case value
+        when ColorValue
+          # already converted
+          return value
+        when ::Array
+          case value.length
+          # CMYK value
+          when 4
+            value = value.map do |e|
+              if ::Numeric === e
+                e *= 100.0 unless e > 1
+              else
+                e = e.to_s.chomp('%').to_f
+              end
+              e == (int_e = e.to_i) ? int_e : e
+            end
+            case value
+            when [0, 0, 0, 0]
+              return HexColorValue.new 'FFFFFF'
+            when [100, 100, 100, 100]
+              return HexColorValue.new '000000'
+            else
+              value.extend CMYKColorValue
+              return value
+            end
+          # RGB value
+          when 3
+            return HexColorValue.new value.map {|e| '%02X' % e }.join
+          # Nonsense array value; flatten to string
+          else
+            value = value.join
+          end
+        when ::String
+          if value == 'transparent'
+            # FIXME: should we have a TransparentColorValue class?
+            return HexColorValue.new value
+          elsif value.length == 6
+            return HexColorValue.new value.upcase
+          end
+        when ::NilClass
+          return nil
+        else
+          # Unknown type (usually Integer); coerce to String
+          if (value = value.to_s).length == 6
+            return HexColorValue.new value.upcase
+          end
+        end
+        case value.length
+        when 6
+          resolved_value = value
+        when 3
+          # expand hex shorthand (e.g., f00 -> ff0000)
+          resolved_value = value.each_char.map {|c| c * 2 }.join
+        else
+          # truncate or pad with leading zeros (e.g., ff -> 0000ff)
+          resolved_value = (value.slice 0, 6).rjust 6, '0'
+        end
+        HexColorValue.new resolved_value.upcase
+      end
+    end
+  end
+end

data/lib/asciidoctor/pdf/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Asciidoctor
+  module PDF
+    VERSION = '1.5.0'
+  end
+  Pdf = PDF unless const_defined? :Pdf, false
+end

data/lib/asciidoctor/pdf.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'pdf/version'
+require 'asciidoctor' unless defined? Asciidoctor.load
+require 'prawn'
+begin
+  require 'prawn/gmagick'
+rescue LoadError
+end unless defined? GMagick::Image
+require_relative 'pdf/measurements'
+require_relative 'pdf/sanitizer'
+require_relative 'pdf/text_transformer'
+require_relative 'pdf/ext'
+require_relative 'pdf/theme_loader'
+require_relative 'pdf/converter'