poefy 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 00e0ad3b9108ce69d617edf3971dac999fad5094
-  data.tar.gz: 6fda3f2e361c48616f3dfda503f86db91dc9130b
+  metadata.gz: 0defb6d9a94a5162826c5815c0f9f1aac7b98c91
+  data.tar.gz: a8c83d5c423ea918252c47a2aa74897d44ad2c72
 SHA512:
-  metadata.gz: d0ad8d6d99227e14f058ed9821ff4b9c2a8e7ff579b1ab97650283e088452f4632a6c5bde8a680116e50a7572fe7e7b1ab97c3caba02902b3df55cbb70309629
-  data.tar.gz: f14266288f23718113a20bc1b13f3d8848dd53d99f46c3a762994b3221cfc594e426de4af7b9839a67f11c1a05f138b8fc0b2b425fdc9fb77c9f002c2886c072
+  metadata.gz: a09920a71f8feced4ddd7a079c06f8ea2c763f7fa84adb47da81d075d993d94b4ba65e8e1889d3be57081c634f04edb77fee46a3beaf414cdf6ea58bf229eb09
+  data.tar.gz: 5ee1495dab167b26d4ec006b3fadd18e93a85d483e2730f061080dc6cd32988c0d50d5fca542b52d47b48a6abfc9b15e3c30939c477067a238097a525802f988

data/README.md

@@ -38,7 +38,7 @@ The code rather hackily uses system to call `sqlite3`, so make sure you have tha
 
 Make a poefy database from a text file:
 
-    $ poefy shakespeare < shakespeare_sonnets.txt
+    $ poefy shakespeare -o < shakespeare_sonnets.txt
 
 Now, whenever you want to make poems using Shakespeare's lines, you can just use `poefy shakespeare` and it will read from the already created database:
 
@@ -147,11 +147,11 @@ Specify syllable count allowed for each line. There's a few valid forms it can t
 
 If the string is just one number, all lines will be that number of syllables long.
 
-    $ poefy whitman -s'10'
+    $ poefy whitman sonnet -s'10'
 
 If the string is comma delimited, all lines will be any of those numbers of syllables long.
 
-    $ poefy whitman -s'9,10,11'
+    $ poefy whitman sonnet -s'9,10,11'
 
 If the string is an array, each element corresponds to a line in the output. This will skip blank lines.
 
@@ -164,7 +164,8 @@ If the string is a hash, the key will be used to match the line number.
 
     $ poefy whitman -r'aabba' -s'{1:8,2:8,3:5,4:5,5:8}'
     $ poefy whitman -r'aabba' -s'{1:[8,9],2:[8,9],3:[4,5,6],4:[4,5,6],5:[8,9]}'
-    $ poefy whitman -r'aabba' -s'{0:[8,9],3:[4,5,6],4:[4,5,6]}'
+    $ poefy whitman -r'aabba' -s'{0: [8,9],3: [4,5,6],4: [4,5,6]}'
+    $ poefy whitman -r'aabba' -s'{0=>[8,9],3=>[4,5,6],4=>[4,5,6]}'
 
 In the hash form, any lines not explicitly specified will use the value of the '0' key. If there is no '0' key, the lines will be ignored.
 
@@ -188,7 +189,7 @@ If the string is just one regex, all lines will be forced to match that regex.
     $ poefy whitman sonnet -x'^[A-Z].*$'
     $ poefy whitman sonnet -x'^[^e]*$' -s0
 
-If the string is a hash, the key will be used to match the line number. Unlike in the `syllable` string, you must use ruby's `=>` key identifier. Also, you must put the regex inside `/slashes/`.
+If the string is a hash, the key will be used to match the line number. Unlike in the `syllable` string, you must use ruby's `=>` key identifier, and not `:` as in JSON. Also, you must put the regex inside `/slashes/`.
 
 Example, to ensure the first line always starts with capitalisation:
 
