asker-tool 2.1.5 → 2.2.1

data/lib/asker/ai/question.rb

@@ -1,18 +1,31 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 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
+  attr_accessor :name     # Question name used as identification
+  attr_accessor :comment  # Comments asociated
+  attr_accessor :text     # The real text of the question
+  attr_accessor :good     # The correct answer
+  attr_accessor :bads     # Bads answers used by choice type question
+  attr_accessor :matching # Matching answers used by match type question
+  attr_accessor :shorts   # Short answers used by short type question
+  attr_accessor :feedback # Question feedbak
+  attr_reader   :type     # Question type: :choice, :match, :boolean, :short
+  attr_accessor :tags
+  attr_accessor :lang     # Info used when export (YAML)
+  attr_accessor :encode   # image base64 content used when export Moodle xml
 
+  # Initialize object
+  # @param type (Symbol) Question type: choice, match, boolean, short
   def initialize(type = :choice)
     reset(type)
   end
 
+  # Reset attributes
+  # @param type (Symbol) Question type: choice, match, boolean, short
+  # rubocop:disable Metrics/MethodLength
   def reset(type = :choice)
     @name = ''
     @comment = ''
@@ -26,32 +39,41 @@ class Question
     shuffle_on
     @tags = Set.new
     @lang = nil
+    @encode = :none
   end
+  # rubocop:enable Metrics/MethodLength
 
+  # Set choice type
   def set_choice
     @type = :choice
   end
 
+  # Set match type
   def set_match
     @type = :match
   end
 
+  # Set boolean type
   def set_boolean
     @type = :boolean
   end
 
+  # Set short type
   def set_short
     @type = :short
   end
 
+  # Set shuffle off
   def shuffle_off
     @shuffle = false
   end
 
+  # Set shuffle on
   def shuffle_on
     @shuffle = true
   end
 
+  # Return shuffle value
   def shuffle?
     @shuffle
   end

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

@@ -1,16 +1,55 @@
+# frozen_string_literal: true
 
+# Base Stage class
 class BaseStage
+  #
+  # Initialize Stage with ConceptAI
+  # @param concept_ai (ConceptAI)
   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
+
+  def concept
+    @concept_ai.concept
+  end
+
+  def name(option = :raw)
+    @concept_ai.concept.name(option)
+  end
+
+  def names
+    raise 'Change names by concept.names'
+  end
+
+  def num
+    @concept_ai.num
+  end
+
+  def lang
+    raise 'Change lang by concept.lang'
+  end
+
+  def type
+    raise 'Change type by concept.type'
+  end
+
+  def texts
+    raise 'Change texts by cocept.texts'
+  end
+
+  def images
+    raise 'Change images by cocept.images'
+  end
+
+  def neighbors
+    raise 'Change neighbors by concept.neighbors'
+  end
+
+  def random_image_for(option)
+    @concept_ai.random_image_for(option)
+  end
 end

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

@@ -1,87 +1,137 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'set'
 
 require_relative 'base_stage'
 require_relative '../question'
 
+##
+# range b1
 class StageB < BaseStage
-  # range b1
-
-  def run(pTable, pList1, pList2)
-    # process table match
+  ##
+  # Process table data to generate match questions
+  # @param table (Table)
+  # @param list1 (Array) Rows that belong to this table
+  # @param list2 (Array) List with similar rows (same table name) from the neighbours tables
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/MethodLength
+  def run(table, list1, list2)
     questions = []
-    return questions if pTable.fields.count < 2
+    return questions if table.fields.count < 2
 
-    return questions unless type == 'text'
+    return questions unless concept.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)
+    if table.fields.count == 2
+      questions += process_table_match2fields(table, list1, list2, 0, 1)
+    elsif table.fields.count == 3
+      questions += process_table_match2fields(table, list1, list2, 0, 1)
+      questions += process_table_match2fields(table, list1, list2, 0, 2)
+    elsif table.fields.count == 4
+      questions += process_table_match2fields(table, list1, list2, 0, 1)
+      questions += process_table_match2fields(table, list1, list2, 0, 2)
+      questions += process_table_match2fields(table, list1, list2, 0, 3)
     end
 
     questions
   end
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/MethodLength
 
-  def process_table_match2fields(pTable, pList1, pList2, pIndex1, pIndex2)
+  ##
+  # Process table data to generate match questions
+  # @param p_table (Table)
+  # @param list1 (Array) Rows that belong to this table
+  # @param list2 (Array) List with similar rows (same table name) from the neighbours tables
+  # @param index1 (Integer) Use this field number
+  # @param index2 (Integer) Use this field number
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/CyclomaticComplexity
+  # rubocop:disable Style/ConditionalAssignment
+  # rubocop:disable Metrics/BlockLength
+  # rubocop:disable Metrics/PerceivedComplexity
+  def process_table_match2fields(p_table, list1, list2, index1, index2)
     questions = []
+    lang = concept.lang
 
-    if pList1.count>3
-      pList1.each_cons(4) do |e1,e2,e3,e4|
-        e = [ e1, e2, e3, e4 ]
+    if list1.count > 3
+      list1.each_cons(4) do |e1, e2, e3, e4|
+        e = [e1, e2, e3, e4]
 
