zine_brewer 1.3.2 → 1.5.0

data/vendor/bundle/ruby/2.7.0/gems/kramdown-2.3.0/VERSION

@@ -0,0 +1 @@
+2.3.0

data/vendor/bundle/ruby/2.7.0/gems/kramdown-2.3.0/bin/kramdown

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown which is licensed under the MIT.
+#++
+#
+
+require 'optparse'
+require 'rbconfig'
+require 'yaml'
+require 'kramdown'
+
+def add_kramdown_options(opts, parsed_options, banner: [], ignore: [])
+  banner_shown = false
+  defined_options = []
+  Kramdown::Options.definitions.sort.each do |n, definition|
+    next if ignore.include?(n)
+
+    unless banner_shown
+      opts.separator("")
+      banner.each {|part| opts.separator(part) }
+      opts.separator("")
+      banner_shown = true
+    end
+
+    defined_options << n
+    no = n.to_s.tr('_', '-')
+    if definition.type == Kramdown::Options::Boolean
+      opts.on("--[no-]#{no}") {|v| parsed_options[n] = Kramdown::Options.parse(n, v) }
+    else
+      type = definition.type
+      type = String if type == Symbol || type == Object
+      opts.on("--#{no} ARG", type) {|v| parsed_options[n] = Kramdown::Options.parse(n, v) }
+    end
+
+    definition.desc.split(/\n/).each do |line|
+      opts.separator opts.summary_indent + ' ' * 6 + line
+    end
+    opts.separator ''
+  end
+  defined_options
+end
+
+config_file = nil
+begin
+  config_dir = case RbConfig::CONFIG['host_os']
+               when /bccwin|cygwin|djgpp|mingw|mswin|wince/i
+                 File.expand_path((ENV['HOME'] || ENV['USERPROFILE'] || "~") + "/AppData/Local")
+               when /darwin|mac os/
+                 File.expand_path("~/Library/Preferences/")
+               else
+                 File.expand_path(ENV['XDG_CONFIG_HOME'] || '~/.config')
+               end
+  config_file = File.join(config_dir, "kramdownrc")
+rescue StandardError
+end
+
+options = {}
+format = ['html']
+
+defined_options = []
+OptionParser.new do |opts|
+  opts.banner = "Usage: kramdown [options] [FILE FILE ...]"
+  opts.summary_indent = ' ' * 4
+
+  opts.separator ""
+  opts.separator "Command line options:"
+  opts.separator ""
+
+  opts.on("-i", "--input ARG", "Specify the input format: kramdown (default), " \
+          "html, or markdown") {|v| options[:input] = v }
+  opts.on("-o", "--output ARG", Array, "Specify one or more output formats separated by commas: " \
+          "html (default),", "kramdown, latex, man or remove_html_tags") {|v| format = v }
+  opts.on("-x", "--extension EXT", Array, "Load one or more extensions (without the 'kramdown-' " \
+          "prefix) separated", "by commas (e.g. parser-gfm,syntax-coderay)",
+          "Note: Use this option before other options!") do |exts|
+    exts.each do |ext|
+      begin
+        require "kramdown-#{ext}"
+        new_options = add_kramdown_options(opts, options, banner: ["#{ext} options:"],
+                                           ignore: defined_options)
+        defined_options.concat(new_options)
+      rescue LoadError
+        $stderr.puts "Couldn't load extension #{ext}, ignoring"
+      end
+    end
+  end
+  opts.separator ""
+  opts.on("--no-config-file", "Do not read any configuration file. Default behavior is to check " \
+          "for a", "configuration file and read it if it exists.") { config_file = nil }
+  opts.on("--config-file FILE", "Specify the name of a configuration file with kramdown options " \
+          "in YAML", "format, e.g. \"auto_id_prefix: ARG\" instead of \"--auto-id-prefix ARG\"",
+          "and \"auto_ids: false\" instead of \"--no-auto-ids\".",
+          "Default: #{config_file}") {|v| config_file = v }
+  opts.separator ""
+  opts.on("-v", "--version", "Show the version of kramdown") do
+    puts Kramdown::VERSION
+    exit
+  end
+  opts.on("-h", "--help", "Show the help") do
+    puts opts.summarize('', 5, 72)
+    exit
+  end
+
+  new_options = add_kramdown_options(opts, options, banner: ["kramdown options:"])
+  defined_options.concat(new_options)
+end.parse!
+
+begin
+  if config_file && File.exist?(config_file)
+    config_file_options = YAML.safe_load(File.read(config_file), [Symbol])
+    case config_file_options
+    when nil # empty configuration file except perhaps YAML header and comments
+      # Nothing to do
+    when Hash
+      options = config_file_options.merge(options)
+    else
+      raise Kramdown::Error, "No YAML map in configuration file \"#{config_file}\""
+    end
+  end
+  doc = Kramdown::Document.new(ARGF.read, options)
+  result = ''
+  format.each {|f| result = doc.send("to_#{f}") }
+  puts result
+  doc.warnings.each {|warn| $stderr.puts "Warning: #{warn}" }
+rescue Kramdown::Error => e
+  $stderr.puts "Error: #{e.message}"
+  exit(1)
+end

