random-words 1.0.11 → 1.0.13

data/lib/random-words/generator.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+# !/usr/bin/env ruby
 # frozen_string_literal: true
 
 # Random Sentence Generator
@@ -92,7 +92,7 @@ module RandomWords
     end
 
     # Display debug message
-    def debug(msg)
+    def dbg(msg)
       return unless @debug
 
       "%#{msg}%"
@@ -110,7 +110,10 @@ module RandomWords
     # Define number of sentences in paragraphs
     # @param length [Integer] The number of sentences in the paragraph
     def paragraph_length=(length)
-      raise ArgumentError, 'Paragraph length must be a positive integer' unless length.is_a?(Integer) && length.positive?
+      unless length.is_a?(Integer) && length.positive?
+        raise ArgumentError,
+              'Paragraph length must be a positive integer'
+      end
 
       @paragraph_length = length
     end
@@ -200,7 +203,8 @@ module RandomWords
     end
 
     def use_extended_punctuation=(use_extended_punctuation)
-      raise ArgumentError, 'use_extended_punctuation must be a boolean' unless [true, false].include?(use_extended_punctuation)
+      raise ArgumentError, 'use_extended_punctuation must be a boolean' unless [true,
+                                                                                false].include?(use_extended_punctuation)
 
       @use_extended_punctuation = use_extended_punctuation
       @terminators.concat(@config.dictionary[:extended_punctuation]) if use_extended_punctuation
@@ -237,7 +241,7 @@ module RandomWords
       result = SENTENCE_PARTS.cycle.take(number).map { |part| send(part.to_sym) }.take(number)
       result.map do |word|
         word.split(/ /).last
-      end.join(' ').compress
+      end.join(' ').article_agree.compress
     end
 
     # Generate a series of random words up to a specified length
@@ -250,7 +254,7 @@ module RandomWords
     #   characters(50) # Generates a string with at least 50 characters
     #   characters(50, 100) # Generates a string with between 50 and 100 characters
     #   characters(50, whole_words: false) # Generates a string with 50 characters allowing word truncation
-    def characters(min, max = nil, whole_words: true, whitespace: true, dead_switch: 0)
+    def characters(min, max = nil, whole_words: true, whitespace: true, article: true, dead_switch: 0)
       result = ''
       max ||= min
       raise ArgumentError, 'Infinite loop detected' if dead_switch > 40
@@ -258,7 +262,7 @@ module RandomWords
       whole_words = false if dead_switch > 15
 
       space = whitespace ? ' ' : ''
-      current_part = 0
+      current_part = article ? 0 : 1
       while result.length < max && result.length < min
         word = send(SENTENCE_PARTS[current_part].to_sym)
         word.gsub!(/ +/, '') unless whitespace
@@ -338,7 +342,6 @@ module RandomWords
       code_langs[Random.rand(code_langs.count)]
     end
 
-    # rubocop:disable Layout/LineLength
     # Return random code snippet
     # @param lang [Symbol] The language of the code snippet
     # @return [String] A randomly generated code snippet
@@ -356,27 +359,52 @@ module RandomWords
       lang ||= code_lang
       code_snippets[lang.to_sym]
     end
-    # rubocop:enable Layout/LineLength
 
     # Generate random markdown
     # @param settings [Hash] Settings for generating markdown
     # @return [String] A randomly generated markdown string
     def markdown(settings = {})
-      input = RandomWords::LoremMarkdown.new(settings).output
-      RandomWords::HTML2Markdown.new(input).markdown
+      input = RandomWords::LoremHTML.new(settings)
+      meta = {}
+      if settings[:meta_type]
+        meta[:type] = settings[:meta_type]
+        meta[:title] = input.title if input.title
+        meta[:style] = settings[:style] || 'style.css'
+        meta[:date] = Time.now.strftime('%Y-%m-%d %H:%M:%S')
+      end
+      RandomWords::HTML2Markdown.new(input, nil, meta).to_s
     end
 
     # Generate random HTML
     # @param settings [Hash] Settings for generating HTML
     # @return [String] A randomly generated HTML string
     def html(settings = {})
