poefy 0.5.1

data/lib/poefy/generation.rb

@@ -0,0 +1,268 @@
+#!/usr/bin/env ruby
+# Encoding: UTF-8
+
+################################################################################
+# Handle the procedural generation of poems.
+################################################################################
+
+require 'timeout'
+
+################################################################################
+
+module Poefy
+
+  module Generation
+
+    # Generate specific poem types.
+    def poem poetic_form = @poetic_form
+
+      if !@db.exists?
+        return handle_error 'ERROR: Database does not yet exist', nil
+      end
+
+      # Validate the poetic form hash.
+      raise ArgumentError, 'Argument must be a hash' unless
+            poetic_form.is_a?(Hash)
+      poetic_form = validate_poetic_form poetic_form
+
+      # Make sure the hash contains ':form' or ':rhyme' keys.
+      if !(poetic_form[:form] or poetic_form[:rhyme])
+        return handle_error \
+          "ERROR: No valid rhyme or form option specified.\n" +
+          "       Try again using the -f or -r option.\n", nil
+      end
+
+      # Loop until we find a valid poem.
+      output = poem_proper_sentence poetic_form
+
+      # Return nil if poem could not be created.
+      return nil if (output.nil? or output == [] or output == [''])
+
+      # Indent the output using the :indent string.
+      output = do_indent(output, get_poetic_form_indent(poetic_form))
+
+      # Append nil lines to the end if the :rhyme demands it.
+      rhyme = tokenise_rhyme get_poetic_form_rhyme poetic_form
+      (output.length...rhyme.length).each do |i|
+        output[i] = ''
+      end
+
+      output
+    end
+
+    # Get all rhyming lines for the word.
+    def rhymes word, key = nil
+      return nil if word.nil?
+      sproc = @db.db.prepare %Q[
+        SELECT rhyme, final_word, syllables, line
+        FROM lines
+        WHERE rhyme = ?
+        ORDER BY rhyme, final_word, syllables, line
+      ]
+      output = word.to_phrase.rhymes.keys.map do |rhyme|
+        sproc.reset!
+        sproc.bind_param(1, rhyme)
+        sproc.execute.to_a
+      end.flatten
+      sproc.close
+      if !key.nil? and %w[rhyme final_word syllables line].include?(key)
+        output.map!{ |i| i[key] }
+      end
+      output
+    end
+
+
+    private
+
+      # Generate a poem using the database and a poem format.
+      # If ':proper' then loop to find a valid poem.
+      def poem_proper_sentence poetic_form = @poetic_form
+        poetic_form = validate_poetic_form poetic_form
+        output, count_down = [], 500
+
+        # Final line must close with sentence-end punctuation.
+        # Don't start poems with these words.
+        banned_first_words = poetic_form[:proper] ? %w{and but or nor yet} : []
+
+        loop do
+          output = gen_poem_using_conditions poetic_form
+          break if output.nil? or output.empty?
+          if !banned_first_words.include?(first_word(output[0]).downcase) and
+              ( !poetic_form[:proper] or has_stop_punctuation?(output[-1]) )
+            break
+          end
+
+          # Fail after some number of failures.
+          if (count_down -= 1) == 0 and poetic_form[:proper]
+            return handle_error \
+              "ERROR: Proper sentence structure not able to be honoured.\n" +
+              "       Ensure the input has closing punctuation or\n" +
+              "       try again using the -p option."
+          end
+        end
+
+        # (previous way of dealing with closing full stops)
+        # (leaving the code commented out for now)
+        # output[-1] = end_the_sentence(output[-1])
+        output
+      end
+
+      # Use the constraints in 'poetic_form' to generate a poem.
+      def gen_poem_using_conditions poetic_form = @poetic_form
+        poetic_form = poetic_form_full poetic_form
+        poetic_form = validate_poetic_form poetic_form
+
+        # Tokenise the rhyme string, and return [] if invalid.
+        tokenised_rhyme = tokenise_rhyme poetic_form[:rhyme]
+        if tokenised_rhyme == []
+          return handle_error 'ERROR: Rhyme string is not valid', []
+        end
+
+        # Add lines number as ':line' in each element's hash.
+        by_line = conditions_by_line(tokenised_rhyme, poetic_form)
+
+        # Now we have ':line', so we can break the array order.
+        # Let's get rid of empty lines, and group by the rhyme letter.
+        conditions_by_rhyme = by_line.reject do |i|
+          i[:rhyme] == ' '
+        end.group_by do |i|
+          i[:rhyme_letter]
+        end
+
+        # Okay, this is great. But if we're making villanelles we'll need
+        #   duplicated refrain lines. So we won't need unique rhymes for those.
+        # So make a distinct set of lines conditions, still grouped by rhyme.
+        # This will be the same as [conditions_by_rhyme], except duplicate lines
+        #   are removed. (These are lines with capitals and numbers: i.e. A1, B2)
+        # It will keep the condition hash of only the first refrain line.
+        distinct_line_conds = Hash.new { |h,k| h[k] = [] }
+        conditions_by_rhyme.each do |key, values|
+          uppers = []
+          values.each do |v|
+            char_1 = v[:rhyme][0]
+            if char_1 == char_1.upcase
+              if !uppers.include?(v[:rhyme])
+                uppers << v[:rhyme]
+                distinct_line_conds[key] << v
+              end
+            else
+              distinct_line_conds[key] << v
+            end
+          end
+        end
+
+        # Right, let's now loop through each rhyme group and find all from
+        #   the database where the number of lines can be fulfilled.
+
+        # First, get the order of rhymes, from most to least.
+        distinct_line_conds = distinct_line_conds.sort_by{ |k,v| v.count }.reverse
+
+        # This will store the rhymes that have already been used in the poem.
+        # This is so we do not duplicate rhymes between distinct rhyme letters.
+        rhymes_already_used = []
+
+        # This is the final set of lines.
+        all_lines = []
+
+        # Loop through each rhyme group to find lines that satisfy the conditions.
+        distinct_line_conds.each do |rhyme_letter, line_conds|
+
+          # The conditions that will be passed to '#conditional_selection'.
+          # This is an array of procs, one for each line.
+          conditions = line_conds.map do |cond|
+            proc { |arr, elem| diff_end(arr, elem) and validate_line(elem, cond)}
+          end
+
+          # Get all rhymes from the database with at least as many final
+          #   words as there are lines to be matched.
+          rhymes = nil
+
+          # If all the lines include a 'syllable' condition,
+          #   then we can specify to only query for matching lines.
+          if line_conds.all?{ |i| i[:syllable] }
+            min = line_conds.min do |a, b|
+              [*a[:syllable]].min <=> [*b[:syllable]].min
+            end[:syllable]
+            max = line_conds.max do |a, b|
+              [*a[:syllable]].max <=> [*b[:syllable]].max
+            end[:syllable]
+            min_max = { min: [*min].min, max: [*max].max }
+            min_max = nil if min_max[:max] == 0
+            rhymes = @db.sproc_rhymes_all!(line_conds.count, min_max)
+          else
+            rhymes = @db.sproc_rhymes_all!(line_conds.count)
+          end
+
+          # Get just the rhyme part of the hash.
+          rhymes = rhymes.map{ |i| i['rhyme'] }
+          rhymes = rhymes - rhymes_already_used
+
+          # For each rhyme, get all lines and try to sastify all conditions.
+          out = []
+          rhymes.shuffle.each do |rhyme|
+            out = try_rhyme(conditions, rhyme)
+            break if !out.empty?
+          end
+          if out.empty?
+            return handle_error 'ERROR: Not enough rhyming lines in the input'
+          end
+          rhymes_already_used << out.first['rhyme']
+
+          # Add the line number back to the array.
+          line_conds.count.times do |i|
+            out[i]['line_number'] = line_conds[i][:line]
+          end
+
+          out.each do |i|
+            all_lines << i
+          end
+        end
+
+        # Transpose lines to their actual location.
+        poem_lines = []
+        all_lines.each do |line|
+          poem_lines[line['line_number'] - 1] = line['line']
+        end
+
+        # Go back to the [by_line] array and find all the refrain line nos.
+        refrains = Hash.new { |h,k| h[k] = [] }
+        by_line.reject{ |i| i[:rhyme] == ' ' }.each do |line|
+          if line[:rhyme][0] == line[:rhyme][0].upcase
+            refrains[line[:rhyme]] << line[:line]
+          end
+        end
+        refrains.keys.each do |k|
+          refrains[k].sort!
+        end
+
+        # Use the first refrain line and repeat it for the others.
+        refrains.each do |key, values|
+          values[1..-1].each do |i|
+            poem_lines[i-1] = poem_lines[values.first-1]
+          end
+        end
+
+        poem_lines
+      end
+
+      # Loop through the rhymes until we find one that works.
+      # (In a reasonable time-frame)
+      def try_rhyme conditions, rhyme
+        output = []
+        lines = @db.sproc_lines_all!(rhyme)
+        begin
+          Timeout::timeout(2) do
+            output = conditional_selection(lines.shuffle, conditions)
+            break
+          end
+        rescue
+          output = []
+        end
+        output
+      end
+
+  end
+
+end
+
+################################################################################

