poefy 0.6.1 → 1.0.0

data/bin/poefy_make

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+# Encoding: UTF-8
+
+################################################################################
+# Determine which database interface to use, based on the gems installed.
+# Generate initial corpora.
+################################################################################
+
+require_relative '../lib/poefy.rb'
+
+Poefy.console = true
+
+################################################################################
+
+# Determine which database interface to use, based on the gems installed.
+# Attempt to load exactly one of the below files.
+# Array is ordered by priority, so use PostgreSQL before SQLite.
+def determine_database_interface
+  loaded_file = nil
+  [
+    'poefy/pg',
+    'poefy/sqlite3'
+  ].each do |file|
+    begin
+      require_relative file
+      loaded_file = File.basename(file)
+      break
+    rescue LoadError
+    end
+  end
+
+  # Exit and send error to the console if no file loaded.
+  if loaded_file.nil?
+    msg = "ERROR: Please specify the type of database to use." +
+        "\n       The 'poefy' gem does not implement a database interface" +
+        "\n       by default; you must install one of the below gems:" +
+        "\n         gem install poefy-sqlite3" +
+        "\n         gem install poefy-pg"
+    STDERR.puts msg
+    exit 1
+  end
+
+  loaded_file
+end
+
+# If the user already has a database interface setup, then use that.
+# If they don't, then determine based off installed gems.
+if Poefy.database_type(false).nil?
+  Poefy.database_type = determine_database_interface
+end
+
+# Should already be setup, but just run this to confirm no error is thrown.
+Poefy.require_db
+
+################################################################################
+
+# Create corpora from the text files included with the repository.
+# Exclude all lines which do not contain lowercase letters.
+def make_db database, textfile, description
+  file  = Poefy.root + '/data/' + textfile
+  input = File.readlines(file).keep_if { |i| i =~ /[a-z]/ }
+  poefy = Poefy::Poem.new database
+  poefy.make_database! input, description
+  poefy.close
+end
+
+[
+  [
+    'shakespeare',
+    'shakespeare_sonnets.txt',
+    "Shakespeare's sonnets"
+  ],[
+    'therese',
+    'st_therese_of_lisieux.txt',
+    "St. Thérèse of Lisieux"
+  ],[
+    'whitman',
+    'whitman_leaves.txt',
+    "Walt Whitman, Leaves of Grass"
+  ],[
+    'dickinson',
+    'emily_dickinson.txt',
+    "Emily Dickinson"
+  ],[
+    'spoke',
+    'english_as_she_is_spoke.txt',
+    "English As She Is Spoke"
+  ]
+].each do |i|
+  make_db(*i)
+end
+
+################################################################################

