poefy 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 42c9b9aed17a520bca45c074ceb06f6e797dd082
-  data.tar.gz: 3920e82bb6324eaf83f61091602e3c2398db4d42
+  metadata.gz: e04a9ee24cb090de963b812bcf8ec3b8109b2587
+  data.tar.gz: '028bc8ed0525d9bcc77a358162f904aef19d6556'
 SHA512:
-  metadata.gz: be56e85cacb37a40c48995c7f032f1f5d12c396a69f317db12a17e401bcde8d3bbcc1f37c375aebf3b7e2aa164184d40c12e6d8481ff4ff70a634ab0bbf67e59
-  data.tar.gz: 6508356de1969dcfafa22b3f141f280c23c872bc9ca89ba4d9f066fb68981e24232d592cc412e593243489256b1265eb3e2347f47cf04b97009ba0676adb5ceb
+  metadata.gz: de3b67a5f31522c5e3741fdf821a56cc155a03e7c49a13a4387d87c11de3dbb220be6d74263fd8743d3c17042fc41150baec3efb4726fd0e010c10899b701a82
+  data.tar.gz: 117a747d04707cad5062d07fa1ed3eabc173783129de31fef102f426484bf17ad5f2b5b841f497233982130175bb2b8d500567245747b82874557f35bfa617bf

data/README.md

@@ -25,7 +25,7 @@ Or install it yourself as:
 
     $ gem install poefy
 
-The repo comes with some text files included. To generate databases for these files, execute special `make_dbs` command:
+The repo comes with some text files included. To generate databases for these files, execute the special `make_dbs` command:
 
     $ poefy make_dbs
 
@@ -100,6 +100,12 @@ To view and amend these definitions, the code is in `lib/poefy/poetic_forms.rb`.
     rhyme:    'aabba',
     indent:   '',
     syllable: '{1:[8],2:[8],3:[4,5],4:[4,5],5:[8]}'
+  },
+  double_dactyl: {
+    rhyme:    'abcd efgd',
+    indent:   '',
+    syllable: '[6,6,6,4,0,6,6,6,4]',
+    regex:    '{7=>/^\S+$/}'
   }
 }
 ```
@@ -267,7 +273,9 @@ puts poefy.poem ({ rhyme: 'abab cdcd efef gg', indent: '0101 0101 0011 01' })
 puts poefy.poem ({ form: 'sonnet' })
 puts poefy.poem ({ form: :sonnet, syllable: 0 })
 puts poefy.poem ({ form: :sonnet, syllable: 10 })
-puts poefy.poem ({ form: :sonnet, regex: poefy.acrostic('pauldpthompson') })
+puts poefy.poem ({ form: :sonnet, regex: /^[A-Z].*$/ })
+puts poefy.poem ({ form: :sonnet, regex: '^[A-Z].*$' })
+puts poefy.poem ({ form: :sonnet, acrostic: 'pauldpthompson' })
 puts poefy.poem ({ form: 'sonnet', indent: '01010101001101' })
 puts poefy.poem ({ form: 'sonnet', proper: false })
 ```
@@ -309,7 +317,7 @@ Use sed to filter out lines that are too short:
 
 ### Make a database, ignoring uppercase lines
 
-Use sed to filter out lines that only contain 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
 

data/bin/poefy

@@ -57,7 +57,7 @@ def parse_options
             ' ' * 37 + "Specifies rhyme, indent and syllable\n" +
             ' ' * 37 + "One of:\n" +
             ' ' * 39 + forms_by_4.join("\n" + ' ' * 39)) do |s|
-      options[:form] = s.to_sym
+      options[:form] = s
     end
     opts.on('-r', '--rhyme STRING', "See big block of text below") do |s|
       options[:rhyme] = s
@@ -76,9 +76,7 @@ def parse_options
 
     opts.on('-a', '--acrostic STRING',
             "Overwrite 'regex' option to generate an acrostic") do |s|
-      obj = nil
-      obj.extend(Poefy::PoeticForms)
-      options[:regex] = obj.acrostic s
+      options[:acrostic] = s
     end
 
     # Handle proper sentence structure.
@@ -146,26 +144,28 @@ if first_arg.nil?
   exit 0
 end
 
-# If the first argument is 'makedbs', then make
+# If the first argument is 'make_dbs', then make
 #   databases from the included text files.
 if first_arg == 'make_dbs'
