random-words 1.0.11 → 1.0.12

data/bin/randw

@@ -4,188 +4,6 @@
 require_relative "../lib/random-words"
 require "optparse"
 
-module RandomWords
-  # Terminal methods for testing
-  class Terminal
-    def initialize(source = :english)
-      # Create an instance of the generator
-      @sentence_generator = RandomWords::Generator.new(source)
-      @sentence_generator.use_extended_punctuation = true
-      @colors = {
-        text: :yellow,
-        counter: :boldcyan,
-        marker: :boldgreen,
-        bracket: :cyan,
-        language: :boldmagenta,
-      }
-      @sources = @sentence_generator.sources.keys.map(&:to_s)
-    end
-
-    def colors
-      {
-        black: 30,
-        red: 31,
-        green: 32,
-        yellow: 33,
-        blue: 34,
-        magenta: 35,
-        cyan: 36,
-        white: 37,
-        boldblack: "1;30",
-        boldred: "1;31",
-        boldgreen: "1;32",
-        boldyellow: "1;33",
-        boldblue: "1;34",
-        boldmagenta: "1;35",
-        boldcyan: "1;36",
-        boldwhite: "1;37",
-        reset: 0,
-      }
-    end
-
-    def colorize_text(text, color)
-      return text unless $stdout.isatty
-
-      return text unless colors.key?(color)
-
-      color_code = colors[color]
-
-      "\e[#{color_code}m#{text}\e[0m"
-    end
-
-    def header_1(text)
-      puts colorize_text("\n\n#{text}", :boldgreen)
-      puts colorize_text("=" * text.length, :boldgreen)
-      puts "\n"
-    end
-
-    def header_2(text)
-      puts colorize_text("\n\n#{text}", :boldyellow)
-      puts colorize_text("-" * text.length, :boldyellow)
-      puts "\n"
-    end
-
-    def paragraphs(length, count = 3)
-      @sentence_generator.sentence_length = length
-      @sentence_generator.paragraph_length = count
-      @sentence_generator.source = @sources.sample
-
-      header_2("Random Paragraph (#{@sentence_generator.paragraph_length} #{@sentence_generator.sentence_length} sentences)")
-      graf = @sentence_generator.paragraph
-      puts text(graf)
-      puts counter("#{graf.split(/ /).count} words, #{graf.length} characters")
-    end
-
-    def sentence(length)
-      header_2("Random #{length} sentence")
-      @sentence_generator.sentence_length = length
-      s = @sentence_generator.sentence
-      puts text(s)
-      puts counter("#{s.split(/ /).count} words, #{s.length} characters")
-    end
-
-    # Generate and print random combined sentences
-    def combined_sentences(length = nil)
-      number_of_sentences = length || 2
-
-      header_1("Random Combined Sentences:")
-      @sources.count.times do |i|
-        @sentence_generator.source = @sources[i - 1]
-        @sentence_generator.sentence_length = :medium
-        @sentence_generator.paragraph_length = number_of_sentences
-        @sentence_generator.sentences(number_of_sentences)
-        s = @sentence_generator.sentence
-        puts "#{marker} #{text(s)}"
-        puts counter("#{s.split(/ /).count} words, #{s.length} characters")
-        puts colorize_text(" " * 2, :boldwhite)
-      end
-    end
-
-    def random_sentences
-      header_1("Random Sentences")
-      @sentence_generator.lengths.keys.each_with_index do |length, index|
-        @sentence_generator.source = @sources[index]
-        sentence(length)
-      end
-    end
-
-    def random_paragraphs
-      header_1("Random Paragraphs")
-      @sentence_generator.lengths.keys.each_with_index do |length, index|
-        @sentence_generator.source = @sources[index]
-        paragraphs(length, 3)
-      end
-    end
-
-    # Generate and print specified number of words
-    def random_words
-      number_of_words = []
-      @sources.count.times do |i|
-        puts i
-        number_of_words << (i * i) * 5 + 10
-      end
-
-      header_1("#{number_of_words} Random Words")
-      @sources.each_with_index do |source, index|
-        header_2("#{number_of_words[index]} Random Words")
-        @sentence_generator.source = source
-        s = @sentence_generator.words(number_of_words[index])
-        puts "#{marker} #{text(s)}  "
-        puts counter("#{s.split(/ /).count} words, #{s.length} characters")
-      end
-    end
-
-    # Generate and print specified number of characters
-    def random_characters
-      header_1("Random Characters (exact length)")
-      [20, 50, 120, 200, 500].each_with_index do |i, index|
-        @sentence_generator.source = @sources[index]
-        chars = @sentence_generator.characters(i, whole_words: true)
-        puts "#{marker} #{colorize_text("#{i}:", :boldwhite)} #{text(chars)} #{counter(chars.length)}"
-      end
-
-      # Generate and print specified number of characters
-      max_characters = [15, 25, 53, 110, 600]
-      min_characters = [10, 20, 50, 100, 500]
-
-      header_1("Random Characters (length range)")
-      max_characters.count.times do |i|
-        @sentence_generator.source = @sources[i]
-        chars = @sentence_generator.characters(min_characters[i], max_characters[i], whole_words: true)
-        range = "#{marker} #{colorize_text("[#{min_characters[i]}-#{max_characters[i]}]: ", :boldwhite)}"
-        puts "#{range}#{text(chars)} #{counter(chars.length)}"
-      end
-    end
-
-    def marker
-      colorize_text("•", @colors[:marker])
-    end
-
-    def text(text)
-      colorize_text(text, @colors[:text])
-    end
-
-    def language
-      "#{colorize_text("(",
-                       @colors[:bracket])}#{colorize_text("#{@sentence_generator.source}", @colors[:language])}#{colorize_text(")",
-                                                                                                                               @colors[:bracket])}"
-    end
-
-    def counter(length)
-      "#{colorize_text("[",
-                       @colors[:bracket])}#{colorize_text("#{length}", @colors[:counter])}#{colorize_text("]", @colors[:bracket])} #{language}"
-    end
-
-    def print_test
-      combined_sentences(3)
-      random_sentences
-      random_paragraphs
-      random_words
-      random_characters
-    end
-  end
-end
-
 # Default options for the script
 
 @options = {
@@ -210,7 +28,11 @@ markdown_help = <<HELP
                                      mark: add ==highlights==
                                      headers: add headlines
                                      image: add images
+                                     hr: add horizontal rules
                                      table: add tables
+                                     fn: add footnotes
+                                     complete: complete HTML output
+                                     meta:[mmd|yaml]: add metadata header
 HELP
 
 OptionParser.new do |opts|
@@ -361,13 +183,18 @@ def markdown_settings(settings)
     mark: false,
     headers: false,
     table: false,
-    extended: false
+    extended: false,
+    footnote: false,
+    hr: false,
+    meta_type: nil,
+    complete: false,
+    style: "style.css"
   }
   sources = []
   RandomWords::Generator.new(:latin).sources.each { |k, v| sources.concat(v.names.map(&:to_s)) }
 
   markdown_options = defaults.dup