-      RandomWords::LoremMarkdown.new(settings).output
+      html = RandomWords::LoremHTML.new(settings)
+      if settings[:complete]
+        style = settings[:style] || 'style.css'
+        <<~EOOUTPUT
+          <!DOCTYPE html>
+          <html lang="en">
+          <head>
+          \t<meta charset="UTF-8">
+          \t<meta name="viewport" content="width=device-width, initial-scale=1.0">
+          \t<title>#{html.title}</title>
+          \t<link rel="stylesheet" href="#{style}">
+          </head>
+          <body>
+            #{html.output.indent("\t")}
+          </body>
+          </html>
+        EOOUTPUT
+      else
+        html.output
+      end
     end
 
     # Generate a random name
     # @return [String] A randomly generated name
     def name
-      "#{debug('NAM')}#{random_name}"
+      "#{dbg('NAM')}#{random_name}"
     end
 
     private
@@ -509,7 +537,7 @@ module RandomWords
     # @example
     #  random_conjunction # Returns a random conjunction
     def random_conjunction
-      "#{debug('COC')}#{coordinating_conjunctions.sample}"
+      "#{dbg('COC')}#{coordinating_conjunctions.sample}"
     end
 
     # Generate a random number with a plural noun
@@ -526,65 +554,65 @@ module RandomWords
                end
       if num == 1 || (RandomWords.testing && !RandomWords.tested.include?('random_noun'))
         RandomWords.tested << 'random_noun' if RandomWords.testing
-        "#{debug('NUM')}#{number} #{random_noun}"
+        "#{dbg('NUM')}#{number} #{random_noun}"
       else
         RandomWords.tested << 'random_plural_noun' if RandomWords.testing
-        "#{debug('NUM')}#{number} #{random_plural_noun}"
+        "#{dbg('NUM')}#{number} #{random_plural_noun}"
       end
     end
 
     # Generate a random phrase
     # @return [String] A randomly selected phrase
     def random_phrase
-      "#{debug('PHR')}#{phrases.sample}"
+      "#{dbg('PHR')}#{phrases.sample}"
     end
 
     # Generate a random noun
     # @return [String] A randomly selected noun
     def random_noun
-      "#{debug('NOU')}#{nouns.sample}"
+      "#{dbg('NOU')}#{nouns.sample}"
     end
 
     # Generate a random plural noun
     # @return [String] A randomly selected plural noun
     def random_plural_noun
-      "#{debug('PLN')}#{plural_nouns.sample}"
+      "#{dbg('PLN')}#{plural_nouns.sample}"
     end
 
     # Generate a random verb
     # @return [String] A randomly selected verb
     def random_verb
-      "#{debug('VER')}#{verbs.sample}"
+      "#{dbg('VER')}#{verbs.sample}"
     end
 
     # Generate a random plural verb
     # @return [String] A randomly selected plural verb
     def random_plural_verb
-      "#{debug('PLV')}#{plural_verbs.sample}"
+      "#{dbg('PLV')}#{plural_verbs.sample}"
     end
 
     # Generate a random passive verb
     # @return [String] A randomly selected passive verb
     def random_passive_verb
-      "#{debug('PAV')}#{passive_verbs.sample}"
+      "#{dbg('PAV')}#{passive_verbs.sample}"
     end
 
     # Generate a random adverb
     # @return [String] A randomly selected adverb
     def random_adverb
-      "#{debug('ADV')}#{adverbs.sample}"
+      "#{dbg('ADV')}#{adverbs.sample}"
     end
 
     # Generate a random adjective
     # @return [String] A randomly selected adjective
     def random_adjective
-      "#{debug('ADJ')}#{adjectives.sample}"
+      "#{dbg('ADJ')}#{adjectives.sample}"
     end
 
     # Generate a random article
     # @return [String] A randomly selected article
     def random_article
-      "#{debug('ART')}#{articles.rotate[0]}"
+      "#{dbg('ART')}#{articles.rotate[0]}"
     end
 
     # Generate a random article for a noun
@@ -610,13 +638,13 @@ module RandomWords
     # Generate a random plural article
     # @return [String] A randomly selected plural article
     def random_plural_article
-      "#{debug('PLA')}#{plural_articles.rotate[0]}"
+      "#{dbg('PLA')}#{plural_articles.rotate[0]}"
     end
 
     # Generate a random clause
     # @return [String] A randomly selected clause
     def random_clause
-      "#{debug('CLA')}#{clauses.sample}"
+      "#{dbg('CLA')}#{clauses.sample}"
     end
 
     # Generate a random set of separators
@@ -627,25 +655,25 @@ module RandomWords
     # Generate a random separator
     # @return [String] A randomly selected separator
     def random_separator