-  input = `sed '/[a-z]/!d' data/shakespeare_sonnets.txt`
+  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' data/st_therese_of_lisieux.txt`
+  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' data/whitman_leaves.txt`
+  input = `sed '/[a-z]/!d' #{path}/whitman_leaves.txt`
   poefy = Poefy::PoefyGen.new 'whitman'
   poefy.make_database input, false
 
-  input = `sed '/[a-z]/!d' data/emily_dickinson.txt`
+  input = `sed '/[a-z]/!d' #{path}/emily_dickinson.txt`
   poefy = Poefy::PoefyGen.new 'dickinson'
   poefy.make_database input, false
 
-  input = `sed '/[a-z]/!d' data/english_as_she_is_spoke.txt`
+  input = `sed '/[a-z]/!d' #{path}/english_as_she_is_spoke.txt`
   poefy = Poefy::PoefyGen.new 'spoke'
   poefy.make_database input, false
 
@@ -174,7 +174,7 @@ end
 
 # Poetic form name is the second argument, if it exists.
 second_arg = (ARGV.length > 1) ? ARGV[1] : ''
-options[:form] = second_arg.to_sym
+options[:form] = second_arg
 
 # Create poefy object.
 poefy = Poefy::PoefyGen.new first_arg, options
@@ -190,11 +190,7 @@ end
 
 # Create a database using input.
 if data
-  if options[:overwrite]
-    poefy.make_database! data
-  else
-    poefy.make_database data
-  end
+  poefy.make_database data, options[:overwrite]
 
 # Make a new poem, and output it.
 else
@@ -202,4 +198,7 @@ else
   puts poem if poem
 end
 
+# Close the database connection.
+poefy.close
+
 ################################################################################

data/lib/poefy.rb

@@ -15,7 +15,6 @@ require 'wordfilter'
 require 'tempfile'
 require 'sqlite3'
 require 'timeout'
-require 'json'
 
 require_relative 'poefy/version.rb'
 require_relative 'poefy/self.rb'

data/lib/poefy/conditional_satisfaction.rb

@@ -6,6 +6,22 @@
 #   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.
+# Both methods 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.
+# If none of the conditions match, then it will run in factorial time,
+#   which will get exponentially longer the more elements there are in the
+#   input array.
+# I would recommend wrapping inside a Timeout block to assuage this. If it
+#   fails to resolve in, say, two seconds, then it's probably not possible
+#   to fit the conditions to the lines:
+#       begin
+#         Timeout::timeout(2) do
+#           output = conditional_selection(lines.shuffle, conditions)
+#         end
+#       rescue
+#         output = []
+#       end
 ################################################################################
 # '#conditional_permutation' returns a complete permutation of an array.
 # i.e. output length == array length
@@ -18,11 +34,6 @@
 #     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
@@ -63,7 +74,13 @@ module Poefy
         valid = valid && [*poetic_form[:syllable]].include?(line['syllables'])
       end
       if poetic_form[:regex]
-        valid = valid && !!(line['line'].match(poetic_form[:regex]))
+        if poetic_form[:regex].respond_to?(:each)
+          poetic_form[:regex].each do |i|
+            valid = valid && !!(line['line'].match(i))
+          end
+        else
+          valid = valid && !!(line['line'].match(poetic_form[:regex]))
+        end
       end
       valid
     end
@@ -113,10 +130,9 @@ module Poefy
     # 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
+    def conditional_permutation array, conditions,
+                                current_iter = 0,
+                                current_array = []
       output = []
 
       # Get the current conditional.
@@ -128,7 +144,7 @@ module Poefy
 
         # Test the condition. If we've run out of elements
         #   in the condition array, then allow any value.
-        valid = cond ? cond.call(elem) : true
+        valid = cond ? cond.call(current_array, elem) : true
         if valid
 
           # Remove this element from the array, and recurse.
@@ -138,8 +154,9 @@ module Poefy
           # 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)
+            new_val = conditional_permutation(remain, conditions,
+                                              current_iter + 1,
+                                              current_array + [elem])
           end
 
           # If we cannot use this value, because it breaks future conditions.
@@ -184,8 +201,9 @@ module Poefy
           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])
+          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?

data/lib/poefy/database.rb

@@ -23,17 +23,17 @@ module Poefy
     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
