asker-tool 2.1.7 → 2.2.0

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

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

@@ -1,13 +1,20 @@
+# frozen_string_literal: true
 
 require_relative 'base_stage'
 require_relative '../question'
 
 # StageF: process tables with 1 field
+# rubocop:disable Metrics/ClassLength
 class StageF < BaseStage
+  ##
+  # run stage_f: generate guqestion for tables with 1 field
+  # @param table (Table)
+  # @param list1 (Array) List of Rows from this table
+  # @param list2 (Array) List of Row from other tables
   def run(table, list1, list2)
     # process_table1field
     questions = []
-    return questions if table.fields.count>1
+    return questions if table.fields.count > 1
 
     questions += run_only_this_concept(table, list1)
     questions += run_with_other_concepts(table, list1, list2)
@@ -15,29 +22,32 @@ class StageF < BaseStage
     questions
   end
 
-private
+  private
 
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/MethodLength
   def run_only_this_concept(table, list1)
     questions = []
-    s1 = Set.new #Set of rows from this concept
+    lang = concept.lang
+    s1 = Set.new # Set of rows from this concept
     list1.each { |item| s1 << item[:data][0] }
     a1 = s1.to_a
     a1.shuffle!
 
     if a1.size > 3
-      a1.each_cons(4) do |e1,e2,e3,e4|
-        e = [ e1, e2, e3, e4 ]
+      a1.each_cons(4) do |e1, e2, e3, e4|
+        e = [e1, e2, e3, e4]
         questions += make_questions_with(e, table)
 
-        #Question filtered text
-        e = [ e1, e2, e3, e4 ]
+        # Question filtered text
+        e = [e1, e2, e3, e4]
         e.shuffle!
         t = "(a) #{e[0]}, (b) #{e[1]}, (c) #{e[2]}, (d) #{e[3]}"
-        filtered=lang.text_with_connectors(t)
+        filtered = lang.text_with_connectors(t)
         indexes = filtered[:indexes]
 
-        groups = (indexes.combination(4).to_a).shuffle
-        max    = (indexes.size/4).to_i
+        groups = indexes.combination(4).to_a.shuffle
+        max    = (indexes.size / 4).to_i
         groups[0, max].each do |i|
           i.sort!
           q = Question.new(:match)
@@ -46,9 +56,10 @@ private
           s = lang.build_text_from_filtered(filtered, i)
           q.text = random_image_for(name(:raw))
           q.text += lang.text_for(:f3, name(:decorated), table.fields[0].capitalize, s)
-          i.each_with_index do |value,index|
+          i.each_with_index do |value, index|
             q.matching << [(index + 1).to_s, filtered[:words][value][:word].downcase]
           end
+          q.matching << ['', lang.do_mistake_to(filtered[:words][rand(filtered[:words].size)][:word].downcase)]
           questions << q
         end
       end
@@ -58,59 +69,72 @@ private
     end
     questions
   end
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/MethodLength
 
-  def make_questions_with(e, table)
+  # rubocop:disable Lint/BooleanSymbol
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  def make_questions_with(values, table)
     questions = []
+    lang = concept.lang
 
-    e.shuffle!
+    values.shuffle!
     q = Question.new(:choice)
-    q.name = "#{name(:id)}-#{num}-f1true#{e.size}-#{table.name}"
+    q.name = "#{name(:id)}-#{num}-f1true#{values.size}-#{table.name}"
     q.text = random_image_for(name(:raw))
-    q.text += lang.text_for(:f1, name(:decorated), table.fields[0].capitalize, e.join('</li><li>'))
+    q.text += lang.text_for(:f1, name(:decorated), table.fields[0].capitalize, values.join('</li><li>'))
     q.good =  lang.text_for(:true)
     q.bads << lang.text_for(:misspelling)
     q.bads << lang.text_for(:false)
 
-    if type == 'text'
-      e.shuffle!
+    if concept.type == 'text'
+      values.shuffle!
       q = Question.new(:short)
