poetize 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.swp
+.DS_Store
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Gem's dependencies specified in poetize.gemspec
+gemspec

data/README.md

@@ -0,0 +1,55 @@
+#ABOUT
+
+Our goal is to provide a tool that parses a poem and analyzes it according to the following:
+
+* Strophes
+    * Name (based on number of verses) [done]
+    * Type (based on verse metrics)
+* Verses
+    * Syllable division
+    * Grammatical
+    * Poetical
+    * Metric and name
+    * Cadency (rhythm)
+* Poem
+    * Number os strophes [done]
+    * Number of verses [done]
+    * Rhymes
+    * Name (based on strophe structure)
+
+We are focusing in the portuguese (brazillian) language since it's our native language and phonetics vary from language to language.
+
+For more details and examples, see our wiki: https://github.com/lfilho/poetize/wiki
+
+#USAGE
+
+Certify you chmod the poetize file to be an executable:
+
+`$chmod +x poetize`
+
+Then run in your shell:
+
+`$ poetize file_path [, ignore_line[, ignore_line[,...]]]`
+
+The ignore_line argument is the line(s) you want the program to ignore (i.e. the title, author, date created, dedicated to, etc...)
+
+##Usage examples:
+
+`poetize ./samples/my_poem.txt`
+
+`poetize /home/user/docs/love_poem.txt 1 2 13 14`
+#REFERENCES
+
+Good site for learning about "poetic science": 
+
+* For portuguese language:
+    * http://mpbsapiens.com/ciencia-poetica/
+    * http://pt.wikipedia.org/wiki/Versifica%C3%A7%C3%A3o
+    * http://www.portaldalinguaportuguesa.org/?action=divisao&page=present
+
+* For english language: 
+    * http://en.wikipedia.org/wiki/Poem
+
+#ABOUT THE DEVELOPERS
+
+We started this project to learn Ruby and TDD so expect it to be noobly coded :-) Feel free to refactor the code and contribute to our learning experience ;-)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/analyzer/analyzer.rb

@@ -0,0 +1,44 @@
+# coding: utf-8
+$app_path = File.dirname(__FILE__) + '/../'
+require $app_path + 'lib/file_handler'
+require $app_path + 'lib/hyphenator'
+require $app_path + 'analyzer/strophe_analyzer'
+
+class Analyzer
+  def initialize(poem)
+    @poem = poem
+    @ident = 3
+  end
+
+  def analyze
+    prefix = ' ' * @ident + '- '
+    output = "This poem:\n" + prefix +
+      "Contains #{@poem.number_of_strophes} strophes;\n" + prefix +
+      "Contains #{@poem.number_of_verses} verses;\n" +
+      "As for the strophes:\n"
+    output += analyze_strophes.reduce(''){|out, n| out + prefix + n + "\n"}
+    output += "Grammatical syllable divison:\n"
+    output += divide_grammatically
+  end
+
+  private
+
+  def analyze_strophes
+    strophe_analyzer = StropheAnalyzer.new @poem
+    strophe_analyzer.analyze
+  end
+
+  def divide_grammatically
+    hyphenated = ''
+    @poem.body.each do |line|
+      new_line = ' ' * @ident
+      line.split(' ').each do |word|
+        hyp = Hyphenator.new
+        new_line << hyp.hyphenate(word) + ' '
+      end
+      hyphenated << new_line + "\n"
+    end
+
+    hyphenated
+  end
+end

data/analyzer/strophe_analyzer.rb

