poefy 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e04a9ee24cb090de963b812bcf8ec3b8109b2587
-  data.tar.gz: '028bc8ed0525d9bcc77a358162f904aef19d6556'
+  metadata.gz: 74eb4a29190ce96b7e4c49838738574986803a81
+  data.tar.gz: 80af1c2cbf3ea78fe04d914552e7505be66001d1
 SHA512:
-  metadata.gz: de3b67a5f31522c5e3741fdf821a56cc155a03e7c49a13a4387d87c11de3dbb220be6d74263fd8743d3c17042fc41150baec3efb4726fd0e010c10899b701a82
-  data.tar.gz: 117a747d04707cad5062d07fa1ed3eabc173783129de31fef102f426484bf17ad5f2b5b841f497233982130175bb2b8d500567245747b82874557f35bfa617bf
+  metadata.gz: bb486fbdfaec63fbac58598d59fbb1f3e4711bdc3178ef83d8dcad77782543afd65d787466752f003fcd664fc6eaad6552f76370a0afc7089907b6c179b33d51
+  data.tar.gz: f981d141281f73e2d9203a4b568bb32a941c744ad98a1d395738a05630df97212d9f63eabec6d6f63aec505d22c010d9e2524944acde7d348221678955425096

data/README.md

@@ -211,6 +211,22 @@ You must also beware of repeated lines (uppercase letters in the rhyme string).
     $ poefy therese rondeau -a'grown ever softer'
 
 
+#### Option `-A` or `--acrostic_x`
+
+This does the same as `-a`, but with special workarounds for 'x'. In the case that a line needs to match '^x', it will instead match '^ex' and replace with 'eX'. It will also use indentation to line-up the letters vertically:
+
+    $ poefy whitman -s8 -r abcbdd -A taxman
+
+````
+  To reason's early paradise,
+  And that death and dismay are great.
+ eXult O shores, and ring O bells!
+  May-be kill'd, unknown to her mate,
+  Around the idea of thee.
+  now, for all you cannot see me?
+````
+
+
 #### Option `-p` or `--proper`
 
 This is used to ensure that the first word in the first line is not 'and but or nor yet', and the final line ends with closing punctuation (full stop, exclamation, or question mark). The default for this is `true`, but you can set it to `false` if necessary, for example if your input lines do not use punctuation.
