aac-metrics 0.0.1 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fbfbfcd5c426a844f692b0cfb1151bd800dc0fe9d679b838a5308479c087b58
-  data.tar.gz: b056c6c7339b7c8da6d1cba1f3d05e0c27da02aa49958cd186242e570bde7639
+  metadata.gz: b241e25385bbf1330a3ba38d9a3cb4935ea570a8e629b18be1775557f96c6c7c
+  data.tar.gz: '07127794d01330821ff34bb36acf64f6fb538a3b13ca98c61ddbb3d83fca53ff'
 SHA512:
-  metadata.gz: ee6cb311b8c50c78cda543094f71840e35a119b23c82f42e131f5a2927b393edde3874a823bb2fdc1dc0f6db3d30d480eb65407da50cb0634536668676194257
-  data.tar.gz: 2d9bf2b511df96879609260448b1de4712146d117853147a9dc591f848b677f59526c0439f7d8a619d108264f0be21412de3761c34f3231eeafde9795efcbf41
+  metadata.gz: 262a150c97739c793df16ac9abef5b633010f5d62be8031a160996654edfa63ed3bc79c8fb42f60916212ba8d70465165c0a50b995000ef5872c3d0a9768dee7
+  data.tar.gz: 2e3f426ceaaf6445d31531a328d36e237bb7a33a980714afcc68c707421ebd71bfbcfb19cc37edfed60a4513aa08ca1de8f952ff7ef4330925fbe5492ed4d172

data/lib/aac-metrics/loader.rb

@@ -3,19 +3,68 @@ require 'typhoeus'
 require 'digest'
 
 module AACMetrics::Loader
-  def self.retrieve(obfset)
-    if !obfset.match(/\.obfset/)
-      obfset = Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'sets', obfset + '*.obfset')))[0]
+  def self.retrieve(obfset, unsub=true)
+    if obfset.is_a?(Hash) && obfset['boards']
+      json = []
+      obfset['boards'].each do |board|
+        new_board = {
+          "id" => board['id'],
+          "buttons" => [],
+          "locale" => board['locale'] || 'en',
+          "grid" => board['grid'],
+        }
+        board['buttons'].each do |button|
+          new_button = {
+            "label" => ((button['vocalization'] || '').length > 0 ? button['vocalization'] : button['label']).to_s.downcase.gsub(/’/, ''),
+            "id" => button['id']
+          }
+          if button['load_board'] && button['load_board']['id']
+            new_button['load_board'] = {'id' => button['load_board']['id']}
+          end
+          new_board['buttons'].push(new_button)
+        end
+        json << new_board
+      end
+      return json
+    elsif obfset.match(/^http/)
+      res = Typhoeus.get(obfset, timeout: 10)
+      json = JSON.parse(res.body)
+    elsif !obfset.match(/\.obfset/)
+      fn = obfset
+      obfset = Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'sets', fn + '*.obfset')))[0]
+      analysis = nil
+      if !obfset
+        analysis = Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'sets', fn + '*.analysis')))[0]
+      end
+      if obfset
+        json = JSON.parse(File.read(obfset))
+      elsif analysis
+        json = JSON.parse(File.read(analysis))
+      end
+    else
+      json = JSON.parse(File.read(obfset))
     end
-    json = JSON.parse(File.read(obfset))
-    base = self.base_words(json[0]['locale'])
-    json.each do |brd|
-      brd['buttons'].each do |btn|
-        if btn['label'].match(/^\$/)
-          word = base[btn['label'].sub(/^\$/, '')]
-          btn['label'] = word if word
+    if unsub
+      locale = json.is_a?(Array) ? json[0]['locale'] : json['locale']
+      base = self.base_words(locale)
+      if json.is_a?(Array)
+        json.each do |brd|
+          brd['buttons'].each do |btn|
+            if btn['label'].match(/^\$/)
+              word = base[btn['label'].sub(/^\$/, '')]
+              btn['label'] = word if word
+            end
+            btn['label'] = btn['label'].gsub(/’/, '')
+          end
+        end
+      elsif json.is_a?(Hash)
+        (json['buttons'] || []).each do |button|
+          if button['label'].match(/^\$/)
+            word = base[button['label'].sub(/^\$/, '')]
+            button['label'] = word if word
+          end
+          button['label'] = button['label'].gsub(/’/, '')
         end
-        btn['label'] = btn['label'].gsub(/’/, '')
       end
     end
     json
@@ -35,7 +84,6 @@ module AACMetrics::Loader
       path = paths.shift
       visited_paths[path] = idx
       new_json = {
-        "format" => "open-board-0.1",
         "id" => "brd#{idx}",
         "buttons" => [],
         "grid" => {},
@@ -46,9 +94,9 @@ module AACMetrics::Loader
         if token
           path += "?access_token=#{token}"
         end
-        req = Typhoeus.get(path)
+        req = Typhoeus.get(path, timeout: 10)
         json = JSON.parse(req.body)
-        puts path
+        # puts path
       else
         if !File.exist?(path)
           orig_path = path
@@ -57,7 +105,7 @@ module AACMetrics::Loader
             path = File.expand_path(File.join(fn, "..", "..", orig_path))
           end
         end
-        puts "#{path}"
+        # puts "#{path}"
         json = JSON.parse(File.read(path))
       end
       if json && json['grid']
@@ -139,20 +187,34 @@ module AACMetrics::Loader
   end
 
   def self.ingest(fn, token=nil)
-    content = process(fn, token)
-    boards = content[:boards]
-    words = content[:words]
-    words_path = content[:words_path]
-    output_fn = Digest::MD5.hexdigest(Time.now.to_i.to_s + rand(9999).to_s)[0, 10] + ".obfset"
-    output = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'sets', output_fn))
-    f = File.open(output, 'w')
-    f.write(JSON.pretty_generate(boards))
-    f.close
-    if words
-      new_words = {}
-      words.to_a.sort_by{|h, w| w }.each{|h, w| new_words[h] = w }
-      f = File.open(words_path, 'w')
-      f.write(JSON.pretty_generate(new_words))
+    output = nil
+    boards = nil
+    if fn.match(/\.obfset$/)
+      boards = retrieve(fn, false)
+      output = fn
+    else
+      content = process(fn, token)
+      boards = content[:boards]
+      words = content[:words]
+      words_path = content[:words_path]
+      output_fn = Digest::MD5.hexdigest(Time.now.to_i.to_s + rand(9999).to_s)[0, 10] + ".obfset"
+      output = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'sets', output_fn))
+      f = File.open(output, 'w')
+      f.write(JSON.pretty_generate(boards))
+      f.close
+      if words
+        new_words = {}
+        words.to_a.sort_by{|h, w| w }.each{|h, w| new_words[h] = w }
+        f = File.open(words_path, 'w')
+        f.write(JSON.pretty_generate(new_words))
+        f.close
+      end
+    end
+    if boards
+      analysis = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'sets', fn.sub(/\.obfset$/, '.analysis')))
+      res = AACMetrics::Metrics.analyze(boards)
+      f = File.open(analysis, 'w')
+      f.write(JSON.pretty_generate(res))
       f.close
     end
     output
@@ -171,6 +233,8 @@ module AACMetrics::Loader
     locale = locale.split(/-|_/)[0]
     common_paths = Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'sets', "*.common.#{locale}.obfset")))
     files = common_paths.map{|p| File.basename(p) }.sort
+    common_analysis_paths = Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'sets', "*.common.#{locale}.analysis")))
+    files += common_analysis_paths.map{|p| File.basename(p) }.sort
     path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'sets', "common_words.#{locale}.json"))    
     res = JSON.parse(File.read(path)) rescue nil
     if !res || true

data/lib/aac-metrics/metrics.rb

@@ -1,95 +1,208 @@
 module AACMetrics::Metrics
   def self.analyze(obfset, output=true)
-    visited_board_ids = {}
-    to_visit = [{board: obfset[0], level: 0, entry_x: 1.0, entry_y: 1.0}]
-    locale = obfset[0]['locale']
-    known_buttons = {}
-    sqrt2 = Math.sqrt(2)
-    while to_visit.length > 0
-      board = to_visit.shift
-      visited_board_ids[board[:board]['id']] = board[:level]
-      puts board[:board]['id'] if output
-      btn_height = 1.0  / board[:board]['grid']['rows'].to_f
-      btn_width = 1.0  / board[:board]['grid']['columns'].to_f
-      board_effort = 0
-      # add effort for level of complexity when new board is rendered
-      board_effort += 0.005 * board[:board]['grid']['rows'] * board[:board]['grid']['columns']
-      # add effort for number of visible buttons
-      board_effort += 0.01 * board[:board]['grid']['order'].flatten.length
+    locale = nil
+    buttons = []
+    total_boards = 1
+    
+    if obfset.is_a?(Hash) && obfset['buttons']
+      locale = obfset['locale'] || 'en'
+      buttons = []
+      obfset['buttons'].each do |btn|
+        buttons << {
+          id: btn['id'],
+          label: btn['label'],
+          level: btn['level'],
+          effort: btn['effort']
+        }
+      end
+      total_boards = obfset['total_boards']
+    else
+      visited_board_ids = {}
+      to_visit = [{board: obfset[0], level: 0, entry_x: 1.0, entry_y: 1.0}]
+      locale = obfset[0]['locale']
+      known_buttons = {}
+      sqrt2 = Math.sqrt(2)
+      while to_visit.length > 0
+        board = to_visit.shift
+        visited_board_ids[board[:board]['id']] = board[:level]
+        puts board[:board]['id'] if output
+        btn_height = 1.0  / board[:board]['grid']['rows'].to_f
+        btn_width = 1.0  / board[:board]['grid']['columns'].to_f
+        board_effort = 0
+        # add effort for level of complexity when new board is rendered
+        board_effort += 0.005 * board[:board]['grid']['rows'] * board[:board]['grid']['columns']
+        # add effort for number of visible buttons
+        board_effort += 0.01 * board[:board]['grid']['order'].flatten.length
 