-      q.name = "#{name(:id)}-#{num}-f1short#{e.size}-#{table.name}"
+      q.name = "#{name(:id)}-#{num}-f1short#{values.size}-#{table.name}"
       q.text = random_image_for(name(:raw))
-      q.text += lang.text_for(:f1, lang.hide_text(name(:raw)), table.fields[0].capitalize, e.join('</li><li>'))
+      q.text += lang.text_for(:f1, lang.hide_text(name(:raw)), table.fields[0].capitalize, values.join('</li><li>'))
       q.shorts << name(:raw)
       q.shorts << name(:raw).tr('-_', ' ')
       questions << q
 
-      e.shuffle!
-      save = e[0]
-      e[0] = lang.do_mistake_to(e[0])
+      values.shuffle!
+      save = values[0]
+      values[0] = lang.do_mistake_to(values[0])
       q = Question.new(:choice)
-      q.name = "#{name(:id)}-#{num}-f1name-misspelled#{e.size}-#{table.name}"
+      q.name = "#{name(:id)}-#{num}-f1name-misspelled#{values.size}-#{table.name}"
       q.text = random_image_for(name(:raw))
-      q.text += lang.text_for(:f1, lang.do_mistake_to(name(:decorated)), table.fields[0].capitalize, e.join('</li><li>'))
+      q.text += lang.text_for(:f1, lang.do_mistake_to(name(:decorated)), \
+                              table.fields[0].capitalize, values.join('</li><li>'))
       q.good =  lang.text_for(:misspelling)
       q.bads << lang.text_for(:true)
       q.bads << lang.text_for(:false)
       q.feedback = "Concept name #{name(:raw)} misspelled!"
-      e[0] = save
+      values[0] = save
       questions << q
     end
 
-    e.shuffle!
-    save = e[0]
-    e[0] = lang.do_mistake_to(e[0])
+    values.shuffle!
+    save = values[0]
+    values[0] = lang.do_mistake_to(values[0])
     q = Question.new(:choice)
-    q.name = "#{name(:id)}-#{num}-f1true-misspelled#{e.size}-#{table.name}"
+    q.name = "#{name(:id)}-#{num}-f1true-misspelled#{values.size}-#{table.name}"
     q.text = random_image_for(name(:raw))
-    q.text += lang.text_for(:f1, name(:decorated), table.fields[0].capitalize, e.join('</li><li>'))
+    q.text += lang.text_for(:f1, name(:decorated), table.fields[0].capitalize, values.join('</li><li>'))
     q.good =  lang.text_for(:misspelling)
     q.bads << lang.text_for(:true)
     q.bads << lang.text_for(:false)
     q.feedback = "Text #{save} mispelled!"
-    e[0] = save
+    values[0] = save
     questions << q
   end
+  # rubocop:enable Lint/BooleanSymbol
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
 
+  # rubocop:disable Lint/BooleanSymbol
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
   def run_with_other_concepts(table, list1, list2)
     questions = []
 
@@ -133,17 +157,17 @@ private
       q = Question.new(:choice)
       q.name = "#{name(:id)}-#{num}-f1false-#{table.name}"
       q.text = random_image_for(name(:raw))
-      q.text += lang.text_for(:f1, name(:decorated), table.fields[0].capitalize, e.join('</li><li>'))
-      q.good =  lang.text_for(:false)
-      q.bads << lang.text_for(:misspelling)
-      q.bads << lang.text_for(:true)
+      q.text += concept.lang.text_for(:f1, name(:decorated), table.fields[0].capitalize, e.join('</li><li>'))
+      q.good =  concept.lang.text_for(:false)
+      q.bads << concept.lang.text_for(:misspelling)
+      q.bads << concept.lang.text_for(:true)
       questions << q
 
       f4 = a2.shuffle![0]
       q = Question.new(:choice)
       q.name = "#{name(:id)}-#{num}-f2outsider-#{table.name}"
       q.text = random_image_for(name(:raw))