-      "#{debug('SEP')}#{random_separators.sample}"
+      "#{dbg('SEP')}#{random_separators.sample}"
     end
 
     # Generate a random subordinate conjunction
     # @return [String] A randomly selected subordinate conjunction
     def random_subordinate_conjunction
-      "#{debug('SUC')}#{subordinate_conjunctions.rotate[0]}"
+      "#{dbg('SUC')}#{subordinate_conjunctions.rotate[0]}"
     end
 
     # Generate a random coordinating conjunction
     # @return [String] A randomly selected coordinating conjunction
     def random_coordinating_conjunction
-      "#{debug('COC')}#{coordinating_conjunctions.rotate[0]}"
+      "#{dbg('COC')}#{coordinating_conjunctions.rotate[0]}"
     end
 
     # Generate a random preposition
     # @return [String] A randomly selected preposition
     def random_preposition
-      "#{debug('PRE')}#{prepositions.rotate[0]}"
+      "#{dbg('PRE')}#{prepositions.rotate[0]}"
     end
 
     # Generate a random prepositional phrase
@@ -662,7 +690,7 @@ module RandomWords
                  "#{random_article_for_word(noun)} #{noun}"
                end
 
-      "#{debug('PRP')}#{preposition} #{phrase}"
+      "#{dbg('PRP')}#{preposition} #{phrase}"
     end
 
     # Generate a random terminator

data/lib/random-words/html2markdown.rb

@@ -12,12 +12,18 @@ module RandomWords
     # Initialize the HTML2Markdown converter
     # @param str [String] The HTML string to convert
     # @param baseurl [String] The base URL for resolving relative links
-    def initialize(str, baseurl = nil)
+    def initialize(str, baseurl = nil, meta = {})
       @links = []
+      @footnotes = []
       @baseuri = (baseurl ? URI.parse(baseurl) : nil)
       @section_level = 0
-      @encoding = str.encoding
-      @markdown = output_for(Nokogiri::HTML(str, baseurl).root).gsub(/\n\n\n+/, "\n\n\n")
+      input = str.is_a?(String) ? str : str.output
+      @encoding = input.encoding
+      @markdown = output_for(Nokogiri::HTML(input, baseurl).root).gsub(/\n\n\n+/, "\n\n\n").strip
+      @title = meta[:title] if meta[:title]
+      @date = meta[:date] if meta[:date]
+      @style = meta[:style] if meta[:style]
+      @meta_type = meta[:type] if meta[:type]
     end
 
     # Convert the HTML to Markdown
@@ -26,12 +32,45 @@ module RandomWords
     #   converter = HTML2Markdown.new('<p>Hello world</p>')
     #   puts converter.to_s
     def to_s
+      meta = ''
+
+      if @meta_type
+        meta = <<~EOMETA
+          title: #{@title}
+          date: #{@date}
+          css: #{@style}
+        EOMETA
+        case @meta_type
+        when :multimarkdown
+          meta = <<~EOMMD
+            #{meta}
+
+          EOMMD
+        when :yaml
+          meta = <<~EOYAML
+            ---
+            #{meta}
+            ---
+          EOYAML
+        end
+      end
       i = 0
       @markdown = TableCleanup.new(@markdown).clean
-      "#{@markdown}\n\n" + @links.map { |link|
-        i += 1
-        "[#{i}]: #{link[:href]}" + (link[:title] ? %( "#{link[:title]}") : '')
-      }.join("\n")
+      out = "#{meta}#{@markdown}"
+
+      if @links.any?
+        out += "\n\n" + @links.map do |link|
+          i += 1
+          "[#{i}]: #{link[:href]}" + (link[:title] ? %( "#{link[:title]}") : '')
+        end.join("\n")
+      end
+
+      if @footnotes.any?
+        out += "\n\n" + @footnotes.map { |link|
+          "[^fn#{link[:counter]}]: #{link[:title]}"
+        }.join("\n\n")
+      end
+      out
     end
 
     # Recursively convert child nodes
@@ -42,6 +81,14 @@ module RandomWords
       end.join
     end
 
+    # Add a footnote to the list of links
+    # @param counter [String] The footnote counter
+    # @param link [Hash] The link to add
+    def add_footnote(counter, link)
+      @footnotes << { counter: counter, title: link[:title] }
+      @footnotes.length
+    end
+
     # Add a link to the list of links
     # @param link [Hash] The link to add
     def add_link(link)