-        #Question type <b1match>: match 4 items from the same table
+        # 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] ]
+        q = Question.new(:match)
+        q.name = "#{name}-#{num}-b1match4x4-#{p_table.name}"
+        q.tags << 'match'
+        q.tags << 'random'
+        q.text = random_image_for(name) \
+                 + lang.text_for(:b1, name, p_table.fields[index1].capitalize, p_table.fields[index2].capitalize)
+        q.matching << [e[0][:data][index1], e[0][:data][index2]]
+        q.matching << [e[1][:data][index1], e[1][:data][index2]]
+        q.matching << [e[2][:data][index1], e[2][:data][index2]]
+        q.matching << [e[3][:data][index1], e[3][:data][index2]]
+        # Add an extra line
+        if list2.count.positive?
+          q.matching << ['', list2[0][:data][index2]]
+        else
+          q.tags << 'misspell'
+          q.matching << ['', lang.do_mistake_to(e[0][:data][index2])]
+        end
         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) ]
+        q = Question.new(:match)
+        q.name = "#{name}-#{num}-b1match3x1misspelled-#{p_table.name}"
+        q.tags << 'match'
+        q.tags << 'random'
+        q.text = random_image_for(name) \
+                 + lang.text_for(:b1, name, p_table.fields[index1].capitalize, p_table.fields[index2].capitalize)
+        q.matching << [e[0][:data][index1], e[0][:data][index2]]
+        q.matching << [e[1][:data][index1], e[1][:data][index2]]
+        q.matching << [e[2][:data][index1], e[2][:data][index2]]
+        q.matching << [lang.do_mistake_to(e[3][:data][index1]), lang.text_for(:misspelling)]
+        # Add an extra line
+        if list2.count.positive?
+          q.matching << ['', list2[0][:data][index2]]
+        else
+          q.tags << 'misspell'
+          q.matching << ['', lang.do_mistake_to(e[0][:data][index2])]
+        end
         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] )
+    if list1.count > 2 && list2.count.positive?
+      s = Set.new
+      list1.each do |i|
+        s.add(i[:data][index1] + '<=>' + i[:data][index2])
       end
-      s.add( pList2[0][:data][pIndex1]+"<=>"+pList2[0][:data][pIndex2] )
-      a=s.to_a
+      s.add(list2[0][:data][index1] + '<=>' + list2[0][:data][index2])
 
       # 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) ]
+        q = Question.new(:match)
+        q.name = "#{name}-#{num}-b1match3x1-#{p_table.name}"
+        q.tags << 'match'
+        q.tags << 'random'
+        q.text = random_image_for(name) \
+                 + lang.text_for(:b1, name, p_table.fields[index1].capitalize, p_table.fields[index2].capitalize)
+        q.matching << [list1[0][:data][index1], list1[0][:data][index2]]
+        q.matching << [list1[1][:data][index1], list1[1][:data][index2]]
+        q.matching << [list1[2][:data][index1], list1[2][:data][index2]]
+        q.matching << [list2[0][:data][index1], lang.text_for(:error)]
+        q.matching << ['', lang.do_mistake_to(list1[0][:data][index2])]
         questions << q
       end
     end
 
-    return questions
+    questions
   end
-
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/CyclomaticComplexity
+  # rubocop:enable Style/ConditionalAssignment
+  # rubocop:enable Metrics/BlockLength
+  # rubocop:enable Metrics/PerceivedComplexity
 end

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

@@ -1,160 +1,145 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'set'
 
 require_relative 'base_stage'
 require_relative '../question'
 
+# range d1-d4
 class StageD < BaseStage
-  # range d1-d4
-
+  # rubocop:disable Lint/BooleanSymbol
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/BlockLength
+  # rubocop:disable Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/PerceivedComplexity
   def run
     # Stage D: process every definition, I mean every <def> tag
     questions = []
-    return questions unless type == 'text'
+    return questions unless concept.type == 'text'
 
+    lang = concept.lang
     # 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
+    concept.texts.each do |t|
+      s = Set.new [name(:raw), lang.text_for(:none)]
+      concept.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 = 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)
+      # Question choose between 4 options, good none (Syntax error)
+      if s.count > 3
+        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)}"
+        q.feedback = "Option misspelled!: #{name(:raw)}"
         questions << q
       end
 
       s.delete(name(:raw))
-      a=s.to_a
+      a = s.to_a
 
-      #Question choose between 4 options, good none
-      if s.count>3 then
+      # Question choose between 4 options, good none
+      if s.count > 3
         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.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
-
+      # Question choice => mispelled
       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.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}"
+      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
+      # Question choice => name mispelled
+      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
 
+      # Question choice => true
       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.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
+      # Question choice => false
+      if a.size > 1
         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.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 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('_', ' ')
+      concept.names.each { |n| q.shorts << n if n != name }
+      questions << q
 
-      #Question filtered text questions
-      filtered=lang.text_with_connectors(t)
+      # 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|
+      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 ]
+        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
+    questions
   end
-
+  # rubocop:enable Lint/BooleanSymbol
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/BlockLength
+  # rubocop:enable Metrics/CyclomaticComplexity
+  # rubocop:enable Metrics/PerceivedComplexity
 end