poefy 0.6.1 → 1.0.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: poefy
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Paul Thompson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-19 00:00:00.000000000 Z
+date: 2017-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,25 +53,53 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: poefy-sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: poefy-pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: conditional_sample
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.13
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.13
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: ruby_rhymes
   requirement: !ruby/object:Gem::Requirement
@@ -133,12 +161,14 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.4.0
 description: Create poems from an input text file, by generating and querying a SQLite
-  database describing each line. Poems are created using a template to select lines
-  from the database, according to closing rhyme, syllable count, and regex matching.
+  or PostgreSQL database describing each line. Poems are created using a template
+  to select lines from the database, according to closing rhyme, syllable count, and
+  regex matching.
 email:
 - nossidge@gmail.com
 executables:
 - poefy
+- poefy_make
 extensions: []
 extra_rdoc_files: []
 files:
@@ -149,32 +179,41 @@ files:
 - README.md
 - Rakefile
 - bin/poefy
+- bin/poefy_make
 - data/emily_dickinson.txt
 - data/english_as_she_is_spoke.txt
 - data/shakespeare_sonnets.txt
-- data/spec_test_tiny.txt
 - data/st_therese_of_lisieux.txt
 - data/whitman_leaves.txt
 - lib/poefy.rb
-- lib/poefy/conditional_satisfaction.rb
+- lib/poefy/conditional_sample.rb
 - lib/poefy/core_extensions/array.rb
 - lib/poefy/database.rb
+- lib/poefy/db_type.rb
 - lib/poefy/generation.rb
 - lib/poefy/handle_error.rb
-- lib/poefy/poefy_gen_base.rb
+- lib/poefy/poem_base.rb
 - lib/poefy/poetic_form_from_text.rb
 - lib/poefy/poetic_forms.rb
 - lib/poefy/self.rb
 - lib/poefy/string_manipulation.rb
 - lib/poefy/version.rb
 - poefy.gemspec
-- spec/poefy_spec.rb
+- spec/poefy_unit_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/nossidge/poefy
 licenses:
 - GPL-3.0
 metadata: {}
-post_install_message: 
+post_install_message: |-
+  ---
+  Thanks for installing poefy.
+  Please also install one of the below gems:
+    $ gem install poefy-pg
+    $ gem install poefy-sqlite
+  Then run this command to generate the included corpora:
+    $ poefy_make
+  ---
 rdoc_options: []
 require_paths:
 - lib

data/data/spec_test_tiny.txt

@@ -1,12 +0,0 @@
-a man
-a plan
-a flan
-a can
-a dan
-a fish
-a dish
-a wish
-a bee
-a sea
-a tree
-a flea

data/lib/poefy/conditional_satisfaction.rb

@@ -1,226 +0,0 @@
-#!/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.
-# 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
-# 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]
-################################################################################
-# '#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]
-        [*poetic_form[:regex]].each do |i|
-          valid = valid && !!(line['line'].match(i))
-        end
-      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[:token],
-          rhyme_letter: rhyme[:rhyme_letter]
-        }
-        if rhyme[:refrain] and rhyme[:refrain] != ' '
-          line_hash[:refrain] = rhyme[:refrain]
-        end
-        line_hash[:exact] = rhyme[:exact] if rhyme[:exact]
-        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.
-    def conditional_permutation array, conditions,
-                                current_iter = 0,
-                                current_array = []
-      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(current_array, 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,
-                                              current_array + [elem])
-          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
-
-################################################################################