poefy-pg 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 562ca9a5d0e1e8fc84fce3f1d2cc1191f67b72b8
+  data.tar.gz: 532339860c2f1ad84288c8232162b31de8854154
+SHA512:
+  metadata.gz: 8a95524ade873f8ff08785a8d4abdb94bb808f15c92fb73bf5fb6daa11f6c9f62f288ef86d44fc305f186a31eb6ea2369927f9471a769b00bb88c6a713cfa270
+  data.tar.gz: 1f7f41a631894cb7191805f0d8024290dc2757c0f1fdcd2c10ba4d3c6a69dbf4f5341407d5174262ce1f8ec00c0ef146339dea24cf540d688d713b35580863b6

data/.gitignore

@@ -0,0 +1,77 @@
+
+################################################################################
+# Ruby specific files
+
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+################################################################################
+# Rails stuff
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+# Ignore Byebug command history file.
+.byebug_history
+
+# Ignore application configuration
+/config/application.yml
+
+################################################################################
+# System and config files
+desktop.ini
+.agignore
+.ignore
+*.lnk
+
+################################################################################
+# App specific files
+
+# Development files
+work*.rb
+/~/
+
+# Config files
+settings.yml
+
+# Data files
+/data/
+
+# Output files
+/output/

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (C) 2017 Paul Thompson
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+Full text of this licence: <https://www.gnu.org/licenses/gpl.html>

data/README.md

