aac-metrics 0.2.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bddb8e430a21868a5b26312fb5924f36b914446dc212d849330462768fd9b233
-  data.tar.gz: c5ddd0e2b835678f0dabf8743099b29d462612d94a4aa4dd261e1cb7337eaa02
+  metadata.gz: 9d8e0a136e07e00454338b3ddafc3d3374a0b38cb19f915110aef990dfea3f20
+  data.tar.gz: dcc8109cc6c77156e12205e7f518059696aa271d622b085ea0399877dd488542
 SHA512:
-  metadata.gz: 876e09d6be2b2e2b7579c11bb06367296ee7fbba627db0f8d421b4e60d2b7042d9a41433f9b1af10c78a6fc8ac84077170224e059a5a5ba30db6b217cab56936
-  data.tar.gz: 5072598db0226690da77985e4e1ed760b24f0d0edc2bc99a5961e59d7f8e8bfa549073f4d0b223559ba48d7d2348556041d8b513944e5427c9c158db3b467f6c
+  metadata.gz: 0de1a12d33d59f0440bab00fb60e426ced9c9cb95c2311931ac0a67a10032e1752b8803b91ef5fb5e80e1f0aa610575ae56917ef42ad7e15cbcb0ac04d4be31b
+  data.tar.gz: f372e88fcac486795074d2f425da2d9ff1651b7ad5e6af66b6df46b3e573c927ba30106465bdace6a350c3d6704b425f65bd4b1fb7b60a0ce4142fd2ba9eb83b

data/README.md

@@ -2,6 +2,24 @@
 
 A tool for analysing and comparing grid-based AAC board sets
 
+To compare two datasets 
+`ruby setup.rb qc24 qc112`
+
+To compare two datasets and export the minimal obfset for the first
+`ruby setup.rb qc24 qc112 export`
+`ruby setup.rb qc24 qc112 render` # updates interactive preview in sets/preview.html
+
+To generate an obfset from an external data source
+`ruby lib/ingester.rb path/to/manifest-from-unzipped-obz.json`
+`ruby lib/ingester.rb path/to/compiled-set.obfset`
+`ruby lib/ingester.rb path/to/root-file.obf`
+
+
+NOTE: if you add an obfset to sets, it will be accessible
+simply by its prefix. If you add ".common" to the filename
+similar to the existing files, it will be added to the 
+corpus of "common" word sets.
+
 ## License
 
 Licensed under the MIT License.

data/lib/aac-metrics/loader.rb

@@ -20,6 +20,7 @@ module AACMetrics::Loader
           }
           if button['load_board'] && button['load_board']['id']
             new_button['load_board'] = {'id' => button['load_board']['id']}
+            new_button['load_board']['temporary_home'] = button['load_board']['temporary_home'] if button['load_board']['temporary_home'] == true || button['load_board']['temporary_home'] == 'prior'
             new_button['load_board']['add_to_sentence'] = true if button['load_board']['add_to_sentence']
           end
           new_board['buttons'].push(new_button)
@@ -73,11 +74,11 @@ module AACMetrics::Loader
       if json.is_a?(Array)
         json.each do |brd|
           brd['buttons'].each do |btn|
-            if btn['label'].match(/^\$/)
+            if (btn['label'] || '').match(/^\$/)
               word = base[btn['label'].sub(/^\$/, '')]
               btn['label'] = word if word
             end
-            btn['label'] = btn['label'].gsub(/’/, '')
+            btn['label'] = (btn['label'] || '').gsub(/’/, '')
           end
         end
       elsif json.is_a?(Hash)
@@ -159,6 +160,12 @@ module AACMetrics::Loader
               # record load_board reference
               btn_idx += 1
               if btn['load_board']
+                if !btn['load_board']['path'] && btn['load_board']['id']
+                  bpath = File.join(File.dirname(path), btn['load_board']['id'] + '.obf')
+                  if File.exists?(bpath)
+                    btn['load_board']['path'] = bpath
+                  end
+                end
                 if btn['load_board']['path']
                   if visited_paths[btn['load_board']['path']]
                     new_btn['load_board'] = {'id' => "brd#{visited_paths[btn['load_board']['path']]}"}
