markita 5.0.241001 → 6.0.250327

data/lib/markita/markdown/fold.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Markita top level namespace
+module Markita
+  # Markdown namespace
+  # :reek:InstanceVariableAssumption :reek:ClassVariable
+  class Markdown
+    # Module to isolate from Markdown
+    # :reek:DuplicateMethodCall
+    module Fold
+      RGX = /^[-.]{3} #/
+      METADATA = /^(\w+): (.*)$/
+      def self.scrape4metadata(line, metadata, attributes)
+        if (md = Fold::METADATA.match(line))
+          if (key = md[1]) == 'attributes'
+            attributes.push " #{md[2]}"
+          else
+            metadata[key] = md[2]
+          end
+        end
+      end
+    end
+
+    @@parsers << :fold
+
+    # category: method
+    # :reek:DuplicateMethodCall ok here
+    def fold
+      return false unless Fold::RGX.match?(@line)
+
+      # Fold with optional metadata
+      until Fold::RGX.match?(line_gets)
+        Fold.scrape4metadata(@line, @metadata, @attributes)
+      end
+      line_gets
+      true
+    end
+  end
+end

data/lib/markita/markdown/footnotes.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Markita top level namespace
+module Markita
+  # Markdown namespace
+  # :reek:InstanceVariableAssumption :reek:ClassVariable
+  class Markdown
+    # Module to isolate from Markdown
+    module Footnotes
+      RGX = /^\[\^\d+\]:/
+    end
+
+    @@parsers << :footnotes
+
+    # :reek:TooManyStatements
+    def footnotes
+      return false unless (continue = Footnotes::RGX.match?(@line))
+
+      @html << "<small>\n"
+      while continue
+        @html << "#{inline(@line.chomp)}<br>\n"
+        continue = Footnotes::RGX.match?(line_gets)
+      end
+      @html << "</small>\n"
+      true
+    end
+  end
+end