@@ -0,0 +1,84 @@
+# coding: utf-8
+$app_path = File.dirname(__FILE__) + '/../'
+require $app_path + 'lib/file_handler'
+
+class StropheAnalyzer
+    attr_accessor :number_of_verses, :number_of_strophes
+    def initialize(poem)
+        @strophes = poem.strophes
+        @analyzis_output = Array.new
+        @strophes_verse_count = Array.new
+        @number_of_strophes = poem.number_of_strophes
+        @number_of_verses = poem.number_of_verses
+    end
+
+    def analyze
+        analyze_names
+        analyze_fixed_form
+        @analyzis_output
+    end
+
+    private
+
+    def analyze_names
+        name_num = Hash.new
+
+        @strophes.each_with_index do |n,i|
+            num_verses = n.number_of_verses
+            @strophes_verse_count << num_verses
+            if name_num[num_verses].nil?
+                name_num[num_verses] = [i+1]
+            else
+                name_num[num_verses] << i+1
+            end
+        end
+
+        name_num.each do |n|
+            num_items = n[1].size
+            name = Strophe.name(n[0])
+            temp = n[1].to_s.gsub(/[\[\]]/, '')
+            if num_items == 1
+                @analyzis_output << "Strophe #{temp} is #{name}"
+            elsif
+                temp = temp.reverse.sub(",", " and".reverse).reverse
+                @analyzis_output << "Strophes #{temp} are #{name}s"
+            end
+        end
+    end
+
+    def analyze_fixed_form
+        return if fixed_form_ballad?
+        return if fixed_form_italian_sonet?
+        return if fixed_form_english_sonet?
+    end
+
+    public
+
+    def fixed_form_ballad?
+        odd_verses = Array.new
+        even_verses = Array.new
+        @strophes_verse_count.each_slice(2) do |n|
+            odd_verses << n[0] unless n[0].nil?
+            even_verses << n[1] unless n[1].nil?
+        end
+        is_odds_same = odd_verses.all? {|n| n == odd_verses[0] }
+        is_evens_same = even_verses.all? {|n| n == odd_verses[0]/2 }
+        if (is_odds_same && is_evens_same)
+            @analyzis_output << "Which makes this poem is a Ballad! (" +
+                Strophe.name(odd_verses[0]) + " verses with " +
+                Strophe.name(even_verses[0]) + " verses between them)."
+            return true
+        end
+        false
+    end
+
+    def fixed_form_italian_sonet?
+        #TODO
+        false
+    end
+
+    def fixed_form_english_sonet?
+        #TODO
+        false
+    end
+end

data/bin/poetize

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+$app_path = File.dirname(__FILE__) + '/../'
+require $app_path + 'lib/text_handler'
+require $app_path + 'lib/file_handler'
+require $app_path + 'model/poem'
+require $app_path + 'analyzer/analyzer'
+
+if ARGV.size < 1
+    puts <<-eol
+== Usage:
+    poetize file_path [, ignore_line[, ignore_line[,...]]]
+== Examples:
+    poetize /home/user/docs/my_poem.txt
+    poetize /home/user/docs/my_poem.txt 1 2 13 14
+    eol
+    exit
+end
+
+file_path = ARGV[0]
+ignore_lines = ARGV.drop(1).map{|n| n = n.to_i - 1}
+text = ""
+if File.exists? file_path
+    text = FileHandler.get_file_contents file_path
+end
+
+metadata = Array.new
+ignore_lines.reverse_each do |n|
+    metadata << text[n]
+    text.delete_at n
+end
+
+metadata = TextHandler.normalize_text metadata.reverse!
+body = TextHandler.normalize_text text
+
+poem = Poem.new metadata, body
+analyzer = Analyzer.new poem
+puts analyzer.analyze

data/lib/file_handler.rb

@@ -0,0 +1,16 @@
+class FileHandler
+    def self.get_file_contents(file_path)
+        begin
+            text = Array.new
+            File.open file_path do |file|
+                while line = file.gets
+                    text << line
+                end
+            end
+            text
+        rescue Exception => e
+            raise e.message
+            puts e.backtrace.inspect
+        end
+    end
+end

data/lib/hyphenator.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+require 'rubygems'
+require 'text-hyphen'
+
+class Hyphenator
+  ACCENTED_CHARS = /[çãâäõáéíóúêôàü]/
+
+  def initialize
+    @hyphenator = Text::Hyphen.new do |h|
+      h.left = 0
+      h.right = 0
+      h.language = 'pt'
+    end
+
+    @orig_accented_chars_pos = Hash.new
+  end
+
+  def hyphenate(word)
+    word = remove_accents word
+    hyphenated_raw = @hyphenator.visualize word
+    hyphenated_final = put_accents_back word, hyphenated_raw
+  end
+
+  private
+  def put_accents_back(word, hyphenated_word)
+    if @orig_accented_chars_pos.size > 0
+      dashes_pos = @hyphenator.hyphenate word
+      @orig_accented_chars_pos.keys.sort.each do |k|
+        offset = 0
+        dashes_pos.reverse.each_with_index do |p, i|
+          if k >= p
+            offset = dashes_pos.size - i
+            break
+          end
+        end
+        hyphenated_word[k + offset] = @orig_accented_chars_pos[k]
+      end
+
+      clean
+    end
+
+    hyphenated_word
+  end
+
+  def remove_accents(word)
+    reversed = word.reverse
+    last_pos = reversed =~ ACCENTED_CHARS
+
+    if (!last_pos.nil?)
+      orig_pos = word.size - 1 - last_pos
+      @orig_accented_chars_pos[orig_pos] = reversed[last_pos]
+      word = replace_accented(reversed, last_pos).reverse
+      remove_accents word
+    else
+      return word
+    end
+  end
+
+  def replace_accented(word, pos)
+    char = word[pos]
+
+    case char
+    when /[ç]/ then r = 'c'
+    when /[ãâäàá]/ then r = 'a'
+    when /[éê]/ then r = 'e'
+    when /[í]/ then r = 'i'
+    when /[õôó]/ then r = 'o'
+    when /[úü]/ then r = 'u'
+    end
+
+    word[pos] = r
+    word
+  end
+
+  def clean
+    @orig_accented_chars_pos = Hash.new
+  end
+end