data/lib/poefy/handle_error.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# Encoding: UTF-8
+
+################################################################################
+# Handle error message.
+# Quit the program if called from console.
+################################################################################
+
+module Poefy
+
+  module HandleError
+
+    private
+
+      def handle_error msg, return_value = nil
+        if @console
+          STDERR.puts msg
+          exit 1
+        end
+        return_value
+      end
+
+  end
+
+end
+
+################################################################################

data/lib/poefy/poefy_gen_base.rb

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+# Encoding: UTF-8
+
+################################################################################
+# Base internals for the PoefyGen class.
+################################################################################
+
+require 'json'
+
+################################################################################
+
+module Poefy
+
+  module PoefyGenBase
+
+    attr_reader :console, :db, :local, :overwrite
+
+    def initialize db_name, options = {}
+      handle_options options
+      @db = Poefy::Database.new get_database_file(db_name), @console
+    end
+
+    # Make a database using the given lines.
+    def make_database input, overwrite = @overwrite
+      if overwrite
+        make_database! input
+      else
+        @db.make_new validate_lines input
+      end
+    end
+    def make_database! input
+      @db.make_new! validate_lines input
+    end
+
+    # Close the database.
+    def close
+      @db.close
+    end
+
+    # Validate the lines. Arg could be a filename,
+    #   newline delimited string, or array of lines.
+    def validate_lines input
+
+      # If the input is a file, then read it.
+      lines = File.exists?(input) ? File.read(input) : input
+
+      # If lines is not an array, assume string and split on newlines.
+      lines = lines.respond_to?(:each) ? lines : lines.split("\n")
+      lines.map(&:strip!)
+      lines
+    end
+
+    private
+
+      # Find the correct database file.
+      # If local, just use the value.
+      # Else, use the database in /data/ directory.
+      def get_database_file database_name
+        if @local
+          database_name
+        else
+          path = File.expand_path('../../../data', __FILE__)
+          file = File.basename(database_name, '.db')
+          path + '/' + file + '.db'
+        end
+      end
+
+      # Handle the optional initialize options hash.
+      def handle_options options
+        @console     = options[:console]   || false
+        @overwrite   = options[:overwrite] || false
+        @local       = options[:local]     || false
+        @poetic_form = {}
+        @poetic_form[:proper] = options[:proper] || true
+        @poetic_form = validate_poetic_form options
+      end
+
+      # Make sure the options hash is in order.
+      def validate_poetic_form poetic_form
+        input, output = poetic_form, {}
+        form_string   = get_valid_form input[:form]
+
+        # Handle obvious inputs.
+        output[:form]     = form_string      if form_string
+        output[:rhyme]    = input[:rhyme]    if input[:rhyme]
+        output[:indent]   = input[:indent]   if input[:indent]
+        output[:syllable] = input[:syllable] if input[:syllable]
+        output[:regex]    = input[:regex]    if input[:regex]
+
+        # Tokenise string to arrays and hashes.
+        rhyme = get_poetic_form_rhyme(output)
+        if output[:rhyme]
+          output[:rhyme] = tokenise_rhyme output[:rhyme]
+        end
+        if output[:syllable]
+          output[:syllable] = transform_string_syllable output[:syllable], rhyme
+        end
+        if output[:regex]
+          output[:regex] = transform_string_regex output[:regex], rhyme
+        end
+
+        # Get from instance by default.
+        output[:proper] = input[:proper].nil? ?
+                            @poetic_form[:proper] : input[:proper]
+
+        # Tiny amendment to solve later errors.
+        output[:rhyme] = ' ' if output[:rhyme] == ''
+        output
+      end
+
+      # Handle error message. Quit the program if called from console.
+      def handle_error msg
+        if @console
+          STDERR.puts msg
+          exit 1
+        end
+        nil
+      end
+
+  end
+
+end
+
+################################################################################