poefy 0.5.1

data/lib/poefy/conditional_satisfaction.rb

@@ -0,0 +1,208 @@
+#!/usr/bin/env ruby
+# Encoding: UTF-8
+
+################################################################################
+# Two methods for assessing permutations of an input array versus an
+#   array of conditions for each element.
+# Both methods return an output array consisting of samples from an
+#   input array, for which output[0] satisfies condition[0], etc.
+################################################################################
+# '#conditional_permutation' returns a complete permutation of an array.
+# i.e. output length == array length
+# Any elements in the array that are extra to the number of conditions will
+# be assumed valid.
+#   array = [1,2,3,4,5].shuffle
+#   conditions = [
+#     proc { |arr, elem| elem < 2},
+#     proc { |arr, elem| elem > 2},
+#     proc { |arr, elem| elem > 1}
+#   ]
+#   possible output = [1,3,4,5,2]
+#
+#
+#   ToDo: This is now not used! Need to add 'current_array' argument.
+#
+#
+################################################################################
+# '#conditional_selection' returns an array that satisfies only the conditions.
+# i.e. output length == conditions length
+#   array = [1,2,3,4,5].shuffle
+#   conditions = [
+#     proc { |arr, elem| elem < 2},
+#     proc { |arr, elem| elem > 2},
+#     proc { |arr, elem| elem > 1}
+#   ]
+#   possible output = [1,5,3]
+################################################################################
+# Condition array:
+# Must contain boolean procs using args |arr, elem|
+# 'arr'   is a reference to the current array that has been built up
+#         through the recursion chain.
+# 'elem'  is a reference to the current element.
+################################################################################
+
+module Poefy
+
+  module ConditionalSatisfaction
+
+    # 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]
+        valid = valid && !!(line['line'].match(poetic_form[:regex]))
+      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,
+          rhyme_letter: rhyme[0].downcase
+        }
+        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
+
+    ############################################################################
+
+    # Return a permutation of 'array' where each element validates to the
+    #   same index in a 'conditions' array of procs that return Boolean.
+    # Will not work on arrays that contain nil values.
+    # This may take a whole lot of time, depending on how lenient the
+    #   conditions are. It is better for the stricter conditions to be
+    #   at the start of the array, due to the way the code is written.
+    def conditional_permutation array, conditions, current_iter = 0
+      output = []
+
+      # Get the current conditional.
+      cond = conditions[current_iter]
+
+      # Loop through and return the first element that validates.
+      valid = false
+      array.each do |elem|
+
+        # Test the condition. If we've run out of elements
+        #   in the condition array, then allow any value.
+        valid = cond ? cond.call(elem) : true
+        if valid
+
+          # Remove this element from the array, and recurse.
+          remain = array.dup
+          delete_first(remain, elem)
+
+          # If the remaining array is empty, no need to recurse.
+          new_val = nil
+          if !remain.empty?
+            new_val = conditional_permutation(remain,
+                      conditions, current_iter + 1)
+          end
+
+          # If we cannot use this value, because it breaks future conditions.
+          if !remain.empty? && new_val.empty?
+            valid = false
+          else
+            output << elem << new_val
+          end
+        end
+
+        break if valid
+      end
+
+      output.flatten.compact
+    end
+
+    # Return values from 'array' where each element validates to the same
+    #   index in a 'conditions' array of procs that return Boolean.
+    # Return an array of conditions.length
+    def conditional_selection array, conditions,
+                              current_iter = 0,
+                              current_array = []
+      output = []
+
+      # Get the current conditional.
+      cond = conditions[current_iter]
+
+      # Return nil if we have reached the end of the conditionals.
+      return nil if cond.nil?
+
+      # Loop through and return the first element that validates.
+      valid = false
+      array.each do |elem|
+
+        # Test the condition. If we've run out of elements
+        #   in the condition array, then allow any value.
+        valid = cond.call(current_array, elem)
+        if valid
+
+          # Remove this element from the array, and recurse.
+          remain = array.dup
+          delete_first(remain, elem)
+
+          # If the remaining array is empty, no need to recurse.
+          new_val = conditional_selection(remain,
+                    conditions, current_iter + 1, current_array + [elem])
+
+          # If we cannot use this value, because it breaks future conditions.
+          if new_val and new_val.empty?
+            valid = false
+          else
+            output << elem << new_val
+          end
+        end
+
+        break if valid
+      end
+
+      output.flatten.compact
+    end
+
+  end
+
+end
+
+################################################################################

data/lib/poefy/database.rb

