poefy 1.1.0 → 2.0.0

data/lib/poefy/generation.rb

@@ -17,7 +17,7 @@ module Poefy
     def poem poetic_form = @poetic_form
 
       # Can't do much if the database doesn't exist.
-      raise Poefy::MissingDatabase unless @corpus.exists?
+      raise Poefy::MissingDatabase unless @corpus.exist?
 
       # Validate the poetic form hash.
       raise ArgumentError, 'Argument must be a hash' unless
@@ -206,10 +206,6 @@ module Poefy
           #   words as there are lines to be matched.
           rhymes = nil
 
-          # If all the lines include a 'regex' condition,
-          #   then we can specify to only query for matching lines.
-          regex_all = regex_for_all line_conds
-
           # If all the lines include a 'syllable' condition,
           #   then we can specify to only query for matching lines.
           begin
@@ -226,7 +222,7 @@ 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, min_max, regex_all)
+            out = try_rhyme(conditions, rhyme, min_max, line_conds)
             break if !out.empty?
           end
           if out.empty?
@@ -300,14 +296,26 @@ module Poefy
 
       # Loop through the rhymes until we find one that works.
       # (In a reasonable time-frame)
-      def try_rhyme conditions, rhyme, syllable_min_max = nil, regex_all = nil
+      private def try_rhyme conditions, rhyme, syllable_min_max = nil, line_conds = nil
         output = []
         lines = @corpus.lines_by_rhyme(rhyme, syllable_min_max)
 
         # To reduce the number of permutations, reject lines
         #   that do not match any of the lines regex.
-        lines.reject! { |i| !(i['line'].match(regex_all)) } if regex_all
+        regex_conds = line_conds.map { |i| i[:regex] }
+        if !regex_conds.include?(nil) and !regex_conds.include?(//)
+          new_lines = []
+          [*regex_conds].each do |regex_group|
+            possible_lines = lines.dup
+            [*regex_group].each do |regex|
+              possible_lines.reject! { |i| !(i['line'].match(regex)) }
+            end
+            new_lines += possible_lines
+          end
+          lines = new_lines
+        end
 
+        # Get a sample from the lines that works for all the conditions.
         begin
           Timeout::timeout(2) do
             output = lines.shuffle.conditional_sample(conditions)
@@ -334,16 +342,6 @@ module Poefy
         min_max
       end
 
-      # If every line has a regex, then return a regex union.
-      def regex_for_all line_conds
-        output = nil
-        if line_conds.all?{ |i| i[:regex] }
-          all_regex = line_conds.map{ |i| i[:regex] }
-          output = Regexp.union all_regex.flatten
-        end
-        output
-      end
-
   end
 
 end

data/lib/poefy/poem_base.rb

@@ -1,112 +1,114 @@
-#!/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
-
-################################################################################
+#!/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 = nil
+      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.exist?(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]
+        @local       = !!options[:local]
+        @poetic_form = {}
+        @poetic_form[:proper] = true
+        @poetic_form[:proper] = !!options[:proper] if options[:proper]
+        @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
+
+################################################################################