@@ -213,7 +214,7 @@ You must also beware of repeated lines (uppercase letters in the rhyme string).
 
 #### Option `-A` or `--acrostic_x`
 
-This does the same as `-a`, but with special workarounds for 'x'. In the case that a line needs to match '^x', it will instead match '^ex' and replace with 'eX'. It will also use indentation to line-up the letters vertically:
+This does the same as `-a`, but with special workarounds for 'x'. In the case that a line needs to match /^x/, it will instead match /^ex/ and replace with 'eX'. It will also use indentation to line-up the letters vertically:
 
     $ poefy whitman -s8 -r abcbdd -A taxman
 
@@ -269,12 +270,18 @@ You can do the same thing for the other keys: `rhyme`, `final_word`, and `syllab
 
 #### Special case: poetic form from text file
 
-If the second argument is a reference to a text file, then the output will be a poem with the same structure as the file.
+If you pipe in text and don't use the `-o` option to create a database, then the output will be a poem with the same structure as the file. This can also be accomplished if the second argument is a reference to a text file. So, assuming you have a `lyrics` script that will return song lines for you:
+
+    $ lyrics 'carly rae jepsen' 'call me maybe' | tee jep.txt | poefy whitman
+    $ poefy whitman < jep.txt
+    $ poefy whitman jep.txt
 
 The program will scan by line, looking for rhyme, syllables and repeated lines. It will then build up a constraint hash and use that as the poetic form.
 
 Any line that is bracketed in `[square]` or `{curly}` braces will be duplicated exactly in the output. This is for lines such as "chorus" or "1st verse" descriptions. This seems to work nicely with lyrics from genius.com.
 
+Also, any indentation will be preserved, assuming 2 spaces per "indent".
+
 Here's an example of a song that can be sung to the same tune as "[I Want to Hold Your Hand][1]", but using lyrics from all Beatles songs:
 
 ````
@@ -366,6 +373,8 @@ puts poefy.poem ({ form: :sonnet, regex: '^[A-Z].*$' })
 puts poefy.poem ({ form: :sonnet, acrostic: 'pauldpthompson' })
 puts poefy.poem ({ form: 'sonnet', indent: '01010101001101' })
 puts poefy.poem ({ form: 'sonnet', proper: false })
+puts poefy.poem ({ form_from_text: 'how_do_i_love_thee.txt' })
+puts poefy.poem ({ form_from_text: 'how_do_i_love_thee.txt', syllable: 0 })
 ```
 
 All options can be specified at object initialisation, and subsequent poems will use those options as default:

data/bin/poefy

@@ -46,8 +46,11 @@ def parse_options
       poefy whitman -r 'A1bA2 abA1 abA2 abA1 abA2 abA1A2'
     ].gsub('      ','       ')
 
-    databases = Poefy.all_databases.join("\n" + ' ' * 21)
-    databases = "Databases available: " + databases
+    databases = (Poefy.all_databases - ['test'])
+                 .each_slice(4).to_a
+                 .map { |i| i.join ', ' }
+                 .join("\n" + ' ' * 21)
+    databases = 'Databases available: ' + databases
 
     opts.banner = program_info + "\n" + usage + "\n" + databases + "\n\n"
 
@@ -93,6 +96,13 @@ def parse_options
       options[:proper] = false
     end
 
