poefy 1.0.0 → 1.1.0

data/lib/poefy/generation.rb

@@ -16,9 +16,8 @@ module Poefy
     # Generate specific poem types.
     def poem poetic_form = @poetic_form
 
-      if !@corpus.exists?
-        return handle_error 'ERROR: Database does not yet exist', nil
-      end
+      # Can't do much if the database doesn't exist.
+      raise Poefy::MissingDatabase unless @corpus.exists?
 
       # Validate the poetic form hash.
       raise ArgumentError, 'Argument must be a hash' unless
@@ -27,11 +26,12 @@ module Poefy
       poetic_form = @poetic_form.merge 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" +
-          "       Use -h or --help to view valid forms."
+      # Make sure the rhyme token is not empty.
+      rhyme = poetic_form[:rhyme]
+      if !(rhyme || poetic_form[:form])
+        raise Poefy::MissingFormOrRhyme
+      elsif (rhyme && rhyme.count == 1 && rhyme.first[:token] == ' ')
+        raise Poefy::MissingFormOrRhyme
       end
 
       # Loop until we find a valid poem.
@@ -59,6 +59,15 @@ module Poefy
       output
     end
 
+    # Same as the above method, but swallow any errors.
+    def poem! poetic_form = @poetic_form
+      begin
+        poem poetic_form
+      rescue Poefy::Error
+        nil
+      end
+    end
+
     private
 
       # Use the constraints in 'poetic_form' to generate a poem.
@@ -69,7 +78,7 @@ module Poefy
         # 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', []
+          raise Poefy::RhymeError
         end
 
         # Expand poetic_form[:transform], if there's just one element.
@@ -93,6 +102,11 @@ module Poefy
         # Add line number as ':line' in each element's hash.
         by_line = conditions_by_line(tokenised_rhyme, poetic_form)
 
+        # Remove any regexes that are empty arrays [].
+        by_line.each do |i|
+          i.delete(:regex) if i[:regex] == []
+        end
+
         # If the poetic_form[:proper] option is true, we're going to
         #   need to add additional regex conditions to the first and
         #   last lines.
@@ -198,7 +212,11 @@ module Poefy
 
           # If all the lines include a 'syllable' condition,
           #   then we can specify to only query for matching lines.
-          min_max = syllable_min_max line_conds
+          begin
+            min_max = syllable_min_max line_conds
+          rescue
+            raise Poefy::SyllableError
+          end
           rhymes = @corpus.rhymes_by_count(line_conds.count, min_max)
 
           # Get just the rhyme part of the hash.
@@ -216,7 +234,7 @@ module Poefy
             if poetic_form[:proper]
               msg += "\n       Perhaps try again using the -p option."
             end
-            return handle_error msg
+            raise Poefy::NotEnoughData.new(msg)
           end
           rhymes_already_used << out.first['rhyme']
 

data/lib/poefy/poem_base.rb

@@ -1,112 +1,112 @@
-#!/usr/bin/env ruby
-# Encoding: UTF-8
-
-################################################################################
-# Base internals for the Poem class.
-################################################################################
-
-module Poefy
-
-  module PoemBase
-
-    attr_reader :corpus, :local, :overwrite
-
-    def initialize db_name, options = {}
-      handle_options options
-      @corpus = Poefy::Database.new db_name, @local
-    end
-
-    # Make a database using the given lines.
-    def make_database input, description = nil, overwrite = @overwrite
-      lines = validate_lines input
-      lines.map! do |line|
-        line.force_encoding('utf-8')
-            .gsub("\u00A0", ' ')
-            .strip
-      end
-      @corpus.close if @corpus
-      if overwrite
-        @corpus.make_new! lines, description
-      else
-        @corpus.make_new lines, description
-      end
-    end
-    def make_database! input, description = nil
-      make_database input, description, true
-    end
-
-    # Close the database.
-    def close
-      @corpus.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.to_s) ? File.read(input) : input
-
-      # If lines is not an array, assume string and split on newlines.
-      lines.respond_to?(:each) ? lines : lines.split("\n")
-    end
-
-    private
-
-      # Handle the optional initialize options hash.
-      def handle_options options
-        @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]
-
-        # Apply ':form_from_text' before any others.
-        if input[:form_from_text]
-          lines = validate_lines input[:form_from_text]
-          form = poetic_form_from_text lines
-          input = form.merge input
-        end
-
-        # 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]
-        output[:acrostic]   = input[:acrostic]   if input[:acrostic]
-        output[:acrostic_x] = input[:acrostic_x] if input[:acrostic_x]
-        output[:transform]  = input[:transform]  if input[:transform]
-
-        # Tokenise string to arrays and hashes.
-        if output[:rhyme]
-          output[:rhyme] = tokenise_rhyme output[:rhyme]
-        end
-        rhyme = get_poetic_form_rhyme(output)
-        if output[:syllable] and rhyme != ' '
-          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
-
-  end
-
-end
-
-################################################################################
+#!/usr/bin/env ruby
+# Encoding: UTF-8
+
+################################################################################
+# Base internals for the Poem class.
+################################################################################
+
+module Poefy
+
+  module PoemBase
+
+    attr_reader :corpus, :local, :overwrite
+
+    def initialize db_name, options = {}
+      handle_options options
+      @corpus = Poefy::Database.new db_name, @local
+    end
+
+    # Make a database using the given lines.
+    def make_database input, description = nil, overwrite = @overwrite
+      lines = validate_lines input
+      lines.map! do |line|
+        line.force_encoding('utf-8')
+            .gsub("\u00A0", ' ')
+            .strip
+      end
+      @corpus.close if @corpus
+      if overwrite
+        @corpus.make_new! lines, description
+      else
+        @corpus.make_new lines, description
+      end
+    end
+    def make_database! input, description = nil
+      make_database input, description, true
+    end
+
+    # Close the database.
+    def close
+      @corpus.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.to_s) ? File.read(input) : input
+
+      # If lines is not an array, assume string and split on newlines.
+      lines.respond_to?(:each) ? lines : lines.split("\n")
+    end
+
+    private
+
+      # Handle the optional initialize options hash.
+      def handle_options options
+        @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]
+
+        # Apply ':form_from_text' before any others.
+        if input[:form_from_text]
+          lines = validate_lines input[:form_from_text]
+          form = poetic_form_from_text lines
+          input = form.merge input
+        end
+
+        # 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]
+        output[:acrostic]   = input[:acrostic]   if input[:acrostic]
+        output[:acrostic_x] = input[:acrostic_x] if input[:acrostic_x]
+        output[:transform]  = input[:transform]  if input[:transform]
+
+        # Tokenise string to arrays and hashes.
+        if output[:rhyme]
+          output[:rhyme] = tokenise_rhyme output[:rhyme]
+        end
+        rhyme = get_poetic_form_rhyme_longest(output)
+        if output[:syllable] and rhyme != ' '
+          output[:syllable] = transform_input_syllable output[:syllable], rhyme
+        end
+        if output[:regex]
+          output[:regex] = transform_input_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
+
+  end
+
+end
+
+################################################################################