promper 0.1.3

data/lib/gab_tree.rb

@@ -0,0 +1,165 @@
+class GabTree
+  require 'tree'
+  require 'string_to_ipa'
+  require './matching'
+  require 'test/unit'
+
+
+  attr_reader :match_critera, :phoneme_convert
+  attr_accessor :root_node, :node_counter, :target_phoneme
+
+  def initialize(target_phoneme, args={})
+    @target_phoneme = target_phoneme    
+    @phoneme_convert = args[:phoneme_convert] || default_phoneme_convert
+    @match_critera = args[:match_criteria] || default_match_criteria
+
+    if @phoneme_convert == true
+      @target_phoneme = target_phoneme_convert
+    else
+      @target_phoneme = default_target_phoneme
+    end
+    
+    @node_counter = 0
+    @root_node = Tree::TreeNode.new(
+      node_counter_to_string, ["NONE IM THE ROOT!", @target_phoneme,
+      state: :ready_to_continue])    
+  end
+
+  def default_phoneme_convert    
+    false
+  end
+
+  def default_match_criteria    
+    ExactMatch.new
+  end
+
+  def target_phoneme_convert
+    if @phoneme_convert == true
+        list_of_words = @target_phoneme.split
+        ipa_list = list_of_words.map do |word|
+          word.to_ipa.tr('ˈˌ', '')
+        end
+        ipa_list = ipa_list.join
+    end
+  end
+
+  def default_target_phoneme
+    target_phoneme.downcase.gsub(/\s+/, "")
+  end
+
+  def node_counter_to_string
+    node_counter.to_s    
+  end
+
+  def iterate_until_finished
+    until finished? do
+      iterate_over_leaves     
+    end    
+  end
+
+  def finished?
+    @finished_check = false
+
+    nodes = check_leaves
+    nodes.each do |node|      
+      if check_node_state(node) == :completed # How can I do this on one line?
+        @finished_check = true
+      elsif check_node_state(node) == :aborted
+        @finished_check = true      
+      else
+        @finished_check = false
+        break
+      end        
+    end
+
+    @finished_check
+  end
+
+  def iterate_over_leaves
+    nodes = check_leaves
+
+    nodes.each do |node|
+
+      unless check_node_state(node) == :ready_to_continue
+        next
+      else
+        if checked_all_target_phonemes?(node)
+          change_node_state_completed(node)
+        else
+          try_to_make_leaves(node)                    
+          change_node_state_completed(node)
+        end
+      end
+      
+      if failedToMakeLeaves?(node)
+        change_node_state_aborted(node)
+      end
+    end
+  end
+
+  def check_leaves
+    root_node.each_leaf
+  end
+
+  def check_node_state(node)
+    node.content[2][:state]
+  end
+
+  def checked_all_target_phonemes?(node)
+    begin 
+      node.content[1].length == 0
+    rescue
+      true
+    end
+  end
+
+  def change_node_state_aborted(node)
+    node.content[2][:state] = :aborted
+  end
+
+  def change_node_state_completed(node)
+    node.content[2][:state] = :completed
+  end
+
+  def failedToMakeLeaves?(node)
+    node.is_leaf? && !checked_all_target_phonemes?(node)
+  end
+  
+  def try_to_make_leaves(node)
+    @remaining_phoneme = get_remaining_phoneme_from(node)
+    @match_array = make_match_array(@remaining_phoneme)
+    unless @match_array == nil
+      make_child_nodes(@match_array, node)
+    end
+  end
+
+  def get_remaining_phoneme_from(node)
+    node.content[1]
+  end
+
+  def make_match_array(node_target_phoneme) # Consider renaming to remaining_phoneme
+    match_array = match_critera.match(node_target_phoneme)
+    match_array
+  end
+
+  # Put as a separate method to remind me I have to figure out
+  # what is going on! For some reason I can't increment
+  # the counter if I use node_counter += 1. Strange!
+  def node_counter_increment
+    @node_counter += 1
+  end
+
+  def make_child_nodes(match_array, node)
+    match_array.each do |matched_phoneme, remaining_phoneme_chunk|      
+      node_counter_increment         
+      node << Tree::TreeNode.new(
+        node_counter_to_string, [matched_phoneme, remaining_phoneme_chunk,
+        state: :ready_to_continue])      
+    end
+  end
+end
+
+
+
+
+

data/lib/gab_tree_processor.rb