data/vendor/bundle/ruby/2.7.0/gems/kramdown-2.3.0/data/kramdown/document.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <% if @converter.root.options[:encoding] %>
+    <meta http-equiv="Content-type" content="text/html;charset=<%= @converter.root.options[:encoding] %>">
+    <% end %>
+<%
+extend ::Kramdown::Utils::Html
+title = ''
+h = @converter.root.children.find {|c| c.type == :header}
+if h
+  collector = lambda {|c| c.children.collect {|cc| cc.type == :text ? escape_html(cc.value, :text) : collector.call(cc)}.join('')}
+  title = collector.call(h)
+end
+%>
+    <title><%= title %></title>
+    <meta name="generator" content="kramdown <%= ::Kramdown::VERSION %>" />
+  </head>
+  <body>
+  <%= @body %>
+  </body>
+</html>

data/vendor/bundle/ruby/2.7.0/gems/kramdown-2.3.0/data/kramdown/document.latex

@@ -0,0 +1,50 @@
+<%
+encmap = {
+  'UTF-8' => 'utf8x',
+  'US-ASCII' => 'ascii',
+  'ISO-8859-1' => 'latin1',
+  'ISO-8859-2' => 'latin2',
+  'ISO-8859-3' => 'latin3',
+  'ISO-8859-4' => 'latin4',
+  'ISO-8859-5' => 'latin5',
+  'ISO-8859-9' => 'latin9',
+  'ISO-8859-10' => 'latin10',
+  'CP850' => 'cp850',
+  'CP852' => 'cp852',
+  'CP858' => 'cp858',
+  'CP437' => 'cp437',
+  'CP865' => 'cp865',
+  'CP1250' => 'cp120',
+  'CP1252' => 'cp1252',
+  'CP1257' => 'cp1257'
+}
+%>
+\documentclass{scrartcl}
+<% if RUBY_VERSION >= '1.9' %>
+\usepackage[<%= encmap[@body.encoding.name] %>]{inputenc}
+<% else %>
+\usepackage[mathletters]{ucs}
+\usepackage[utf8x]{inputenc}
+<% end %>
+\usepackage[T1]{fontenc}
+\usepackage{listings}
+<% @converter.data[:packages].each {|pkg| %>\usepackage{<%= pkg %>}
+<% } %>
+\usepackage{hyperref}
+
+<% if @converter.data[:packages].include?('fancyvrb') %>
+\VerbatimFootnotes
+<% end %>
+
+<% if @converter.data[:packages].include?('acronym') %>
+<%   @converter.root.options[:abbrev_defs].each_pair do |k,v| %>\acrodef{<%= @converter.normalize_abbreviation_key(k) %>}[<%= k %>]{<%= @converter.escape(v) %>}
+<%   end %>
+<% end %>
+
+\setcounter{footnote}{<%= @converter.options[:footnote_nr] - 1 %>}
+
+\hypersetup{colorlinks=true,urlcolor=blue}
+
+\begin{document}
+<%= @body %>
+\end{document}