data/lib/poefy/conditional_sample.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+# Encoding: UTF-8
+
+################################################################################
+# Code for interfacing with the 'conditional_sample' gem.
+################################################################################
+
+module Poefy
+
+  module ConditionalSample
+
+    # Delete the first matching value in an array.
+    def delete_first array, value
+      array.delete_at(array.index(value) || array.length)
+    end
+
+    # Make sure each line ends with a different word.
+    # This is intented to be used in 'conditions' procs.
+    def diff_end arr, elem
+      !arr.map{ |i| i['final_word'] }.include?(elem['final_word'])
+    end
+
+    # See if a line matches to a particular 'poetic_form'
+    def validate_line line, poetic_form
+      valid = true
+      if poetic_form[:syllable] and poetic_form[:syllable] != 0
+        valid = valid && [*poetic_form[:syllable]].include?(line['syllables'])
+      end
+      if poetic_form[:regex]
+        [*poetic_form[:regex]].each do |i|
+          valid = valid && !!(line['line'].match(i))
+        end
+      end
+      valid
+    end
+
+    # Input a rhyme array and a poetic_form hash.
+    # Create a line by line array of conditions.
+    # This will be used to analyse the validity of corpus lines.
+    def conditions_by_line tokenised_rhyme, poetic_form
+      output = []
+      tokenised_rhyme.each.with_index do |rhyme, index|
+        line_hash = {
+          line: index + 1,
+          rhyme: rhyme[:token],
+          rhyme_letter: rhyme[:rhyme_letter]
+        }
+        if rhyme[:refrain] and rhyme[:refrain] != ' '
+          line_hash[:refrain] = rhyme[:refrain]
+        end
+        line_hash[:exact] = rhyme[:exact] if rhyme[:exact]
+        poetic_form.keys.each do |k|
+          if poetic_form[k].is_a? Hash
+            line_hash[k] = poetic_form[k][index + 1]
+          end
+        end
+        output << line_hash
+      end
+      output
+    end
+
+    # Group by element, with count as value. Ignore spaces.
+    # e.g. {"A1"=>4, "b"=>6, "A2"=>4, "a"=>5}
+    #  =>  {"b"=>6, "a"=>7}
+    def unique_rhymes tokenised_rhyme
+
+      # Group by element, with count as value. Ignore spaces.
+      # e.g. {"A1"=>4, "b"=>6, "A2"=>4, "a"=>5}
+      tokens = tokenised_rhyme.reject { |i| i == ' ' }
+      grouped = tokens.each_with_object(Hash.new(0)) { |k,h| h[k] += 1 }
+
+      # For each uppercase token, add one to the corresponding lowercase.
+      uppers = grouped.keys.select{ |i| /[[:upper:]]/.match(i) }
+      uppers.each { |i| grouped[i[0].downcase] += 1 }
+
+      # Delete from the grouped hash if uppercase.
+      grouped.delete_if { |k,v| /[[:upper:]]/.match(k) }
+      grouped
+    end
+
+  end
+
+end
+
+################################################################################

data/lib/poefy/core_extensions/array.rb

@@ -5,60 +5,99 @@
 # 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 { ... }
+#--
+# Declare module structure.
+#++
 module Poefy
   module CoreExtensions
+    module Array
+      module SortByDistance
+      end
+    end
+  end
+end
 
-    # 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
+#--
+# Define module methods.
+#++
+module Poefy::CoreExtensions::Array::SortByDistance
+
+  ##
+  # Take an array index and return a permutation of the
+  # items sorted by distance from that index.
+  # If 'index' is not specified, return an Enumerator
+  # of the results for all indices, in order.
+  #
+  # The ':reverse' keyword argument switches the equally close
+  # neighbours from lowest index first to highest first.
+  # It's an option added mostly for completeness, but it's
+  # there if you need it.
+  #
+  def sort_by_distance_from_index index = nil, reverse: false
+
+    # Return Enumerator of all possible output arrays.
+    if index.nil?
+      Enumerator.new(self.count) do |y|
+        self.each.with_index do |value, index|
+          y << self.sort_by_distance_from_index(index, reverse: reverse)
         end
       end
-    end
 
-    module Array
+    # Return Enumerator of results for a single index.
+    else
+      Enumerator.new(self.count) do |y|
+        y << self[index]
+        counter = 0
+        loop do
+          counter += 1
 
-      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
+          # Consider negative indices OOB, not from array tail.
+          below_index = index - counter
+          below_index = nil if below_index < 0
+          below = self[below_index] if below_index
+
+          # This is fine, uses nil as default value if OOB.
+          above = self[index + counter]
+
+          # Both the elements with index one higher and one lower
+          # are equally close neighbours to the subject element.
+          # The default is to output the element with the lowest
+          # index first. With ':reverse' set to true, the highest
+          # index is appended first.
+          if reverse
+            y << above if above
+            y << below if below
+          else
+            y << below if below
+            y << above if above
           end
-          IndexValueArray.new(index, self[index], others)
+
+          # Break if we're at the last element.
+          break if !above and !below
         end
       end
     end
   end