-  settings = settings.split(%r{[,/.\|]}).map(&:strip)
+  settings = settings.split(%r{[,/\|]}).map(&:strip)
 
   settings.each do |setting|
     case setting
@@ -384,7 +211,9 @@ def markdown_settings(settings)
         headers: true,
         image: true,
         table: true,
-        extended: true
+        extended: true,
+        footnote: true,
+        hr: true
       }
       markdown_options.merge!(new_options)
     when Regexp.union(sources)
@@ -415,6 +244,23 @@ def markdown_settings(settings)
       markdown_options[:length] = setting.to_length
     when 'x', 'extended'
       markdown_options[:extended] = true
+    when 'fn', 'footnotes'
+      markdown_options[:footnote] = true
+    when 'img', 'image'
+      markdown_options[:image] = true
+    when 'hr'
+      markdown_options[:hr] = true
+    when 'comp', 'complete'
+      markdown_options[:complete] = true
+    when /^(style|css):(.*)$/i
+      markdown_options[:style] = Regexp.last_match(2)
+    when /^meta:(.*?)$/i
+      case Regexp.last_match(1)
+      when 'mmd', 'multimarkdown'
+        markdown_options[:meta_type] = :multimarkdown
+      when 'yaml'
+        markdown_options[:meta_type] = :yaml
+      end
     else
       markdown_options[:source] = setting.to_source
     end

data/lib/random-words/generator.rb

@@ -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
@@ -362,15 +366,41 @@ module RandomWords
     # @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

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 = <<~EOF
+            #{meta}
+
+          EOF
+        when :yaml
+          meta = <<~EOF
+            ---
+            #{meta}
+            ---
+          EOF
+        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'
+        children = 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")

data/lib/random-words/{lorem-markdown.rb → lorem-html.rb}

@@ -2,13 +2,16 @@
 
 module RandomWords
   # Generates random Lorem Ipsum text in Markdown format.
-  class LoremMarkdown
+  class LoremHTML
     # Stores the output
     attr_accessor :output
 
     # Stores the RandomWords::Generator
     attr_accessor :generator
 
+    # Stores the title
+    attr_reader :title
+
     # Generates random Lorem Ipsum text.
     # @param options [Hash] Options for generating Lorem Ipsum text.
     # @return [String] A string of random Lorem Ipsum text.
@@ -18,7 +21,9 @@ module RandomWords
         strong: false,
         link: false,
         code: false,
-        mark: false
+        mark: false,
+        footnote: false,
+        hr: false
       }
 
       defaults = {
@@ -36,7 +41,10 @@ module RandomWords
         mark: false,
         headers: false,
         table: false,
-        extended: false
+        extended: false,
+        footnote: false,
+        hr: false,
+        image: false
       }
 
       @options = defaults.merge(options)
@@ -46,6 +54,7 @@ module RandomWords
                                                 paragraph_length: @options[:sentences],
                                                 use_extended_punctuation: @options[:extended]
                                               })
+      @title = fragment(2, 5).cap_first
 
       @output = ''
       strong = @options[:decorate]
@@ -53,16 +62,22 @@ module RandomWords
       links = @options[:link]
       code = @options[:code]
       mark = @options[:mark]
