poefy 0.5.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 74eb4a29190ce96b7e4c49838738574986803a81
-  data.tar.gz: 80af1c2cbf3ea78fe04d914552e7505be66001d1
+  metadata.gz: 00e0ad3b9108ce69d617edf3971dac999fad5094
+  data.tar.gz: 6fda3f2e361c48616f3dfda503f86db91dc9130b
 SHA512:
-  metadata.gz: bb486fbdfaec63fbac58598d59fbb1f3e4711bdc3178ef83d8dcad77782543afd65d787466752f003fcd664fc6eaad6552f76370a0afc7089907b6c179b33d51
-  data.tar.gz: f981d141281f73e2d9203a4b568bb32a941c744ad98a1d395738a05630df97212d9f63eabec6d6f63aec505d22c010d9e2524944acde7d348221678955425096
+  metadata.gz: d0ad8d6d99227e14f058ed9821ff4b9c2a8e7ff579b1ab97650283e088452f4632a6c5bde8a680116e50a7572fe7e7b1ab97c3caba02902b3df55cbb70309629
+  data.tar.gz: f14266288f23718113a20bc1b13f3d8848dd53d99f46c3a762994b3221cfc594e426de4af7b9839a67f11c1a05f138b8fc0b2b425fdc9fb77c9f002c2886c072

data/README.md

@@ -267,6 +267,78 @@ $ poefy dickinson rhyme confuse line
 You can do the same thing for the other keys: `rhyme`, `final_word`, and `syllables`.
 
 
+#### Special case: poetic form from text file
+
+If the second argument is a reference to a text file, then the output will be a poem with the same structure as the file.
+
+The program will scan by line, looking for rhyme, syllables and repeated lines. It will then build up a constraint hash and use that as the poetic form.
+
+Any line that is bracketed in `[square]` or `{curly}` braces will be duplicated exactly in the output. This is for lines such as "chorus" or "1st verse" descriptions. This seems to work nicely with lyrics from genius.com.
+
+Here's an example of a song that can be sung to the same tune as "[I Want to Hold Your Hand][1]", but using lyrics from all Beatles songs:
+
+````
+$ poefy beatles data/beatles/i_want_to_hold_your_hand.txt
+[Chorus 1]
+Now the sun turns out his light
+And, though we may be blind
+It's been a hard day's night
+What goes on in your mind?
+What goes on in your mind?
+What goes on in your mind?
+
+[Verse 1]
+Feeling two-foot small
+As I write this letter
+The walrus was Paul
+I left you far behind
+You're not the hurting kind
+What goes on in your mind?
+
+[Bridge]
+I'll remember all the little things we've done
+Sleep pretty darling, do not cry
+In the sun
+In the sun
+In the sun
+
+[Chorus 2]
+You know I feel alright
+And, though we may be blind
+It's been a hard day's night
+What goes on in your mind?
+What goes on in your mind?
+What goes on in your mind?
+
+[Bridge]
+I'll remember all the little things we've done
+Sleep pretty darling, do not cry
+In the sun
+In the sun
+In the sun
+
+[Chorus 3]
+You know I feel alright
+And, though we may be blind
+I want a love that's right
+What goes on in your mind?
+What goes on in your mind?
+What goes on in your mind?
+What goes on in your mind?
+````
+
+You can tell that it's only based on whole line changes. Very similar lines are replaced with rhyming, but dissimilar ones. Something for me to think about.
+
+````
+[Original]                       [Generated]
+You'll let me hold your hand     I left you far behind
+I'll let me hold your hand       You're not the hurting kind
+I want to hold your hand         What goes on in your mind?
+````
+
+[1]: https://genius.com/The-beatles-i-want-to-hold-your-hand-lyrics
+
+
 ### As a Ruby Gem
 
 To make a poefy database and generate poems from it:

data/bin/poefy

@@ -193,13 +193,19 @@ if second_arg == 'rhyme'
   exit 0
 end
 
+# If the second argument is a file, then use that as the poetic_form.
+updated_poetic_form = {}
+if File.exists?(second_arg)
+  updated_poetic_form = poefy.poetic_form_from_text(second_arg)
+end
+
 # Create a database using input.
 if data
   poefy.make_database data, options[:overwrite]
 
 # Make a new poem, and output it.
 else
-  poem = poefy.poem
+  poem = poefy.poem(updated_poetic_form)
   puts poem if poem
 end
 

data/lib/poefy/conditional_satisfaction.rb

@@ -92,7 +92,10 @@ module Poefy
           rhyme: rhyme[:token],
           rhyme_letter: rhyme[:rhyme_letter]
         }
-        line_hash[:refrain] = rhyme[:refrain] if rhyme[:refrain]
+        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]

data/lib/poefy/generation.rb

@@ -137,11 +137,11 @@ module Poefy
           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
+          # Get all refrains and group them.
+          refrains = by_line.select do |i|
+            i[:refrain]
           end.group_by do |i|
-            i[:rhyme]
+            i[:refrain]
           end
 
           # Now make each refrain :regex be an array of all.
@@ -276,6 +276,11 @@ module Poefy
           end
         end
 
+        # Do the same for [:exact] lines.
+        poetic_form[:rhyme].each.with_index do |line, index|
+          poem_lines[index] = line[:exact] if line[:exact]
+        end
+
         # Carry out transformations, if necessary.
         the_poem = poem_lines
         if poetic_form[:transform]