@@ -0,0 +1,7 @@
+# poefy-pg
+
+by Paul Thompson - nossidge@gmail.com
+
+PostgreSQL interface for the 'poefy' gem.
+
+Please see the [poefy](https://github.com/nossidge/poefy) documentation.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.verbose = false
+end
+task :default => :spec
+task :test    => :spec

data/lib/poefy/pg/version.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# Encoding: UTF-8
+
+module Poefy
+
+  module Pg
+
+    def self.version_number
+      major = 0
+      minor = 1
+      tiny  = 0
+      pre   = nil
+
+      string = [major, minor, tiny, pre].compact.join('.')
+      Gem::Version.new string
+    end
+
+    def self.version_date
+      '2017-10-02'
+    end
+
+  end
+
+end

data/lib/poefy/pg.rb

@@ -0,0 +1,295 @@
+#!/usr/bin/env ruby
+# Encoding: UTF-8
+
+################################################################################
+# Extend 'Database' class for connecting to a PostgreSQL database.
+# These methods are specific to PostgreSQL.
+# Other databases should be implemented in separate gems.
+################################################################################
+
+require 'pg'
+
+################################################################################
+
+module Poefy
+
+  class Database
+
+    # Open a connection, execute a query, close the connection.
+    def self.single_exec! sql, sql_args = nil
+      output = nil
+      begin
+        con = PG.connect(
+          :dbname   => 'poefy',
+          :user     => 'poefy',
+          :password => 'poefy'
+        )
+        output = if sql_args
+          con.exec(sql, [*sql_args]).values
+        else
+          con.exec(sql).values
+        end
+      ensure
+        con.close if con
+      end
+      output
+    end
+
+    # List all tables in the database.
+    # Does not include tables used for testing.
+    def self.list
+      rs = Database::single_exec! <<-SQL
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = 'public';
+      SQL
+      rs.flatten.reject do |i|
+        i.start_with?('spec_')
+      end.sort - ['test']
+    end
+
+    # Get the description of a table.
+    def self.desc table_name
+      begin
+        sql = "SELECT obj_description($1::regclass, 'pg_class');"
+        single_exec!(sql, [table_name]).flatten.first.to_s
+      rescue
+        ''
+      end
+    end
+
+    # List all database files and their descriptions.
+    def self.list_with_desc
+      Database::list.map do |i|
+        begin
+          [i, Database::desc(i)]
+        rescue
+          [i, '']
+        end
+      end.to_h
+    end
+
+    ############################################################################
+
+    # This is the type of database that is being used.
+    # It is also used as a signifier that a database has been specified.
+    def type
+      'pg'
+    end
+
+    # Get/set the description of the table.
+    def desc
+      Database::desc table
+    end
+    def desc=(description)
+      safe_desc = description.to_s.gsub("'","''")
+      execute! "COMMENT ON TABLE #{table} IS '#{safe_desc}';"
+    end
+
+    # The number of lines in the table.
+    def count
+      return 0 if not exists?
+      sql = "SELECT COUNT(*) AS num FROM #{table};"
+      execute!(sql).first['num'].to_i
+    end
+
+    # See if the table exists or not.
+    # Attempt to access table, and return false on error.
+    def exists?
+      open_connection
+      @db.exec("SELECT $1::regclass", [*table])
+      true
+    rescue PG::UndefinedTable
+      false
+    end
+
+    # Get all rhyming lines for the word.
+    def rhymes word, key = nil
+      return nil if word.nil?
+
+      sql = <<-SQL
+        SELECT rhyme, final_word, syllables, line
+        FROM #{table}
+        WHERE rhyme = $1
+        ORDER BY rhyme, final_word, syllables, line
+      SQL
+      output = word.to_phrase.rhymes.keys.map do |rhyme|
+        execute!(sql, [rhyme]).to_a
+      end.flatten
+
+      if !key.nil? and %w[rhyme final_word syllables line].include?(key)
+        output.map!{ |i| i[key] }
+      end
+      output
+    end
+
+    private
+
+      # The name of the table.
+      def table
+        @name
+      end
+
+      # Create a new table.
+      def new_connection
+        open_connection
+      end
+
+      # Open a connection to the database.
+      def open_connection
+        @db ||= PG.connect(
+          :dbname   => 'poefy',
+          :user     => 'poefy',
+          :password => 'poefy'
+        )
+      end
+
+      # Execute a query.
+      def execute! sql, *args
+        db.exec sql, *args
+      end
+
+      # Insert an array of lines.
+      def insert_lines table_name, rows
+        sql = "INSERT INTO #{table_name} VALUES ( $1, $2, $3, $4 )"
+        db.transaction do |db_tr|
+          rows.each do |line|
+            db_tr.exec sql, line
+          end
+        end
+      end
+
+      ##########################################################################
+
+      # Create the table and the index.
+      def create_table table_name, description = nil
+        index_name = 'idx_' + table_name
+        execute! <<-SQL
+          SET client_min_messages TO WARNING;
+          DROP INDEX IF EXISTS #{index_name};
+          DROP TABLE IF EXISTS #{table_name};
+          CREATE TABLE #{table_name} (
+            line        TEXT,
+            syllables   SMALLINT,
+            final_word  TEXT,
+            rhyme       TEXT
+          );
+          CREATE INDEX #{index_name} ON #{table_name} (
+            rhyme, final_word, line
+          );
+        SQL
+        self.desc = description
+      end
+
+      ##########################################################################
+
+      # Define SQL of the stored procedures.
+      def sprocs_sql_hash
+        sql = {}
+        sql[:rbc] = <<-SQL
+          SELECT rhyme, COUNT(rhyme) AS count
+          FROM (
+            SELECT rhyme, final_word, COUNT(final_word) AS wc
+            FROM #{table}
+            GROUP BY rhyme, final_word
+          ) AS sub_table
+          GROUP BY rhyme
+          HAVING COUNT(rhyme) >= $1
+        SQL
+        sql[:rbcs] = <<-SQL
+          SELECT rhyme, COUNT(rhyme) AS count
+          FROM (
+            SELECT rhyme, final_word, COUNT(final_word) AS wc
+            FROM #{table}
+            WHERE syllables BETWEEN $1 AND $2
+            GROUP BY rhyme, final_word
+          ) AS sub_table
+          GROUP BY rhyme
+          HAVING COUNT(rhyme) >= $3
+        SQL
+        sql[:la] = <<-SQL
+          SELECT line, syllables, final_word, rhyme
+          FROM #{table} WHERE rhyme = $1
+        SQL
+        sql[:las] = <<-SQL
+          SELECT line, syllables, final_word, rhyme
+          FROM #{table} WHERE rhyme = $1
+          AND syllables BETWEEN $2 AND $3
+        SQL
+        sql
+      end
+
+      # Create the stored procedures in the database.
+      def create_sprocs
+        sprocs_sql_hash.each do |key, value|
+          db.prepare key.to_s, value
+        end
+      rescue
+        handle_error \
+          "ERROR: Database table structure is invalid.\n" +
+          "       Please manually DROP the corrupt table and recreate it."
+      end
+
+      # Find rhymes and counts greater than a certain length.
+      def sproc_rhymes_by_count rhyme_count
+        rs = db.exec_prepared 'rbc', [rhyme_count]
+        rs.values.map do |row|
+          {
+            'rhyme' => row[0],
+            'count' => row[1].to_i
+          }
+        end
+      end
+
+      # Also adds syllable selection.
+      def sproc_rhymes_by_count_syllables rhyme_count, syllable_min_max
+        arg_array = [
+          syllable_min_max[:min],
+          syllable_min_max[:max],
+          rhyme_count
+        ]
+        rs = db.exec_prepared 'rbcs', arg_array
+        rs.values.map do |row|
+          {
+            'rhyme' => row[0],
+            'count' => row[1].to_i
+          }
+        end
+      end
+
+      # Find all lines for a certain rhyme.
+      def sproc_lines_by_rhyme rhyme
+        rs = db.exec_prepared 'la', [rhyme]
+        rs.values.map do |row|
+          {
+            'line'       => row[0],
+            'syllables'  => row[1].to_i,
+            'final_word' => row[2],
+            'rhyme'      => row[3]
+          }
+        end
+      end
+
+      # Also adds syllable selection.
+      def sproc_lines_by_rhyme_syllables rhyme, syllable_min_max
+        arg_array = [
+          rhyme,
+          syllable_min_max[:min],
+          syllable_min_max[:max]
+        ]
+        rs = db.exec_prepared 'las', arg_array
+        rs.values.map do |row|
+          {
+            'line'       => row[0],
+            'syllables'  => row[1].to_i,
+            'final_word' => row[2],
+            'rhyme'      => row[3]
+          }
+        end
+      end
+
+  end
+
+end
+
+################################################################################