+
+  ##
+  # Find all elements that match 'value' and return the
+  # sort_by_distance results for all, as an Enumerator.
+  #
+  def sort_by_distance_from_value value = nil, reverse: false
+    matching = self.each_index.select { |i| self[i] == value }
+    Enumerator.new(matching.count) do |y|
+      matching.each do |index|
+        y << self.sort_by_distance_from_index(index, reverse: reverse)
+      end
+    end
+  end
 end
 
+#--
+# Extend Array class.
+#++
 class Array
-  include Poefy::CoreExtensions::Array
+  include Poefy::CoreExtensions::Array::SortByDistance
 end
 
 ################################################################################

data/lib/poefy/database.rb

@@ -2,12 +2,10 @@
 # Encoding: UTF-8
 
 ################################################################################
-# Class for connecting to a sqlite3 database.
+# Base class for connecting to a database.
+# Install gem 'poefy-sqlite3' or 'poefy-pg' for implementation.
 ################################################################################
 
-require 'sqlite3'
-require 'tempfile'
-
 require_relative 'string_manipulation.rb'
 require_relative 'handle_error.rb'
 
@@ -20,38 +18,38 @@ module Poefy
     include Poefy::StringManipulation
     include Poefy::HandleError
 
-    attr_reader :console, :db_file
-
-    # Finalizer must be a class variable.
-    @@final = proc { |dbase, sproc| proc {
-      sproc.each { |k, v| v.close }
-      dbase.close if dbase
-    } }
+    attr_reader :name, :local
 
-    def initialize db_file, console = false
-      @db_file = db_file
-      @console = console
+    def initialize name, local = false
+      @local = local
+      @name = name.to_s
       @sproc = {}
+      type
       db
-      ObjectSpace.define_finalizer(self, @@final.call(@db, @sproc))
     end
 
-    # Open global database session, if not already existing.
-    # This is called in all methods where it is needed. So no need to
-    #   execute it before any calling code.
+    ############################################################################
+
+    # Validate that a database type has been required.
+    # This will be overwritten by a database-specific method,
+    #   so raise an error if no database has been specified yet.
+    # Due to the way 'bin/poefy' is set up, that code will fail before
+    #   this point is reached, so this error is only from Ruby calls.
+    def type
+      msg = "No database interface specified. " +
+            "Please require 'poefy/sqlite3' or 'poefy/pg'"
+      raise LoadError, msg
+    end
+
+    # Open instance database session, if not already existing.
     def db
-      if not @db
-        if !exists?
-          @db = nil
-        else
-          begin
-            @db = SQLite3::Database.open(@db_file)
-            @db.results_as_hash = true
-          rescue
-            @db = nil
-            return handle_error 'ERROR: Database contains invalid structure'
-          end
+      if not @db and exists?
+        begin
+          open_connection
           create_sprocs
+        rescue
+          @db = nil
+          return handle_error 'ERROR: Database contains invalid structure'
         end
       end
       @db
@@ -64,68 +62,37 @@ module Poefy
       @db = nil
     end
 
-    # See if the database file exists or not.
-    def exists?
-      File.exists?(@db_file)
-    end
-
     # Creates a database with the correct format.
     #   Convert input lines array to SQL import format file.
     #   Delete database if already exists.
     #   Create database using SQL import file.
     #   Delete both files.
-    def make_new lines
-      make_new!(lines) if !exists?
+    def make_new lines, description = nil
+      make_new!(lines, description) if !exists?
     end
 
     # Force new database, overwriting existing.
-    def make_new! lines
+    def make_new! lines, description = nil
 
-      # Convert the lines array into an import file.
-      sql_import_file = save_sql_import_file lines
+      # Create a new database.
+      new_connection
 
-      # Delete any existing database.
-      File.delete(@db_file) if File.exists?(@db_file)
+      # Create the lines table and the index.
+      create_table table, description
 