-      q.text += lang.text_for(:f2, name(:decorated), table.fields[0].capitalize)
+      q.text += concept.lang.text_for(:f2, name(:decorated), table.fields[0].capitalize)
       q.good =  f4
       q.bads << e1
       q.bads << e2
@@ -153,4 +177,8 @@ private
 
     questions
   end
+  # rubocop:enable Lint/BooleanSymbol
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
 end
+# rubocop:enable Metrics/ClassLength

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

@@ -1,42 +1,49 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'base64_compatible' # TODO: Don't work with Moodle Gift images
 require 'set'
 
 require_relative 'base_stage'
 require_relative '../question'
 
+# range i1, i2, i3, i4
 class StageI < BaseStage
-  # range i1, i2, i3
-
+  # Stage I: process every image from <def> tag
+  # rubocop:disable Metrics/BlockLength
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/PerceivedComplexity
   def run
-    # Stage I: process every image from <def> tag
-    questions=[]
-    return questions unless type=="text"
+    questions = []
+    return questions unless concept.type == 'text'
 
+    lang = concept.lang
     # for every <image> do this
-    images.each do |url|
-      s=Set.new [name, lang.text_for(:none)]
-      neighbors.each { |n| s.add n[:concept].name }
-      a=s.to_a
-
-      # Question type <f1>: choose between 4 options
-      if s.count>3 then
-        q=Question.new(:choice)
-        q.name="#{name}-#{num}-i1choice"
-        q.text=lang.text_for(:i1, url )
-        q.good=name
+    concept.images.each do |image|
+      url = image[:text]
+      s = Set.new [name, lang.text_for(:none)]
+      concept.neighbors.each { |n| s.add n[:concept].name }
+      a = s.to_a
+
+      # Question type <i1>: choose between 4 options
+      if s.count > 3
+        q = Question.new(:choice)
+        q.name = "#{name}-#{num}-i1choice"
+        q.text = lang.text_for(:i1, url)
+        q.encode = image[:file]
+        q.good = name
         q.bads << lang.text_for(:none)
         q.bads << a[2]
         q.bads << a[3]
         questions << q
       end
 
-      #Question type <i1>: choose between 4 options, good none (Syntax error)
-      if s.count>3 then
-        q=Question.new(:choice)
-        q.name="#{name}-#{num}-i1misspelling"
-        q.text=lang.text_for(:i1, url )
+      # Question type <i1>: choose between 4 options, good none (Syntax error)
+      if s.count > 3
+        q = Question.new(:choice)
+        q.name = "#{name}-#{num}-i1misspelling"
+        q.text = lang.text_for(:i1, url)
+        q.encode = image[:file]
         q.good = lang.text_for(:none)
         q.bads << lang.do_mistake_to(name)
         q.bads << a[2]
@@ -45,96 +52,76 @@ class StageI < BaseStage
       end
 
       s.delete(name)
-      a=s.to_a
+      a = s.to_a
 
-      #Question type <i1>: choose between 4 options, good none
-      if s.count>3 then
+      # Question type <i1>: choose between 4 options, good none
+      if s.count > 3
         q = Question.new(:choice)
-        q.name="#{name}-#{num}-i1none"
-        q.text=lang.text_for(:i1, url )
-        q.good=lang.text_for(:none)
+        q.name = "#{name}-#{num}-i1none"
+        q.text = lang.text_for(:i1, url)
+        q.encode = image[:file]
+        q.good = lang.text_for(:none)
         q.bads << a[1]
         q.bads << a[2]
         q.bads << a[3]
         questions << q
       end
 
-      #Question type <f2>: boolean => TRUE
+      # Question type <i2>: boolean => TRUE
       q = Question.new(:boolean)
-      q.name="#{name}-#{num}-i2true"
-      q.text=lang.text_for(:i2, url, name )
-      q.good="TRUE"
+      q.name = "#{name}-#{num}-i2true"
+      q.text = lang.text_for(:i2, url, name)
+      q.encode = image[:file]
+      q.good = 'TRUE'
       questions << q
 