+    @@final = proc { |dbase, sproc| proc {
+      sproc.each { |k, v| v.close }
       dbase.close if dbase
     } }
 
     def initialize db_file, console = false
       @db_file = db_file
       @console = console
-      ObjectSpace.define_finalizer(self, @@final.call(@db))
+      @sproc = {}
+      db
+      ObjectSpace.define_finalizer(self, @@final.call(@db, @sproc))
     end
 
     # Open global database session, if not already existing.
@@ -41,11 +41,16 @@ module Poefy
     #   execute it before any calling code.
     def db
       if not @db
-        begin
-          open
-        rescue
+        if !exists?
           @db = nil
-          return handle_error 'ERROR: Database does not yet exist'
+        else
+          begin
+            open
+            create_sprocs
+          rescue
+            @db = nil
+            return handle_error 'ERROR: Database contains invalid structure'
+          end
         end
       end
       @db
@@ -66,10 +71,9 @@ module Poefy
 
     # 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
+      @sproc.each { |k, v| v.close rescue nil }
+      @db.close if @db
+      @db = nil
     end
 
     # See if the database file exists or not.
@@ -93,7 +97,7 @@ module Poefy
       sql_import_file = save_sql_import_file lines
 
       # Delete any existing database.
-      File.delete(@db_file) rescue nil
+      File.delete(@db_file) if File.exists?(@db_file)
 
       # Write SQL and SQLite instructions to temp file,
       #   import to database, delete temp file.
@@ -133,14 +137,20 @@ module Poefy
 
     # Public interfaces for private stored procedure methods.
     def sproc_rhymes_all! rhyme_count, syllable_min_max = nil
+      db
       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
+    def sproc_lines_all! rhyme, syllable_min_max = nil
+      db
+      if syllable_min_max
+        sproc_lines_all_syllables rhyme, syllable_min_max
+      else
+        sproc_lines_all rhyme
+      end
     end
 
     private
@@ -174,77 +184,83 @@ module Poefy
 
       ##########################################################################
 
-      # 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 >= ?
-          ]
+      # 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_rhymes_by_count = db.prepare sql
+            @sproc[key] = db.prepare value
           rescue
+            raise 'ERROR: Database table structure is invalid'
             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
+
+      # 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
-        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
+        @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
-        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
+        @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/generation.rb

@@ -29,11 +29,12 @@ module Poefy
       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
+          "       Try again using the -f or -r option.\n" +
+          "       Use -h or --help to view valid forms."
       end
 
       # Loop until we find a valid poem.
-      output = poem_proper_sentence poetic_form
+      output = gen_poem_using_conditions poetic_form
 
       # Return nil if poem could not be created.
       return nil if (output.nil? or output == [] or output == [''])
@@ -41,7 +42,7 @@ module Poefy
       # 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.
+      # Append blank 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] = ''
@@ -74,39 +75,6 @@ module Poefy
 
     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
@@ -118,9 +86,60 @@ module Poefy
           return handle_error 'ERROR: Rhyme string is not valid', []
         end
 
-        # Add lines number as ':line' in each element's hash.
+        # Add acrostic to the regex, if necessary.
+        if poetic_form[:acrostic]
+          poetic_form[:regex] =
+            merge_hashes poetic_form[:regex], acrostic(poetic_form[:acrostic])
+        end
+
+        # Add line number as ':line' in each element's hash.
         by_line = conditions_by_line(tokenised_rhyme, poetic_form)
 
+        # If the poetic_form[:proper] option is true, we're going to
+        #   need to add additional regex conditions to the first and
+        #   last lines.
+        # This is pretty easy for non-repeating lines, but for refrains
+        #   we need to apply the regex for all occurrences.
+        if poetic_form[:proper]
+
+          # Turn the regex into an array, if it isn't already.
+          # Then add the banned starting words.
+          line_conds = [*by_line[0][:regex]]
+          line_conds += [/^((?!and).)/i]
+          line_conds += [/^((?!but).)/i]
+          line_conds += [/^((?!or).)/i]
+          line_conds += [/^((?!nor).)/i]
+          line_conds += [/^((?!yet).)/i]
+          by_line[0][:regex] = line_conds
+
+          # Same for the last line.
+          line_conds = [*by_line[tokenised_rhyme.count-1][:regex]]
+          line_conds += [/[\.?!]$/]
+          by_line[tokenised_rhyme.count-1][:regex] = line_conds
+
+          # Get all refrains by uppercase rhyme token.
+          refrains = by_line.reject do |i|
+            i[:rhyme] == i[:rhyme].downcase
+          end.group_by do |i|
+            i[:rhyme]
+          end
+
+          # Now make each refrain :regex be an array of all.
+          refrain_regex = Hash.new { |h,k| h[k] = [] }
+          refrains.each do |key, value|
+            refrain_regex[key] = value.map do |i|
+              i[:regex]
+            end.flatten.compact
+          end
+
+          # Go through [by_line] and update each :regex.
+          by_line.each do |i|
+            if not refrain_regex[i[:rhyme]].empty?
+              i[:regex] = refrain_regex[i[:rhyme]]
+            end
+          end
+        end
+
         # 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|