data/vendor/bundle/ruby/2.7.0/gems/kramdown-2.3.0/lib/kramdown.rb

@@ -0,0 +1,10 @@
+# -*- coding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown which is licensed under the MIT.
+#++
+#
+
+require 'kramdown/document'

data/vendor/bundle/ruby/2.7.0/gems/kramdown-2.3.0/lib/kramdown/converter.rb

@@ -0,0 +1,68 @@
+# -*- coding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown which is licensed under the MIT.
+#++
+#
+
+require 'kramdown/utils'
+
+module Kramdown
+
+  # This module contains all available converters, i.e. classes that take a root Element and convert
+  # it to a specific output format. The result is normally a string. For example, the
+  # Converter::Html module converts an element tree into valid HTML.
+  #
+  # Converters use the Base class for common functionality (like applying a template to the output)
+  # \- see its API documentation for how to create a custom converter class.
+  module Converter
+
+    autoload :Base, 'kramdown/converter/base'
+    autoload :Html, 'kramdown/converter/html'
+    autoload :Latex, 'kramdown/converter/latex'
+    autoload :Kramdown, 'kramdown/converter/kramdown'
+    autoload :Toc, 'kramdown/converter/toc'
+    autoload :RemoveHtmlTags, 'kramdown/converter/remove_html_tags'
+    autoload :HashAST, 'kramdown/converter/hash_ast'
+    autoload :HashAst, 'kramdown/converter/hash_ast'
+    autoload :Man, 'kramdown/converter/man'
+
+    extend ::Kramdown::Utils::Configurable
+
+    configurable(:syntax_highlighter)
+
+    ['Minted', "Rouge"].each do |klass_name|
+      kn_down = klass_name.downcase.intern
+      add_syntax_highlighter(kn_down) do |converter, text, lang, type, opts|
+        require "kramdown/converter/syntax_highlighter/#{kn_down}"
+        klass = ::Kramdown::Utils.deep_const_get("::Kramdown::Converter::SyntaxHighlighter::#{klass_name}")
+        if !klass.const_defined?(:AVAILABLE) || klass::AVAILABLE
+          add_syntax_highlighter(kn_down, klass)
+        else
+          add_syntax_highlighter(kn_down) { nil }
+        end
+        syntax_highlighter(kn_down).call(converter, text, lang, type, opts)
+      end
+    end
+
+    configurable(:math_engine)
+
+    ["Mathjax"].each do |klass_name|
+      kn_down = klass_name.downcase.intern
+      add_math_engine(kn_down) do |converter, el, opts|
+        require "kramdown/converter/math_engine/#{kn_down}"
+        klass = ::Kramdown::Utils.deep_const_get("::Kramdown::Converter::MathEngine::#{klass_name}")
+        if !klass.const_defined?(:AVAILABLE) || klass::AVAILABLE
+          add_math_engine(kn_down, klass)
+        else
+          add_math_engine(kn_down) { nil }
+        end
+        math_engine(kn_down).call(converter, el, opts)
+      end
+    end
+
+  end
+
+end

data/vendor/bundle/ruby/2.7.0/gems/kramdown-2.3.0/lib/kramdown/converter/base.rb