@@ -0,0 +1,252 @@
+#!/usr/bin/env ruby
+# Encoding: UTF-8
+
+################################################################################
+# Class for connecting to a sqlite3 database.
+################################################################################
+
+require 'sqlite3'
+require 'tempfile'
+
+require_relative 'string_manipulation.rb'
+require_relative 'handle_error.rb'
+
+################################################################################
+
+module Poefy
+
+  class Database
+
+    include Poefy::StringManipulation
+    include Poefy::HandleError
+
+    attr_reader :console, :db_file
+
+    # Finalizer must be a class variable.
+    @@final = proc { |dbase| proc {
+      @sproc_lines_all.close if @sproc_lines_all
+      @sproc_rhymes_by_count.close if @sproc_rhymes_by_count
+      @sproc_rhymes_by_count_syllables.close if @sproc_rhymes_by_count_syllables
+      dbase.close if dbase
+    } }
+
+    def initialize db_file, console = false
+      @db_file = db_file
+      @console = console
+      ObjectSpace.define_finalizer(self, @@final.call(@db))
+    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.
+    def db
+      if not @db
+        begin
+          open
+        rescue
+          @db = nil
+          return handle_error 'ERROR: Database does not yet exist'
+        end
+      end
+      @db
+    end
+
+    # Open the database file.
+    def open
+      @db = SQLite3::Database.open(@db_file)
+      @db.results_as_hash = true
+
+      # Create a REGEX function in SQLite.
+      # http://stackoverflow.com/questions/7302311
+      @db.create_function('regexp', 2) do |func, pattern, expression|
+        regexp = Regexp.new(pattern.to_s, Regexp::IGNORECASE)
+        func.result = expression.to_s.match(regexp) ? 1 : 0
+      end
+    end
+
+    # Close the database file.
+    def close
+      @sproc_lines_all.close if @sproc_lines_all
+      @sproc_rhymes_by_count.close if @sproc_rhymes_by_count
+      @sproc_rhymes_by_count_syllables.close if @sproc_rhymes_by_count_syllables
+      db.close
+    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?
+    end
+
+    # Force new database, overwriting existing.
+    def make_new! lines
+
+      # Convert the lines array into an import file.
+      sql_import_file = save_sql_import_file lines
+
+      # Delete any existing database.
+      File.delete(@db_file) rescue nil
+
+      # 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 }
+
+      # Create the database using the SQL instructions.
+      `sqlite3 #{@db_file} < #{sql_instruction_file}`
+
+      # 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('"','""')
+    end
+
+    # Public interfaces for private stored procedure methods.
+    def sproc_rhymes_all! rhyme_count, syllable_min_max = nil
+      if syllable_min_max
+        sproc_rhymes_by_count_syllables rhyme_count, syllable_min_max
+      else
+        sproc_rhymes_by_count rhyme_count
+      end
+    end
+    def sproc_lines_all! rhyme
+      sproc_lines_all rhyme
+    end
+
+    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 = []
+        lines.map do |line|
+          next if Wordfilter.blacklisted? line
+          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|
+            rhyme_ = format_sql_string rhyme
+            sql_lines << "\"#{line_}\"\t#{syll}\t\"#{final_}\"\t\"#{rhyme_}\""
+          end
+        end
+        sql_file = tmpfile
+        File.open(sql_file, 'w') { |fo| fo.puts sql_lines }
+        sql_file
+      end
+
+      # Generate a random temporary file.
+      def tmpfile
+        Dir::Tmpname.make_tmpname ['tmp-','.txt'], nil
+      end
+
+      ##########################################################################
+
+      # Find rhymes and counts greater than a certain length.
+      def sproc_rhymes_by_count rhyme_count
+        if not @sproc_rhymes_by_count
+          sql = %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 >= ?
+          ]
+          begin
+            @sproc_rhymes_by_count = db.prepare sql
+          rescue
+            return handle_error 'ERROR: Database table structure is invalid'
+          end
+        end
+        @sproc_rhymes_by_count.reset!
+        @sproc_rhymes_by_count.bind_param(1, rhyme_count)
+        @sproc_rhymes_by_count.execute.to_a
+      end
+
+      # Also adds syllable selection.
+      def sproc_rhymes_by_count_syllables rhyme_count, syllable_min_max
+        if not @sproc_rhymes_by_count_syllables
+          sql = %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 >= ?
+          ]
+          begin
+            @sproc_rhymes_by_count_syllables = db.prepare sql
+          rescue
+            return handle_error 'ERROR: Database table structure is invalid'
+          end
+        end
+        @sproc_rhymes_by_count_syllables.reset!
+        @sproc_rhymes_by_count_syllables.bind_param(1, syllable_min_max[:min])
+        @sproc_rhymes_by_count_syllables.bind_param(2, syllable_min_max[:max])
+        @sproc_rhymes_by_count_syllables.bind_param(3, rhyme_count)
+        @sproc_rhymes_by_count_syllables.execute.to_a
+      end
+
+      ##########################################################################
+
+      # Find all lines for a certain rhyme.
+      def sproc_lines_all rhyme
+        if not @sproc_lines_all
+          sql = %Q[
+            SELECT line, syllables, final_word, rhyme
+            FROM lines WHERE rhyme = ?
+          ]
+          begin
+            @sproc_lines_all = db.prepare sql
+          rescue
+            return handle_error 'ERROR: Database table structure is invalid'
+          end
+        end
+        @sproc_lines_all.reset!
+        @sproc_lines_all.bind_param(1, rhyme)
+        @sproc_lines_all.execute.to_a
+      end
+
+  end
+
+end
+
+################################################################################