@@ -179,19 +198,8 @@ module Poefy
 
           # 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
+          min_max = syllable_min_max line_conds
+          rhymes = @db.sproc_rhymes_all!(line_conds.count, min_max)
 
           # Get just the rhyme part of the hash.
           rhymes = rhymes.map{ |i| i['rhyme'] }
@@ -200,11 +208,15 @@ module Poefy
           # For each rhyme, get all lines and try to sastify all conditions.
           out = []
           rhymes.shuffle.each do |rhyme|
-            out = try_rhyme(conditions, rhyme)
+            out = try_rhyme(conditions, rhyme, min_max)
             break if !out.empty?
           end
           if out.empty?
-            return handle_error 'ERROR: Not enough rhyming lines in the input'
+            msg = 'ERROR: Not enough rhyming lines in the input.'
+            if poetic_form[:proper]
+              msg += "\n       Perhaps try again using the -p option."
+            end
+            return handle_error msg
           end
           rhymes_already_used << out.first['rhyme']
 
@@ -247,13 +259,12 @@ module Poefy
 
       # Loop through the rhymes until we find one that works.
       # (In a reasonable time-frame)
-      def try_rhyme conditions, rhyme
+      def try_rhyme conditions, rhyme, syllable_min_max = nil
         output = []
-        lines = @db.sproc_lines_all!(rhyme)
+        lines = @db.sproc_lines_all!(rhyme, syllable_min_max)
         begin
           Timeout::timeout(2) do
             output = conditional_selection(lines.shuffle, conditions)
-            break
           end
         rescue
           output = []
@@ -261,6 +272,22 @@ module Poefy
         output
       end
 
+      # Find min and max syllable count from the conditions.
+      def syllable_min_max line_conds
+        min_max = nil
+        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
+        end
+        min_max
+      end
+
   end
 
 end

data/lib/poefy/poefy_gen_base.rb

@@ -5,10 +5,6 @@
 # Base internals for the PoefyGen class.
 ################################################################################
 
-require 'json'
-
-################################################################################
-
 module Poefy
 
   module PoefyGenBase
@@ -22,14 +18,15 @@ module Poefy
 
     # Make a database using the given lines.
     def make_database input, overwrite = @overwrite
+      @db.close if @db
       if overwrite
-        make_database! input
+        @db.make_new! validate_lines input
       else
         @db.make_new validate_lines input
       end
     end
     def make_database! input
-      @db.make_new! validate_lines input
+      make_database input, true
     end
 
     # Close the database.
@@ -86,6 +83,7 @@ module Poefy
         output[:indent]   = input[:indent]   if input[:indent]
         output[:syllable] = input[:syllable] if input[:syllable]
         output[:regex]    = input[:regex]    if input[:regex]
+        output[:acrostic] = input[:acrostic] if input[:acrostic]
 
         # Tokenise string to arrays and hashes.
         rhyme = get_poetic_form_rhyme(output)

data/lib/poefy/poetic_forms.rb

@@ -106,6 +106,12 @@ module Poefy
         rhyme:    'abab',
         indent:   '0101',
         syllable: '[8,6,8,6]'
+      },
+      double_dactyl: {
+        rhyme:    'abcd efgd',
+        indent:   '',
+        syllable: '[6,6,6,4,0,6,6,6,4]',
+        regex:    '{7=>/^\S+$/}'
       }
     }
 
@@ -231,7 +237,7 @@ module Poefy
         result
       end
 
-      # Sort by keys, to make JSON more human-readable.
+      # Sort by keys, to make it more human-readable.
       def sort_hash input
         output = {}
         input.keys.sort.each do |k|

data/lib/poefy/string_manipulation.rb