data/lib/poetize.rb

@@ -0,0 +1,5 @@
+require "poetize/version"
+
+module Poetize
+  # TODO
+end

data/lib/poetize/version.rb

@@ -0,0 +1,3 @@
+module Poetize
+  VERSION = "0.0.1"
+end

data/lib/text_handler.rb

@@ -0,0 +1,69 @@
+class Object
+    def blank?
+        return true if self.nil?
+        return self.empty? || !self.match(/^(\s|\t|\n|\r)*$/).nil?
+    end
+end
+
+class TextHandler
+    def self.normalize_line(string)
+        string.strip!
+        string.squeeze(' ')
+    end
+
+    def self.normalize_text(text)
+        if !text.is_a?(String) && !text.is_a?(Array)
+            raise "Argument must be a String or a Array"
+            return ''
+        end
+
+        if text.is_a? String
+            # Trying to normalize for different OSes
+            text = text.gsub(/\015\012?/, "\n")
+            text = text.split(/\n/) # Now it's an Array
+        end
+        
+        text = TextHandler.remove_padding_lines(text)
+        new_text = Array.new
+        found_double = false
+        text.each_with_index do |line, i|
+            next_line = text[i+1]
+            if line.blank?
+                if next_line.blank?
+                    found_double = true
+                    new_text << "$doubled$"
+                else
+                    new_text << "$single$"
+                end
+            else
+                new_text << TextHandler.normalize_line(line)
+            end
+        end
+        new_text.select! do |line|
+            found_double ? (line != "$single$") : true
+        end
+
+        new_text = new_text.chunk{|n| n.gsub("$doubled$", "")}.map(&:first)
+        new_text = new_text.map{|n| n.gsub("$single$", "") }
+        new_text
+    end
+
+    private
+    def self.remove_padding_lines(array) 
+        array = TextHandler.remove_first_lines array
+        array = TextHandler.remove_first_lines(array.reverse).reverse
+    end
+
+    def self.remove_first_lines(array)
+        found_text = false 
+        array.compact!
+        for i in 0..array.size-1
+            if array[i].strip.blank?
+                array[i] = nil
+            else
+                break
+            end
+        end
+        array.compact
+    end
+end

data/model/poem.rb

@@ -0,0 +1,25 @@
+$app_path = File.dirname(__FILE__) + '/../'
+require $app_path + 'model/strophe'
+
+class Poem
+    attr_accessor :metadata, :body, :strophes, :number_of_strophes, :number_of_verses
+
+    def initialize(metadata, body)
+        @metadata, @body = metadata, body
+        @strophes = split_in_strophes body
+        @number_of_verses = @strophes.inject(0) {|sum, n| sum + n.number_of_verses }
+        @number_of_strophes = @strophes.size
+    end
+
+    def split_in_strophes(body)
+        body.chunk(&:empty?).select{|n| !n[0]}.map{|n| Strophe.new(n[1])}
+    end
+
+    def to_s
+        "#{@metadata.join("\n")}\n\n#{@body.join("\n")}"
+    end
+
+    def to_html
+        to_s.gsub("\n", "<br />")
+    end
+end

data/model/strophe.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+
+class Strophe
+    @@Name = ["", 'Monóstico', "Dístico", "Terceto", "Quadra", "Quintilhas", "Sextilha", "Sétima", "Oitava", "Nona", "Décima", "Livre ou Polimérica"]
+
+    attr_accessor :number_of_verses, :verses
+
+    def initialize(arr)
+        @verses = arr
+        @number_of_verses = arr.size
+    end
+
+    def self.name(i=number_of_verses)
+        return @@Name[11] if i > 10
+        @@Name[i]
+    end
+    def name(i=number_of_verses)
+        Strophe.name(i)
+    end
+end