+    # Repeat options.
+    opts.separator nil
+    opts.on('-n', '--number INTEGER',
+            "Number of poems to generate") do |n|
+      options[:number] = n.to_i
+    end
+
     # Database options.
     opts.separator nil
     opts.on('-o', '--overwrite',
@@ -145,8 +155,8 @@ data = (not STDIN.tty? and not STDIN.closed?) ? STDIN.read : nil
 # Database is the first argument.
 first_arg = ARGV.first
 if first_arg.nil?
-  puts "ERROR: Please specify a database to read from."
-  exit 0
+  STDERR.puts "ERROR: Please specify a database to read from / to"
+  exit 1
 end
 
 # If the first argument is 'make_dbs', then make
@@ -179,34 +189,50 @@ end
 
 # Poetic form name is the second argument, if it exists.
 second_arg = (ARGV.length > 1) ? ARGV[1] : ''
-options[:form] = second_arg
-
-# Create poefy object.
-poefy = Poefy::PoefyGen.new first_arg, options
+options[:form] = second_arg if second_arg != ''
+
+# If we need to make a database.
+# Exit the program after database is generated.
+if options[:overwrite]
+  poefy = Poefy::PoefyGen.new first_arg
+  if data
+    poefy.make_database data, true
+    poefy.close
+    exit 0
+  else
+    STDERR.puts 'ERROR: Need text input to generate a database'
+    STDERR.puts '       Please pipe some data into the program'
+    exit 1
+  end
+end
 
 # If the second argument is 'rhyme', then output all
 #   lines that rhyme with the word.
 if second_arg == 'rhyme'
+  poefy = Poefy::PoefyGen.new first_arg
   third_arg  = (ARGV.length > 2) ? ARGV[2] : nil
   fourth_arg = (ARGV.length > 3) ? ARGV[3] : nil
   puts poefy.rhymes(third_arg, fourth_arg)
   exit 0
 end
 
-# If the second argument is a file, then use that as the poetic_form.
-updated_poetic_form = {}
-if File.exists?(second_arg)
-  updated_poetic_form = poefy.poetic_form_from_text(second_arg)
+# If there is piped data, or the second argument is a file,
+#   then use that as the poetic_form.
+if data or File.exists?(second_arg)
+  options[:form_from_text] = (data || second_arg)
 end
 
-# Create a database using input.
-if data
-  poefy.make_database data, options[:overwrite]
+# Create poefy object using the options.
+poefy = Poefy::PoefyGen.new first_arg, options
 
-# Make a new poem, and output it.
-else
-  poem = poefy.poem(updated_poetic_form)
-  puts poem if poem
+# Make the correct number of poems, and output them.
+number = options[:number] || 1
+number.times do |i|
+  poem = poefy.poem
+  if poem
+    puts poem
+    puts nil if i < number - 1
+  end
 end
 
 # Close the database connection.

data/lib/poefy.rb

@@ -12,6 +12,7 @@
 
 require 'ruby_rhymes'
 require 'wordfilter'
+require 'humanize'
 require 'tempfile'
 require 'sqlite3'
 require 'timeout'
@@ -26,6 +27,7 @@ require_relative 'poefy/string_manipulation.rb'
 require_relative 'poefy/handle_error.rb'
 require_relative 'poefy/database.rb'
 require_relative 'poefy/conditional_satisfaction.rb'
+require_relative 'poefy/core_extensions/array.rb'
 
 ################################################################################
 

data/lib/poefy/core_extensions/array.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+# Encoding: UTF-8
+
+################################################################################
+# Monkey patch the Array class.
+################################################################################
+
+# [array] is the same array as [self], but ordered by closeness to the index.
+# Optionally pass an integer, for results for just that index element.
+# Returns a Struct, or an array of Structs, in the form:
+#   .index => original index
+#   .value => original element
+#   .array => self array minus value, ordered by closeness to index
+# Example usage:
+#   lines = (1..4).to_a * 2
+#   puts lines.by_distance
+#   puts lines.by_distance(3)
+#   lines.by_distance(3).each { ... }
+module Poefy
+  module CoreExtensions
+
+    # Output struct for #by_distance method.
+    # Array is the most useful data, but index and value are also kept.
+    IndexValueArray = Struct.new(:index, :value, :array) do
+      alias_method :to_a, :array
+      include Enumerable
+      def each &block
+        array.each do |i|
+          block.call i
+        end
+      end
+    end
+
+    module Array
+
+      def by_distance index = nil
+        if index.nil?
+          self.map.with_index do |value, index|
+            self.by_distance index
+          end
+        else
+          others, counter = [], 0
+          loop do
+            counter += 1
+            below_index = index - counter
+            below_index = nil if below_index < 0
+            below = self[below_index] if below_index
+            above = self[index + counter]
+            others << below if below
+            others << above if above
+            break if !above and !below
+          end
+          IndexValueArray.new(index, self[index], others)
+        end
+      end
+    end
+  end
+end
+
+class Array
+  include Poefy::CoreExtensions::Array
+end
+
+################################################################################

data/lib/poefy/database.rb

@@ -158,17 +158,28 @@ module Poefy
       def save_sql_import_file lines
         sql_lines = []
         lines.map do |line|
+
+          # Don't add the line if it contains a blacklisted? substring.
           next if Wordfilter.blacklisted? line
+
+          # Format the line for SQL parsing.
           line_ = format_sql_string line
-          final = line.to_phrase.last_word.downcase rescue ''
 
-          final_ = format_sql_string final
-          syll = syllables line
-          get_rhymes(line).each do |rhyme|
+          # Get the phrase info for the line.
+          phrase = phrase_info line
+          syll   = phrase[:syllables]
+          rhymes = phrase[:rhymes]
+          final_ = format_sql_string phrase[:last_word]
+
+          # There may be more than one rhyme, so add a database
+          #   record for each rhyme.
+          rhymes.each do |rhyme|
             rhyme_ = format_sql_string rhyme
             sql_lines << "\"#{line_}\"\t#{syll}\t\"#{final_}\"\t\"#{rhyme_}\""
           end
         end
+
+        # Save the SQL spec to a temporary file, and return the filename.
         sql_file = tmpfile
         File.open(sql_file, 'w') { |fo| fo.puts sql_lines }
         sql_file

data/lib/poefy/poefy_gen_base.rb

@@ -18,11 +18,13 @@ module Poefy
 
     # Make a database using the given lines.
     def make_database input, overwrite = @overwrite
+      lines = validate_lines input
+      lines.map(&:strip!)
       @db.close if @db
       if overwrite
-        @db.make_new! validate_lines input
+        @db.make_new! lines
       else
-        @db.make_new validate_lines input
+        @db.make_new lines
       end
     end
     def make_database! input
@@ -43,7 +45,6 @@ module Poefy
 
       # If lines is not an array, assume string and split on newlines.
       lines = lines.respond_to?(:each) ? lines : lines.split("\n")
-      lines.map(&:strip!)
       lines
     end
 
@@ -77,6 +78,13 @@ module Poefy
         input, output = poetic_form, {}
         form_string   = get_valid_form input[:form]
 
+        # Apply ':form_from_text' before any others.
+        if input[:form_from_text]
+          lines = validate_lines input[:form_from_text]
+          form = poetic_form_from_text lines
+          input = form.merge input
+        end
+
         # Handle obvious inputs.
         output[:form]       = form_string        if form_string
         output[:rhyme]      = input[:rhyme]      if input[:rhyme]

data/lib/poefy/poetic_form_from_text.rb

@@ -10,16 +10,29 @@ module Poefy
   module PoeticFormFromText
 
     # Read a song lyric file, output a poetic_form that matches its form.
-    def poetic_form_from_text text_file
-      lines = File.readlines(text_file).map(&:strip)
+    def poetic_form_from_text lines
+
+      # If lines is not an array, assume string and split on newlines.
+      lines = lines.respond_to?(:each) ? lines : lines.split("\n")
+
+      # Remove duplicate '' elements that are neighbours in the array.
+      # https://genius.com/The-monkees-im-a-believer-lyrics
+      prev_line = ''
+      lines.map! do |i|
+        out = (i == '' && prev_line == '') ? nil : i
+        prev_line = i
+        out
+      end
+      lines.compact!
 
       # For refrains, we don't care about the lines exactly, just
       #   the structure. So we can delete punctuation and downcase.
       lines = lines.map do |line|
-        {
-          orig: line,
-          downcase: line.gsub(/[[:punct:]]/, '').downcase
-        }
+        hash = {}
+        hash[:orig] = line
+        hash[:strip] = line.strip
+        hash[:downcase] = line.strip.gsub(/[[:punct:]]/, '').downcase
+        hash
       end
 
       # Find all the lines that are duplicated.
@@ -38,27 +51,26 @@ module Poefy
         hash = {}
 
         # Text of the line.
-        hash[:orig] = line[:orig]
+        hash[:strip] = line[:strip]
         hash[:downcase] = line[:downcase]
 
+        # Get the phrase info for the line.
+        phrase = phrase_info line[:strip]
+
         # Misc details.
         hash[:num] = index + 1
-        hash[:syllable] = syllables(hash[:downcase])
-        hash[:last_word] = (text.to_phrase.last_word rescue '')
+        hash[:syllable] = phrase[:syllables]
+        hash[:last_word] = phrase[:last_word]
+        hash[:indent] = (line[:orig].length - line[:orig].lstrip.length) / 2
 
-        # The rhyme for the line.
-        # ToDo: For now, just get the first rhyme of the tag array.
-        rhyme_tag = get_rhymes(hash[:downcase]).first
-        hash[:rhyme_tag] = rhyme_tag || ' '
-        hash[:rhyme_letter] = rhyme_tag
-        hash[:rhyme] = ' ' if hash[:downcase] == ''
+        # The rhyme tag array for the line.
+        hash[:rhyme_tags] = phrase[:rhymes]
 
         # Map [:refrain] and [:exact].
         # (They are mutually exclusive)
         # If it needs to be an exact line, we don't need rhyme tokens.
-        if bracketed?(line[:orig].strip)
-          hash[:exact] = line[:orig]
-          hash[:rhyme] = ' '
+        if bracketed?(line[:strip])
+          hash[:exact] = line[:strip]
           hash[:rhyme_letter] = nil
           hash[:syllable] = 0
         elsif refrains.keys.include?(line[:downcase])
@@ -68,14 +80,32 @@ module Poefy
         hash
       end
 
-    #  puts '########################################'
-    #  lines.each { |i| puts i }
+      # [:rhyme_tags] may well contain more than one rhyme tag.
+      # e.g. 'wind' rhymes with 'sinned' and 'find'.
+      # So we will compare this array against the rhymes of each
+      #   other line in the array, to find the correct one to use.
+      # We will work from the closest lines, until we find a match.
+      lines.each.with_index do |line, index|
+
+        # Compare each other rhyme tag, order by closeness.
+        found_rhyme = line[:rhyme_tags].first
+        if line[:rhyme_tags].length > 1
+          lines.by_distance(index).each do |i|
+            i[:rhyme_tags].each do |tag|
+              if line[:rhyme_tags].include?(tag)
+                found_rhyme = tag
+                break
+              end
+            end
+          end
+        end
 
-    #  # Compare each [:rhyme_tag] against the rest of the array.
-    #  lines_TODO = lines.map do |text|
-    #    remaining = lines - [text]
-    #    rhyme_tags = remaining.map { |i| i[:rhyme_tag] }
-    #  end
+        # If we haven't found the rhyme, then it doesn't matter,
+        #   just use the first in the tag array.
+        lines[index][:rhyme_tags]   = *found_rhyme
+        lines[index][:rhyme_tag]    =  found_rhyme
+        lines[index][:rhyme_letter] =  found_rhyme
+      end
 
       # Split into separate sections, [:rhyme] and [:syllable].
       rhyme = lines.map do |line|
@@ -92,9 +122,15 @@ module Poefy
         syllable[index+1] = line[:syllable] if line[:syllable] > 0
       end
 
+      # Has to be a single character, so 9 is the maximum.
+      indent = lines.map do |line|
+        line[:indent] >= 9 ? 9 : line[:indent]
+      end.join
+
       poetic_form = {
         rhyme: rhyme,
-        syllable: syllable
+        syllable: syllable,
+        indent: indent
       }
       poetic_form
     end

data/lib/poefy/string_manipulation.rb

@@ -7,6 +7,7 @@
 
 require 'ruby_rhymes'
 require 'wordfilter'
+require 'humanize'
 
 ################################################################################
 
@@ -27,14 +28,67 @@ module Poefy
         (text.gsub(/[[:punct:]]/,'').scan(/^[^ ]+/).first rescue '') || ''
       end
 
-      # Uses 'ruby_rhymes' to find the rhyme key for a text.
-      def get_rhymes text
-        (numeric?(text[-1]) ? [] : text.to_phrase.rhymes.keys) rescue []
+      # Return info that is returned using 'ruby_rhymes' '#to_phrase'
+      # But also account for numbers and initialisms.
+      def phrase_info text
+        input = humanize_instr text
+        phrase = input.to_phrase rescue nil
+        return { rhymes: [], syllables: 0, last_word: '' } if phrase.nil?
+        last_word = phrase.last_word.downcase rescue ''
+        rhy = phrase.rhymes.keys rescue []
+        rhy = rhyme_initialism(input) if rhy.empty?
+        syl = syllables_correct text rescue 0
+        { rhymes: rhy, syllables: syl, last_word: last_word }
       end
 
-      # The number of syllables in the text.
-      def syllables text
-        text.to_phrase.syllables rescue 0
+      # Humanize every number in the text.
+      # This will not work for floats.
+      # It will also break emoticons, but GIGO.
+      def humanize_instr text
+        output = text
+        loop do
+          num = output[/\d+/]
+          break if not num
+          output.sub!(num, num.to_i.humanize)
+        end
+        output
+      end
+
+      # We will only call this method if there are no dictionary rhymes.
+      # If the last word is uppercase, then assume it's an initialism.
+      # Get the last letter and rhyme that.
+      # Else, return an empty array, as normal.
+      def rhyme_initialism text
+        output = []
+        last_word = text.split.last
+        if last_word and last_word == last_word.upcase
+          letter = last_word.scan(/[A-Z]/).last
+          output = letter.to_phrase.rhymes.keys rescue []
+        end
+        output
+      end
+
+      # Get the correct syllable count, even for initialisms.
+      # e.g. "Flew in from Miami Beach BOAC"
+      #      "I'm back in the U.S.S.R"
+      def syllables_correct text
+        syll_count = 0
+
+        # This is similar to how 'ruby_rhymes' splits to word.
+        # But that gem ignores case, which we need.
+        text.gsub(/[^A-Z ']/i,'').split.each do |word|
+
+          # If the word has no rhymes, and it is uppercase, then assume
+          #   it's an initialism and count each letter's syllables.
+          if word.to_phrase.rhyme_keys.empty? and word == word.upcase
+            word.gsub(/[^A-Z]/,'').split('').each do |i|
+              syll_count += i.to_phrase.syllables
+            end
+          else
+            syll_count += word.to_phrase.syllables
+          end
+        end
+        syll_count
       end
 
       # Final line must close with sentence-end punctuation.

data/lib/poefy/version.rb

@@ -12,13 +12,13 @@ module Poefy
   end
 
   def self.version_date
-    '2017-06-02'
+    '2017-06-19'
   end
 
   module VERSION
     MAJOR = 0
     MINOR = 6
-    TINY  = 0
+    TINY  = 1
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')

data/poefy.gemspec

@@ -30,4 +30,5 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency('sqlite3',     '~> 1.3', '>= 1.3.13')
   s.add_runtime_dependency('ruby_rhymes', '~> 0.1', '>= 0.1.2')
   s.add_runtime_dependency('wordfilter',  '~> 0.2', '>= 0.2.6')
+  s.add_runtime_dependency('humanize',    '~> 1.4', '>= 1.4.0')
 end

data/spec/poefy_spec.rb

@@ -618,6 +618,105 @@ describe Poefy::PoefyGen do
     end
   end
 
+  ##############################################################################
+
+  describe "using the form_from_text option" do
+    before(:all) do
+      @file = "#{@root}/data/i_want_to_hold_your_hand.txt"
+    end
+
+    it "should use the exact poetic form 1" do
+      poefy = Poefy::PoefyGen.new(:beatles, {
+        form_from_text: @file
+      })
+      poem = poefy.poem
+      expect(poem.count).to be 46
+    end
+
+    it "should use the exact poetic form 2" do
+      poefy = Poefy::PoefyGen.new :beatles
+      poem = poefy.poem({
+        form_from_text: @file
+      })
+      expect(poem.count).to be 46
+    end
+
+    it "should correctly modify the poetic form 1" do
+      poefy = Poefy::PoefyGen.new(:beatles, {
+        form_from_text: @file,
+        syllable: 6
+      })
+      poem = poefy.poem
+      expect(poem.count).to be 46
+    end
+
+    it "should correctly modify the poetic form 2" do
+      poefy = Poefy::PoefyGen.new :beatles
+      poem = poefy.poem({
+        form_from_text: @file,
+        syllable: 6
+      })
+      expect(poem.count).to be 46
+    end
+
+    it "should correctly modify the poetic form 3" do
+      poefy = Poefy::PoefyGen.new(:beatles, {
+        form_from_text: @file
+      })
+      poem = poefy.poem({
+        syllable: 6
+      })
+      expect(poem.count).to be 46
+    end
+
+    it "should correctly replace the poetic form" do
+      poefy = Poefy::PoefyGen.new(:beatles, {
+        syllable: 6
+      })
+      poem = poefy.poem({
+        form_from_text: @file
+      })
+      expect(poem.count).to be 46
+    end
+
+    ############################################################################
+
+    describe "private method #poetic_form_from_text" do
+
+      # Singleton which includes the method.
+      # Make the private methods public.
+      let(:obj) do
+        class Sing
+          include Poefy::PoeticFormFromText
+          include Poefy::StringManipulation
+          public *private_instance_methods
+        end.new
+      end
+
+      it "80 should rhyme with weighty" do
+        lines = ["Lorem ipsum dolor weighty", "Lorem ipsum dolor 80"]
+        form = obj.poetic_form_from_text(lines)
+        expect(form[:rhyme].uniq.count).to be 1
+      end
+      it "80 should not rhyme with shoe" do
+        lines = ["Lorem ipsum dolor shoe", "Lorem ipsum dolor 80"]
+        form = obj.poetic_form_from_text(lines)
+        expect(form[:rhyme].uniq.count).to_not be 1
+      end
+      it "2 should rhyme with shoe" do
+        lines = ["Lorem ipsum dolor shoe", "Lorem ipsum dolor 2"]
+        form = obj.poetic_form_from_text(lines)
+        expect(form[:rhyme].uniq.count).to be 1
+      end
+      it "2 should not rhyme with weighty" do
+        lines = ["Lorem ipsum dolor weighty", "Lorem ipsum dolor 2"]
+        form = obj.poetic_form_from_text(lines)
+        expect(form[:rhyme].uniq.count).to_not be 1
+      end
+    end
+
+  end
+
 end
 
 ################################################################################

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: poefy
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Paul Thompson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-02 00:00:00.000000000 Z
+date: 2017-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -112,6 +112,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.2.6
+- !ruby/object:Gem::Dependency
+  name: humanize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.0
 description: Create poems from an input text file, by generating and querying a SQLite
   database describing each line. Poems are created using a template to select lines
   from the database, according to closing rhyme, syllable count, and regex matching.
@@ -137,6 +157,7 @@ files:
 - data/whitman_leaves.txt
 - lib/poefy.rb
 - lib/poefy/conditional_satisfaction.rb
+- lib/poefy/core_extensions/array.rb
 - lib/poefy/database.rb
 - lib/poefy/generation.rb
 - lib/poefy/handle_error.rb
@@ -169,7 +190,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Create rhyming poetry by rearranging lines of text