-      #Question type <i2>: boolean => FALSE
-      if neighbors.count>0 then
+      # Question type <i2>: boolean => FALSE
+      if concept.neighbors.count.positive?
         q = Question.new(:boolean)
-        q.name="#{name}-#{num}-i2false"
-        q.text=lang.text_for(:i2, url, neighbors[0][:concept].name )
-        q.good="FALSE"
+        q.name = "#{name}-#{num}-i2false"
+        q.text = lang.text_for(:i2, url, concept.neighbors[0][:concept].name)
+        q.encode = image[:file]
+        q.good = 'FALSE'
         questions << q
       end
 
-      #Question type <i3>: hidden name questions
+      # Question type <i3>: hidden name questions
       q = Question.new(:short)
-      q.name="#{name}-#{num}-i3short"
-      q.text=lang.text_for(:i3, url, lang.hide_text(name) )
+      q.name = "#{name}-#{num}-i3short"
+      q.text = lang.text_for(:i3, url, lang.hide_text(name))
+      q.encode = image[:file]
       q.shorts << name
-      q.shorts << name.gsub("-"," ").gsub("_"," ")
+      q.shorts << name.gsub('-', ' ').gsub('_', ' ')
       questions << q
 
-      #Question filtered text questions
-      texts.each do |t|
-        filtered=lang.text_with_connectors(t)
-
-        if filtered[:words].size>=4 then
-#          indexes=Set.new
-#          words=filtered[:words]
-#          while indexes.size<4
-#            i=rand(filtered[:words].size)
-#            flag=true
-#            flag=false if words[i].include?("[") or words[i].include?("]") or words[i].include?("(") or words[i].include?(")") or words[i].include?("\"")
-#            indexes << i if flag
-#          end
-#          indexes=indexes.to_a.sort
-          indexes = filtered[:indexes]
-          groups = (indexes.combination(4).to_a).shuffle
-          max    = (indexes.size/4).to_i
-          groups[0,max].each do |e|
-            q = Question.new(:match)
-            q.shuffle_off
-            q.name = "#{name}-#{num}-i4filtered"
-            e.sort!
-            s=lang.build_text_from_filtered( filtered, e )
-            q.text = lang.text_for(:i4, url , s)
-            e.each_with_index do |value,index|
-              q.matching << [ (index+1).to_s, filtered[:words][value][:word].downcase ]
-            end
+      # Question filtered text questions
+      concept.texts.each do |t|
+        filtered = lang.text_with_connectors(t)
+        next if filtered[:words].size < 4
+
+        indexes = filtered[:indexes]
+        groups = indexes.combination(4).to_a.shuffle
+        max    = (indexes.size / 4).to_i
+        groups[0, max].each do |e|
+          q = Question.new(:match)
+          q.shuffle_off
+          q.name = "#{name}-#{num}-i4filtered"
+          q.encode = image[:file]
+          e.sort!
+          s = lang.build_text_from_filtered(filtered, e)
+          q.text = lang.text_for(:i4, url, s)
+          e.each_with_index do |value, index|
+            q.matching << [index.next.to_s, filtered[:words][value][:word].downcase]
           end
-          questions << q
         end
-      end #each texts
-    end #each images
-    return questions
-  end
-
-private
-
-  def html_for_raw_image(filename)
-    dirname = File.dirname(@concept_ia.filename)
-    filepath = File.join(dirname,filename)
-    content = File.open(filepath).read
-    content64 = Base64Compatible.encode64( content )
-    output =""
-    until(content64.nil?) do
-      output = output + content64[0,76]+"\n"
-      tmp = content64[76,9999999]
-      content64 = tmp
+        questions << q
+      end
     end
-
-    ext =  File.extname(filename)
-    output = "<img src='data:image/#{ext};base64,#{output}' />"
-    return output
+    questions
   end
-
+  # rubocop:enable Metrics/BlockLength
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/CyclomaticComplexity
+  # rubocop:enable Metrics/PerceivedComplexity
 end