@@ -0,0 +1,257 @@
+# -*- coding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown which is licensed under the MIT.
+#++
+#
+
+require 'erb'
+require 'kramdown/utils'
+require 'kramdown/document'
+
+module Kramdown
+
+  module Converter
+
+    # == \Base class for converters
+    #
+    # This class serves as base class for all converters. It provides methods that can/should be
+    # used by all converters (like #generate_id) as well as common functionality that is
+    # automatically applied to the result (for example, embedding the output into a template).
+    #
+    # A converter object is used as a throw-away object, i.e. it is only used for storing the needed
+    # state information during conversion. Therefore one can't instantiate a converter object
+    # directly but only use the Base::convert method.
+    #
+    # == Implementing a converter
+    #
+    # Implementing a new converter is rather easy: just derive a new class from this class and put
+    # it in the Kramdown::Converter module (the latter is only needed if auto-detection should work
+    # properly). Then you need to implement the #convert method which has to contain the conversion
+    # code for converting an element and has to return the conversion result.
+    #
+    # The actual transformation of the document tree can be done in any way. However, writing one
+    # method per element type is a straight forward way to do it - this is how the Html and Latex
+    # converters do the transformation.
+    #
+    # Have a look at the Base::convert method for additional information!
+    class Base
+
+      # Can be used by a converter for storing arbitrary information during the conversion process.
+      attr_reader :data
+
+      # The hash with the conversion options.
+      attr_reader :options
+
+      # The root element that is converted.
+      attr_reader :root
+
+      # The warnings array.
+      attr_reader :warnings
+
+      # Initialize the converter with the given +root+ element and +options+ hash.
+      def initialize(root, options)
+        @options = options
+        @root = root
+        @data = {}
+        @warnings = []
+      end
+      private_class_method(:new, :allocate)
+
+      # Returns whether the template should be applied before the conversion of the tree.
+      #
+      # Defaults to false.
+      def apply_template_before?
+        false
+      end
+
+      # Returns whether the template should be applied after the conversion of the tree.
+      #
+      # Defaults to true.
+      def apply_template_after?
+        true
+      end
+
+      # Convert the element tree +tree+ and return the resulting conversion object (normally a
+      # string) and an array with warning messages. The parameter +options+ specifies the conversion
+      # options that should be used.
+      #
+      # Initializes a new instance of the calling class and then calls the #convert method with
+      # +tree+ as parameter.
+      #
+      # If the +template+ option is specified and non-empty, the template is evaluate with ERB
+      # before and/or after the tree conversion depending on the result of #apply_template_before?
+      # and #apply_template_after?. If the template is evaluated before, an empty string is used for
+      # the body; if evaluated after, the result is used as body. See ::apply_template.
+      #
+      # The template resolution is done in the following way (for the converter ConverterName):
+      #
+      # 1. Look in the current working directory for the template.
+      #
+      # 2. Append +.converter_name+ (e.g. +.html+) to the template name and look for the resulting
+      #    file in the current working directory (the form +.convertername+ is deprecated).
+      #
+      # 3. Append +.converter_name+ to the template name and look for it in the kramdown data
+      #    directory (the form +.convertername+ is deprecated).
+      #
+      # 4. Check if the template name starts with 'string://' and if so, strip this prefix away and
+      #    use the rest as template.
+      def self.convert(tree, options = {})
+        converter = new(tree, ::Kramdown::Options.merge(options.merge(tree.options[:options] || {})))
+
+        if !converter.options[:template].empty? && converter.apply_template_before?
+          apply_template(converter, '')
+        end
+        result = converter.convert(tree)
+        if result.respond_to?(:encode!) && result.encoding != Encoding::BINARY
+          result.encode!(tree.options[:encoding] ||
+                         (raise ::Kramdown::Error, "Missing encoding option on root element"))
+        end
+        if !converter.options[:template].empty? && converter.apply_template_after?
+          result = apply_template(converter, result)
+        end
+
+        [result, converter.warnings]
+      end
+
+      # Convert the element +el+ and return the resulting object.
+      #
+      # This is the only method that has to be implemented by sub-classes!
+      def convert(_el)
+        raise NotImplementedError
+      end
+
+      # Apply the +template+ using +body+ as the body string.
+      #
+      # The template is evaluated using ERB and the body is available in the @body instance variable
+      # and the converter object in the @converter instance variable.
+      def self.apply_template(converter, body) # :nodoc:
+        erb = ERB.new(get_template(converter.options[:template]))
+        obj = Object.new
+        obj.instance_variable_set(:@converter, converter)
+        obj.instance_variable_set(:@body, body)
+        erb.result(obj.instance_eval { binding })
+      end
+
+      # Return the template specified by +template+.
+      def self.get_template(template) # :nodoc:
+        format_ext = '.' + ::Kramdown::Utils.snake_case(self.name.split(/::/).last)
+        shipped = File.join(::Kramdown.data_dir, template + format_ext)
+        if File.exist?(template)
+          File.read(template)
+        elsif File.exist?(template + format_ext)
+          File.read(template + format_ext)
+        elsif File.exist?(shipped)
+          File.read(shipped)
+        elsif template.start_with?('string://')
+          template.sub(/\Astring:\/\//, '')
+        else
+          raise "The specified template file #{template} does not exist"
+        end
+      end
+
+      # Add the given warning +text+ to the warning array.
+      def warning(text)
+        @warnings << text
+      end
+
+      # Return +true+ if the header element +el+ should be used for the table of contents (as
+      # specified by the +toc_levels+ option).
+      def in_toc?(el)
+        @options[:toc_levels].include?(el.options[:level]) && (el.attr['class'] || '') !~ /\bno_toc\b/
+      end
+
+      # Return the output header level given a level.
+      #
+      # Uses the +header_offset+ option for adjusting the header level.
+      def output_header_level(level)
+        [[level + @options[:header_offset], 6].min, 1].max
+      end
+
+      # Extract the code block/span language from the attributes.
+      def extract_code_language(attr)
+        if attr['class'] && attr['class'] =~ /\blanguage-\S+/
+          attr['class'].scan(/\blanguage-(\S+)/).first.first
+        end
+      end
+
+      # See #extract_code_language
+      #
+      # *Warning*: This version will modify the given attributes if a language is present.
+      def extract_code_language!(attr)
+        lang = extract_code_language(attr)
+        attr['class'] = attr['class'].sub(/\blanguage-\S+/, '').strip if lang
+        attr.delete('class') if lang && attr['class'].empty?
+        lang
+      end
+
+      # Highlight the given +text+ in the language +lang+ with the syntax highlighter configured
+      # through the option 'syntax_highlighter'.
+      def highlight_code(text, lang, type, opts = {})
+        return nil unless @options[:syntax_highlighter]
+
+        highlighter = ::Kramdown::Converter.syntax_highlighter(@options[:syntax_highlighter])
+        if highlighter
+          highlighter.call(self, text, lang, type, opts)
+        else
+          warning("The configured syntax highlighter #{@options[:syntax_highlighter]} is not available.")
+          nil
+        end
+      end
+
+      # Format the given math element with the math engine configured through the option
+      # 'math_engine'.
+      def format_math(el, opts = {})
+        return nil unless @options[:math_engine]
+
+        engine = ::Kramdown::Converter.math_engine(@options[:math_engine])
+        if engine
+          engine.call(self, el, opts)
+        else
+          warning("The configured math engine #{@options[:math_engine]} is not available.")
+          nil
+        end
+      end
+
+      # Generate an unique alpha-numeric ID from the the string +str+ for use as a header ID.
+      #
+      # Uses the option +auto_id_prefix+: the value of this option is prepended to every generated
+      # ID.
+      def generate_id(str)
+        str = ::Kramdown::Utils::Unidecoder.decode(str) if @options[:transliterated_header_ids]
+        gen_id = basic_generate_id(str)
+        gen_id = 'section' if gen_id.empty?
+        @used_ids ||= {}
+        if @used_ids.key?(gen_id)
+          gen_id += "-#{@used_ids[gen_id] += 1}"
+        else
+          @used_ids[gen_id] = 0
+        end
+        @options[:auto_id_prefix] + gen_id
+      end
+
+      # The basic version of the ID generator, without any special provisions for empty or unique
+      # IDs.
+      def basic_generate_id(str)
+        gen_id = str.gsub(/^[^a-zA-Z]+/, '')
+        gen_id.tr!('^a-zA-Z0-9 -', '')
+        gen_id.tr!(' ', '-')
+        gen_id.downcase!
+        gen_id
+      end
+
+      SMART_QUOTE_INDICES = {lsquo: 0, rsquo: 1, ldquo: 2, rdquo: 3} # :nodoc:
+
+      # Return the entity that represents the given smart_quote element.
+      def smart_quote_entity(el)
+        res = @options[:smart_quotes][SMART_QUOTE_INDICES[el.value]]
+        ::Kramdown::Utils::Entities.entity(res)
+      end
+
+    end
+
+  end
+
+end