zine_brewer 1.3.0 → 1.3.1

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

@@ -1,300 +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/converter'
-
-module Kramdown
-
-  module Converter
-
-    # Converts a Kramdown::Document to a manpage in groff format. See man(7), groff_man(7) and
-    # man-pages(7) for information regarding the output.
-    class Man < Base
-
-      def convert(el, opts = {indent: 0, result: +''}) #:nodoc:
-        send("convert_#{el.type}", el, opts)
-      end
-
-      private
-
-      def inner(el, opts, use = :all)
-        arr = el.children.reject {|e| e.type == :blank }
-        arr.each_with_index do |inner_el, index|
-          next if use == :rest && index == 0
-          break if use == :first && index > 0
-          options = opts.dup
-          options[:parent] = el
-          options[:index] = index
-          options[:prev] = (index == 0 ? nil : arr[index - 1])
-          options[:next] = (index == arr.length - 1 ? nil : arr[index + 1])
-          convert(inner_el, options)
-        end
-      end
-
-      def convert_root(el, opts)
-        @title_done = false
-        opts[:result] = +".\\\" generated by kramdown\n"
-        inner(el, opts)
-        opts[:result]
-      end
-
-      def convert_blank(*)
-      end
-      alias convert_hr convert_blank
-      alias convert_xml_pi convert_blank
-
-      def convert_p(el, opts)
-        if (opts[:index] != 0 && opts[:prev].type != :header) ||
-            (opts[:parent].type == :blockquote && opts[:index] == 0)
-          opts[:result] << macro("P")
-        end
-        inner(el, opts)
-        newline(opts[:result])
-      end
-
-      def convert_header(el, opts)
-        return unless opts[:parent].type == :root
-        case el.options[:level]
-        when 1
-          unless @title_done
-            @title_done = true
-            data = el.options[:raw_text].scan(/([^(]+)\s*\((\d\w*)\)(?:\s*-+\s*(.*))?/).first ||
-              el.options[:raw_text].scan(/([^\s]+)\s*(?:-*\s+)?()(.*)/).first
-            return unless data && data[0]
-            name = data[0]
-            section = (data[1].to_s.empty? ? el.attr['data-section'] || '7' : data[1])
-            description = (data[2].to_s.empty? ? nil : " - #{data[2]}")
-            date = el.attr['data-date'] ? quote(el.attr['data-date']) : nil
-            extra = (el.attr['data-extra'] ? quote(escape(el.attr['data-extra'].to_s)) : nil)
-            opts[:result] << macro("TH", quote(escape(name.upcase)), quote(section), date, extra)
-            if description
-              opts[:result] << macro("SH", "NAME") << escape("#{name}#{description}") << "\n"
-            end
-          end
-        when 2
-          opts[:result] << macro("SH", quote(escape(el.options[:raw_text])))
-        when 3
-          opts[:result] << macro("SS", quote(escape(el.options[:raw_text])))
-        else
-          warning("Header levels greater than three are not supported")
-        end
-      end
-
-      def convert_codeblock(el, opts)
-        opts[:result] << macro("sp") << macro("RS", 4) << macro("EX")
-        opts[:result] << newline(escape(el.value, true))
-        opts[:result] << macro("EE") << macro("RE")
-      end
-
-      def convert_blockquote(el, opts)
-        opts[:result] << macro("RS")
-        inner(el, opts)
-        opts[:result] << macro("RE")
-      end
-
-      def convert_ul(el, opts)
-        compact = (el.attr['class'] =~ /\bcompact\b/)
-        opts[:result] << macro("sp") << macro("PD", 0) if compact
-        inner(el, opts)
-        opts[:result] << macro("PD") if compact
-      end
-      alias convert_dl convert_ul
-      alias convert_ol convert_ul
-
-      def convert_li(el, opts)
-        sym = (opts[:parent].type == :ul ? '\(bu' : "#{opts[:index] + 1}.")
-        opts[:result] << macro("IP", sym, 4)
-        inner(el, opts, :first)
-        if el.children.size > 1
-          opts[:result] << macro("RS")
-          inner(el, opts, :rest)
-          opts[:result] << macro("RE")
-        end
-      end
-
-      def convert_dt(el, opts)
-        opts[:result] << macro(opts[:prev] && opts[:prev].type == :dt ? "TQ" : "TP")
-        inner(el, opts)
-        opts[:result] << "\n"
-      end
-
-      def convert_dd(el, opts)
-        inner(el, opts, :first)
-        if el.children.size > 1
-          opts[:result] << macro("RS")
-          inner(el, opts, :rest)
-          opts[:result] << macro("RE")
-        end
-        opts[:result] << macro("sp") if opts[:next] && opts[:next].type == :dd
-      end
-
-      TABLE_CELL_ALIGNMENT = {left: 'l', center: 'c', right: 'r', default: 'l'}
-
-      def convert_table(el, opts)
-        opts[:alignment] = el.options[:alignment].map {|a| TABLE_CELL_ALIGNMENT[a] }
-        table_options = ["box"]
-        table_options << "center" if el.attr['class'] =~ /\bcenter\b/
-        opts[:result] << macro("TS") << "#{table_options.join(' ')} ;\n"
-        inner(el, opts)
-        opts[:result] << macro("TE") << macro("sp")
-      end
-
-      def convert_thead(el, opts)
-        opts[:result] << opts[:alignment].map {|a| "#{a}b" }.join(' ') << " .\n"
-        inner(el, opts)
-        opts[:result] << "=\n"
-      end
-
-      def convert_tbody(el, opts)
-        opts[:result] << ".T&\n" if opts[:index] != 0
-        opts[:result] << opts[:alignment].join(' ') << " .\n"
-        inner(el, opts)
-        opts[:result] << (opts[:next].type == :tfoot ? "=\n" : "_\n") if opts[:next]
-      end
-
-      def convert_tfoot(el, opts)
-        inner(el, opts)
-      end
-
-      def convert_tr(el, opts)
-        inner(el, opts)
-        opts[:result] << "\n"
-      end
-
-      def convert_td(el, opts)
-        result = opts[:result]
-        opts[:result] = +''
-        inner(el, opts)
-        if opts[:result] =~ /\n/
-          warning("Table cells using links are not supported")
-          result << "\t"
-        else
-          result << opts[:result] << "\t"
-        end
-      end
-
-      def convert_html_element(*)
-        warning("HTML elements are not supported")
-      end
-
-      def convert_xml_comment(el, opts)
-        newline(opts[:result]) << ".\"#{escape(el.value, true).rstrip.gsub(/\n/, "\n.\"")}\n"
-      end
-      alias convert_comment convert_xml_comment
-
-      def convert_a(el, opts)
-        if el.children.size == 1 && el.children[0].type == :text &&
-            el.attr['href'] == el.children[0].value
-          newline(opts[:result]) << macro("UR", escape(el.attr['href'])) << macro("UE")
-        elsif el.attr['href'].start_with?('mailto:')
-          newline(opts[:result]) << macro("MT", escape(el.attr['href'].sub(/^mailto:/, ''))) <<
-            macro("UE")
-        else
-          newline(opts[:result]) << macro("UR", escape(el.attr['href']))
-          inner(el, opts)
-          newline(opts[:result]) << macro("UE")
-        end
-      end
-
-      def convert_img(_el, _opts)
-        warning("Images are not supported")
-      end
-
-      def convert_em(el, opts)
-        opts[:result] << '\fI'
-        inner(el, opts)
-        opts[:result] << '\fP'
-      end
-
-      def convert_strong(el, opts)
-        opts[:result] << '\fB'
-        inner(el, opts)
-        opts[:result] << '\fP'
-      end
-
-      def convert_codespan(el, opts)
-        opts[:result] << "\\fB#{escape(el.value)}\\fP"
-      end
-
-      def convert_br(_el, opts)
-        newline(opts[:result]) << macro("br")
-      end
-
-      def convert_abbreviation(el, opts)
-        opts[:result] << escape(el.value)
-      end
-
-      def convert_math(el, opts)
-        if el.options[:category] == :block
-          convert_codeblock(el, opts)
-        else
-          convert_codespan(el, opts)
-        end
-      end
-
-      def convert_footnote(*)
-        warning("Footnotes are not supported")
-      end
-
-      def convert_raw(*)
-        warning("Raw content is not supported")
-      end
-
-      def convert_text(el, opts)
-        text = escape(el.value)
-        text.lstrip! if opts[:result][-1] == "\n"
-        opts[:result] << text
-      end
-
-      def convert_entity(el, opts)
-        opts[:result] << unicode_char(el.value.code_point)
-      end
-
-      def convert_smart_quote(el, opts)
-        opts[:result] << unicode_char(::Kramdown::Utils::Entities.entity(el.value.to_s).code_point)
-      end
-
-      TYPOGRAPHIC_SYMS_MAP = {
-        mdash: '\(em', ndash: '\(em', hellip: '\.\.\.',
-        laquo_space: '\[Fo]', raquo_space: '\[Fc]', laquo: '\[Fo]', raquo: '\[Fc]'
-      }
-
-      def convert_typographic_sym(el, opts)
-        opts[:result] << TYPOGRAPHIC_SYMS_MAP[el.value]
-      end
-
-      def macro(name, *args)
-        ".#{[name, *args].compact.join(' ')}\n"
-      end
-
-      def newline(text)
-        text << "\n" unless text[-1] == "\n"
-        text
-      end
-
-      def quote(text)
-        "\"#{text.gsub(/"/, '\\"')}\""
-      end
-
-      def escape(text, preserve_whitespace = false)
-        text = (preserve_whitespace ? text.dup : text.gsub(/\s+/, ' '))
-        text.gsub!('\\', "\\e")
-        text.gsub!(/^\./, '\\\\&.')
-        text.gsub!(/[.'-]/) {|m| "\\#{m}" }
-        text
-      end
-
-      def unicode_char(codepoint)
-        "\\[u#{codepoint.to_s(16).rjust(4, '0')}]"
-      end
-
-    end
-
-  end
-end

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

@@ -1,32 +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.
-#++
-#
-
-module Kramdown::Converter::MathEngine
-
-  # Uses the MathJax javascript library for displaying math.
-  #
-  # Note that the javascript library itself is not include or linked, this has to be done
-  # separately. Only the math content is marked up correctly.
-  module Mathjax
-
-    def self.call(converter, el, opts)
-      value = converter.escape_html(el.value)
-      result = el.options[:category] == :block ?  "\\[#{value}\\]\n" : "\\(#{value}\\)"
-      if el.attr.empty?
-        result
-      elsif el.options[:category] == :block
-        converter.format_as_block_html('div', el.attr, result, opts[:indent])
-      else
-        converter.format_as_span_html('span', el.attr, "$#{el.value}$")
-      end
-    end
-
-  end
-
-end

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

@@ -1,57 +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/converter'
-
-module Kramdown
-
-  module Converter
-
-    # Removes all block (and optionally span) level HTML tags from the element tree.
-    #
-    # This converter can be used on parsed HTML documents to get an element tree that will only
-    # contain native kramdown elements.
-    #
-    # *Note* that the returned element tree may not be fully conformant (i.e. the content models of
-    # *some elements may be violated)!
-    #
-    # This converter modifies the given tree in-place and returns it.
-    class RemoveHtmlTags < Base
-
-      def initialize(root, options)
-        super
-        @options[:template] = ''
-      end
-
-      def convert(el)
-        real_el, el = el, el.value if el.type == :footnote
-
-        children = el.children.dup
-        index = 0
-        while index < children.length
-          if [:xml_pi].include?(children[index].type) ||
-              (children[index].type == :html_element && %w[style script].include?(children[index].value))
-            children[index..index] = []
-          elsif children[index].type == :html_element &&
-            ((@options[:remove_block_html_tags] && children[index].options[:category] == :block) ||
-             (@options[:remove_span_html_tags] && children[index].options[:category] == :span))
-            children[index..index] = children[index].children
-          else
-            convert(children[index])
-            index += 1
-          end
-        end
-        el.children = children
-        real_el || el
-      end
-
-    end
-
-  end
-end

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

@@ -1,56 +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.
-#++
-#
-
-module Kramdown
-  module Converter
-
-    # == Container for Syntax Highlighters
-    #
-    # This module serves as container for the syntax highlighters that can be used together with
-    # kramdown.
-    #
-    # A syntax highlighter should not store any data itself but should use the provided converter
-    # object to do so (See Kramdown::Converter::Base#data).
-    #
-    # == Implementing a Syntax Highlighter
-    #
-    # Implementing a new syntax highlighter is easy because it is just an object that needs to
-    # respond to #call.
-    #
-    # The method #call needs to take the following arguments:
-    #
-    # converter:: This argument contains the converter object that calls the syntax highlighter. It
-    #             can be used, for example, to store data in Kramdown::Converter::Base#data for one
-    #             conversion run.
-    #
-    # text:: The raw text that should be highlighted.
-    #
-    # lang:: The language that the text should be highlighted for (e.g. ruby, python, ...).
-    #
-    # type:: The type of text, either :span for span-level code or :block for a codeblock.
-    #
-    # opts:: A Hash with options that may be passed from the converter.
-    #
-    # The return value of the method should be the highlighted text, suitable for the given
-    # converter (e.g. HTML for the HTML converter).
-    #
-    # == Special Implementation Details
-    #
-    # HTML converter:: If the syntax highlighter is used with an HTML converter, it should return
-    #                  :block type text correctly wrapped (i.e. normally inside a pre-tag, but may
-    #                  also be a table-tag or just a div-tag) but :span type text *without* a
-    #                  code-tag!
-    #
-    #                  Also, a syntax highlighter should store the default highlighting language for
-    #                  the invocation in the +opts+ hash under the key :default_lang.
-    module SyntaxHighlighter
-    end
-
-  end
-end

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

@@ -1,35 +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.
-#++
-#
-
-module Kramdown::Converter::SyntaxHighlighter
-
-  # Uses Minted to highlight code blocks and code spans.
-  module Minted
-
-    def self.call(converter, text, lang, type, _opts)
-      opts = converter.options[:syntax_highlighter_opts]
-
-      # Fallback to default language
-      lang ||= opts[:default_lang]
-
-      options = []
-      options << "breaklines" if opts[:wrap]
-      options << "linenos" if opts[:line_numbers]
-      options << "frame=#{opts[:frame]}" if opts[:frame]
-
-      if lang && type == :block
-        "\\begin{minted}[#{options.join(',')}]{#{lang}}\n#{text}\n\\end{minted}"
-      elsif lang && type == :span
-        "\\mintinline{#{lang}}{#{text}}"
-      else
-        nil
-      end
-    end
-  end
-end