poefy 0.6.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0defb6d9a94a5162826c5815c0f9f1aac7b98c91
-  data.tar.gz: a8c83d5c423ea918252c47a2aa74897d44ad2c72
+  metadata.gz: c669c795f0aa86b7641c6b0246bf7af4c70a044c
+  data.tar.gz: 1d6b45c4c036677c7dcffa769576eac72e997d7c
 SHA512:
-  metadata.gz: a09920a71f8feced4ddd7a079c06f8ea2c763f7fa84adb47da81d075d993d94b4ba65e8e1889d3be57081c634f04edb77fee46a3beaf414cdf6ea58bf229eb09
-  data.tar.gz: 5ee1495dab167b26d4ec006b3fadd18e93a85d483e2730f061080dc6cd32988c0d50d5fca542b52d47b48a6abfc9b15e3c30939c477067a238097a525802f988
+  metadata.gz: 83b5d17cea7d870b77cd04ee06120f24ccd7b09fc4184472c1c9a893e0c9aeea64b9d255b9585515689ff06e19a1d9fe3cd841c1eda89d124a2807ff9b25a5c3
+  data.tar.gz: 58e698d002d74198bbd10fbea4a66f402a664e8d182a6c1c4ee2455b3829ad068b3de81437f03d8ad5d9ab76585ce79357de5179c795f356b539f8d543b9fea1

data/.gitignore

@@ -67,6 +67,9 @@ desktop.ini
 work*.rb
 /~/
 
+# Config files
+settings.yml
+
 # Data files
 /data/
 

data/.rspec

@@ -1,2 +1 @@
---color
 --require spec_helper

data/README.md