-      # Write SQL and SQLite instructions to temp file,
-      #   import to database, delete temp file.
-      # The SQL file is finicky. Each line requires no leading whitespace.
-      sql_instruction_file = tmpfile
-      sql = %Q[
-        CREATE TABLE IF NOT EXISTS lines (
-          line TEXT, syllables INT, final_word TEXT, rhyme TEXT
-        );
-        CREATE INDEX idx ON lines (rhyme, final_word, line);
-        .separator "\t"
-        .import #{sql_import_file} lines
-      ].split("\n").map(&:strip).join("\n")
-      File.open(sql_instruction_file, 'w') { |fo| fo.write sql }
+      # Convert the lines array into an expanded array of rhyme metadata.
+      import_data = lines_rhyme_metadata lines
 
-      # Create the database using the SQL instructions.
-      `sqlite3 #{@db_file} < #{sql_instruction_file}`
+      # Import the data.
+      insert_lines table, import_data
 
-      # Delete temporary files.
-      File.delete sql_instruction_file
-      File.delete sql_import_file
-    end
-
-    # Execute an SQL request.
-    def execute! sql
-      begin
-        db.execute sql
-      rescue
-        return handle_error 'ERROR: Database has incorrect table structure', []
-      end
-    end
-
-    # Format a string for SQL.
-    def format_sql_string string
-      string.gsub('"','""')
+      # Recreate the stored procedures.
+      create_sprocs
     end
 
     # Public interfaces for private stored procedure methods.
     # Use instance variables to keep a cache of the results.
-    def sproc_rhymes_all! rhyme_count, syllable_min_max = nil
+    def rhymes_by_count rhyme_count, syllable_min_max = nil
       db
       @rbc = Hash.new { |h,k| h[k] = {} } if @rbc.nil?
       if @rbc[rhyme_count][syllable_min_max].nil?
@@ -137,14 +104,14 @@ module Poefy
       end
       @rbc[rhyme_count][syllable_min_max].dup
     end
-    def sproc_lines_all! rhyme, syllable_min_max = nil
+    def lines_by_rhyme rhyme, syllable_min_max = nil
       db
       @la = Hash.new { |h,k| h[k] = {} } if @la.nil?
       if @la[rhyme][syllable_min_max].nil?
         @la[rhyme][syllable_min_max] = if syllable_min_max
-          sproc_lines_all_syllables(rhyme, syllable_min_max)
+          sproc_lines_by_rhyme_syllables(rhyme, syllable_min_max)
         else
-          sproc_lines_all(rhyme)
+          sproc_lines_by_rhyme(rhyme)
         end
       end
       @la[rhyme][syllable_min_max].dup
@@ -152,123 +119,33 @@ module Poefy
 
     private
 
-      # Turn an array of string lines into an SQL import file.
-      # Format is "line, final_word, rhyme, syllables"
-      # Use tabs as delimiters.
-      def save_sql_import_file lines
-        sql_lines = []
+      ##########################################################################
+
+      # For each line, figure out the needed rhyme metadata.
+      # Output is an array: [line, final_word, rhyme, syllables]
+      def lines_rhyme_metadata lines
+        output = []
         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
-
           # Get the phrase info for the line.
           phrase = phrase_info line
           syll   = phrase[:syllables]
           rhymes = phrase[:rhymes]