+      footnotes = @options[:footnote]
+      hr = @options[:hr]
+      image = @options[:image]
       force = []
       # Generate the specified number of paragraphs.
       @options[:grafs].times.with_index do |_, i|
-        @output += paragraph(1, em: em, strong: strong, links: links, code: code, mark: mark, force: force)
+        @output += paragraph(1, em: em, strong: strong, links: links, code: code, mark: mark, footnotes: footnotes,
+                                force: force)
         em = Random.rand(0..3).zero? && @options[:decorate]
         strong = Random.rand(0..3).zero? && @options[:decorate]
         links = Random.rand(0..3).zero? && @options[:link]
         code = Random.rand(0..3).zero? && @options[:code]
+        footnotes = Random.rand(0..3).zero? && @options[:footnote]
 
         if i == @options[:grafs] - 2
+          force << :footnote if !@added[:footnote] && @options[:footnote]
           force << :code if !@added[:code] && @options[:code]
           force << :link if !@added[:link] && @options[:link]
           force << :em if !@added[:em] && @options[:decorate]
@@ -92,6 +107,16 @@ module RandomWords
         inject_block(2, -> { list(items, :ol) })
       end
 
+      # Add horizontal rule if specified.
+      inject_block(1, -> { "<hr>\n\n" }) if @options[:hr]
+
+      # Add image if specified.
+      if @options[:image]
+        inject_block(1, lambda {
+          "<img src=\"https://picsum.photos/400/200\" alt=\"#{fragment(1, 4).cap_first}\" />\n\n"
+        })
+      end
+
       # Add definition list if specified.
       inject_block(1, -> { list(items, :dl) }) if @options[:dl]
 
@@ -147,6 +172,7 @@ module RandomWords
         strong = roll(2) && @options[:decorate]
         code = roll(4) && @options[:code]
         mark = roll(6) && @options[:mark]
+
         frag = fragment(1, 4).cap_first
         long_frag = fragment(4, 8).cap_first
         long_frag = inject_inline(long_frag, -> { link }) if links
@@ -154,6 +180,7 @@ module RandomWords
         long_frag = inject_inline(long_frag, -> { emphasis(:strong) }) if strong
         long_frag = inject_inline(long_frag, -> { code_span }, 1) if code
         long_frag = inject_inline(long_frag, -> { emphasis(:mark) }, 1) if mark
+
         long_frag = long_frag.restore_spaces if links
         if type == :dl
           ul += "\t<dt>#{frag}</dt>\n"
@@ -185,9 +212,7 @@ module RandomWords
                          strong: @options[:decorate],
                          links: @options[:link],
                          code: @options[:code],
-                         mark: @options[:mark]).gsub(
-                           /\n+/, "\n"
-                         )
+                         mark: @options[:mark]).squeeze("\n")
       quote += blockquote(level2, true).strip if level2.positive?
       "#{quote}#{cite}</blockquote>#{newline}"
     end
@@ -298,6 +323,16 @@ module RandomWords
                                                                                               8).cap_first}</a>"
     end
 
+    # Generates a random footnote
+    # @return [String] The generated footnote.
+    def footnote
+      @added[:footnote] = true
+      @counter ||= 0
+      @counter += 1
+      %(<a%%href="#fn:#{@counter}"%%id="fnref:#{@counter}"%%title="#{fragment(10,
+                                                                              20)}"%%class="footnote"><sup>#{@counter}</sup></a>)
+    end
+
     # Injects a block of text into the output.
     # @param [Integer] count The number of blocks to inject.
     # @param [Proc] block The block whose result to inject.
@@ -362,7 +397,7 @@ module RandomWords
     # @param [Boolean] mark Whether to include mark tags.
     # @param [Array] force An array of tags to force.
     # @return [String] The generated paragraph.
-    def paragraph(count, em: false, strong: false, links: false, code: false, mark: false, force: [])
+    def paragraph(count, em: false, strong: false, links: false, code: false, mark: false, footnotes: false, force: [])
       output = ''
       s = { short: 2, medium: 4, long: 6, very_long: 8 }[@options[:length]]
       count.times do
@@ -372,13 +407,15 @@ module RandomWords
         should_code = force.include?(:code) || (code && roll(6))
         should_link = force.include?(:links) || (links && roll(4))
         should_mark = force.include?(:mark) || (mark && roll(8))
+        should_footnote = force.include?(:footnote) || (footnotes && roll(8))
+
         p = inject_inline(p, -> { link }) if should_link
         p = inject_inline(p, -> { emphasis('em') }) if should_em
         p = inject_inline(p, -> { emphasis('strong') }) if should_strong
         p = inject_inline(p, -> { emphasis('mark') }, 1) if should_mark
         p = inject_inline(p, -> { code_span }, 1) if should_code
-
-        output += "<p>#{p.restore_spaces.cap_first.term('.')}</p>\n\n"
+        fn = should_footnote ? footnote.restore_spaces : ''
+        output += "<p>#{p.restore_spaces.cap_first.term('.')}#{fn}</p>\n\n"
       end
       output
     end