@@ -1,8 +1,16 @@
+__Warning: This project is undergoing serious revision at the moment, and parts of this readme are invalid.__
+
+__For the correct documentation for the most recent gem version (0.6.1), please see the revision here:
+[README.md](https://github.com/nossidge/poefy/blob/fb4e39a88296074075a8ad1708e60747f3323baf/README.md)__
+
+__Version 1.0.0 is coming soon, with Postgres support as the major feature.__
+
+
 # Poefy
 
 by [Paul Thompson](https://tilde.town/~nossidge) - nossidge@gmail.com
 
-Create poems from an input text file, by generating and querying a SQLite database that describes each line.
+Create rhyming poems from an input text file, by generating and querying a SQLite or PostgreSQL database that describes each line.
 
 Poems are created using a template to select lines from the database, according to closing rhyme, syllable count, and regex matching.
 
@@ -11,59 +19,95 @@ I wrote this because I was banging my head against a wall trying to use [Tracery
 
 ## Installation
 
-Add this line to your application's Gemfile:
+### Install the base gem
 
-```ruby
-gem 'poefy'
-```
+    $ gem install poefy
 
-And then execute:
 
-    $ bundle
+### Install a database gem
 
-Or install it yourself as:
+You have two options when it comes to databases.
 
-    $ gem install poefy
 
-The repo comes with some text files included. To generate databases for these files, execute the special `make_dbs` command:
+#### PostgreSQL
+
+Install [PostgreSQL 9.0+](https://www.postgresql.org/download/)
+
+Install the below gem.
+
+    $ gem install poefy-pg
+
+Create a new user:
+
+    username: 'poefy'
+    password: 'poefy'
+
+Then create a new database, with the above user as the owner:
 
-    $ poefy make_dbs
+    database: 'poefy'
 
-The code rather hackily uses system to call `sqlite3`, so make sure you have that installed and in your PATH.
+Everything is called 'poefy'. Nice and easy.
+
+
+#### SQLite
+
+Install [SQLite 3.0+](https://sqlite.org/download.html)
+
+Just install the below gem. There is no further setup needed.
+
+    $ gem install poefy-sqlite3
+
+
+### Set up some example corpora
+
+The repo comes with some initial text files included. To generate corpora for these files, execute the special `poefy_make` binary:
+
+    $ poefy_make
+
+This command will also setup a `settings.yml` file in the gem root. By default it will be set to 'pg' or 'sqlite3', depending on which gem you installed. If you need to change that setting you can run either of the below:
+
+    $ poefy -D pg
+    $ poefy -D sqlite3
+
+You can use the `-D` option by itself without the argument to see the current database setting.
 
 
 ## Usage
 
 ### From the Command Line
 
-Make a poefy database from a text file:
+To make a poefy corpus from a text file, run either of the below:
+
+    $ poefy shakespeare -m < shakespeare_sonnets.txt
+    $ poefy shakespeare --make < shakespeare_sonnets.txt
 
-    $ poefy shakespeare -o < shakespeare_sonnets.txt
+This will create a corpus describing each line of Shakespeare's sonnets. The type of corpus depends on whether you are using PosgreSQL (saved as a table in the 'poefy' database) or SQLite (saved to a database file as ROOT/data/CORPUS.db).
 
-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:
+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 corpora:
 
     $ poefy shakespeare sonnet
     $ poefy shakespeare limerick
-    $ poefy shakespeare.db villanelle
+    $ poefy shakespeare villanelle
 
-The file extension `.db` is assumed for all databases. You can leave it out if you want.
+If you later want to remake the corpus, for example to add new lines, you can use the `-m` option again and the existing corpus will be overwritten.
 
-If you later want to remake the database, for example to add new lines, you can use the `-o` option and the existing database will be overwritten.
+    $ cat shakespeare_sonnets.txt shakespeare_plays.txt | poefy shakespeare -m
 
-    $ cat shakespeare_sonnets.txt shakespeare_plays.txt | poefy shakespeare -o
+You can use the `-L` or `--list` option to view available corpora.
 
-This database is stored in the same directory as the gem, so it can be accessed by all users on your system. To store a database in a different directory, you can use the `-l` or `--local` option:
+__For SQLite users only:__
+This corpus database file is stored in the same directory as the gem, so it can be accessed by all users on your system. To store a corpus in a different directory, you can use the `-l` or `--local` option:
 
     $ poefy -l path/to/eliot.db < eliot.txt
 
 You then need to use the `-l` option when generating poems:
 
     $ poefy -l path/to/eliot.db rondeau
-    $ poefy -l path/to/eliot    ballade
+    $ poefy path/to/eliot.db ballade -l
     $ cd path/to
     $ poefy -l eliot.db ballata
 
-You can use the `-h` or `--help` option to view available databases.
+Note that using this option, you *do* need to specify the '.db' file extension of the chosen corpus.
 
 
 #### Option `-f` or `--form`
@@ -239,7 +283,7 @@ To clarify: using the `-p` or `--proper` option will DISABLE this functionality.
 
 If the second argument is `rhyme`, then output all lines that rhyme with the word.
 
-This gives a basic look into the database contents.
+This gives a basic look into the contents of the corpus table.
 
 ````
 $ poefy dickinson rhyme confuse
@@ -270,7 +314,7 @@ You can do the same thing for the other keys: `rhyme`, `final_word`, and `syllab
 
 #### Special case: poetic form from text 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:
+If you pipe in text and don't use the `-m` option to create a corpus, 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`][1] script that will return song lines for you:
 
     $ lyrics 'carly rae jepsen' 'call me maybe' | tee jep.txt | poefy whitman
     $ poefy whitman < jep.txt
@@ -282,7 +326,7 @@ Any line that is bracketed in `[square]` or `{curly}` braces will be duplicated
 
 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:
+Here's an example of a song that can be sung to the same tune as "[I Want to Hold Your Hand][2]", but using lyrics from all Beatles songs:
 
 ````
 $ poefy beatles data/beatles/i_want_to_hold_your_hand.txt
@@ -343,7 +387,8 @@ I'll let me hold your hand       You're not the hurting kind
 I want to hold your hand         What goes on in your mind?
 ````
 
-[1]: https://genius.com/The-beatles-i-want-to-hold-your-hand-lyrics
+[1]: https://github.com/nossidge/lyrics
+[2]: https://genius.com/The-beatles-i-want-to-hold-your-hand-lyrics
 
 
 ### As a Ruby Gem
@@ -352,17 +397,35 @@ To make a poefy database and generate poems from it:
 
 ```ruby
 require 'poefy'
-poefy = Poefy::PoefyGen.new('shakespeare')
-poefy.make_database('shakespeare_sonnets.txt')
+
+# Choose one of the below require lines.
+require 'poefy/pg'
+require 'poefy/sqlite3'
+
+# Or you could just run this. It will require the
+# database gem that is specified in 'settings.yml'
+Poefy.require_db
+
+# Set up a Poem object using the name of the corpus.
+poefy = Poefy::Poem.new('shakespeare')
+
+# Filename is the text file containing the lines.
+# Description is an explanation of the data.
+filename    = 'shakespeare_sonnets.txt'
+description = 'The sonnets of Shakespeare'
+poefy.make_database(filename, description)
+
+# Close the database link.
+poefy.close
 ```
 
-`make_database` will accept a filename string, an array of lines, or a long string delimited by newlines.
+`filename` will accept a string path to a file, an array of lines, or a long string delimited by newlines. `description` is optional.
 
 You only have to make the database once. And then to generate poems:
 
 ```ruby
 # Different ways to generate sonnets
-poefy = Poefy::PoefyGen.new('shakespeare')
+poefy = Poefy::Poem.new('shakespeare')
 puts poefy.poem ({ rhyme: 'ababcdcdefefgg' })
 puts poefy.poem ({ rhyme: 'abab cdcd efef gg', indent: '0101 0101 0011 01' })
 puts poefy.poem ({ form: 'sonnet' })
@@ -375,13 +438,16 @@ 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 })
+poefy.close
 ```
 
+The #poem method requires at least one option of `:rhyme`, `:form`, or `:form_from_text`
+
 All options can be specified at object initialisation, and subsequent poems will use those options as default:
 
 ```ruby
 # Default to use rondeau poetic form, and proper sentence validation
-poefy = Poefy::PoefyGen.new('shakespeare', { form: 'rondeau', proper: true })
+poefy = Poefy::Poem.new('shakespeare', { form: 'rondeau', proper: true })
 
 # Generate a properly sentenced rondeau
 puts poefy.poem
@@ -391,6 +457,8 @@ puts poefy.poem ({ proper: false })
 
 # Generate a proper rondeau with a certain indentation
 puts poefy.poem ({ indent: '01012 0012 010112' })
+
+poefy.close
 ```
 
 
@@ -405,8 +473,9 @@ transform_hash = {
    4 => proc { |line, num, poem| line.upcase },
   12 => proc { |line, num, poem| line.upcase }
 }
-poefy = Poefy::PoefyGen.new 'shakespeare'
+poefy = Poefy::Poem.new 'shakespeare'
 puts poefy.poem({ form: :sonnet, transform: transform_hash })
+poefy.close
 ```
 
 The key for the hash corresponds to the line of the poem, starting from 1 (not 0). You can use negative keys to specify from the end of the poem. Any key that is not an integer or is out of the array bounds will be ignored.
@@ -415,8 +484,9 @@ If you don't include a hash, then the proc will be applied to each line. So to a
 
 ```ruby
 transform_proc = proc { |line, num, poem| "#{num.to_s.rjust(2)} #{line}" }
-poefy = Poefy::PoefyGen.new 'shakespeare'
+poefy = Poefy::Poem.new 'shakespeare'
 puts poefy.poem({ form: :sonnet, transform: transform_proc })
+poefy.close
 ```
 
 The proc arguments `|line, num, poem|` are: the text of the line that is being replaced, the number of the line, and the full poem array as it was before any transformations had occurred.
@@ -424,6 +494,84 @@ The proc arguments `|line, num, poem|` are: the text of the line that is being r
 The transformations are implemented after the poem has been generated, but before the `indent` has occurred.
 
 
+#### Corpus internals
+
+The `Poefy::Poem.poem` method will do the work of creating a poem for you, but the object also exposes more information about the corpus, if you need it. This is done through the `Poefy::Poem.corpus` object.
+
+```ruby
+# If the corpus database already exists:
+poefy = Poefy::Poem.new('shakespeare')
+puts poefy.corpus.type      # "sqlite3" or "pg"
+puts poefy.corpus.name      # "shakespeare"
+puts poefy.corpus.count     # 2137
+puts poefy.corpus.exists?   # true
+
+# If the corpus has not been generated yet:
+poefy = Poefy::Poem.new('plath')
+puts poefy.corpus.type      # "sqlite3" or "pg"
+puts poefy.corpus.name      # "plath"
+puts poefy.corpus.count     # 0
+puts poefy.corpus.exists?   # false
+```
+
+To view or change the description of the corpus.
+
+```ruby
+poefy = Poefy::Poem.new('shakespeare')
+puts 'Initial description:  ' + poefy.corpus.desc
+# Initial description:  Shakespeare's sonnets
+
+poefy.corpus.desc = 'a brand new string'
+puts 'Updated description:  ' + poefy.corpus.desc
+# Updated description:  a brand new string
+```
+
+There's also a public interface to find rhyming lines within the corpus. Let's say we need to find 6 lines with the same rhyme. First, we will get an array of all rhyme keys that have at least 6 distinct final words. Then select one rhyme at random. Use that rhyme to find all lines that have that rhyme key, and remove lines with duplicate last words (so that we don't rhyme e.g. "tree" with "tree"). Then grab a sample 6 lines from that array.
+
+```ruby
+poefy = Poefy::Poem.new('shakespeare')
+line_count = 6
+
+rhymes = poefy.corpus.rhymes_by_count(line_count)
+rhyme = rhymes.sample['rhyme']
+lines = poefy.corpus.lines_by_rhyme(rhyme)
+lines = lines.map{ |i| i['line'] }.shuffle
+lines.uniq!{ |i| i.to_phrase.last_word.downcase }
+puts lines.sample(line_count)
+
+# Mine eye and heart are at a mortal war,
+# Like as the waves make towards the pebbled shore,
+# Let those whom nature hath not made for store,
+# All mine was thine, before thou hadst this more.
+# O! though I love what others do abhor,
+# To show false Art what beauty was of yore.
+```
+
+You can also specify a range for the lines' syllable counts. Just use a hash with keys ':min' and ':max' as the second argument.
+
+```ruby
+poefy = Poefy::Poem.new('whitman')
+line_count = 6
+syllables = {min: 8, max: 8}
+
+rhymes = poefy.corpus.rhymes_by_count(line_count, syllables)
+rhyme = rhymes.sample['rhyme']
+lines = poefy.corpus.lines_by_rhyme(rhyme, syllables)
+lines = lines.map{ |i| i['line'] }.shuffle
+lines.uniq!{ |i| i.to_phrase.last_word.downcase }
+puts lines.sample(line_count)
+
+# As I wended the shores I know,
+# Rhone, and the Guadalquiver flow,
+# Scooting obliquely high and low.
+# O heart-sick days! O nights of woe!
+# Ceaseless she paces to and fro,
+# To be lost if it must be so!
+```
+
+`#rhymes_by_count` and `#lines_by_rhyme` are the only stored procedures that return corpus lines. All the other filtering and line arrangement is done based on the records returned by these two methods.
+
+
 ## Some tips
 
 ### Make a database from a delimited file
@@ -432,26 +580,26 @@ Databases are created using data piped into poefy, so you can do any pre-process
 
 Use awk to get final field from tab delimited IRC logs.
 
-    $ awk -F$'\t' '{print $NF}' irc_log_20170413.txt | poefy -o irc
+    $ awk -F$'\t' '{print $NF}' irc_log_20170908.txt | poefy -m irc
 
 
 ### Make a database, ignoring short lines
 
 Use sed to filter out lines that are too short:
 
-    $ sed -r '/^.{,20}$/d' st_therese_of_lisieux.txt | poefy -o therese
+    $ sed -r '/^.{,20}$/d' st_therese_of_lisieux.txt | poefy -m therese
 
 
 ### Make a database, ignoring uppercase lines
 
 Use sed to filter out lines that do not contain lowercase letters. For example, the sonnets file contains lines with the number of the sonnet, e.g. "CXLVII."
 
-    $ sed -r 'sed '/[a-z]/!d' shakespeare_sonnets.txt | poefy -o shakespeare
+    $ sed -r 'sed '/[a-z]/!d' shakespeare_sonnets.txt | poefy -m shakespeare
 
 
 ### Problem: it won't output lines that I know are valid
 
-This code uses a gem called `wordfilter` that will automatically filter out lines that contain [grotty words](https://github.com/dariusk/wordfilter/blob/master/lib/badwords.json). If you really definitely truly don't want to exclude a certain word, you can remove them from the blacklist. For example, if your input lines are from a dissertation on the dance styles of the ska and reggae music scenes, you can call:
+This code uses a gem called `wordfilter` that will automatically filter out lines that contain [grotty words](https://github.com/dariusk/wordfilter/blob/master/lib/badwords.json). If you really definitely truly don't want to exclude a certain word, you can remove that word from the blacklist. For example, if your input lines are from a dissertation on the dance styles of the ska and reggae music scenes, in your Ruby code you can call:
 
 ```ruby
 Wordfilter.remove_word('skank')

data/bin/poefy

@@ -2,20 +2,34 @@
 # Encoding: UTF-8
 
 ################################################################################
-# Use Poefy::PoefyGen to make a poem from the command line.
+# Use Poefy::Poem to make a poem from the command line.
 ################################################################################
 
 require 'optparse'
 
 require_relative '../lib/poefy.rb'
 
+Poefy.console = true
+Poefy.require_db
+
+################################################################################
+
+# List the corpora & descriptions in a nice table format.
+def corpora
+  output = Poefy.corpora_with_desc
+  width = output.keys.max_by(&:length).length
+  output.map do |key, value|
+    sprintf "%-#{width}s  %s", key, value
+  end
+end
+
 ################################################################################
 
 def parse_options
-  options = { console: true }
+  options = {}
 
   # Set up variables used later.
-  forms = Poefy::PoeticForms::POETIC_FORMS.keys.reject { |i| i == :default }
+  forms = Poefy.poetic_forms
   forms_by_4 = forms.each_slice(4).to_a.map { |i| i.join ', ' }
   rhyme_docs = "    This is the most important argument.
       All other form strings are based on this.
@@ -39,20 +53,18 @@ def parse_options
       Paul Thompson - nossidge@gmail.com
     ].gsub('      ','  ')
 
-    usage = %[Usage: poefy shakespeare < shakespeare_sonnets.txt
+    usage = %[Usage: poefy shakespeare -m < shakespeare_sonnets.txt
+      poefy shakespeare -d "The sonnets of Shakespeare"
       poefy shakespeare sonnet
       poefy spoke haiku
       poefy therese -r 'abab cdcd efef gg' -i '0101 0101 0011 01'
       poefy whitman -r 'A1bA2 abA1 abA2 abA1 abA2 abA1A2'
+      poefy -Lc
     ].gsub('      ','       ')
 
-    databases = (Poefy.all_databases - ['test'])
-                 .each_slice(4).to_a
-                 .map { |i| i.join ', ' }
-                 .join("\n" + ' ' * 21)
-    databases = 'Databases available: ' + databases
+    list = 'Corpora: ' + corpora.join("\n         ")
 
-    opts.banner = program_info + "\n" + usage + "\n" + databases + "\n\n"
+    opts.banner = program_info + "\n" + usage + "\n" + list + "\n\n"
 
     # These will be further validated within the class.
     opts.on('-f', '--form STRING',
@@ -62,7 +74,7 @@ def parse_options
             ' ' * 39 + forms_by_4.join("\n" + ' ' * 39)) do |s|
       options[:form] = s
     end
-    opts.on('-r', '--rhyme STRING', "See big block of text below") do |s|
+    opts.on('-r', '--rhyme STRING', "(See 'Description of rhyme string' below)") do |s|
       options[:rhyme] = s
     end
     opts.on('-i', '--indent STRING', "Indentation of each line") do |s|
@@ -103,18 +115,52 @@ def parse_options
       options[:number] = n.to_i
     end
 
-    # Database options.
+    # Corpus options.
     opts.separator nil
-    opts.on('-o', '--overwrite',
-            "Overwrite existing database with new input") do
-      options[:overwrite] = true
+    opts.on('-m', '--make [STRING]',
+            "Make new or overwrite existing corpus with piped input\n" + ' ' * 39 +
+            "Argument is a description of the corpus") do |s|
+      options[:make_corpus] = true
+      options[:corpus_desc] = s
+    end
+    opts.on('-d', '--desc STRING',
+            "Overwrite the description of the corpus") do |s|
+      options[:corpus_desc] = s
     end
     opts.on('-l', '--local',
-            "Default is to use database files from /data/\n" + ' ' * 39 +
-            "With this option, use files from elsewhere") do
+            "(SQLite only) Default is to use database files from /data/\n" + ' ' * 39 +
+            "With this option, paths are relative to working directory") do
       options[:local] = true
     end
 
+    # Database internals.
+    opts.separator nil
+    opts.on('-L', '--list [C|D]',
+            "List all the installed corpora\n" + ' ' * 39 +
+            "Append 'c' or 'd' to list just the corpora or descriptions") do |s|
+      s ||= ' '
+      if s[0].casecmp('c').zero?
+        puts Poefy.corpora
+      elsif s[0].casecmp('d').zero?
+        puts Poefy.corpora_with_desc.values
+      else
+        puts corpora
+      end
+      exit 0
+    end
+    opts.on('-D', '--database [pg|sqlite3]',
+            "Display the database implementation setting\n" + ' ' * 39 +
+            "Append 'pg' or 'sqlite3' to change programs") do |s|
+      s ||= ' '
+      if s[0].casecmp('p').zero?
+        Poefy.database_type = 'pg'
+      elsif s[0].casecmp('s').zero?
+        Poefy.database_type = 'sqlite3'
+      end
+      puts Poefy.database_type
+      exit 0
+    end
+
     # Help output.
     opts.separator nil
     opts.on('-h', '--help', 'Display this help screen' ) do
@@ -152,67 +198,53 @@ options = parse_options
 # Read data lines from STDIN.
 data = (not STDIN.tty? and not STDIN.closed?) ? STDIN.read : nil
 
-# Database is the first argument.
+# Corpus name is the first argument.
 first_arg = ARGV.first
 if first_arg.nil?
-  STDERR.puts "ERROR: Please specify a database to read from / to"
+  STDERR.puts "ERROR: Please specify a corpus name to read from/to"
   exit 1
 end
 
-# If the first argument is 'make_dbs', then make
-#   databases from the included text files.
-if first_arg == 'make_dbs'
-  path = File.expand_path('../../data', __FILE__)
-
-  input = `sed '/[a-z]/!d' #{path}/shakespeare_sonnets.txt`
-  poefy = Poefy::PoefyGen.new 'shakespeare'
-  poefy.make_database input, false
-
-  input = `sed '/[a-z]/!d' #{path}/st_therese_of_lisieux.txt`
-  poefy = Poefy::PoefyGen.new 'therese'
-  poefy.make_database input, false
-
-  input = `sed '/[a-z]/!d' #{path}/whitman_leaves.txt`
-  poefy = Poefy::PoefyGen.new 'whitman'
-  poefy.make_database input, false
-
-  input = `sed '/[a-z]/!d' #{path}/emily_dickinson.txt`
-  poefy = Poefy::PoefyGen.new 'dickinson'
-  poefy.make_database input, false
-
-  input = `sed '/[a-z]/!d' #{path}/english_as_she_is_spoke.txt`
-  poefy = Poefy::PoefyGen.new 'spoke'
-  poefy.make_database input, false
-
-  exit 0
-end
-
 # Poetic form name is the second argument, if it exists.
 second_arg = (ARGV.length > 1) ? ARGV[1] : ''
 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 we need to make a corpus.
+# Exit the program after corpus is generated.
+if options[:make_corpus]
+  poefy = Poefy::Poem.new first_arg
   if data
-    poefy.make_database data, true
+    poefy.make_database data, options[:corpus_desc], true
     poefy.close
     exit 0
   else
-    STDERR.puts 'ERROR: Need text input to generate a database'
+    STDERR.puts 'ERROR: Need text input to generate a corpus'
     STDERR.puts '       Please pipe some data into the program'
     exit 1
   end
 end
 
+# If we need to update a corpus description.
+# Exit the program after corpus is generated.
+if options[:corpus_desc]
+  poefy = Poefy::Poem.new first_arg
+  begin
+    poefy.corpus.desc = options[:corpus_desc]
+    poefy.close
+    exit 0
+  rescue
+    STDERR.puts "ERROR: Corpus '#{first_arg}' does not yet exist"
+    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
+  poefy = Poefy::Poem.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)
+  puts poefy.corpus.rhymes(third_arg, fourth_arg)
   exit 0
 end
 
@@ -223,7 +255,7 @@ if data or File.exists?(second_arg)
 end
 
 # Create poefy object using the options.
-poefy = Poefy::PoefyGen.new first_arg, options
+poefy = Poefy::Poem.new first_arg, options
 
 # Make the correct number of poems, and output them.
 number = options[:number] || 1