zine_brewer 1.3.0 → 1.3.1

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

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

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

@@ -1,132 +0,0 @@
-#!/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

@@ -1,22 +0,0 @@
-<!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

@@ -1,50 +0,0 @@
-<%
-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

@@ -1,10 +0,0 @@
-# -*- 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

@@ -1,68 +0,0 @@
-# -*- 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

@@ -1,257 +0,0 @@
-# -*- 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