@@ -0,0 +1,69 @@
+require './gab_tree'
+class GabTreeProcessor < GabTree
+  attr_reader :gab_tree
+  def initialize(gab_tree) # Root node of gab_tree
+    @gab_tree = gab_tree
+  end
+
+  def result
+    leaf_phoneme_array_from_completed_tree
+  end
+
+  def check_leaves # This seems to duplicate the GabTree class code.
+    gab_tree.each_leaf
+  end
+
+  def leaf_phoneme_array_from_completed_tree
+    nodes = check_leaves()
+    node_parents_path = node_parents_path_from_nodes(nodes)
+    parents_content = conv_node_parents_path_to_parents_content(node_parents_path)
+    leafs_content = get_leaf_content(nodes)    
+    zipped_content = leafs_content.zip(parents_content)
+    massage_zipped_content(zipped_content)   
+  end
+
+  def only_keep_completed_nodes(nodes)
+    nodes.each do |node|      
+      if node.content[2][:state] != :completed        
+        nodes.delete(node)
+      end
+    end
+  end
+
+  def node_parents_path_from_nodes(nodes)
+    nodes = nodes.select  {|node| node.content[2][:state] == :completed }
+    nodes.map do |node|
+      parents = node.parentage
+    end
+  end
+
+  def conv_node_parents_path_to_parents_content(node_parents_path)
+    node_parents_path.map do |node_path|
+      content_from_node_path(node_path)        
+    end
+  end
+
+  def content_from_node_path(node_path)
+    node_path.map do |node|
+      node.content[0]
+    end
+  end
+
+  def get_leaf_content(nodes)
+    nodes = nodes.select  {|node| node.content[2][:state] == :completed }
+    nodes.map do |node|
+      node.content[0]
+    end
+  end
+
+  def massage_zipped_content(zipped_content)
+    flattened_matches = zipped_content.map do |match|
+      match.flatten      
+    end
+
+    flattened_matches.map do |match|
+      match.pop
+      match.reverse
+    end
+  end
+end

data/lib/matching.rb