data/lib/poefy/poetic_form_from_text.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+# Encoding: UTF-8
+
+################################################################################
+# Read a song lyric file, output a poetic_form that matches its form.
+################################################################################
+
+module Poefy
+
+  module PoeticFormFromText
+
+    # Read a song lyric file, output a poetic_form that matches its form.
+    def poetic_form_from_text text_file
+      lines = File.readlines(text_file).map(&:strip)
+
+      # For refrains, we don't care about the lines exactly, just
+      #   the structure. So we can delete punctuation and downcase.
+      lines = lines.map do |line|
+        {
+          orig: line,
+          downcase: line.gsub(/[[:punct:]]/, '').downcase
+        }
+      end
+
+      # Find all the lines that are duplicated.
+      # These will be the refrain lines.
+      refrains = lines.map { |i| i[:downcase] }
+      refrains = refrains.inject(Hash.new(0)) { |h, e| h[e] += 1 ; h }
+      refrains = refrains.select { |k, v| v > 1 && k != '' }.keys
+
+      # Give each a unique refrain ID.
+      buffer = {}
+      refrains.each.with_index { |line, id| buffer[line] = id }
+      refrains = buffer
+
+      # Loop through and describe each line.
+      lines = lines.map.with_index do |line, index|
+        hash = {}
+
+        # Text of the line.
+        hash[:orig] = line[:orig]
+        hash[:downcase] = line[:downcase]
+
+        # Misc details.
+        hash[:num] = index + 1
+        hash[:syllable] = syllables(hash[:downcase])
+        hash[:last_word] = (text.to_phrase.last_word rescue '')
+
+        # The rhyme for the line.
+        # ToDo: For now, just get the first rhyme of the tag array.
+        rhyme_tag = get_rhymes(hash[:downcase]).first
+        hash[:rhyme_tag] = rhyme_tag || ' '
+        hash[:rhyme_letter] = rhyme_tag
+        hash[:rhyme] = ' ' if hash[:downcase] == ''
+
+        # Map [:refrain] and [:exact].
+        # (They are mutually exclusive)
+        # If it needs to be an exact line, we don't need rhyme tokens.
+        if bracketed?(line[:orig].strip)
+          hash[:exact] = line[:orig]
+          hash[:rhyme] = ' '
+          hash[:rhyme_letter] = nil
+          hash[:syllable] = 0
+        elsif refrains.keys.include?(line[:downcase])
+          hash[:refrain] = refrains[line[:downcase]]
+        end
+
+        hash
+      end
+
+    #  puts '########################################'
+    #  lines.each { |i| puts i }
+
+    #  # Compare each [:rhyme_tag] against the rest of the array.
+    #  lines_TODO = lines.map do |text|
+    #    remaining = lines - [text]
+    #    rhyme_tags = remaining.map { |i| i[:rhyme_tag] }
+    #  end
+
+      # Split into separate sections, [:rhyme] and [:syllable].
+      rhyme = lines.map do |line|
+        hash = {}
+        hash[:token] = line[:rhyme_letter] || ' '
+        hash[:rhyme_letter] = hash[:token]
+        hash[:refrain] = line[:refrain] if line[:refrain]
+        hash[:exact] = line[:exact] if line[:exact]
+        hash
+      end
+
+      syllable = {}
+      lines.map.with_index do |line, index|
+        syllable[index+1] = line[:syllable] if line[:syllable] > 0
+      end
+
+      poetic_form = {
+        rhyme: rhyme,
+        syllable: syllable
+      }
+      poetic_form
+    end
+
+  end
+
+end
+
+################################################################################

data/lib/poefy/string_manipulation.rb

@@ -99,6 +99,13 @@ module Poefy
         output
       end
 
+      # Is the string enclosed in brackets?
+      def bracketed? string
+        square = (string[0] == '[' and string[-1] == ']')
+        curly  = (string[0] == '{' and string[-1] == '}')
+        square or curly
+      end
+
   end
 
 end

data/lib/poefy/version.rb

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

data/lib/poefy.rb

@@ -21,6 +21,7 @@ require_relative 'poefy/self.rb'
 require_relative 'poefy/poefy_gen_base.rb'
 require_relative 'poefy/generation.rb'
 require_relative 'poefy/poetic_forms.rb'
+require_relative 'poefy/poetic_form_from_text.rb'
 require_relative 'poefy/string_manipulation.rb'
 require_relative 'poefy/handle_error.rb'
 require_relative 'poefy/database.rb'
@@ -37,6 +38,7 @@ module Poefy
     include Poefy::PoefyGenBase
     include Poefy::Generation
     include Poefy::PoeticForms
+    include Poefy::PoeticFormFromText
     include Poefy::StringManipulation
     include Poefy::ConditionalSatisfaction
     include Poefy::HandleError

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: poefy
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Paul Thompson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-30 00:00:00.000000000 Z
+date: 2017-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -141,6 +141,7 @@ files:
 - lib/poefy/generation.rb
 - lib/poefy/handle_error.rb
 - lib/poefy/poefy_gen_base.rb
+- lib/poefy/poetic_form_from_text.rb
 - lib/poefy/poetic_forms.rb
 - lib/poefy/self.rb
 - lib/poefy/string_manipulation.rb