@@ -297,6 +313,36 @@ puts poefy.poem ({ indent: '01012 0012 010112' })
 ```
 
 
+#### Option `transform:`
+
+An option that is not included in the CLI interface is the `transform` poem option. This is a hash of procs that transform a line somehow.
+
+For example, to all-caps the 4th and 12th lines:
+
+```ruby
+transform_hash = {
+   4 => proc { |line, num, poem| line.upcase },
+  12 => proc { |line, num, poem| line.upcase }
+}
+poefy = Poefy::PoefyGen.new 'shakespeare'
+puts poefy.poem({ form: :sonnet, transform: transform_hash })
+```
+
+The key for the hash corresponds to the line of the poem, starting from 1 (not 0). You can use negative keys to specify from the end of the poem. Any key that is not an integer or is out of the array bounds will be ignored.
+
+If you don't include a hash, then the proc will be applied to each line. So to add line numbers to the whole poem:
+
+```ruby
+transform_proc = proc { |line, num, poem| "#{num.to_s.rjust(2)} #{line}" }
+poefy = Poefy::PoefyGen.new 'shakespeare'
+puts poefy.poem({ form: :sonnet, transform: transform_proc })
+```
+
+The proc arguments `|line, num, poem|` are: the text of the line that is being replaced, the number of the line, and the full poem array as it was before any transformations had occurred.
+
+The transformations are implemented after the poem has been generated, but before the `indent` has occurred.
+
+
 ## Some tips
 
 ### Make a database from a delimited file

data/bin/poefy

@@ -74,10 +74,15 @@ def parse_options
       options[:regex] = s
     end
 
+    # Options for acrostic poems.
     opts.on('-a', '--acrostic STRING',
-            "Overwrite 'regex' option to generate an acrostic") do |s|
+            "Generate an acrostic on a certain word") do |s|
       options[:acrostic] = s
     end
+    opts.on('-A', '--acrostic_x STRING',
+            "Generate an acrostic with better handling of 'x'") do |s|
+      options[:acrostic_x] = s
+    end
 
     # Handle proper sentence structure.
     opts.separator nil

data/lib/poefy/conditional_satisfaction.rb

@@ -74,12 +74,8 @@ module Poefy
         valid = valid && [*poetic_form[:syllable]].include?(line['syllables'])
       end
       if 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]))
+        [*poetic_form[:regex]].each do |i|
+          valid = valid && !!(line['line'].match(i))
         end
       end
       valid
@@ -93,9 +89,10 @@ module Poefy
       tokenised_rhyme.each.with_index do |rhyme, index|
         line_hash = {
           line: index + 1,
-          rhyme: rhyme,
-          rhyme_letter: rhyme[0].downcase
+          rhyme: rhyme[:token],
+          rhyme_letter: rhyme[:rhyme_letter]
         }
+        line_hash[:refrain] = rhyme[:refrain] if rhyme[:refrain]
         poetic_form.keys.each do |k|
           if poetic_form[k].is_a? Hash
             line_hash[k] = poetic_form[k][index + 1]

data/lib/poefy/database.rb

@@ -45,30 +45,18 @@ module Poefy
           @db = nil
         else
           begin
-            open
-            create_sprocs
+            @db = SQLite3::Database.open(@db_file)
+            @db.results_as_hash = true
           rescue
             @db = nil
             return handle_error 'ERROR: Database contains invalid structure'
           end
+          create_sprocs
         end
       end
       @db
     end
 
-    # Open the database file.
-    def open
-      @db = SQLite3::Database.open(@db_file)
-      @db.results_as_hash = true
-
-      # Create a REGEX function in SQLite.
-      # http://stackoverflow.com/questions/7302311
-      @db.create_function('regexp', 2) do |func, pattern, expression|
-        regexp = Regexp.new(pattern.to_s, Regexp::IGNORECASE)
-        func.result = expression.to_s.match(regexp) ? 1 : 0
-      end
-    end
-
     # Close the database file.
     def close
       @sproc.each { |k, v| v.close rescue nil }
@@ -136,21 +124,30 @@ module Poefy
     end
 
     # Public interfaces for private stored procedure methods.
+    # Use instance variables to keep a cache of the results.
     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
+      @rbc = Hash.new { |h,k| h[k] = {} } if @rbc.nil?
+      if @rbc[rhyme_count][syllable_min_max].nil?
+        @rbc[rhyme_count][syllable_min_max] = if syllable_min_max
+          sproc_rhymes_by_count_syllables(rhyme_count, syllable_min_max)
+        else
+          sproc_rhymes_by_count(rhyme_count)
+        end
       end
+      @rbc[rhyme_count][syllable_min_max].dup
     end
     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
+      @la = Hash.new { |h,k| h[k] = {} } if @la.nil?
+      if @la[rhyme][syllable_min_max].nil?
+        @la[rhyme][syllable_min_max] = if syllable_min_max
+          sproc_lines_all_syllables(rhyme, syllable_min_max)
+        else
+          sproc_lines_all(rhyme)
+        end
       end
+      @la[rhyme][syllable_min_max].dup
     end
 
     private

data/lib/poefy/generation.rb

@@ -24,6 +24,7 @@ module Poefy
       raise ArgumentError, 'Argument must be a hash' unless
             poetic_form.is_a?(Hash)
       poetic_form = validate_poetic_form poetic_form
+      poetic_form = @poetic_form.merge poetic_form
 
       # Make sure the hash contains ':form' or ':rhyme' keys.
       if !(poetic_form[:form] or poetic_form[:rhyme])
@@ -34,7 +35,14 @@ module Poefy
       end
 
       # Loop until we find a valid poem.
-      output = gen_poem_using_conditions poetic_form
+      # There are cases where valid permutations are not able to be
+      #   genned on the first try, so keep trying a few more times.
+      output, count_down = nil, 10
+      loop do
+        output = gen_poem_using_conditions poetic_form
+        break if !output.nil? || count_down == 0
+        count_down -= 1
+      end
 
       # Return nil if poem could not be created.
       return nil if (output.nil? or output == [] or output == [''])
@@ -86,8 +94,20 @@ module Poefy
           return handle_error 'ERROR: Rhyme string is not valid', []
         end
 
+        # Expand poetic_form[:transform], if there's just one element.
+        if poetic_form[:transform] and !poetic_form[:transform].respond_to?(:each)
+          poetic_form[:transform] = fill_hash poetic_form[:transform],
+                                              1..tokenised_rhyme.count
+        end
+
         # Add acrostic to the regex, if necessary.
-        if poetic_form[:acrostic]
+        if poetic_form[:acrostic_x]
+          acrostic_opts = acrostic_x(poetic_form[:acrostic_x])
+          poetic_form[:regex] =
+            merge_hashes poetic_form[:regex], acrostic_opts[:regex]
+          poetic_form[:transform] =
+            merge_hashes acrostic_opts[:transform], poetic_form[:transform]
+        elsif poetic_form[:acrostic]
           poetic_form[:regex] =
             merge_hashes poetic_form[:regex], acrostic(poetic_form[:acrostic])
         end
@@ -148,23 +168,21 @@ module Poefy
           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.
+        # Okay, this is great. But if we're making villanelles we'll need to
+        #   duplicate 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)
+        # This will be the same as [conditions_by_rhyme], except duplicate
+        #   lines are removed. (In string input, 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 = []
+          refrains = []
           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
+            if !v[:refrain]
+              distinct_line_conds[key] << v
+            elsif !refrains.include?(v[:refrain])
+              refrains << v[:refrain]
               distinct_line_conds[key] << v
             end
           end
@@ -196,6 +214,10 @@ 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.
           min_max = syllable_min_max line_conds
@@ -208,7 +230,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)
+            out = try_rhyme(conditions, rhyme, min_max, regex_all)
             break if !out.empty?
           end
           if out.empty?
@@ -233,14 +255,14 @@ module Poefy
         # Transpose lines to their actual location.
         poem_lines = []
         all_lines.each do |line|
-          poem_lines[line['line_number'] - 1] = line['line']
+          poem_lines[line['line_number'] - 1] = line['line'].dup
         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]
+          if line[:refrain]
+            refrains[line[:refrain]] << line[:line]
           end
         end
         refrains.keys.each do |k|
@@ -254,14 +276,37 @@ module Poefy
           end
         end
 
-        poem_lines
+        # Carry out transformations, if necessary.
+        the_poem = poem_lines
+        if poetic_form[:transform]
+
+          # Due to the 'merge_hashes' above, each 'poetic_form[:transform]'
+          #   value may contain an array of procs.
+          poetic_form[:transform].each do |key, procs|
+            begin
+              # This is to ensure that e.g. '-2' will access from the end.
+              i = (key > 0) ? key - 1 : key
+              [*procs].each do |proc|
+                the_poem[i] = proc.call(the_poem[i], i + 1, poem_lines).to_s
+              end
+            rescue
+            end
+          end
+        end
+
+        the_poem
       end
 
       # Loop through the rhymes until we find one that works.
       # (In a reasonable time-frame)
-      def try_rhyme conditions, rhyme, syllable_min_max = nil
+      def try_rhyme conditions, rhyme, syllable_min_max = nil, regex_all = nil
         output = []
         lines = @db.sproc_lines_all!(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
+
         begin
           Timeout::timeout(2) do
             output = conditional_selection(lines.shuffle, conditions)
@@ -288,6 +333,16 @@ 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/poefy_gen_base.rb

@@ -13,7 +13,7 @@ module Poefy
 
     def initialize db_name, options = {}
       handle_options options
-      @db = Poefy::Database.new get_database_file(db_name), @console
+      @db = Poefy::Database.new get_database_file(db_name.to_s), @console
     end
 
     # Make a database using the given lines.
@@ -39,7 +39,7 @@ module Poefy
     def validate_lines input
 
       # If the input is a file, then read it.
-      lines = File.exists?(input) ? File.read(input) : input
+      lines = File.exists?(input.to_s) ? 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")
@@ -78,19 +78,21 @@ module Poefy
         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]
-        output[:acrostic] = input[:acrostic] if input[:acrostic]
+        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.
-        rhyme = get_poetic_form_rhyme(output)
         if output[:rhyme]
           output[:rhyme] = tokenise_rhyme output[:rhyme]
         end
-        if output[:syllable]
+        rhyme = get_poetic_form_rhyme(output)
+        if output[:syllable] and rhyme != ' '
           output[:syllable] = transform_string_syllable output[:syllable], rhyme
         end
         if output[:regex]

data/lib/poefy/poetic_forms.rb

@@ -82,7 +82,7 @@ module Poefy
         syllable: ''
       },
       petrarchan: {
-        rhyme:    ['abbaabbacdecde','abbaabbacdccdc',
+        rhyme:    ['abbaabbacdecde','abbaabbacdccdc','abbaabbacdcddc',
                    'abbaabbacddcdd','abbaabbacddece','abbaabbacdcdcd'],
         indent:   ['01100110010010','10001000100100'],
         syllable: ''
@@ -120,14 +120,35 @@ module Poefy
     #   acrostic('unin tell igib le')
     def acrostic word
       output = {}
-      counter = 1
-      word.split('').each do |i|
-        output[counter] = /^[#{i.upcase}#{i.downcase}]/ if i != ' '
-        counter += 1
+      word.split('').each.with_index do |char, i|
+        output[i + 1] = /^[#{char.downcase}]/i if char != ' '
       end
       output
     end
 
+    # Create a regex specification for acrostics.
+    # Uses special logic for 'X'.
+    # Match words starting 'ex' and then change case to 'eX'.
+    def acrostic_x word
+      regex = {}
+      transform = {}
+      word.split('').each.with_index do |char, i|
+        if char.downcase == 'x'
+          regex[i + 1] = /^ex/i
+          transform[i + 1] = proc do |line|
+            line[0..1] = 'eX'
+            ' ' + line
+          end
+        elsif char != ' '
+          regex[i + 1] = /^[#{char.downcase}]/i
+          transform[i + 1] = proc do |line|
+            '  ' + line
+          end
+        end
+      end
+      { regex: regex, transform: transform }
+    end
+
     private
 
       # Can the string be converted to integer?
@@ -144,14 +165,16 @@ module Poefy
       # Get full form, from either the user-specified options,
       #   or the default poetic form.
       def poetic_form_full poetic_form = @poetic_form
-        rhyme =    get_poetic_form_token :rhyme, poetic_form
-        indent =   get_poetic_form_token :indent, poetic_form
-        syllable = get_poetic_form_token :syllable, poetic_form
-        regex =    get_poetic_form_token :regex, poetic_form
-        poetic_form[:rhyme]    = rhyme
-        poetic_form[:indent]   = indent   if indent != ''
-        poetic_form[:syllable] = syllable if syllable != ''
-        poetic_form[:regex]    = regex    if regex
+        rhyme     = get_poetic_form_token :rhyme,     poetic_form
+        indent    = get_poetic_form_token :indent,    poetic_form
+        syllable  = get_poetic_form_token :syllable,  poetic_form
+        regex     = get_poetic_form_token :regex,     poetic_form
+        transform = get_poetic_form_token :transform, poetic_form
+        poetic_form[:rhyme]     = rhyme
+        poetic_form[:indent]    = indent    if indent    != ''
+        poetic_form[:syllable]  = syllable  if syllable  != ''
+        poetic_form[:regex]     = regex     if regex
+        poetic_form[:transform] = transform if transform != ' '
         poetic_form
       end
 
@@ -207,7 +230,16 @@ module Poefy
           return handle_error 'ERROR: Rhyme string is not valid', []
         end
         tokens = [' '] if tokens == ['']
-        tokens
+
+        # Output as a hash.
+        tokens.map do |i|
+          hash = {
+            token: i,
+            rhyme_letter: i[0].downcase
+          }
+          hash[:refrain] = i if i[0] == i[0].upcase
+          hash
+        end
       end
 
       # Indent an array of lines using a string of numbers.

data/lib/poefy/string_manipulation.rb

@@ -89,6 +89,16 @@ module Poefy
         new_hash
       end
 
+      # Fill a hash with a single value.
+      # Keys are integers in a range.
+      def fill_hash value, key_range
+        output = {}
+        key_range.each do |i|
+          output[i] = value
+        end
+        output
+      end
+
   end
 
 end

data/lib/poefy/version.rb

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

data/spec/poefy_spec.rb

@@ -531,6 +531,93 @@ describe Poefy::PoefyGen do
     end
   end
 
+  ##############################################################################
+
+  describe "reusing the same PoefyGen instance" do
+    it "should correctly merge the option hashes" do
+
+      # Default to use rondeau poetic form, and proper sentence validation
+      poefy = Poefy::PoefyGen.new('shakespeare', { form: 'rondeau', proper: true })
+
+      # Generate a properly sentenced rondeau
+      poem = poefy.poem
+      expect(poem.count).to be 17
+
+      # Generate a rondeau without proper validation
+      poem = poefy.poem ({ proper: false })
+      expect(poem.count).to be 17
+
+      # Generate a proper rondeau with a certain indentation
+      poem = poefy.poem ({ indent: '01012 0012 010112' })
+      expect(poem.count).to be 17
+
+      # Generate other forms
+      poem = poefy.poem ({ rhyme: 'abbaabbacdecde' })
+      expect(poem.count).to be 14
+      poem = poefy.poem ({ form: 'sonnet' })
+      expect(poem.count).to be 14
+      poem = poefy.poem ({ form: 'ballade' })
+      expect(poem.count).to be 31
+
+      # Generate a default rondeau again
+      poem = poefy.poem
+      expect(poem.count).to be 17
+    end
+  end
+
+  ##############################################################################
+
+  describe "using the transform option" do
+
+    it "should correctly transform the output 1" do
+      poefy = Poefy::PoefyGen.new :shakespeare
+      transform_hash = {
+         4 => proc { |line, num, poem| line.upcase },
+        12 => proc { |line, num, poem| line.upcase }
+      }
+      poem = poefy.poem({ form: :sonnet, transform: transform_hash })
+      expect(poem.count).to be 14
+      expect(poem[3]).to  eq poem[3].upcase
+      expect(poem[11]).to eq poem[11].upcase
+    end
+
+    it "should correctly transform the output 2" do
+      poefy = Poefy::PoefyGen.new :shakespeare
+      transform_hash = {
+         4 => proc { |line, num, poem| poem.count },
+        -3 => proc { |line, num, poem| poem.count },
+         7 => proc { |line, num, poem| 'test string' }
+      }
+      poem = poefy.poem({ form: :sonnet, transform: transform_hash })
+      expect(poem.count).to be 14
+      expect(poem[3]).to  eq '14'
+      expect(poem[11]).to eq '14'
+      expect(poem[6]).to  eq 'test string'
+    end
+
+    it "should correctly transform the output 3" do
+      poefy = Poefy::PoefyGen.new :shakespeare
+      transform_proc = proc { |line, num, poem| line.downcase }
+      poem = poefy.poem({ form: :sonnet, transform: transform_proc })
+      expect(poem.count).to be 14
+      poem.each do |i|
+        expect(i).to eq i.downcase
+      end
+    end
+
+    it "should correctly transform the output 4" do
+      poefy = Poefy::PoefyGen.new :shakespeare
+      transform_proc = proc { |line, num, poem| "#{num} #{line.downcase}" }
+      poem = poefy.poem({ form: :sonnet, transform: transform_proc })
+      expect(poem.count).to be 14
+      poem.each.with_index do |line, index|
+        expect(line).to eq line.downcase
+        first_word = line.split(' ').first
+        expect(first_word).to eq (index + 1).to_s
+      end
+    end
+  end
+
 end
 
 ################################################################################

metadata

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