@@ -176,9 +183,14 @@ module AACMetrics::Loader
                     new_btn['load_board'] = {'tmp_path' => btn['load_board']['data_url']}
                   end
                 else
+                  puts path
                   puts "Link found with no access #{btn['load_board'].to_json}"
                 end
+                new_btn['load_board']['temporary_home'] = true if new_btn['load_board'] && btn['load_board']['temporary_home']
+                new_btn['load_board']['temporary_home'] = true if new_btn['load_board'] && btn['ext_coughdrop_home_lock']
                 new_btn['load_board']['add_to_sentence'] = true if new_btn['load_board'] && btn['load_board']['add_to_sentence']
+                new_btn['load_board']['add_to_sentence'] = true if new_btn['load_board'] && btn['ext_coughdrop_add_to_vocalization']
+                new_btn['load_board']['add_to_sentence'] = true if new_btn['load_board'] && btn['ext_coughdrop_add_vocalization']
               elsif btn['action']
                 # TODO: track keyboard actions and don't
                 # treat action buttons for metrics

data/lib/aac-metrics/metrics.rb

@@ -1,14 +1,8 @@
 # TODO:
 # Qualitative evaluation criteria:
-# - this set looks easy to learn for communicators
-# - this set looks easy to learn for supporters
-# - this vocabulary organization of this set makes sense
 # - this set provides clear locations for user-specific words to be added
 # - this set supports the use of grammatical forms (tenses and other inflections)
 # - this set provides predefined simplification for beginning communicators
-# - this set allows for long-term vocabulary growth over time
-# - this vocabulary looks like it will work well for young users
-# - this vocabulary looks like it will work well for adult users
 
 # Effort algorithms for scanning/eyes
 module AACMetrics::Metrics
@@ -30,14 +24,16 @@ module AACMetrics::Metrics
     # as the link used to get there if they share an id
   def self.analyze(obfset, output=true, include_obfset=false)
     locale = nil
-    buttons = []
+    buttons = nil
     set_refs = {}
     grid = {}
+    alt_scores = {}
 
     if obfset.is_a?(Hash) && obfset['buttons']
       locale = obfset['locale'] || 'en'
       set_refs = obfset['reference_counts']
       grid = obfset['grid']