data/poefy-pg.gemspec

@@ -0,0 +1,31 @@
+# Encoding: UTF-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'poefy/pg/version.rb'
+
+Gem::Specification.new do |s|
+  s.name          = 'poefy-pg'
+  s.authors       = ['Paul Thompson']
+  s.email         = ['nossidge@gmail.com']
+
+  s.summary       = %q{PostgreSQL interface for the 'poefy' gem}
+  s.description   = %q{PostgreSQL interface for the 'poefy' gem}
+  s.homepage      = 'https://github.com/nossidge/poefy-pg'
+
+  s.version       = Poefy::Pg.version_number
+  s.date          = Poefy::Pg.version_date
+  s.license       = 'GPL-3.0'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ['lib']
+
+  s.add_development_dependency('bundler',     '~> 1.13')
+  s.add_development_dependency('rake',        '~> 10.0')
+  s.add_development_dependency('rspec',       '~> 3.0')
+  s.add_development_dependency('ruby_rhymes', '~> 0.1')
+
+  s.add_runtime_dependency('poefy', '~> 1.0',  '>= 1.0.0')
+  s.add_runtime_dependency('pg',    '~> 0.21', '>= 0.21.0')
+end

data/spec/poefy_pg_spec.rb

@@ -0,0 +1,682 @@
+#!/usr/bin/env ruby
+# Encoding: UTF-8
+
+################################################################################
+
+describe Poefy::Poem, "-- Postgres" do
+
+  before(:all) do
+    require 'poefy/pg'
+    @root = Poefy.root
+    dbs = %w{spec_test_tiny spec_shakespeare spec_whitman}
+    dbs.each do |db_name|
+      Poefy::Database.single_exec! <<-SQL
+        SET client_min_messages TO WARNING;
+        DROP TABLE IF EXISTS #{db_name};
+      SQL
+    end
+  end
+
+  after(:all) do
+    dbs = %w{spec_test_tiny spec_shakespeare spec_whitman}
+    dbs.each do |db_name|
+      Poefy::Database.single_exec! <<-SQL
+        SET client_min_messages TO WARNING;
+        DROP TABLE IF EXISTS #{db_name};
+      SQL
+    end
+  end
+
+  ##############################################################################
+
+  describe "using tiny dataset 'spec_test_tiny'" do
+    corpus = "spec_test_tiny"
+
+    # Create a small corpus of a few rhymes.
+    text_array = %w{man plan flan can dan fish dish wish bee sea tree flea}
+    text_array.map!{ |i| 'a ' + i }
+    text_string = text_array.join("\n")
+    row_count = text_array.count
+
+    before(:each) do
+      @poefy = Poefy::Poem.new(corpus, { proper: false })
+    end
+    after(:each) do
+      @poefy.close
+    end
+    it "initialised object not nil" do
+      expect(@poefy).to_not be_nil
+    end
+
+    # Create corpora in the three different ways.
+    describe "@poefy#make_database!" do
+
+      it "Use array of strings" do
+        @poefy.make_database! text_array
+        expect(@poefy.corpus.exists?).to be true
+        expect(@poefy.corpus.count).to be row_count
+        poem = @poefy.poem({ rhyme: 'aabb' })
+        expect(poem.count).to be 4
+      end
+
+      it "Use one long newline delimited string" do
+        @poefy.make_database! text_string
+        expect(@poefy.corpus.exists?).to be true
+        expect(@poefy.corpus.count).to be row_count
+        poem = @poefy.poem({ rhyme: 'aabb' })
+        expect(poem.count).to be 4
+      end
+
+      it "Use text lines from a file" do
+
+        # Create a temp file.
+        tmp = Tempfile.new('spec-', Poefy.root + '/spec')
+        text_path = tmp.path
+        tmp.write text_string
+        tmp.close
+
+        @poefy.make_database! text_path
+        expect(@poefy.corpus.exists?).to be true
+        expect(@poefy.corpus.count).to be row_count
+        poem = @poefy.poem({ rhyme: 'aabb' })
+        expect(poem.count).to be 4
+
+        # Delete the temp file.
+        tmp.delete
+      end
+    end
+
+    # Make sure that the description can be updated as specified
+    #   and that it doesn't cause SQL injection.
+    describe "corpus description using #desc=" do
+      it "@poefy.corpus.desc is initially empty" do
+        expect(@poefy.corpus.desc).to eq ''
+      end
+
+      values = [
+        "test",
+        " -- test",
+        "; -- test",
+        "test' -- ",
+        "test'' -- ",
+        "'test' -- ",
+        "'test'' -- ",
+        "Shakespeare's sonnets",
+        "Shakespeare's -- sonnets",
+        "Shakespeare's; -- sonnets",
+        "test' ; INSERT INTO spec_test_tiny VALUES('foo') -- ",
+        "105 OR 1=1",
+        "' or ''='"
+      ]
+      values.each do |value|
+        it "@poefy.corpus.desc = #{value}" do
+          @poefy.corpus.desc = value
+          expect(@poefy.corpus.desc).to eq value
+          expect(@poefy.corpus.count).to be row_count
+        end
+      end
+    end
+
+    describe ":rhyme option" do
+
+      describe "should return nil" do
+        it "blank, no argument" do
+          poem = @poefy.poem
+          expect(poem).to be_nil
+        end
+        it "({  })" do
+          poem = @poefy.poem ({  })
+          expect(poem).to be_nil
+        end
+        it "({ rhyme: nil })" do
+          poem = @poefy.poem ({ rhyme: nil })
+          expect(poem).to be_nil
+        end
+        it "({ rhyme: ' ' })" do
+          poem = @poefy.poem ({ rhyme: ' ' })
+          expect(poem).to be_nil
+        end
+        it "({ rhyme: '' })" do
+          poem = @poefy.poem ({ rhyme: '' })
+          expect(poem).to be_nil
+        end
+      end
+
+      describe "should return correct number of lines" do
+        rhymes = %w{a b z A aa ab zz AA AB AA1 A1 B1 Z1 AB1 A1A1A1A1B1B1B1B1B1}
+        rhymes += ['A1A1A1 A1A1A1 B1B1B1B1B1B1','a b c a b c']
+        rhymes += ['   abc','abc   ','   abc   ']
+        rhymes += ['n   aaa   n','n   aXXXa   N1']
+        rhymes.each do |i|
+          it "({ rhyme: '#{i}' })" do
+            poem = @poefy.poem ({ rhyme: i })
+            expect(poem.count).to be i.gsub(/[0-9]/,'').length
+          end
+        end
+      end
+
+      describe "should accept characters other than number" do
+        rhymes = %w{. , : .. ., ,, :: (()) @ ~ <<>< A1A1A1...a;}
+        rhymes.each do |i|
+          it "({ rhyme: '#{i}' })" do
+            poem = @poefy.poem ({ rhyme: i })
+            expect(poem.count).to be i.gsub(/[0-9]/,'').length
+          end
+        end
+      end
+
+      describe "should be nil if can't parse rhyme string" do
+        rhymes = %w{a1 b1 ab1 Ab1 AAAAABb1 1 1111 1122 11221 ;;::1. }
+        rhymes += ['AA Bb1','11 11','11 1 1','..1.']
+        rhymes.each do |i|
+          it "({ rhyme: '#{i}' })" do
+            poem = @poefy.poem ({ rhyme: i })
+            expect(poem).to be_nil
+          end
+        end
+      end
+
+      describe "should be nil if can't complete rhyme string" do
+        rhymes = %w{aaaaaa abcd aaaaabbbbb}
+        rhymes.each do |i|
+          it "({ rhyme: '#{i}' })" do
+            poem = @poefy.poem ({ rhyme: i })
+            expect(poem).to be_nil
+          end
+        end
+      end
+
+      describe "should correctly repeat uppercase lines" do
+        lines = 200
+        it "({ rhyme: 'A' * #{lines} })" do
+          poem = @poefy.poem ({ rhyme: 'A' * lines })
+          expect(poem.count).to be lines
+          expect(poem.uniq.count).to be 1
+        end
+        it "({ rhyme: ('A'..'C').to_a.map { |i| i * #{lines} }.join })" do
+          rhyme = ('A'..'C').to_a.map { |i| i * lines }.join
+          poem = @poefy.poem ({ rhyme: rhyme })
+          expect(poem.count).to be lines * 3
+          expect(poem.uniq.count).to be 3
+        end
+      end
+
+      describe "should be nil if can't complete repeating rhyme string" do
+        lines = 200
+        it "({ rhyme: ('A'..'D').to_a.map { |i| i * #{lines} }.join })" do
+          rhyme = ('A'..'D').to_a.map { |i| i * lines }.join
+          poem = @poefy.poem ({ rhyme: rhyme })
+          expect(poem).to be_nil
+        end
+      end
+
+    end
+
+    describe ":form option" do
+
+      describe "should return correct number of lines" do
+        it "({ form: :default })" do
+          poem = @poefy.poem ({ form: :default })
+          expect(poem.count).to be 1
+        end
+      end
+
+      describe "should be nil if given a named form it can't fulfil" do
+        it "({ form: 'sonnet' })" do
+          poem = @poefy.poem ({ form: 'sonnet' })
+          expect(poem).to be_nil
+        end
+        it "({ form: :villanelle })" do
+          poem = @poefy.poem ({ form: :villanelle })
+          expect(poem).to be_nil
+        end
+      end
+
+      describe "should be nil if given a junk named form" do
+        it "({ form: 'sonnet_junk' })" do
+          poem = @poefy.poem ({ form: 'sonnet_junk' })
+          expect(poem).to be_nil
+        end
+        it "({ form: :not_a_form })" do
+          poem = @poefy.poem ({ form: :not_a_form })
+          expect(poem).to be_nil
+        end
+        it "({ form: :not_a_form, indent: '0010' })" do
+          poem = @poefy.poem ({ form: :not_a_form, indent: '0010' })
+          expect(poem).to be_nil
+        end
+      end
+
+      describe "should be valid if given a junk named form, and a rhyme" do
+        it "({ form: :not_a_form, rhyme: 'abcb' })" do
+          poem = @poefy.poem ({ form: :not_a_form, rhyme: 'abcb' })
+          expect(poem.count).to be 4
+        end
+      end
+
+      describe "should overwrite a named form if another option is specified" do
+        it "({ form: 'default', rhyme: 'ab' })" do
+          poem = @poefy.poem ({ form: 'default', rhyme: 'ab' })
+          expect(poem.count).to be 2
+        end
+        it "({ form: :villanelle, rhyme: 'abcb' })" do
+          poem = @poefy.poem ({ form: :villanelle, rhyme: 'abcb' })
+          expect(poem.count).to be 4
+        end
+      end
+    end
+  end
+
+  ##############################################################################
+
+  describe "using dataset 'spec_shakespeare'" do
+
+    file_txt = "shakespeare_sonnets.txt"
+    file_db  = "spec_shakespeare"
+
+    # All the Shakespeare lines are pentameter, so some forms should fail.
+    forms      = Poefy::PoeticForms::POETIC_FORMS
+    forms_fail = [:limerick, :haiku, :common, :ballad, :double_dactyl]
+    forms_pass = forms.keys - forms_fail
+
+    before(:each) do
+      @poefy = Poefy::Poem.new(file_db, { proper: false })
+    end
+    after(:each) do
+      @poefy.close
+    end
+
+    it "initialised object not nil" do
+      expect(@poefy).to_not be_nil
+    end
+
+    describe "#make_database( '#{@root}/data/#{file_txt}', true )" do
+      it "should make the database '#{@root}/data/#{file_db}" do
+        input = `sed '/[a-z]/!d' #{@root}/data/#{file_txt}`
+        @poefy.make_database! input
+        expect(@poefy.corpus.exists?).to be true
+      end
+    end
+
+    describe "using acrostic option" do
+      describe "should return correct number of lines" do
+        it "({ form: :sonnet, acrostic: 'pauldpthompson' })" do
+          poem = @poefy.poem ({ form: :sonnet,
+                                acrostic: 'pauldpthompson' })
+          expect(poem.count).to be 14
+        end
+      end
+      describe "should fail to be created" do
+        it "({ form: :sonnet, acrostic: 'qqqqqqqqqqqqqq' })" do
+          poem = @poefy.poem ({ form: :sonnet,
+                                acrostic: 'qqqqqqqqqqqqqq' })
+          expect(poem).to be_nil
+        end
+      end
+    end
+
+    describe "using form string" do
+      describe "should return correct number of lines" do
+
+        # Make sure each form's lines match the expected output.
+        # Generate a few to be sure.
+        forms_pass.each do |form|
+          it "({ form: #{form} })" do
+            10.times do
+              poem = @poefy.poem ({ form: form })
+              expect(poem.count).to satisfy do |c|
+                [*forms[form][:rhyme]].map do |r|
+                  r.gsub(/[0-9]/,'').length
+                end.include?(c)
+              end
+            end
+          end
+        end
+      end
+
+      describe "should fail to be created" do
+        forms_fail.each do |form|
+          it "({ form: #{form} })" do
+            4.times do
+              poem = @poefy.poem ({ form: form })
+              expect(poem).to be_nil
+            end
+          end
+        end
+      end
+    end
+
+    describe "make sonnets" do
+      sonnet_options = [
+        { rhyme: 'ababcdcdefefgg' },
+        { rhyme: 'abab cdcd efef gg', indent: '0101 0101 0011 01' },
+        { form: 'sonnet' },
+        { form: :sonnet, syllable: 0 },
+        { form: :sonnet, syllable: 10 },
+        { form: :sonnet, regex: /^[A-Z].*$/ },
+        { form: :sonnet, regex: '^[A-Z].*$' },
+        { form: :sonnet, acrostic: 'pauldpthompson' },
+        { form: 'sonnet', indent: '01010101001101' },
+        { form: 'sonnet', proper: false }
+      ]
+      sonnet_options.each do |option|
+        it "#{option}" do
+          4.times do
+            poem = @poefy.poem(option)
+            expect(poem).to_not be_nil
+          end
+        end
+      end
+    end
+  end
+
+  ##############################################################################
+
+  describe "using dataset 'spec_whitman'" do
+
+    file_txt = "whitman_leaves.txt"
+    file_db  = "spec_whitman"
+
+    # There's a good mix of syllable count, so all forms should pass.
+    forms      = Poefy::PoeticForms::POETIC_FORMS
+    forms_pass = forms.keys
+
+    before(:each) do
+      @poefy = Poefy::Poem.new(file_db, { proper: false })
+    end
+    after(:each) do
+      @poefy.close
+    end
+
+    it "initialised object not nil" do
+      expect(@poefy).to_not be_nil
+    end
+
+    describe "#make_database( '#{@root}/data/#{file_txt}', true )" do
+      it "should make the database '#{@root}/data/#{file_db}" do
+        input = `sed '/[a-z]/!d' #{@root}/data/#{file_txt}`
+        @poefy.make_database! input
+        expect(@poefy.corpus.exists?).to be true
+      end
+    end
+
+    describe "using form string" do
+      describe "should return correct number of lines" do
+
+        # Make sure each form's lines match the expected output.
+        # Generate a few to be sure.
+        forms_pass.each do |form|
+          it "({ form: #{form} })" do
+            10.times do
+              poem = @poefy.poem ({ form: form })
+              expect(poem.count).to satisfy do |c|
+                [*forms[form][:rhyme]].map do |r|
+                  r.gsub(/[0-9]/,'').length
+                end.include?(c)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    describe "make sonnets" do
+      sonnet_options = [
+        { rhyme: 'ababcdcdefefgg' },
+        { rhyme: 'abab cdcd efef gg', indent: '0101 0101 0011 01' },
+        { form: 'sonnet' },
+        { form: :sonnet, syllable: 0 },
+        { form: :sonnet, syllable: 10 },
+        { form: :sonnet, regex: /^[A-Z].*$/ },
+        { form: :sonnet, regex: '^[A-Z].*$' },
+        { form: :sonnet, acrostic: 'pauldpthompson' },
+        { form: 'sonnet', indent: '01010101001101' },
+        { form: 'sonnet', proper: false }
+      ]
+      sonnet_options.each do |option|
+        it "#{option}" do
+          4.times do
+            poem = @poefy.poem(option)
+            expect(poem).to_not be_nil
+          end
+        end
+      end
+    end
+
+    describe "using syllable string" do
+
+      it "({ rhyme: 'abcb defe', syllable: '[8,6,8,6,0,8,6,8,6]' })" do
+        options = {
+          rhyme:    'abcb defe',
+          syllable: '[8,6,8,6,0,8,6,8,6]'
+        }
+        poem = @poefy.poem (options)
+        expect(poem.count).to be options[:rhyme].length
+      end
+
+      it "({ rhyme: 'abcb defe', syllable: '[8,6,8,6,8,6,8,6]' })" do
+        options = {
+          rhyme:    'abcb defe',
+          syllable: '[8,6,8,6,8,6,8,6]'
+        }
+        poem = @poefy.poem (options)
+        expect(poem.count).to be options[:rhyme].length
+      end
+    end
+  end
+
+  ##############################################################################
+
+  describe "reusing the same Poem instance" do
+    it "should correctly merge the option hashes" do
+
+      # Default to use rondeau poetic form, and proper sentence validation
+      poefy = Poefy::Poem.new(
+        'spec_shakespeare',
+        { form: 'rondeau', proper: true }
+      )
+
+      # Generate a properly sentenced rondeau
+      poem = poefy.poem
+      expect(poem.count).to be 17
+
+      # Generate a rondeau without proper validation
+      poem = poefy.poem ({ proper: false })
+      expect(poem.count).to be 17
+
+      # Generate a proper rondeau with a certain indentation
+      poem = poefy.poem ({ indent: '01012 0012 010112' })
+      expect(poem.count).to be 17
+
+      # Generate other forms
+      poem = poefy.poem ({ rhyme: 'abbaabbacdecde' })
+      expect(poem.count).to be 14
+      poem = poefy.poem ({ form: 'sonnet' })
+      expect(poem.count).to be 14
+      poem = poefy.poem ({ form: 'ballade' })
+      expect(poem.count).to be 31
+
+      # Generate a default rondeau again
+      poem = poefy.poem
+      expect(poem.count).to be 17
+
+      poefy.close
+    end
+  end
+
+  ##############################################################################
+
+  describe "using the transform option" do
+
+    it "should correctly transform the output 1" do
+      poefy = Poefy::Poem.new :spec_shakespeare
+      transform_hash = {
+         4 => proc { |line, num, poem| line.upcase },
+        12 => proc { |line, num, poem| line.upcase }
+      }
+      poem = poefy.poem({ form: :sonnet, transform: transform_hash })
+      expect(poem.count).to be 14
+      expect(poem[3]).to  eq poem[3].upcase
+      expect(poem[11]).to eq poem[11].upcase
+      poefy.close
+    end
+
+    it "should correctly transform the output 2" do
+      poefy = Poefy::Poem.new :spec_shakespeare
+      transform_hash = {
+         4 => proc { |line, num, poem| poem.count },
+        -3 => proc { |line, num, poem| poem.count },
+         7 => proc { |line, num, poem| 'test string' }
+      }
+      poem = poefy.poem({ form: :sonnet, transform: transform_hash })
+      expect(poem.count).to be 14
+      expect(poem[3]).to  eq '14'
+      expect(poem[11]).to eq '14'
+      expect(poem[6]).to  eq 'test string'
+      poefy.close
+    end
+
+    it "should correctly transform the output 3" do
+      poefy = Poefy::Poem.new :spec_shakespeare
+      transform_proc = proc { |line, num, poem| line.downcase }
+      poem = poefy.poem({ form: :sonnet, transform: transform_proc })
+      expect(poem.count).to be 14
+      poem.each do |i|
+        expect(i).to eq i.downcase
+      end
+      poefy.close
+    end
+
+    it "should correctly transform the output 4" do
+      poefy = Poefy::Poem.new :spec_shakespeare
+      transform_proc = proc { |line, num, poem| "#{num} #{line.downcase}" }
+      poem = poefy.poem({ form: :sonnet, transform: transform_proc })
+      expect(poem.count).to be 14
+      poem.each.with_index do |line, index|
+        expect(line).to eq line.downcase
+        first_word = line.split(' ').first
+        expect(first_word).to eq (index + 1).to_s
+      end
+      poefy.close
+    end
+  end
+
+  ##############################################################################
+
+  describe "using the form_from_text option" do
+    before(:all) do
+      @text = <<-TEXT
+        [Chorus 1]
+        Oh yeah, I'll tell you something
+        I think you'll understand
+        When I'll say that something
+        I want to hold your hand
+        I want to hold your hand
+        I want to hold your hand
+
+        [Verse 1]
+        Oh please, say to me
+        You'll let me be your man
+        And please, say to me
+        You'll let me hold your hand
+        I'll let me hold your hand
+        I want to hold your hand
+      TEXT
+      @line_count = @text.split("\n").count
+    end
+
+    it "should use the exact poetic form 1" do
+      poefy = Poefy::Poem.new(:spec_whitman, {
+        form_from_text: @text
+      })
+      poem = poefy.poem
+      poem.map!(&:strip!)
+      expect(poem.count).to be @line_count
+      expect(poem[0]).to eq "[Chorus 1]"
+      expect(poem[8]).to eq "[Verse 1]"
+      expect(poem[5]).to eq poem[4]
+      expect(poem[6]).to eq poem[4]
+      poefy.close
+    end
+
+    it "should use the exact poetic form 2" do
+      poefy = Poefy::Poem.new :spec_whitman
+      poem = poefy.poem({
+        form_from_text: @text
+      })
+      poem.map!(&:strip!)
+      expect(poem.count).to be @line_count
+      expect(poem[0]).to eq "[Chorus 1]"
+      expect(poem[8]).to eq "[Verse 1]"
+      expect(poem[5]).to eq poem[4]
+      expect(poem[6]).to eq poem[4]
+      poefy.close
+    end
+
+    it "should correctly modify the poetic form 1" do
+      poefy = Poefy::Poem.new(:spec_whitman, {
+        form_from_text: @text,
+        syllable: 6
+      })
+      poem = poefy.poem
+      poem.map!(&:strip!)
+      expect(poem.count).to be @line_count
+      expect(poem[0]).to eq "[Chorus 1]"
+      expect(poem[8]).to eq "[Verse 1]"
+      expect(poem[5]).to eq poem[4]
+      expect(poem[6]).to eq poem[4]
+      poefy.close
+    end
+
+    it "should correctly modify the poetic form 2" do
+      poefy = Poefy::Poem.new :spec_whitman
+      poem = poefy.poem({
+        form_from_text: @text,
+        syllable: 6
+      })
+      poem.map!(&:strip!)
+      expect(poem.count).to be @line_count
+      expect(poem[0]).to eq "[Chorus 1]"
+      expect(poem[8]).to eq "[Verse 1]"
+      expect(poem[5]).to eq poem[4]
+      expect(poem[6]).to eq poem[4]
+      poefy.close
+    end
+
+    it "should correctly modify the poetic form 3" do
+      poefy = Poefy::Poem.new(:spec_whitman, {
+        form_from_text: @text
+      })
+      poem = poefy.poem({
+        syllable: 6
+      })
+      poem.map!(&:strip!)
+      expect(poem.count).to be @line_count
+      expect(poem[0]).to eq "[Chorus 1]"
+      expect(poem[8]).to eq "[Verse 1]"
+      expect(poem[5]).to eq poem[4]
+      expect(poem[6]).to eq poem[4]
+      poefy.close
+    end
+
+    it "should correctly replace the poetic form" do
+      poefy = Poefy::Poem.new(:spec_whitman, {
+        syllable: 6
+      })
+      poem = poefy.poem({
+        form_from_text: @text
+      })
+      poem.map!(&:strip!)
+      expect(poem.count).to be @line_count
+      expect(poem[0]).to eq "[Chorus 1]"
+      expect(poem[8]).to eq "[Verse 1]"
+      expect(poem[5]).to eq poem[4]
+      expect(poem[6]).to eq poem[4]
+      poefy.close
+    end
+
+  end
+
+end
+
+################################################################################

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'tempfile'
+require 'poefy'
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: poefy-pg
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Paul Thompson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: ruby_rhymes
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: poefy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.21.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.21.0
+description: PostgreSQL interface for the 'poefy' gem
+email:
+- nossidge@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/poefy/pg.rb
+- lib/poefy/pg/version.rb
+- poefy-pg.gemspec
+- spec/poefy_pg_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/nossidge/poefy-pg
+licenses:
+- GPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: PostgreSQL interface for the 'poefy' gem
+test_files: []