@@ -74,6 +74,21 @@ module Poefy
         output_array
       end
 
+      # Combine two hashes together, transforming all values to array.
+      # These arrays are then flattened.
+      def merge_hashes one, two
+        one ||= {}
+        two ||= {}
+        new_hash = Hash.new { |h,k| h[k] = [] }
+        keys = (one.keys + two.keys).sort.uniq
+        keys.each do |key|
+          new_hash[key] << one[key] if one[key]
+          new_hash[key] << two[key] if two[key]
+          new_hash[key].flatten!
+        end
+        new_hash
+      end
+
   end
 
 end

data/lib/poefy/version.rb

@@ -12,13 +12,13 @@ module Poefy
   end
 
   def self.version_date
-    '2017-05-17'
+    '2017-05-22'
   end
 
   module VERSION
     MAJOR = 0
     MINOR = 5
-    TINY  = 1
+    TINY  = 2
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')

data/spec/poefy_spec.rb

@@ -7,6 +7,8 @@ describe Poefy::PoefyGen do
 
   before(:all) do
     @root = File.expand_path('../../', __FILE__)
+    db_file = "#{@root}/data/spec_test_tiny.db"
+    File.delete(db_file) if File.exists?(db_file)
   end
   after(:all) do
     db_file = "#{@root}/data/spec_test_tiny.db"
@@ -31,7 +33,6 @@ describe Poefy::PoefyGen do
     describe "#make_database( '#{@root}/data/#{file_txt}', true )" do
       it "should make the database '#{@root}/data/#{file_db}" do
         db_file = "#{@root}/data/#{file_db}"
-        File.delete(db_file) if File.exists?(db_file)
         @poefy.make_database "#{@root}/data/#{file_txt}", true
         expect(@poefy.db.exists?).to be true
         expect(File.exists?(db_file)).to be true
@@ -41,10 +42,14 @@ describe Poefy::PoefyGen do
     describe ":rhyme option" do
 
       describe "should return nil" do
-        it "({  })" 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
@@ -193,12 +198,15 @@ describe Poefy::PoefyGen do
 
     # All the Shakespeare lines are pentameter, so some forms should fail.
     forms      = Poefy::PoeticForms::POETIC_FORMS
-    forms_fail = [:limerick, :haiku, :common, :ballad]
+    forms_fail = [:limerick, :haiku, :common, :ballad, :double_dactyl]
     forms_pass = forms.keys - forms_fail
 
     before(:each) do
       @poefy = Poefy::PoefyGen.new(file_db, { proper: false })
     end
+    after(:each) do
+      @poefy.close
+    end
 
     it "initialised object not nil" do
       expect(@poefy).to_not be_nil
@@ -207,7 +215,6 @@ describe Poefy::PoefyGen do
     describe "#make_database( '#{@root}/data/#{file_txt}', true )" do
       it "should make the database '#{@root}/data/#{file_db}" do
         db_file = "#{@root}/data/#{file_db}"
-#        File.delete(db_file) if File.exists?(db_file)
         input = `sed '/[a-z]/!d' #{@root}/data/#{file_txt}`
         @poefy.make_database input
         expect(@poefy.db.exists?).to be true
@@ -215,6 +222,23 @@ describe Poefy::PoefyGen do
       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
 
@@ -245,6 +269,29 @@ describe Poefy::PoefyGen do
         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
 
   ##############################################################################
@@ -261,6 +308,9 @@ describe Poefy::PoefyGen do
     before(:each) do
       @poefy = Poefy::PoefyGen.new(file_db, { proper: false })
     end
+    after(:each) do
+      @poefy.close
+    end
 
     it "initialised object not nil" do
       expect(@poefy).to_not be_nil
@@ -269,7 +319,6 @@ describe Poefy::PoefyGen do
     describe "#make_database( '#{@root}/data/#{file_txt}', true )" do
       it "should make the database '#{@root}/data/#{file_db}" do
         db_file = "#{@root}/data/#{file_db}"
-#        File.delete(db_file) if File.exists?(db_file)
         input = `sed '/[a-z]/!d' #{@root}/data/#{file_txt}`
         @poefy.make_database input
         expect(@poefy.db.exists?).to be true
@@ -297,6 +346,29 @@ describe Poefy::PoefyGen do
       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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: poefy
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - Paul Thompson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-17 00:00:00.000000000 Z
+date: 2017-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler