asker-tool 2.1.2

data/lib/asker/ai/ai.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'stages/main'
+require_relative 'ai_calculate'
+
+# Description: Method to be included into every ConceptAI instance.
+# * make_questions: use AI to fill @questions Array
+module AI
+  include AI_calculate
+
+  def make_questions
+    return unless process?
+
+    make_questions_stages_di
+    # Process every table of this concept
+    tables.each do |tab|
+      list1, list2 = get_list1_and_list2_from(tab)
+      make_questions_stages_bsf(tab, list1, list2)
+      make_questions_stages_t(tab, list1, list2)
+    end
+    # -------------------------------------------------------
+    # Exclude questions as is defined into config.ini params
+    exclude_questions
+  end
+
+  def make_questions_stages_di
+    @questions[:d] = StageD.new(self).run  # Process every def{type=text}
+    @questions[:i] = StageI.new(self).run  # Process every def{type=image_url}
+  end
+
+  def make_questions_stages_bsf(tab, list1, list2)
+    # Stage B: process table to make match questions
+    @questions[:b] += StageB.new(self).run(tab, list1, list2)
+    # Stage S: process tables with sequences
+    @questions[:s] += StageS.new(self).run(tab, list1, list2)
+    # Stage F: process tables with only 1 field
+    @questions[:f] += StageF.new(self).run(tab, list1, list2)
+  end
+
+  def make_questions_stages_t(tab, list1, list2)
+    # Stage T: process_tableXfields
+    list3 = list1 + list2
+    list1.each do |row|
+      reorder_list_with_row(list3, row)
+      @questions[:t] += StageT.new(self).run(tab, row, list3)
+    end
+  end
+
+  def exclude_questions
+    param = Application.instance.config['questions']['exclude']
+    return if param.nil?
+
+    tags = param.split(',').each(&:strip!)
+    input = { d: [], b: [], f: [], i: [], s: [], t: [] }
+    output = { d: [], b: [], f: [], i: [], s: [], t: [] }
+
+    @questions.each_pair do |key, qlist|
+      output[key] = qlist.select { |q| string_has_this_tags?(q.name, tags) }
+      input[key] = @questions[key] - output[key]
+    end
+    @questions = input
+    @excluded_questions = output
+  end
+
+  def string_has_this_tags?(input, tags)
+    flag = false
+    tags.each { |e| flag = true if input.include? e }
+    flag
+  end
+end

data/lib/asker/ai/ai_calculate.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# Methods that calculate something
+module AI_calculate
+  def get_list1_and_list2_from(ltable)
+    # create <list1> with all the rows from the table
+    list1 = []
+    count = 1
+    ltable.rows.each do |i|
+      list1 << { id: count, weight: 0, data: i }
+      count += 1
+    end
+
+    # create a <list2> with similar rows (same table name) from the neighbours tables
+    list2 = []
+    neighbors.each do |n|
+      n[:concept].tables.each do |t2|
+        next if t2.name != ltable.name
+        t2.rows.each do |i|
+          list2 << { id: count, weight: 0, data: i }
+          count += 1
+        end
+      end
+    end
+    return list1, list2
+  end
+
+  def calculate_nearness_between_texts(text1, text2)
+    return 0.0 if text2.nil? || text2.empty?
+
+    words = text1.split(' ')
+    count = 0
+    words.each { |w| count += 1 if text2.include?(w) }
+    (count * 100 / words.count)
+  end
+
+  def reorder_list_with_row(list, row)
+    # evaluate every row of the list2
+    list.each do |r|
+      if r[:id] == row[:id]
+        r[:weight] = -300
+      else
+        val = 0
+        s = row[:data].count
+        s.times do |i|
+          val += calculate_nearness_between_texts(row[:data][i], r[:data][i])
+        end
+        val /= s
+        r[:weight] = val
+      end
+    end
+    list.sort! { |a, b| a[:weight] <=> b[:weight] }
+    list.reverse!
+  end
+end

data/lib/asker/ai/concept_ai.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../lang/lang'
+require_relative 'ai'
+require_relative 'question'
+
+# ConceptAI: Add more info to every Concept instance.
+#            Encapsulating AI data => questions
+# * concept
+# * questions
+# * num
+# * random_image_for
+class ConceptAI
+  include AI
+
+  attr_reader :concept
+  attr_reader :questions
+  attr_reader :excluded_questions
+
+  def initialize(concept, world)
+    @concept = concept
+    @world = world
+    @questions = { d: [], b: [], f: [], i: [], s: [], t: [] }
+    @excluded_questions = { d: [], b: [], f: [], i: [], s: [], t: [] }
+    @num = 0 # Used to add a unique number to every question
+  end
+
+  def num
+    @num += 1
+    @num.to_s
+  end
+
+  # If a method call is missing, then delegate to concept parent.
+  def method_missing(method, *args, &block)
+    @concept.send(method, *args, &block)
+  end
+
+  def random_image_for(_conceptname)
+    return '' if rand <= Project.instance.get(:threshold)
+
+    keys = @world.image_urls.keys
+    keys.shuffle!
+    values = @world.image_urls[keys[0]] # keys[0] could be conceptname
+    return '' if values.nil?
+
+    values.shuffle!
+    "<img src=\"#{values[0]}\" alt\=\"image\"><br/>"
+  end
+end

data/lib/asker/ai/question.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+require 'set'
+
+# Define Question class
+class Question
+  attr_accessor :name, :comment, :text
+  attr_accessor :good, :bads, :matching, :shorts
+  attr_accessor :feedback
+  attr_reader   :type
+  attr_accessor :tags, :lang
+
+  def initialize(type = :choice)
+    reset(type)
+  end
+
+  def reset(type = :choice)
+    @name = ''
+    @comment = ''
+    @text = ''
+    @type = type
+    @good = ''
+    @bads = []
+    @matching = []
+    @shorts = []
+    @feedback = nil
+    shuffle_on
+    @tags = Set.new
+    @lang = nil
+  end
+
+  def set_choice
+    @type = :choice
+  end
+
+  def set_match
+    @type = :match
+  end
+
+  def set_boolean
+    @type = :boolean
+  end
+
+  def set_short
+    @type = :short
+  end
+
+  def shuffle_off
+    @shuffle = false
+  end
+
+  def shuffle_on
+    @shuffle = true
+  end
+
+  def shuffle?
+    @shuffle
+  end
+end

data/lib/asker/ai/stages/base_stage.rb

@@ -0,0 +1,16 @@
+
+class BaseStage
+  def initialize(concept_ai)
+    @concept_ai = concept_ai
+  end
+
+  # If a method we call is missing, pass the call onto
+  # the object we delegate to.
+  def method_missing(m, *args, &block)
+    @concept_ai.send(m, *args, &block)
+  end
+
+  def run
+    raise 'Implement run method!'
+  end
+end

data/lib/asker/ai/stages/main.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'stage_d'
+require_relative 'stage_b'
+require_relative 'stage_f'
+require_relative 'stage_i'
+require_relative 'stage_s'
+require_relative 'stage_t'

data/lib/asker/ai/stages/stage_b.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+require 'set'
+
+require_relative 'base_stage'
+require_relative '../question'
+
+class StageB < BaseStage
+  # range b1
+
+  def run(pTable, pList1, pList2)
+    # process table match
+    questions = []
+    return questions if pTable.fields.count < 2
+
+    return questions unless type == 'text'
+
+    if pTable.fields.count>1 then
+      questions += process_table_match2fields(pTable, pList1, pList2, 0, 1)
+    elsif pTable.fields.count>2 then
+      questions += process_table_match2fields(pTable, pList1, pList2, 0, 2)
+      questions += process_table_match2fields(pTable, pList1, pList2, 1, 2)
+    elsif pTable.fields.count>3 then
+      questions += process_table_match2fields(pTable, pList1, pList2, 0, 3)
+      questions += process_table_match2fields(pTable, pList1, pList2, 1, 3)
+      questions += process_table_match2fields(pTable, pList1, pList2, 2, 3)
+    end
+
+    questions
+  end
+
+  def process_table_match2fields(pTable, pList1, pList2, pIndex1, pIndex2)
+    questions = []
+
+    if pList1.count>3
+      pList1.each_cons(4) do |e1,e2,e3,e4|
+        e = [ e1, e2, e3, e4 ]
+
+        #Question type <b1match>: match 4 items from the same table
+        e.shuffle!
+        q=Question.new(:match)
+        q.name="#{name}-#{num.to_s}-b1match4x4-#{pTable.name}"
+        q.text= random_image_for(name) + lang.text_for(:b1, name, pTable.fields[pIndex1].capitalize, pTable.fields[pIndex2].capitalize )
+        q.matching << [ e[0][:data][pIndex1], e[0][:data][pIndex2] ]
+        q.matching << [ e[1][:data][pIndex1], e[1][:data][pIndex2] ]
+        q.matching << [ e[2][:data][pIndex1], e[2][:data][pIndex2] ]
+        q.matching << [ e[3][:data][pIndex1], e[3][:data][pIndex2] ]
+        questions << q
+
+        # Question type <b1match>: match 3 items from table-A and 1 item with error
+        e.shuffle!
+        q=Question.new(:match)
+        q.name="#{name}-#{num.to_s}-b1match3x1misspelled-#{pTable.name}"
+        q.text= random_image_for(name) + lang.text_for(:b1, name, pTable.fields[pIndex1].capitalize, pTable.fields[pIndex2].capitalize )
+        q.matching << [ e[0][:data][pIndex1], e[0][:data][pIndex2] ]
+        q.matching << [ e[1][:data][pIndex1], e[1][:data][pIndex2] ]
+        q.matching << [ e[2][:data][pIndex1], e[2][:data][pIndex2] ]
+        q.matching << [ lang.do_mistake_to(e[3][:data][pIndex1]), lang.text_for(:misspelling) ]
+        questions << q
+      end
+    end
+
+    if pList1.count>2 and pList2.count>0
+      s=Set.new
+      pList1.each do |i|
+        s.add( i[:data][pIndex1]+"<=>"+i[:data][pIndex2] )
+      end
+      s.add( pList2[0][:data][pIndex1]+"<=>"+pList2[0][:data][pIndex2] )
+      a=s.to_a
+
+      # Question 3 items from table-A, and 1 item from table-B
+      if s.count > 3
+        q=Question.new(:match)
+        q.name="#{name}-#{num.to_s}-b1match3x1-#{pTable.name}"
+        q.text= random_image_for(name) + lang.text_for(:b1, name , pTable.fields[pIndex1].capitalize, pTable.fields[pIndex2].capitalize)
+        q.matching << [ pList1[0][:data][pIndex1], pList1[0][:data][pIndex2] ]
+        q.matching << [ pList1[1][:data][pIndex1], pList1[1][:data][pIndex2] ]
+        q.matching << [ pList1[2][:data][pIndex1], pList1[2][:data][pIndex2] ]
+        q.matching << [ pList2[0][:data][pIndex1], lang.text_for(:error) ]
+        questions << q
+      end
+    end
+
+    return questions
+  end
+
+end

data/lib/asker/ai/stages/stage_d.rb

@@ -0,0 +1,160 @@
+# encoding: utf-8
+
+require 'set'
+
+require_relative 'base_stage'
+require_relative '../question'
+
+class StageD < BaseStage
+  # range d1-d4
+
+  def run
+    # Stage D: process every definition, I mean every <def> tag
+    questions = []
+    return questions unless type == 'text'
+
+    # for every <text> do this
+    texts.each do |t|
+      s=Set.new [name(:raw), lang.text_for(:none)]
+      neighbors.each { |n| s.add n[:concept].name(:decorated) }
+      a=s.to_a
+
+      # Question choose between 4 options
+      if s.count > 3
+        q=Question.new(:choice)
+        q.name="#{name(:id)}-#{num}-d1choose"
+        q.text=random_image_for(name(:raw)) + lang.text_for(:d1,t)
+        q.good=name(:raw)
+        q.bads << lang.text_for(:none)
+        q.bads << a[2]
+        q.bads << a[3]
+        questions << q
+      end
+
+      #Question choose between 4 options, good none (Syntax error)
+      if s.count>3 and type=="text" then
+        q=Question.new(:choice)
+        q.name="#{name(:id)}-#{num}-d1none-misspelled"
+        q.text=random_image_for(name(:raw)) + lang.text_for(:d1,t)
+        q.good = lang.text_for(:none)
+        q.bads << lang.do_mistake_to(name(:raw))
+        q.bads << a[2]
+        q.bads << a[3]
+        q.feedback="Option misspelled!: #{name(:raw)}"
+        questions << q
+      end
+
+      s.delete(name(:raw))
+      a=s.to_a
+
+      #Question choose between 4 options, good none
+      if s.count>3 then
+        q = Question.new(:choice)
+        q.name="#{name(:id)}-#{num}-d1none"
+        q.text=random_image_for(name(:raw)) + lang.text_for(:d1,t)
+        q.good=lang.text_for(:none)
+        q.bads << a[1]
+        q.bads << a[2]
+        q.bads << a[3]
+        questions << q
+      end
+
+      #Question boolean => TRUE
+      #q = Question.new(:boolean)
+      #q.name="#{name}-#{num}-d2true"
+      #q.text=random_image_for(name) + lang.text_for(:d2,name,t)
+      #q.good="TRUE"
+      #questions << q
+
+      q = Question.new(:choice)
+      q.name="#{name(:id)}-#{num}-d2def-mispelled"
+      q.text=random_image_for(name(:raw)) + lang.text_for(:d2,name(:decorated), lang.do_mistake_to(t) )
+      q.good=lang.text_for(:misspelling)
+      q.bads << lang.text_for(:true)
+      q.bads << lang.text_for(:false)
+      q.feedback="Definition text mispelled!: #{t}"
+      questions << q
+
+      if type=="text"
+        q = Question.new(:choice)
+        q.name="#{name(:id)}-#{num}-d2name-mispelled"
+        q.text=random_image_for(name(:raw)) + lang.text_for(:d2, lang.do_mistake_to(name(:raw)), t)
+        q.good=lang.text_for(:misspelling)
+        q.bads << lang.text_for(:true)
+        q.bads << lang.text_for(:false)
+        q.feedback="Concept name mispelled!: #{name(:raw)}"
+        questions << q
+      end
+
+      q = Question.new(:choice)
+      q.name="#{name(:id)}-#{num}-d2true"
+      q.text=random_image_for(name(:raw)) + lang.text_for(:d2, name(:raw), t )
+      q.good =  lang.text_for(:true)
+      q.bads << lang.text_for(:misspelling)
+      q.bads << lang.text_for(:false)
+      questions << q
+
+      if a.size>1 then
+        q = Question.new(:choice)
+        q.name="#{name(:id)}-#{num}-d2false-misspelled"
+        q.text=random_image_for(name(:raw)) + lang.text_for(:d2, a[1], t)
+        q.good =  lang.text_for(:false)
+        q.bads << lang.text_for(:misspelling)
+        q.bads << lang.text_for(:true)
+        questions << q
+      end
+
+      #Question type <a4desc>: boolean => FALSE
+      #if neighbors.count>0 then
+      #  q = Question.new(:boolean)
+      #  q.name="#{name}-#{num}-d2false"
+      #  q.text=random_image_for(name) + lang.text_for(:d2, neighbors[0][:concept].name, t)
+      #  q.good="FALSE"
+      #  questions << q
+      #end
+
+      if type=="text"
+        #Question hidden name questions
+        q = Question.new(:short)
+        q.name="#{name(:id)}-#{num}-d3hidden"
+        q.text=random_image_for(name(:raw)) + lang.text_for(:d3, lang.hide_text(name(:raw)), t )
+        q.shorts << name(:raw)
+        q.shorts << name(:raw).gsub("-"," ").gsub("_"," ")
+        names.each do |n|
+          q.shorts << n if n!=name
+        end
+        questions << q
+      end
+
+#      indexes = []
+#      exclude = ["[", "]", "(", ")", "\"" ]
+#      filtered[:words].each_with_index do |item,index|
+#        flag=true
+#        exclude.each { |e| flag=false if (item[:word].include?(e)) }
+#        indexes << index if flag
+#      end
+
+      #Question filtered text questions
+      filtered=lang.text_with_connectors(t)
+      indexes = filtered[:indexes]
+
+      groups = (indexes.combination(4).to_a).shuffle
+      max    = (indexes.size/4).to_i
+      groups[0,max].each do |e|
+        e.sort!
+        q = Question.new(:match)
+        q.shuffle_off
+        q.name = "#{name}-#{num}-d4filtered"
+        s = lang.build_text_from_filtered( filtered, e)
+        q.text = random_image_for(name(:raw)) + lang.text_for(:d4, name(:raw) , s)
+        e.each_with_index do |value,index|
+          q.matching << [ (index+1).to_s, filtered[:words][value][:word].downcase ]
+        end
+        questions << q
+      end
+    end
+
+    return questions
+  end
+
+end