-      board[:board]['grid']['rows'].times do |row_idx|
-        board[:board]['grid']['columns'].times do |col_idx|
-          button_id = (board[:board]['grid']['order'][row_idx] || [])[col_idx]
-          button = board[:board]['buttons'].detect{|b| b['id'] == button_id }
-          next unless button
-          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
-          effort = 0
-          effort += board_effort
-          # add small effort for every prior button when visually scanning
-          effort += prior_buttons * 0.05
-          # add effort for percent distance from entry point
-          effort += Math.sqrt((x - board[:entry_x]) ** 2 + (y - board[:entry_y]) ** 2) / sqrt2
-          # add cumulative effort from previous sequence
-          effort += board[:prior_effort] || 0
-          if button['load_board']
-            try_visit = false
-            # For linked buttons, only traverse if
-            # the board hasn't been visited, or if 
-            # we're not visiting it at a lower level
-            if visited_board_ids[button['load_board']['id']] == nil
-              try_visit = true 
-            elsif visited_board_ids[button['load_board']['id']] > board[:level] + 1
-              try_visit = true 
+        board[:board]['grid']['rows'].times do |row_idx|
+          board[:board]['grid']['columns'].times do |col_idx|
+            button_id = (board[:board]['grid']['order'][row_idx] || [])[col_idx]
+            button = board[:board]['buttons'].detect{|b| b['id'] == button_id }
+            next unless button
+            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
+            effort = 0
+            effort += board_effort
+            # add effort for percent distance from entry point
+            distance = Math.sqrt((x - board[:entry_x]) ** 2 + (y - board[:entry_y]) ** 2) / sqrt2
+            effort += distance
+            if distance > 0.1 || (board[:entry_x] == 1.0 && board[:entry_y] == 1.0)
+              # add small effort for every prior button when visually scanning
+              effort += prior_buttons * 0.05
+            else
+              # ..unless it's right by the previous button, then
+              # add tiny effort for local scan
+              effort += distance * 0.5
             end
-            if to_visit.detect{|b| b[:board]['id'] == button['load_board']['id'] && b[:level] <= board[:level] + 1 }
+            # add cumulative effort from previous sequence
+            effort += board[:prior_effort] || 0
+            if button['load_board']
               try_visit = false
-            end
-            if try_visit
-              next_board = obfset.detect{|brd| brd['id'] == button['load_board']['id'] }
-              if next_board
-                to_visit.push({
-                  board: next_board,
-                  level: board[:level] + 1,
-                  prior_effort: effort + 1.0,
-                  entry_x: x,
-                  entry_y: y
-                })
+              # For linked buttons, only traverse if
+              # the board hasn't been visited, or if 
+              # we're not visiting it at a lower level
+              if visited_board_ids[button['load_board']['id']] == nil
+                try_visit = true 
+              elsif visited_board_ids[button['load_board']['id']] > board[:level] + 1
+                try_visit = true 
+              end
+              if to_visit.detect{|b| b[:board]['id'] == button['load_board']['id'] && b[:level] <= board[:level] + 1 }
+                try_visit = false
+              end
+              if try_visit
+                next_board = obfset.detect{|brd| brd['id'] == button['load_board']['id'] }
+                if next_board
+                  to_visit.push({
+                    board: next_board,
+                    level: board[:level] + 1,
+                    prior_effort: effort + 1.0,
+                    entry_x: x,
+                    entry_y: y
+                  })
+                end
+              end
+            else
+              word = button['label']
+              existing = known_buttons[word]
+              if !existing || board[:level] < existing[:level]
+                known_buttons[word] = {
+                  id: "#{button['id']}::#{board[:board]['id']}",
+                  label: word,
+                  level: board[:level],
+                  effort: effort
+                }
               end
-            end
-          else
-            word = button['label']
-            existing = known_buttons[word]
-            if !existing || board[:level] < existing[:level]
-              known_buttons[word] = {
-                id: "#{button['id']}::#{board[:board]['id']}",
-                label: word,
-                level: board[:level],
-                effort: effort
-              }
             end
           end
         end
       end
+      buttons = known_buttons.to_a.map(&:last)
+      total_boards = visited_board_ids.keys.length
     end
-    buttons = known_buttons.to_a.map(&:last).sort_by{|b| b[:effort] }
+    buttons = buttons.sort_by{|b| [b[:effort] || 1, b[:label] || ""] }
     clusters = {}
     buttons.each do |btn| 
-      puts "#{btn[:label]}\t#{btn[:effort]}" if output
       clusters[btn[:level]] ||= []
       clusters[btn[:level]] << btn
     end
-    clusters.each do |level, buttons|
-      puts "HITS: #{level + 1}" if output
-      puts buttons.map{|b| b[:label] }.join('  ') if output
-    end
-    puts "TOTAL BOARDS: #{visited_board_ids.keys.length}" if output
-    puts "TOTAL WORDS: #{buttons.length}" if output
     {
       locale: locale,
+      total_boards: total_boards,
+      total_buttons: buttons.length,
       buttons: buttons,
       levels: clusters
     }
   end
+
+  def self.analyze_and_compare(obfset, compset)
+    target = AACMetrics::Metrics.analyze(obfset, false)
+    res = {}.merge(target)
+
+    compare = AACMetrics::Metrics.analyze(compset, false)
+    
+    compare_words = []
+    compare_buttons = {}
+    compare_words = compare[:buttons].each do |btn|
+      compare_words << btn[:label]
+      compare_buttons[btn[:label]] = btn
+    end
+
+    efforts = {}
+    target_words = []
+    res[:buttons].each{|b| 
+      target_words << b[:label]
+      efforts[b[:label]] = b[:effort] 
+      comp = compare_buttons[b[:label]]
+      if comp
+        b[:comp_level] = comp[:level]
+        b[:comp_effort] = comp[:effort]
+      end
+    }
+    compare[:buttons].each{|b| 
+      if efforts[b[:label]]
+        efforts[b[:label]] += b[:effort] 
+        efforts[b[:label]] /= 2
+      else
+        efforts[b[:label]] ||= b[:effort] 
+      end
+    }
+    
+    core_lists = AACMetrics::Loader.core_lists(target[:locale])
+    common_words_obj = AACMetrics::Loader.common_words(target[:locale])
+    common_words_obj['efforts'].each{|w, e| efforts[w] ||= e }
+    common_words = common_words_obj['words']
+    
+    too_easy = []
+    too_hard = []
+    target[:buttons].each do |btn|
+      if btn[:effort] && common_words_obj['efforts'][btn[:label]]
+        if btn[:effort] < common_words_obj['efforts'][btn[:label]] - 5
+          too_easy << btn[:label]
+        elsif btn[:effort] > common_words_obj['efforts'][btn[:label]] + 3
+          too_hard << btn[:label]
+        end
+      end
+    end
+    
+    missing = (compare_words - target_words).sort_by{|w| efforts[w] }
+    extras = (target_words - compare_words).sort_by{|w| efforts[w] }
+    # puts "MISSING WORDS (#{missing.length}):"
+    res[:missing_words] = missing
+    # puts missing.join('  ')
+    # puts "EXTRA WORDS (#{extras.length}):"
+    res[:extra_words] = extras
+    # puts extras.join('  ')
+    overlap = (target_words & compare_words & common_words)
+    # puts "OVERLAPPING WORDS (#{overlap.length}):"
+    res[:overlapping_words] = overlap
+    # puts overlap.join('  ')
+    missing = (common_words - target_words)
+    # puts "MISSING FROM COMMON (#{missing.length})"
+    res[:missing] = {
+      :common => {name: "Common Word List", list: missing}
+    }
+    # puts missing.join('  ')
+    core_lists.each do |list|
+      missing = []
+      list['words'].each do |word|
+        words = word.gsub(/’/, '').downcase.split(/\|/)
+        if (target_words & words).length == 0
+          missing << words[0] 
+        end
+      end
+      if missing.length > 0
+        # puts "MISSING FROM #{list['id']} (#{missing.length}):"
+        res[:missing][list['id']] = {name: list['name'], list: missing}
+        # puts missing.join('  ')
+      end
+    end
+    # puts "CONSIDER MAKING EASIER"
+    res[:high_effort_words] = too_hard
+    # puts too_hard.join('  ')
+    # puts "CONSIDER LESS PRIORITY"
+    res[:low_effort_words] = too_easy
+    # puts too_easy.join('  ')
+    res
+  end
 end