@@ -69,7 +116,7 @@ module RandomWords
     # @param str [String] The string to wrap
     # @return [String] The wrapped string
     def wrap(str)
-      return str if str =~ /\n/
+      return str if str.include?("\n")
 
       out = []
       line = []
@@ -80,7 +127,7 @@ module RandomWords
           line = []
         end
       end
-      out << (line.join(' ') + (str[-1..-1] =~ /[ \t\n]/ ? str[-1..-1] : ''))
+      out << (line.join(' ') + (/[ \t\n]/.match?(str[-1..-1]) ? str[-1..-1] : ''))
       out.join("\n")
     end
 
@@ -89,7 +136,13 @@ module RandomWords
     # @return [String] The converted Markdown string
     def output_for(node)
       case node.name
-      when 'head', 'style', 'script'
+      when 'title'
+        @title = node.content
+        ''
+      when 'head'
+        output_for_children(node)
+        ''
+      when 'style', 'script'
         ''
       when 'br'
         "  \n"
@@ -106,7 +159,8 @@ module RandomWords
         "==#{output_for_children(node)}=="
       when 'blockquote'
         @section_level += 1
-        o = "\n\n> #{output_for_children(node).lstrip.gsub("\n", "\n> ")}\n\n".gsub(/> \n(> \n)+/, "> \n")
+        o = "\n\n> #{output_for_children(node).lstrip.gsub("\n", "\n> ")}\n\n".gsub(/> \n(> \n)+/, "> \n").sub(/> \n$/,
+                                                                                                               "\n")
         @section_level -= 1
         o
       when 'cite'
@@ -130,7 +184,7 @@ module RandomWords
           @in_pre = false
           node.text.strip
         else
-          "`#{output_for_children(node).gsub("\n", ' ')}`"
+          "`#{output_for_children(node).tr("\n", ' ')}`"
         end
       when 'pre'
         @in_pre = true
@@ -138,19 +192,25 @@ module RandomWords
         lang = '' if lang.nil? || lang.empty?
         "\n\n```#{lang}\n" + output_for_children(node).lstrip + "\n```\n\n"
       when 'hr'
-        "\n\n----\n\n"
+        "\n\n* * * *\n\n"
       when 'a', 'link'
         link = { href: node['href'], title: node['title'] }
-        "[#{output_for_children(node).gsub("\n", ' ')}][#{add_link(link)}]"
+        if link[:href] =~ /^#fn:(\d+)/
+          counter = Regexp.last_match[1]
+          add_footnote(counter, link)
+          "[^fn#{counter}]"
+        else
+          "[#{output_for_children(node).tr("\n", ' ')}][#{add_link(link)}]"
+        end
       when 'img'
         link = { href: node['src'], title: node['title'] }
         "![#{node['alt']}][#{add_link(link)}]"
       when 'video', 'audio', 'embed'
         link = { href: node['src'], title: node['title'] }
-        "[#{output_for_children(node).gsub("\n", ' ')}][#{add_link(link)}]"
+        "[#{output_for_children(node).tr("\n", ' ')}][#{add_link(link)}]"
       when 'object'
         link = { href: node['data'], title: node['title'] }
-        "[#{output_for_children(node).gsub("\n", ' ')}][#{add_link(link)}]"
+        "[#{output_for_children(node).tr("\n", ' ')}][#{add_link(link)}]"
       when 'i', 'em', 'u'
         "_#{output_for_children(node)}_"
       when 'b', 'strong'
@@ -176,10 +236,10 @@ module RandomWords
         header = "\n"
         if @table_header
           @table_header = false
-          cells = node.children.select do |c|
+          cells = node.children.count do |c|
             %w[th td].include?(c.name)
-          end.count
-          header = "\n|#{cells.times.map { '-------' }.join('|')}|\n"
+          end
+          header = "\n|#{Array.new(cells) { '-------' }.join('|')}|\n"
         end
         node.children.select do |c|
           %w[th td].include?(c.name)
@@ -190,7 +250,7 @@ module RandomWords
         "| #{output_for_children(node)} |"
       when 'text'
         # Sometimes Nokogiri lies. Force the encoding back to what we know it is
-        if (c = node.content.force_encoding(@encoding)) =~ /\S/
+        if /\S/.match?((c = node.content.force_encoding(@encoding)))
           c.gsub!(/\n\n+/, '<$PreserveDouble$>')
           c.gsub!(/\s+/, ' ')
           c.gsub('<$PreserveDouble$>', "\n\n")