+      alt_scores = obfset['alternates']
       buttons = []
       obfset['buttons'].each do |btn|
         buttons << {
@@ -51,6 +47,7 @@ module AACMetrics::Metrics
       end
       total_boards = obfset['total_boards']
     else
+      start_boards = [obfset[0]]
       visited_board_ids = {}
       to_visit = [{board: obfset[0], level: 0, entry_x: 1.0, entry_y: 1.0}]
       set_refs = {}
@@ -87,6 +84,17 @@ module AACMetrics::Metrics
             set_refs[id] += 1
           end
         end
+        board['buttons'].each do |link_btn|
+          if link_btn['load_board'] && link_btn['load_board']['id'] && link_btn['load_board']['temporary_home']
+            # TODO: buttons can have multiple efforts, depending
+            # on if they are navigable from a temporary_home
+            if link_btn['load_board']['temporary_home'] == 'prior'
+              start_boards << board
+            elsif link_btn['load_board']['temporary_home'] == true
+              start_boards << obfset.detect{|b| b['id'] == link_btn['load_board']['id']}
+            end
+          end
+        end
       end
       # If the average grid size is much different than the root
       # grid size, only then use the average as the size for this board set
@@ -99,7 +107,53 @@ module AACMetrics::Metrics
         loc = id.split(/-/)[1]
         set_pcts[id] = cnt.to_f / (cell_refs[loc] || obfset.length).to_f
       end
-      locale = obfset[0]['locale']
+
+      total_boards = nil
+      locale = nil
+      clusters = nil
+      # TODO: this list used to be reversed, but I don't know why.
+      # What we want is for these analyses to be run for the root
+      # board, don't we?
+      # puts JSON.pretty_generate(obfset[0])
+      start_boards.uniq.each do |brd|
+        analysis = analyze_for(obfset, brd, set_pcts, output)
+        buttons ||= analysis[:buttons]
+        if brd != obfset[0]
+          alt_scores[brd['id']] = {
+            buttons: analysis[:buttons],
+            levels: analysis[:levels]
+          }
+        end
+        total_boards ||= analysis[:total_boards]
+        clusters ||= analysis[:levels]
+        locale ||= analysis[:locale]
+      end
+    end
+    res = {
+      analysis_version: AACMetrics::VERSION,
+      locale: locale,
+      total_boards: total_boards,
+      total_buttons: buttons.map{|b| b[:count] || 1}.sum,
+      total_words: buttons.map{|b| b[:label] }.uniq.length,
+      reference_counts: set_refs,
+      grid: {
+        rows: root_rows,
+        columns: root_cols
+      },
+      buttons: buttons,
+      levels: clusters,
+      alternates: alt_scores
+    }
+    if include_obfset
+      res[:obfset] = obfset
+    end
+    res
+  end
+
+  def self.analyze_for(obfset, brd, set_pcts, output)
+      visited_board_ids = {}
+      to_visit = [{board: brd, level: 0, entry_x: 1.0, entry_y: 1.0}]
+      locale = brd['locale'] || 'en'
       known_buttons = {}
       while to_visit.length > 0
         board = to_visit.shift
@@ -173,7 +227,7 @@ module AACMetrics::Metrics
             button_id = (board[:board]['grid']['order'][row_idx] || [])[col_idx]
             button = board[:board]['buttons'].detect{|b| b['id'] == button_id }
             # prior_buttons += 0.1 if !button
-            next unless button
+            next unless button && (button['label'] || button['vocalization'] || '').length > 0
             x = (btn_width / 2)  + (btn_width * col_idx)
             y = (btn_height / 2) + (btn_height * row_idx)
             # prior_buttons = (row_idx * board[:board]['grid']['columns']) + col_idx
@@ -271,10 +325,14 @@ module AACMetrics::Metrics
                 next_board = obfset.detect{|brd| brd['id'] == button['load_board']['id'] }
                 change_effort = BOARD_CHANGE_PROCESSING_EFFORT
                 if next_board
+                  temp_home_id = board[:temporary_home_id]
+                  temp_home_id = board[:board]['id'] if button['load_board']['temporary_home'] == 'prior'
+                  temp_home_id = button['load_board']['id'] if button['load_board']['temporary_home'] == true
                   to_visit.push({
                     board: next_board,
                     level: board[:level] + 1,
                     prior_effort: effort + change_effort,
+                    temporary_home_id: temp_home_id,
                     entry_x: x,
                     entry_y: y,
                     entry_clone_id: button['clone_id'],
@@ -286,29 +344,35 @@ module AACMetrics::Metrics
             if !button['load_board'] || button['load_board']['add_to_sentence']
               word = button['label']
               existing = known_buttons[word]
-              if !existing || effort < existing[:effort] #board[:level] < existing[:level]
-                if board_pcts[button['clone_id']]
-                  effort -= [BOARD_CHANGE_PROCESSING_EFFORT, BOARD_CHANGE_PROCESSING_EFFORT * 0.3 / board_pcts[button['clone_id']]].min
-                elsif board_pcts[button['semantic_id']]
-                  effort -= [BOARD_CHANGE_PROCESSING_EFFORT, BOARD_CHANGE_PROCESSING_EFFORT * 0.5 / board_pcts[button['semantic_id']]].min
-                end
-
-                known_buttons[word] = {
+              if board_pcts[button['clone_id']]
+                effort -= [BOARD_CHANGE_PROCESSING_EFFORT, BOARD_CHANGE_PROCESSING_EFFORT * 0.3 / board_pcts[button['clone_id']]].min
+              elsif board_pcts[button['semantic_id']]
+                effort -= [BOARD_CHANGE_PROCESSING_EFFORT, BOARD_CHANGE_PROCESSING_EFFORT * 0.5 / board_pcts[button['semantic_id']]].min
+              end
+              if !existing || effort < existing[:effort]
+                ww = {
                   id: "#{button['id']}::#{board[:board]['id']}",
                   label: word,
                   level: board[:level],
                   effort: effort,
+                  count: ((existing || {})[:count] || 0) + 1
                 }
+                # If a board set has any temporary_home links,
+                # then that can possibly affect the effort
+                # score for sentences
+                if board[:temporary_home_id]
+                  ww[:temporary_home_id] = board[:temporary_home_id]
+                end
+                known_buttons[word] = ww
               end
             end
             button['effort'] = effort
-
           end
         end
-      end
+      end # end to_visit list
       buttons = known_buttons.to_a.map(&:last)
       total_boards = visited_board_ids.keys.length
-    end
+
     buttons = buttons.sort_by{|b| [b[:effort] || 1, b[:label] || ""] }
     clusters = {}
     buttons.each do |btn| 
@@ -320,25 +384,38 @@ module AACMetrics::Metrics
       locale: locale,
       total_boards: total_boards,
       total_buttons: buttons.length,
-      reference_counts: set_refs,
-      grid: {
-        rows: root_rows,
-        columns: root_cols
-      },
       buttons: buttons,
       levels: clusters
     }
-    if include_obfset
-      res[:obfset] = obfset
-    end
     res
   end
 
+  class ExtraFloat < Numeric
+    include Math
+    def initialize(float=0.0)
+      @float = Float(float)
+    end
+  
+    def to_f
+      @float.to_f
+    end
+
+    def method_missing(message, *args, &block)
+      if block_given?
+        @float.public_send(message, *args, &block)
+      else
+        @float.public_send(message, *args)
+      end
+    end
+  end
+
   SQRT2 = Math.sqrt(2)
   BUTTON_SIZE_MULTIPLIER = 0.09
   FIELD_SIZE_MULTIPLIER = 0.005
   VISUAL_SCAN_MULTIPLIER = 0.015
   BOARD_CHANGE_PROCESSING_EFFORT = 1.0
+  BOARD_HOME_EFFORT = 1.0
+  COMBINED_WORDS_REMEMBERING_EFFORT = 1.0
   DISTANCE_MULTIPLIER = 0.4
   DISTANCE_THRESHOLD_TO_SKIP_VISUAL_SCAN = 0.1
   SKIPPED_VISUAL_SCAN_DISTANCE_MULTIPLIER = 0.5
@@ -377,6 +454,7 @@ module AACMetrics::Metrics
     compare = AACMetrics::Metrics.analyze(compset, false)
     res[:comp_boards] = compare[:total_boards]
     res[:comp_buttons] = compare[:total_buttons]
+    res[:comp_words] = compare[:total_words]
     res[:comp_grid] = compare[:grid]
     
     compare_words = []
@@ -386,9 +464,21 @@ module AACMetrics::Metrics
     compare[:buttons].each do |btn|
       compare_words << btn[:label]
       compare_buttons[btn[:label]] = btn
-      comp_efforts[btn[:label]] = btn[:effort]
+      comp_efforts[btn[:label]] = ExtraFloat.new(btn[:effort])
+      comp_efforts[btn[:label]].instance_variable_set('@temp_home_id', btn[:temporary_home_id])
       comp_levels[btn[:label]] = btn[:level]
     end
+    compare[:alternates].each do |id, alt|
+      efforts = {}
+      levels = {}
+      alt[:buttons].each do |btn|
+        efforts[btn[:label]] = ExtraFloat.new(btn[:effort])
+        efforts[btn[:label]].instance_variable_set('@temp_home_id', btn[:temporary_home_id])
+        levels[btn[:label]] = btn[:level]
+      end
+      comp_efforts["H:#{id}"] = efforts
+      comp_levels["H:#{id}"] = levels
+    end
 
     sortable_efforts = {}
     target_efforts = {}
@@ -400,7 +490,9 @@ module AACMetrics::Metrics
     # very frequent core words and use that when available
     res[:buttons].each{|b| 
       target_words << b[:label]
-      target_efforts[b[:label]] = b[:effort]
+      target_efforts[b[:label]] = ExtraFloat.new(b[:effort])
+      target_efforts[b[:label]].instance_variable_set('@temp_home_id', b[:temporary_home_id])
+
       target_levels[b[:label]] = b[:level]
       sortable_efforts[b[:label]] = b[:effort] 
       comp = compare_buttons[b[:label]]
@@ -409,6 +501,18 @@ module AACMetrics::Metrics
         b[:comp_effort] = comp[:effort]
       end
     }
+    res[:alternates].each do |id, alt|
+      efforts = {}
+      levels = {}
+      alt[:buttons].each do |btn|
+        efforts[btn[:label]] = ExtraFloat.new(btn[:effort])
+        efforts[btn[:label]].instance_variable_set('@temp_home_id', btn[:temporary_home_id])
+        levels[btn[:label]] = btn[:level]
+      end
+      target_efforts["H:#{id}"] = efforts
+      target_levels["H:#{id}"] = levels
+    end
+    res.delete(:alternates)
     # Effort scores are the mean of thw scores from the
     # two sets, or just a singular value if in only one set
     compare[:buttons].each{|b| 
@@ -441,7 +545,6 @@ module AACMetrics::Metrics
         end
       end
     end
-
     
     missing = (compare_words - target_words).sort_by{|w| sortable_efforts[w] }
     missing = missing.select do |word|
@@ -519,20 +622,11 @@ module AACMetrics::Metrics
         end
 
         # Calculate the effort for the target and comp sets
-        effort = target_efforts[word]
-        if !effort
-          words.each{|w| effort ||= target_efforts[w] }
-        end
-        # Fallback penalty for missing word
-        effort ||= spelling_effort(word)
+        effort, level = best_match(word, target_efforts, nil, synonyms)
         reffort = effort
         list_effort += effort
 
-        effort = comp_efforts[word]
-        if !effort
-          words.each{|w| effort ||= comp_efforts[w] }
-        end
-        effort ||= spelling_effort(word)
+        effort, level = best_match(word, comp_efforts, nil, synonyms)
         comp_effort += effort
         # puts "#{word} - #{reffort.round(1)} - #{effort.round(1)}"
       end
@@ -552,50 +646,18 @@ module AACMetrics::Metrics
     res[:care_components][:comp_core] = (comp_effort_tally / core_lists.to_a.length) * 5.0
     comp_effort_tally = res[:care_components][:comp_core]
 
-    # TODO: Assemble or allow a battery of word combinations,
+    # Assemble or allow a battery of word combinations,
     # and calculate the level of effort for each sequence,
     # as well as an average level of effort across combinations.
+    # TODO: sets with temporary_home settings will have custom
+    # effort scores for subsequent words in the sentence
     res[:sentences] = []
     sentences.each do |words|
-      target_effort_score = 0.0
-      comp_effort_score = 0.0
-      words.each_with_index do |word, idx|
-        synonym_words = [word] + (synonyms[word] || [])
-        effort = target_efforts[word] || target_efforts[word.downcase]
-        level = target_levels[word] || target_levels[word.downcase]
-        if !effort
-          synonym_words.each do |w| 
-            if !effort && target_efforts[w]
-              effort = target_efforts[w]
-              level = target_levels[w]
-            end
-          end
-        end
-        effort ||= spelling_effort(word)
-        if level && level > 0 && idx > 0
-          effort += BOARD_CHANGE_PROCESSING_EFFORT
-        end
-        ee = effort
-        target_effort_score += effort
-
-        effort = comp_efforts[word] || comp_efforts[word.downcase]
-        level = comp_levels[word] || comp_levels[word.downcase]
-        if !effort
-          synonym_words.each do |w| 
-            if !effort && comp_efforts[w]
-              effort = comp_efforts[w]
-              level = comp_levels[w]
-            end
-          end
-        end
-        effort ||= spelling_effort(word)
-        if level && level > 0 && idx > 0
-          effort += BOARD_CHANGE_PROCESSING_EFFORT
-        end
-        comp_effort_score += effort
-      end
-      target_effort_score = target_effort_score / words.length
-      comp_effort_score = comp_effort_score / words.length
+      sequence = best_combo(words, target_efforts, target_levels, synonyms)
+      target_effort_score = sequence.map{|w, e| e }.sum.to_f / words.length.to_f
+      sequence = best_combo(words, comp_efforts, comp_levels, synonyms)
+      comp_effort_score = sequence.map{|w, e| e }.sum.to_f / words.length.to_f
+
       res[:sentences] << {sentence: words.join(' '), words: words, effort: target_effort_score, comp_effort: comp_effort_score}
     end
     res[:care_components][:sentences] = res[:sentences].map{|s| s[:effort] }.sum.to_f / res[:sentences].length.to_f * 3.0
@@ -607,20 +669,11 @@ module AACMetrics::Metrics
     fringe.each do |word|
       target_effort_score = 0.0
       comp_effort_score = 0.0
-      synonym_words = [word] + (synonyms[word] || [])
-      effort = target_efforts[word] || target_efforts[word.downcase]
-      if !effort
-        synonym_words.each{|w| effort ||= target_efforts[w] }
-      end
-      # puts "!#{word}" unless effort
-      effort ||= spelling_effort(word)
+
+      effort, level = best_match(word, target_efforts, nil, synonyms)
       target_effort_score += effort
 
-      effort = comp_efforts[word] || comp_efforts[word.downcase]
-      if !effort
-        synonym_words.each{|w| effort ||= comp_efforts[w] }
-      end
-      effort ||= spelling_effort(word)
+      effort, level = best_match(word, comp_efforts, nil, synonyms)
       comp_effort_score += effort
       res[:fringe_words] << {word: word, effort: target_effort_score, comp_effort: comp_effort_score}
     end
@@ -633,19 +686,10 @@ module AACMetrics::Metrics
     common_fringe.each do |word|
       target_effort_score = 0.0
       comp_effort_score = 0.0
-      synonym_words = [word] + (synonyms[word] || [])
-      effort = target_efforts[word] || target_efforts[word.downcase]
-      if !effort
-        synonym_words.each{|w| effort ||= target_efforts[w] }
-      end
-      effort ||= spelling_effort(word)
+      effort, level = best_match(word, target_efforts, nil, synonyms)
       target_effort_score += effort
 
-      effort = comp_efforts[word] || comp_efforts[word.downcase]
-      if !effort
-        synonym_words.each{|w| effort ||= comp_efforts[w] }
-      end
-      effort ||= spelling_effort(word)
+      effort, level = best_match(word, comp_efforts, nil, synonyms)
       comp_effort_score += effort
       res[:common_fringe_words] << {word: word, effort: target_effort_score, comp_effort: comp_effort_score}
     end
@@ -657,13 +701,6 @@ module AACMetrics::Metrics
     target_effort_tally += 70 # placeholder value for future added calculations
     comp_effort_tally += 70
 
-    # puts target_effort_tally
-    # puts comp_effort_tally
-    # puts (target_effort_tally - comp_effort_tally).abs
-    # puts JSON.pretty_generate(res[:care_components])
-#    raise 'arf'
-
-
     res[:target_effort_score] = [0.0, 350.0 - target_effort_tally].max
     res[:comp_effort_score] = [0.0, 350.0 - comp_effort_tally].max
     # puts "CONSIDER MAKING EASIER"
@@ -674,4 +711,94 @@ module AACMetrics::Metrics
     # puts too_easy.join('  ')
     res
   end
+
+  # Find the effort for a word, its synonyms, or its spelling.
+  # Always returns a non-nil effort score
+  def self.best_match(word, target_efforts, target_levels, synonyms)
+    synonym_words = [word] + (synonyms[word] || [])
+    effort = target_efforts[word] || target_efforts[word.downcase]
+    target_levels ||= {}
+    level = target_levels[word] || target_levels[word.downcase]
+    if !effort
+      synonym_words.each do |w| 
+        if !effort && target_efforts[w]
+          effort = target_efforts[w]
+          level = target_levels[w]
+        end
+      end
+    end
+    # Fallback penalty for missing word
+    fallback_effort = spelling_effort(word)
+    effort = fallback_effort if !effort || fallback_effort < effort
+
+    [effort, level || 0]
+  end
+
+  def self.best_combo(words, efforts, levels, synonyms)
+    options = [{next_idx: 0, list: []}]
+    words.length.times do |idx|
+      options.each do |option|
+        home_id = option[:temporary_home_id]
+        if option[:next_idx] == idx
+          combos = forward_combos(words, idx, efforts, levels)
+          if home_id
+            # Effort of hitting home button, and processing change, plus usual
+            combos.each{|c| c[:effort] += BOARD_HOME_EFFORT + BOARD_CHANGE_PROCESSING_EFFORT}
+            more_combos = forward_combos(words, idx, efforts["H:#{home_id}"] || {}, levels["H:#{home_id}"] || {})
+            more_combos.each{|c| c[:temporary_home_id] ||= home_id }
+            combos += more_combos
+          end
+          combos.each do |combo|
+            if idx > 0 && combo[:level] && combo[:level] > 0
+              combo[:effort] += BOARD_CHANGE_PROCESSING_EFFORT
+            end
+            options << {
+              next_idx: idx + combo[:size],
+              list: option[:list] + [[combo[:partial], combo[:effort]]],
+              temporary_home_id: combo[:temporary_home_id]
+            }
+          end
+          effort, level = best_match(words[idx], efforts, levels, synonyms)
+          option[:temporary_home_id] = effort.instance_variable_get('@temp_home_id')
+          effort += BOARD_CHANGE_PROCESSING_EFFORT if idx > 0 && level && level > 0
+          if home_id
+            effort += BOARD_HOME_EFFORT + BOARD_CHANGE_PROCESSING_EFFORT
+            other_effort, other_level = best_match(words[idx], efforts["H:#{home_id}"] || {}, levels["H:#{home_id}"] || {}, synonyms)
+            new_home_id = other_effort.instance_variable_get('@temp_home_id') || home_id
+            other_effort += BOARD_CHANGE_PROCESSING_EFFORT if idx > 0 && other_level && other_level > 0
+            other_list = option[:list] + [[words[idx], other_effort]]
+            options << {next_idx: idx + 1, list: other_list, temporary_home_id: new_home_id}
+          end
+          option[:list] << [words[idx], effort]
+          option[:next_idx] = idx + 1
+        end
+      end
+    end
+    options.sort_by{|o| o[:list].map{|w, e| e}.sum }.reverse[0][:list]
+  end
+
+  # Checks if any buttons will work for multiple words in a sentence
+  def self.forward_combos(words, idx, target_efforts, target_levels)
+    words_left = words.length - idx
+    combos = []
+    skip = 0
+    temp_home_id = nil
+    if words_left > 1
+      (words_left - 1).times do |minus|
+        partial = words[idx, words_left - minus].join(' ')
+        if target_efforts[partial] || target_efforts[partial.downcase]
+          effort = (target_efforts[partial] || target_efforts[partial.downcase]) + COMBINED_WORDS_REMEMBERING_EFFORT
+          level = target_levels[partial] || target_levels[partial.downcase]
+          combos << {
+            partial: partial,
+            effort: effort, 
+            temporary_home_id: effort.instance_variable_get('@temp_home_id'),
+            level: level, 
+            size: words_left - minus
+          }
+        end
+      end
+    end
+    combos
+  end
 end

data/lib/ingester.rb

@@ -1,3 +1,5 @@
+# Imports an obf dataset for future access.
+
 lib_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)