@@ -0,0 +1,232 @@
+
+require './db'
+
+class BasicMatching
+  include DataBase
+
+  def removeTooLongPotentialMatches(
+    potential_match_array, node_target_phoneme)
+    potential_match_array.each do |word|
+      if word.length > node_target_phoneme.length
+        potential_match_array.delete(word)
+      else
+        next
+      end
+    end
+  end
+end
+
+class ExactMatch < BasicMatching
+  def initialize
+    super
+  end
+
+  def determine_first_letter(node_target_phoneme)
+    node_target_phoneme[0]
+  end
+
+  def pull_relevant_values_from_dict(key)
+    db[key]
+  end
+
+  def match(node_target_phoneme)    
+    first_letter = determine_first_letter(node_target_phoneme)
+    relevant_values = pull_relevant_values_from_dict(first_letter)
+    matches = relevant_values.select {|word, phoneme_representation| passes_tests?(word, node_target_phoneme)}    
+    phoneme_chunks = determine_remaining_phoneme_chunks(matches, node_target_phoneme)
+    combine_matches_and_phoneme_chunks(matches,phoneme_chunks)
+  end
+
+  def passes_tests?(word, node_target_phoneme)
+    letter_match?(word, node_target_phoneme) &&
+    length_okay?(word, node_target_phoneme) &&
+    remaining_letter_match?(word, node_target_phoneme)
+  end
+
+  def letter_match?(word, node_target_phoneme, index=0)    
+    word[index] == node_target_phoneme[index]
+  end
+
+  def length_okay?(word, node_target_phoneme)
+    word.length <= node_target_phoneme.length
+  end
+
+  def remaining_letter_match?(word, node_target_phoneme)
+    word_length = word.length
+    word_length.times do |letter|
+      unless letter_match?(word, node_target_phoneme, index=letter)
+        return false        
+      end
+    end
+    true
+  end
+
+  def determine_remaining_phoneme_chunks(final_matches, node_target_phoneme)
+    chunks = final_matches.map do |phonemes|
+      phoneme_length = phonemes.length
+      this_chunk = node_target_phoneme[phoneme_length..-1]
+    end
+  end
+
+  def combine_matches_and_phoneme_chunks(final_matches,phoneme_chunks)
+    final_matches.zip(phoneme_chunks)
+  end
+
+end
+
+class LooseMatch < BasicMatching
+  attr_reader :basic_equivalence_dict, :prev_switch
+  attr_accessor :node_target_phoneme, :previously_searched_phonemes
+  def initialize
+    super
+    @basic_equivalence_dict = {
+  "i" => %w[ɪ ə],
+  "z" => %w[s],
+  "ə" => %w[i ɪ ʌ æ u],
+  "u" => %w[ə],
+  "ɪ" => %w[i],
+  "d" => %w[t],
+  "æ" => %w[ə ʌ ɛ],
+  "s" => %w[z],
+  "ɝ" => %w[r],
+  "r" => %w[ɝ],
+  "a" => %w[ʌ ə],
+  "p" => %w[b],
+  "t" => %w[d],
+  "g" => %w[k],
+  "ʌ" => %w[ə æ i a],
+  "ɛ" => %w[æ],
+  "b" => %w[p],
+  "f" => %w[v],
+  "v" => %w[f],
+  "k" => %w[g],  
+  "j" => %w[ʃ],
+  "ʃ" => %w[j]
+}
+  @previously_searched_phonemes = {}
+  end
+
+  def add_to_prev_phones(node_target_phoneme, matches)
+    previously_searched_phonemes[node_target_phoneme] = matches
+  end
+
+  def one_phoneme_remaining?(node_target_phoneme)
+    begin
+      node_target_phoneme.length == 1
+    rescue
+      false
+    end
+  end
+
+  def bail
+    [node_target_phoneme, ""]
+  end
+
+  def no_phonemes_remaining?(node_target_phoneme)
+    node_target_phoneme == nil ||
+    node_target_phoneme.length == 0
+  end
+
+  def target_phoneme_convert(node_target_phoneme)
+      list_of_words = node_target_phoneme.split
+      ipa_list = list_of_words.map do |word|
+        word.to_ipa.tr('ˈˌ', '')
+      end
+      ipa_list = ipa_list.join
+  end
+
+  def match(node_target_phoneme)
+    if previously_searched_phonemes.key? node_target_phoneme
+      return previously_searched_phonemes[node_target_phoneme]
+    end
+    if one_phoneme_remaining?(node_target_phoneme)
+      bail 
+    elsif no_phonemes_remaining?(node_target_phoneme)
+      return nil
+    else
+      first_letter = determine_first_letter(node_target_phoneme)
+      begin
+        relevant_values = pull_relevant_values_from_dict(first_letter)
+
+        matches = get_relevant_matches(relevant_values, node_target_phoneme)
+        if matches.empty?
+          add_to_prev_phones(node_target_phoneme, nil)
+          return nil
+        else
+          chunks = matches.map do |word, phoneme_representation|
+            determine_remaining_phoneme_chunks(phoneme_representation, node_target_phoneme)
+          end
+          matches = post_processing(chunks, matches)
+        end
+      rescue
+        puts "Inner rescue"
+        puts $!, $@
+      end
+    end
+    add_to_prev_phones(node_target_phoneme, matches)
+    matches
+  end
+
+  def determine_first_letter(node_target_phoneme)
+    node_target_phoneme[0]
+  end
+
+  def pull_relevant_values_from_dict(key)
+    initial_values      = db[key]
+    if basic_equivalence_dict.has_key?(key)
+      equilvalent_keys    = basic_equivalence_dict[key]
+      equilvalent_keys.map do |key|
+        db[key].each do |word|
+          initial_values << word
+        end
+      end
+    end
+    initial_values
+  end
+
+  def get_relevant_matches(relevant_values, node_target_phoneme)
+    rel = relevant_values.map {
+        |word, phoneme_representation| [word, phoneme_representation] if passes_tests?(phoneme_representation, node_target_phoneme)}
+    rel.compact
+  end
+
+  def passes_tests?(word, node_target_phoneme)
+    letter_match?(word, node_target_phoneme) &&
+    length_okay?(word, node_target_phoneme) &&
+    remaining_letter_match?(word, node_target_phoneme)
+  end
+
+  def letter_match?(word, node_target_phoneme, index=0)       
+    word[index] == node_target_phoneme[index] ||
+    (basic_equivalence_dict.key?(word[index]) &&
+    basic_equivalence_dict[word[index]].include?(node_target_phoneme[index]))
+  end
+
+  def length_okay?(word, node_target_phoneme)
+    word.length <= node_target_phoneme.length
+  end
+
+  def remaining_letter_match?(word, node_target_phoneme)
+    word_length = word.length
+    word_length.times do |letter|
+      unless letter_match?(word, node_target_phoneme, index=letter)
+        return false        
+      end
+    end
+    true
+  end
+
+  def determine_remaining_phoneme_chunks(phoneme_representation, node_target_phoneme)
+    phoneme_length = phoneme_representation.length
+    node_target_phoneme[phoneme_length..-1]
+  end
+
+  def post_processing(chunks, matches)
+    matches.zip(chunks).each{ |word, chunk| word[1] = chunk }
+    matches
+  end
+
+  def combine_matches_and_phoneme_chunks(final_matches,phoneme_chunks)
+    final_matches.zip(phoneme_chunks)
+  end
+end