data/lib/markita/markdown/form.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+# Markita top level namespace
+module Markita
+  # Markdown namespace
+  # :reek:InstanceVariableAssumption :reek:ClassVariable
+  class Markdown
+    # Module to isolate from Markdown
+    module Form
+      field = '(\w+:)?\[(\*)?(\w+)(=("[^"]+")(,"[^"]+")*)?\]'
+      FIELD = Regexp.new field
+      RGX = /^!( #{field})+/
+      POST = /!$/
+      ACTION = /\(([^()]*)\)!?$/
+
+      def self.input_select(field, name, values)
+        %(  #{field}:<select name="#{name}">\n).tap do |html|
+          values.each do |value|
+            html << %(    <option value="#{value}">#{value}</option>\n)
+          end
+          html << "  </select>\n"
+        end
+      end
+
+      def self.input_text(field, type, name)
+        %(  #{field}:<input type="#{type}" name="#{name}">\n)
+      end
+
+      # :reek:LongParameterList :reek:TooManyStatements
+      def self.input(type, field, name, values)
+        if field
+          if values.empty? then input_text(field, type, name)
+          elsif values.count > 1 then input_select(field, name, values)
+          else
+            input_defaulted(field, type, name, values)
+          end
+        elsif name == 'submit' then input_submit(values)
+        else
+          input_hidden(name, values)
+        end
+      end
+
+      def self.input_submit(values)
+        %(  <input type="submit" value="#{values[0] || 'Submit'}">\n)
+      end
+
+      def self.input_hidden(name, values)
+        %(  <input type="hidden" name="#{name}" value="#{values[0]}">\n)
+      end
+
+      # :reek:LongParameterList
+      def self.input_defaulted(field, type, name, values)
+        <<-INPUT
+  #{field}:<input type="#{type}" name="#{name}"
+    value="#{values[0]}">
+        INPUT
+      end
+
+      def self.match?(line) = RGX.match?(line)
+
+      # :reek:ControlParameter :reek:NilCheck :reek:LongParameterList
+      def self.maybe(yon, name, field, values)
+        return :NO if yon == :NO || (field.nil? && name == 'submit')
+        return yon unless field && values.count < 2
+
+        yon == :yes ? :no : :YES
+      end
+
+      # :reek:LongYieldList :reek:TooManyStatements
+      def self.scan(line)
+        line.scan(FIELD).each do |field, pwd, name, value|
+          field &&= field[0...-1]
+          values = value ? value[2...-1].split('","') : []
+          type = pwd ? 'password' : 'text'
+          yield field, type, name, values
+        end
+      end
+
+      def self.start(line, attributes)
+        method = POST.match?(line) ? ' method="post"' : ''
+        action = (mdt = ACTION.match(line)) ? %( action="#{mdt[1]}") : ''
+        %(<form#{action}#{method}#{attributes.shift}>\n)
+      end
+
+      def self.stop = %(</form>\n)
+
+      # :reek:ControlParameter
+      def self.submit(yon)
+        case yon
+        when :yes
+          %(  <input type="submit">\n)
+        when :YES
+          %(  <br>\n  <input type="submit">\n)
+        else
+          ''
+        end
+      end
+    end
+
+    @@parsers << :form
+
+    # category: method
+    # :reek:TooManyStatements
+    # rubocop:disable Metrics/MethodLength
+    def form
+      return false unless Form.match?(@line)
+
+      yon = :yes # Append submit button?
+      @html << Form.start(@line, @attributes)
+      loop do
+        Form.scan(@line) do |field, type, name, values|
+          yon = Form.maybe(yon, name, field, values)
+          @html << Form.input(type, field, name, values)
+        end
+        break unless Form.match?(line_gets)
+
+        @html << "  <br>\n"
+      end
+      @html << Form.submit(yon)
+      @html << Form.stop
+      true
+    end
+    # rubocop:enable Metrics/MethodLength
+  end
+end

data/lib/markita/markdown/heading.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Markita top level namespace
+module Markita
+  # Markdown namespace
+  # :reek:InstanceVariableAssumption :reek:ClassVariable
+  class Markdown
+    # Module to isolate from Markdown
+    module Heading
+      RGX = /^(\#{1,6}) (.*)$/
+
+      def self.level_header(line)
+        mdt = RGX.match(line)
+        [mdt[1].length, mdt[2]] if mdt
+      end
+    end
+
+    @@parsers << :heading
+
+    # category: method
+    # :reek:TooManyStatements :reek:UncommunicativeVariableName
+    def heading
+      return false unless (n, header = Heading.level_header(@line))
+
+      id = header.gsub(/\([^()]*\)/, '').scan(/\w+/).join('+')
+      @html << %(<a id="#{id}">\n)
+      @html << "  <h#{n}#{@attributes.shift}>#{inline(header)}</h#{n}>\n"
+      @html << "</a>\n"
+      line_gets
+      true
+    end
+  end
+end

data/lib/markita/markdown/horizontal_rule.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Markita top level namespace
+module Markita
+  # Markdown namespace
+  # :reek:InstanceVariableAssumption :reek:ClassVariable
+  class Markdown
+    # Module to isolate from Markdown
+    module HorizontalRule
+      RGX = /^---+$/
+    end
+
+    @@parsers << :horizontal_rule
+
+    # category: method
+    def horizontal_rule
+      return false unless HorizontalRule::RGX.match?(@line)
+
+      line_gets
+      # Display HR
+      @html << "<hr#{@attributes.shift}>\n"
+      true
+    end
+  end
+end

data/lib/markita/markdown/image.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Markita top level namespace
+module Markita
+  # Markdown namespace
+  # :reek:InstanceVariableAssumption :reek:ClassVariable
+  class Markdown
+    # Module to isolate from Markdown
+    module Image
+      RGX = /^!\[([^\[\]]+)\]\(([^()]+)\)$/
+
+      def self.attributes(line)
+        mdt = RGX.match(line)
+        [mdt[1], *mdt[2].strip.split(/\s+/, 2)] if mdt
+      end
+
+      def self.img_src(src, alt, att)
+        style = Image.style(alt)
+        size = Image.size(alt)
+        %(<img src="#{src}"#{style}#{size}alt="#{alt.strip}"#{att.shift}>\n)
+      end
+
+      def self.size(alt)
+        if (mdt = /(\d+)x(\d+)/.match(alt))
+          %(width="#{mdt[1]}" height="#{mdt[2]}" )
+        else
+          ''
+        end
+      end
+
+      # :reek:ControlParameter
+      def self.style(alt)
+        case alt
+        when /^:.*:$/
+          %( style="display: block; margin-left: auto; margin-right: auto;" )
+        when /:$/
+          %( style="float:left;" )
+        when /^:/
+          %( style="float:right;" )
+        else
+          ' '
+        end
+      end
+    end
+
+    @@parsers << :images
+
+    # category: method
+    # :reek:TooManyStatements
+    def images
+      return false unless (alt, src, href = Image.attributes(@line))
+
+      @html << %(<a href="#{href}">\n) if href
+      @html << Image.img_src(src, alt, @attributes)
+      @html << %(</a>\n) if href
+      line_gets
+      true
+    end
+  end
+end

data/lib/markita/markdown/inline.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# Markita top level namespace
+module Markita
+  # Markdown namespace
+  # :reek:InstanceVariableAssumption in markdown.rb
+  class Markdown
+    # Module to isolate from Markdown
+    # :reek:TooManyConstants
+    module Inline
+      # category: details
+
+      # When the writer does not mean to invoke a substitutions caused by a
+      # special character, that character can be escaped with a backslash.
+      # This is then replaced with its HTML entity.
+      ENTITY = /\\([<>*"~`_&;:\\])/
+      def self.entity(mdt) = "&##{mdt[1].ord};"
+
+      FOOTNOTE = /\[\^(\d+)\](:)?/
+      # :reek:ControlParameter
+      def self.footnote(mdt = nil, num: mdt[1], ref: mdt[2])
+        if ref
+          %(<a id="fn:#{num}" href="#fnref:#{num}">#{num}:</a>)
+        else
+          %(<a id="fnref:#{num}" href="#fn:#{num}"><sup>#{num}</sup></a>)
+        end
+      end
+
+      SUBSCRIPT = /\\\(([^()]+)\)/
+      def self.subscript(mdt) = "<sub>#{mdt[1]}</sub>"
+
+      SUPERSCRIPT = /\\\^\(([^()]+)\)/
+      def self.superscript(mdt) = "<sup>#{mdt[1]}</sup>"
+
+      URL = %r{(https?://[\w./&+?%-]+)}
+      def self.url(mdt, hrf = mdt[1]) = %(<a href="#{hrf}">#{hrf}</a>)
+
+      BOLD = /\*([^*]+)\*/
+      def self.bold(mdt) = "<b>#{mdt[1]}</b>"
+
+      CODE = /`([^`]+)`/
+      def self.code(mdt) = "<code>#{mdt[1].gsub('<', '&lt;')}</code>"
+
+      EMOJI = /:(\w+):/
+      EMOJIS = Hash[*File.read(PATH['emojis.tsv']).split(/\s+/)]
+      def self.emoji(mdt) = (emj = EMOJIS[mdt[1]]) ? "&#x#{emj};" : mdt[0]
+
+      ITALIC = /"([^"]+)"/
+      def self.italic(mdt) = "<i>#{mdt[1]}</i>"
+
+      STRIKE = /~([^~]+)~/
+      def self.strike(mdt) = "<s>#{mdt[1]}</s>"
+
+      UNDERLINE = /_([^_]+)_/
+      def self.underline(mdt) = "<u>#{mdt[1]}</u>"
+
+      ANCHOR = /\[([^\[\]]+)\]\(([^(")]+)\)/
+      def self.anchor(mdt)
+        href, title = mdt[2].split(/\s+/, 2).map(&:strip)
+        title = %( title="#{title}") if title
+        text = tag(mdt[1], EMOJI, method(:emoji))
+        %(<a href="#{href}"#{title}>#{text}</a>)
+      end
+
+      # category: algorithm
+
+      # :reek:DuplicateMethodCall :reek:TooManyStatements
+      # rubocop:disable Metrics/MethodLength
+      def self.tag(entry, regx, m2string, &block)
+        if (mdt = regx.match entry)
+          string = String.new
+          while mdt
+            pre_match = (block ? block.call(mdt.pre_match) : mdt.pre_match)
+            string << (pre_match + m2string[mdt])
+            post_match = mdt.post_match
+            mdt = regx.match(post_match)
+          end
+          string << (block ? block.call(post_match) : post_match)
+          return string
+        end
+        block ? block.call(entry) : entry
+      end
+
+      # :reek:NestedIterators :reek:TooManyStatements
+      # :reek:UncommunicativeVariableName
+      # rubocop:disable Metrics/AbcSize
+      def self.tags(line)
+        line = tag(line, ENTITY, method(:entity))
+        line = tag(line, CODE, method(:code)) do |string|
+          tag(string, ANCHOR, method(:anchor)) do |str|
+            tag(str, URL, method(:url)) do |s|
+              s = tag(s, EMOJI,       method(:emoji))
+              s = tag(s, BOLD,        method(:bold))
+              s = tag(s, ITALIC,      method(:italic))
+              s = tag(s, STRIKE,      method(:strike))
+              s = tag(s, UNDERLINE,   method(:underline))
+              s = tag(s, FOOTNOTE,    method(:footnote))
+              s = tag(s, SUPERSCRIPT, method(:superscript))
+              tag(s, SUBSCRIPT, method(:subscript))
+            end
+          end
+        end
+        line.sub(/ ?[ \\]$/, '<br>')
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+    end
+
+    # category: method
+
+    # :reek:DuplicateMethodCall :reek:TooManyStatements
+    def inline(line)
+      line = Inline.tags(line)
+      line = Inline.tag(line, /[$](\w+)/, lambda do |mdt|
+        @metadata[mdt[1]] || mdt[0]
+      end)
+      Inline.tag(line, /<a href="(\d+)">/, lambda do |mdt|
+        key = mdt[1]
+        %(<a href="#{@metadata[key] || key}">)
+      end)
+    end
+  end
+end

data/lib/markita/markdown/list.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# Markita top level namespace
+module Markita
+  # Markdown namespace
+  # :reek:InstanceVariableAssumption :reek:ClassVariable
+  class Markdown
+    # Module to isolate from Markdown
+    module List
+      # rubocop:disable Lint/MixedRegexpCaptureTypes
+      RGX = /^(?<spaces>\s{0,3})
+              (?<bullet>[*]|(\d+\.)|(-\s\[(\s|x)\]))
+              \s(?<text>\S.*)$/x
+      # rubocop:enable Lint/MixedRegexpCaptureTypes
+
+      def self.level_bullet_text(line)
+        mdt = RGX.match(line)
+        [mdt[:spaces].length, mdt[:bullet], mdt[:text]] if mdt
+      end
+
+      # :reek:ControlParameter
+      def self.style(check)
+        case check
+        when ' '
+          %q( style="list-style-type: '&#9744; '")
+        when 'x'
+          %q( style="list-style-type: '&#9745; '")
+        else
+          ''
+        end
+      end
+
+      def self.type(bullet)
+        bullet[0] =~ /\d/ ? 'ol' : 'ul'
+      end
+    end
+
+    @@parsers << :list
+
+    # category: method
+    # :reek:DuplicateMethodCall :reek:TooManyStatements
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
+    def list
+      return false unless (level, bullet, text = List.level_bullet_text(@line))
+
+      type = List.type(bullet)
+      @html << "<#{type}#{@attributes.shift}>\n"
+      loop do
+        style = List.style(bullet[3])
+        @html << "  <li#{style}>#{inline(text)}</li>\n"
+        current, bullet, text = List.level_bullet_text(line_gets)
+        if current&.>(level)
+          list
+          current, bullet, text = List.level_bullet_text(@line)
+        end
+        break unless current.eql?(level) && type.eql?(List.type(bullet))
+      end
+      @html << "</#{type}>\n"
+      true
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
+  end
+end

data/lib/markita/markdown/markup.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Markita top level namespace
+module Markita
+  # Markdown namespace
+  # :reek:InstanceVariableAssumption :reek:ClassVariable
+  class Markdown
+    # Module to isolate from Markdown
+    module Markup
+      RGX = /^ {0,3}<.*>$/
+    end
+
+    @@parsers << :html_markup
+
+    def html_markup
+      return false unless Markup::RGX.match(@line)
+
+      @html << @line
+      line_gets
+      true
+    end
+  end
+end

data/lib/markita/markdown/script.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Markita top level namespace
+module Markita
+  # Markdown namespace
+  # :reek:InstanceVariableAssumption :reek:ClassVariable
+  class Markdown
+    # Module to isolate from Markdown
+    module Script
+      RGX = /^<script/
+    end
+
+    @@parsers << :script
+
+    # :reek:TooManyStatements :reek:DuplicateMethodCall
+    def script
+      return false unless Script::RGX.match(@line)
+
+      @html << @line
+      while line_gets
+        @html << @line
+        break if %r{^</script>}.match?(@line)
+      end
+      line_gets if @line
+      true
+    end
+  end
+end

data/lib/markita/markdown/split.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Markita top level namespace
+module Markita
+  # Markdown namespace
+  # :reek:InstanceVariableAssumption :reek:ClassVariable
+  class Markdown
+    # Module to isolate from Markdown
+    module Split
+      RGX = /^:?\|:?$/
+
+      # :reek:ControlParameter :reek:DuplicateMethodCall
+      def self.table(code, attributes)
+        case code
+        when '|:'
+          %(<table><tr><td#{attributes.shift}>\n)
+        when '|'
+          %(</td><td#{attributes.shift}>\n)
+        when ':|:'
+          %(</td></tr><tr><td#{attributes.shift}>\n)
+        when ':|'
+          %(</td></tr></table>\n)
+        end
+      end
+    end
+
+    @@parsers << :splits
+
+    # category: method
+    def splits
+      return false unless Split::RGX.match? @line
+
+      @html << Split.table(@line.chomp, @attributes)
+      line_gets
+      true
+    end
+  end
+end

data/lib/markita/markdown/table.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Markita top level namespace
+module Markita
+  # Markdown namespace
+  # :reek:InstanceVariableAssumption :reek:ClassVariable
+  class Markdown
+    # Module to isolate from Markdown
+    module Table
+      RGX = /^\|.+\|$/
+    end
+
+    @@parsers << :table
+
+    # :reek:DuplicateMethodCall :reek:TooManyStatements
+    # :reek:UncommunicativeVariableName
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength, Layout/LineLength
+    def table
+      return false unless Table::RGX.match? @line
+
+      @html << "<table#{@attributes.shift}>\n"
+      @html << "<thead#{@attributes.shift}><tr><th>"
+      @html << @line[1...-1].split('|').map { inline(it.strip) }.join('</th><th>')
+      @html << "</th></tr></thead>\n"
+      align = []
+      while line_gets&.match? Table::RGX
+        @html << '<tr>'
+        @line[1...-1].split('|').each_with_index do |cell, i|
+          case cell
+          when /^\s*:-+:\s*$/
+            align[i] = ' align="center"'
+            @html << '<td><hr></td>'
+          when /^\s*-+:\s*$/
+            align[i] = ' align="right"'
+            @html << '<td><hr></td>'
+          when /^\s*:-+\s*$/
+            align[i] = ' align="left"'
+            @html << '<td><hr></td>'
+          else
+            @html << "<td#{align[i]}>#{inline(cell.strip)}</td>"
+          end
+        end
+        @html << "</tr>\n"
+      end
+      @html << "</table>\n"
+      true
+    end
+    # rubocop:enable Metrics/MethodLength, Layout/LineLength
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+  end
+end