-          final_ = format_sql_string phrase[:last_word]
+          final  = 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_}\""
+            output << [line, syll, final, 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
+        output
       end
 
-      # Generate a random temporary file.
-      def tmpfile
-        Dir::Tmpname.make_tmpname ['tmp-','.txt'], nil
-      end
-
-      ##########################################################################
-
-      # Define all stored procedures.
-      def create_sprocs
-        sql = {}
-        sql[:rbc] = %Q[
-          SELECT rhyme, COUNT(rhyme) AS rc
-          FROM (
-            SELECT rhyme, final_word, COUNT(final_word) AS wc
-            FROM lines
-            GROUP BY rhyme, final_word
-          )
-          GROUP BY rhyme
-          HAVING rc >= ?
-        ]
-        sql[:rbcs] = %Q[
-          SELECT rhyme, COUNT(rhyme) AS rc
-          FROM (
-            SELECT rhyme, final_word, COUNT(final_word) AS wc
-            FROM lines
-            WHERE syllables BETWEEN ? AND ?
-            GROUP BY rhyme, final_word
-          )
-          GROUP BY rhyme
-          HAVING rc >= ?
-        ]
-        sql[:la] = %Q[
-          SELECT line, syllables, final_word, rhyme
-          FROM lines WHERE rhyme = ?
-        ]
-        sql[:las] = %Q[
-          SELECT line, syllables, final_word, rhyme
-          FROM lines WHERE rhyme = ?
-          AND syllables BETWEEN ? AND ?
-        ]
-        sql.each do |key, value|
-          begin
-            @sproc[key] = db.prepare value
-          rescue
-            raise 'ERROR: Database table structure is invalid'
-            return handle_error 'ERROR: Database table structure is invalid'
-          end
-        end
-      end
-
-      # Find rhymes and counts greater than a certain length.
-      def sproc_rhymes_by_count rhyme_count
-        @sproc[:rbc].reset!
-        @sproc[:rbc].bind_param(1, rhyme_count)
-        @sproc[:rbc].execute.to_a
-      end
-
-      # Also adds syllable selection.
-      def sproc_rhymes_by_count_syllables rhyme_count, syllable_min_max
-        @sproc[:rbcs].reset!
-        @sproc[:rbcs].bind_param(1, syllable_min_max[:min])
-        @sproc[:rbcs].bind_param(2, syllable_min_max[:max])
-        @sproc[:rbcs].bind_param(3, rhyme_count)
-        @sproc[:rbcs].execute.to_a
-      end
-
-      # Find all lines for a certain rhyme.
-      def sproc_lines_all rhyme
-        @sproc[:la].reset!
-        @sproc[:la].bind_param(1, rhyme)
-        @sproc[:la].execute.to_a
-      end
-
-      # Also adds syllable selection.
-      def sproc_lines_all_syllables rhyme, syllable_min_max
-        @sproc[:las].reset!
-        @sproc[:las].bind_param(1, rhyme)
-        @sproc[:las].bind_param(2, syllable_min_max[:min])
-        @sproc[:las].bind_param(3, syllable_min_max[:max])
-        @sproc[:las].execute.to_a
-      end
-
-      ##########################################################################
-
   end
 
 end

data/lib/poefy/db_type.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+# Encoding: UTF-8
+
+################################################################################
+# Methods for selecting which database interface to use.
+# And for including the correct gem, based on that choice.
+################################################################################
+
+require 'yaml'
+
+################################################################################
+
+module Poefy
+
+  # Are we running this through the console? (Or as a Ruby library?)
+  def self.console= bool
+    @@console = !!bool
+  end
+  def self.console
+    @@console ||= false
+  end
+
+  # View and amend the database type in the 'settings' file.
+  def self.database_type= db_name
+    settings_file = Poefy.root + '/settings.yml'
+    File.open(settings_file, 'w') do |file|
+      hsh = {'database' => db_name}
+      file.write hsh.to_yaml
+    end
+  end
+  def self.database_type create_file = true
+    settings_file = Poefy.root + '/settings.yml'
+    if not File.exists?(settings_file)
+      return nil if !create_file
+      Poefy.database_type = 'pg'
+    end
+    YAML::load_file(settings_file)['database']
+  end
+
+  # Requires the chosen database interface gem.
+  def self.require_db db_interface_gem = nil
+    begin
+      require 'poefy/' + (db_interface_gem || Poefy.database_type)
+
+    # Exit and send error to the console if no file loaded.
+    rescue LoadError
+      if loaded_file.nil?
+        msg = "ERROR: Please specify the type of database to use." +
+            "\n       The 'poefy' gem does not implement a database interface" +
+            "\n       by default; you must install one of the below gems:" +
+            "\n         gem install poefy-sqlite3" +
+            "\n         gem install poefy-pg"
+        if Poefy.console
+          STDERR.puts msg
+          exit 1
+        end
+        raise msg
+      end
+    end
+  end
+
+end
+
+################################################################################