asker-tool 2.6.0 → 2.7.1

data/lib/asker/formatter/question_moodle_formatter.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: false
 
-require 'erb'
-require_relative '../application'
+require "erb"
+require_relative "../application"
 
 # Transform Questions into Gift format
 class QuestionMoodleFormatter
@@ -12,20 +12,27 @@ class QuestionMoodleFormatter
   def self.to_s(question)
     case question.type
     when :choice
-      fractions = Application.instance.config['questions']['fractions']
+      fractions = Application.instance.config["questions"]["fractions"]
       penalties = fractions
       # penalties = ['', '-50', '-33.33333', '-25', '-20']
       # puts "[DEBUG] fractions : #{fractions}"
       # puts "[DEBUG] penalties : #{penalties}"
 
       penalty = penalties[question.bads.size]
-      template = File.read(File.join(File.dirname(__FILE__), 'moodle', 'multichoice.erb'))
+      template = File.read(File.join(File.dirname(__FILE__), "moodle", "multichoice.erb"))
     when :boolean
-      template = File.read(File.join(File.dirname(__FILE__), 'moodle', 'truefalse.erb'))
+      template = File.read(File.join(File.dirname(__FILE__), "moodle", "truefalse.erb"))
+    when :ddmatch
+      template = File.read(File.join(File.dirname(__FILE__), "moodle", "ddmatch.erb"))
     when :match
-      template = File.read(File.join(File.dirname(__FILE__), 'moodle', 'matching.erb'))
+      template = File.read(File.join(File.dirname(__FILE__), "moodle", "matching.erb"))
+    when :ordering
+      template = File.read(File.join(File.dirname(__FILE__), "moodle", "ordering.erb"))
     when :short
-      template = File.read(File.join(File.dirname(__FILE__), 'moodle', 'shortanswer.erb'))
+      template = File.read(File.join(File.dirname(__FILE__), "moodle", "shortanswer.erb"))
+    else
+      warn "[ERROR] QuestionMoodleFormatter: Unknown type (#{question.type})"
+      exit 1
     end
     renderer = ERB.new(template)
     renderer.result(binding)

data/lib/asker/formatter/rb2haml_formatter.rb

@@ -1,5 +1,7 @@
 # UNDER DEVELOPMENT!!
 
+require_relative "../logger"
+
 module Rb2HamlExporter
   def self.export(filename)
     check_file filename
@@ -8,19 +10,18 @@ module Rb2HamlExporter
   end
 
   def self.check_file(filename)
-    unless File.extname(filename).casecmp('.rb').zero?
-      msg = "[ERROR] Rb2HamlExporter: File name error #{filename}"
-      raise msg
+    unless File.extname(filename).casecmp(".rb").zero?
+      Logger.error "Rb2HamlExporter: File name error #{filename}"
+      exit 1
     end
     unless File.exist? filename
-      msg = "[ERROR] Rb2HamlExporter: File #{filename} not found!"
-      raise msg
+      Logger.error "Rb2HamlExporter: File #{filename} not found!"
+      exit 1
     end
   end
 
   class Map
   end
-
 end
 
-Rb2HamlExporter.export('docs/examples/home/rb/furniture.rb')
+Rb2HamlExporter.export("docs/examples/home/rb/furniture.rb")

data/lib/asker/lang/lang.rb

@@ -1,15 +1,15 @@
-
-require 'erb'
-require 'yaml'
-require_relative 'text_actions'
-require_relative '../logger'
+require "erb"
+require "yaml"
+require_relative "text_actions"
+require_relative "../logger"
 
 class Lang
   include TextActions
 
-  attr_reader :code, :mistakes
+  attr_reader :code
+  attr_reader :mistakes
 
-  def initialize(code = 'en')
+  def initialize(code = "en")
     @code = code.to_s
     load_files
   end
@@ -21,23 +21,23 @@ class Lang
   private
 
   def load_files
-    dirbase = File.join(File.dirname(__FILE__), '..', 'files', 'language')
-    filepath = File.join(dirbase, @code, 'templates.yaml')
+    dirbase = File.join(File.dirname(__FILE__), "..", "files", "language")
+    filepath = File.join(dirbase, @code, "templates.yaml")
     @templates = load_yaml_file(filepath)
-    filepath = File.join(dirbase, @code, 'connectors.yaml')
+    filepath = File.join(dirbase, @code, "connectors.yaml")
     @connectors = load_yaml_file(filepath)
-    filepath = File.join(dirbase, @code, 'mistakes.yaml')
+    filepath = File.join(dirbase, @code, "mistakes.yaml")
     @mistakes = load_yaml_file(filepath)
   end
 
   def load_yaml_file(filepath)
     begin
       content = YAML.load(File.new(filepath))
-    rescue StandardError => e
-      Logger.verboseln '[ERROR] Lang.initialize():' \
-                       " Reading YAML file <#{filepath}>"
-      Logger.verboseln '[ADVISE] Revise apostrophe into string without \ symbol'
-      raise e
+    rescue => e
+      Logger.error "Lang: YAML loading error (#{filepath})"
+      Logger.error "    : Revise apostrophe into string without \\ symbol"
+      Logger.error "    : #{e}"
+      exit 1
     end
     content
   end

data/lib/asker/lang/lang_factory.rb

@@ -1,27 +1,26 @@
 # frozen_string_literal: true
 
-require 'singleton'
-require_relative 'lang'
-require_relative '../application'
+require "singleton"
+require_relative "lang"
+require_relative "../application"
+require_relative "../logger"
 
 ##
-# LangFactory singleton class.
 # * Read all language codes defined into configuration file
 # * and load every language
 # Lang objects are reused
 class LangFactory
   include Singleton
 
-  ##
-  # Read all language codes from configuration file and load every language
   def initialize
-    @default = Application.instance.config['languages']['default'].downcase
+    # Read all language codes from configuration file and load every language
+    @default = Application.instance.config["languages"]["default"].downcase
     @langs = {}
-    Application.instance.config['languages'].each_pair do |key, value|
+    Application.instance.config["languages"].each_pair do |key, value|
       code = key.downcase
-      next if code == 'default'
+      next if code == "default"
 
-      @langs[code] = Lang.new(code) if value.downcase == 'yes'
+      @langs[code] = Lang.new(code) if value.downcase == "yes"
     end
   end
 
@@ -31,15 +30,13 @@ class LangFactory
   def get(code)
     return @langs[code] unless @langs[code].nil?
 
-    puts Rainbow("[ERROR] Unkown Lang code: #{code}").bright
-    puts Rainbow('        => Change input file code lang').bright
-    puts Rainbow('        => Revise configuration from config.ini').bright
-    puts Rainbow('        => Revise template files').bright
+    Logger.error "LangFactory: Unknown Lang with [code=#{code}]"
+    Logger.error "             (a) Revise input file code lang"
+    Logger.error "             (b) Revise asker.ini configuration"
+    Logger.error "             (c) Revise template files"
     exit 1
   end
 
-  ##
-  # Return default Lang object
   def default
     get(@default)
   end

data/lib/asker/lang/text_actions.rb

@@ -1,9 +1,10 @@
 # encoding: utf-8
 
-##
-# Set of functions used by Lang class
+require_relative "../logger"
+
 module TextActions
   ##
+  # Set of functions used by Lang class
   # Return text indicated by lang code...
   def text_for(option, *input)
     @_text1 = input[0] # FIXME: done to avoid linter complaints.
@@ -14,9 +15,10 @@ module TextActions
     @_text6 = input[5]
     @_text7 = input[6]
 
-    # Check if exists option before use it
-    raise "[ERROR] Unkown template #{option}" if @templates[option].nil?
-
+    if @templates[option].nil?
+      Logger.error "TextActions: Unknown template (#{option})"
+      exit 1
+    end
     renderer = ERB.new(@templates[option])
     renderer.result(binding)
   end
@@ -55,12 +57,12 @@ module TextActions
   # @param filter (Boolean) true => apply filter, false => dont filter
   # @return Array
   def text_filter_connectors(input, filter)
-    input_lines = input.split('.')
+    input_lines = input.split(".")
     output_lines = []
     output_words = []
     input_lines.each_with_index do |line, rowindex|
 	    row = []
-      line.split(' ').each_with_index do |word, colindex|
+      line.split(" ").each_with_index do |word, colindex|
         flag = @connectors.include? word.downcase
 
 	      # if <word> is a conector and <pFilter>==true Then Choose this <word>
@@ -72,7 +74,7 @@ module TextActions
           row << word
         end
       end
-      row << '.'
+      row << "."
       output_lines << row
     end
 
@@ -103,12 +105,12 @@ module TextActions
     lines = input_struct[:lines]
     indexes = input_indexes.sort
     counter = 1
-    text = ''
+    text = ""
 
     lines.each do |line|
       line.each do |value|
         if value.class == String
-          text += (' ' + value)
+          text += (" " + value)
         elsif value == value.to_i
           # INFO: ruby 2.4 unifies Fixnum and Bignum into Integer
           #       Avoid using deprecated classes.
@@ -117,14 +119,14 @@ module TextActions
             counter += 1
           else
             word = input_struct[:words][value][:word]
-            text += (' ' + word)
+            text += (" " + word)
           end
         end
       end
     end
-    text.gsub!(' .', '.')
-    text.gsub!(' ,', ',')
-    text = text[1, text.size] if text[0] == ' '
+    text.gsub!(" .", ".")
+    text.gsub!(" ,", ",")
+    text = text[1, text.size] if text[0] == " "
     text
   end
 
@@ -174,20 +176,20 @@ module TextActions
     end
     return text if text != input
 
-    text + 's'
+    text + "s"
   end
 
   def hide_text(input_text)
     input = input_text.clone
     if count_words(input) < 2 && input.size < 10
-      output = '[*]'
+      output = "[*]"
     else
-      output = ''
+      output = ""
       input.each_char do |char|
         if ' !|"@#$%&/()=?¿¡+*(){}[],.-_<>'.include? char
           output += char
         else
-          output += '?'
+          output += "?"
         end
       end
     end

data/lib/asker/loader/code_loader.rb

@@ -1,51 +1,39 @@
 # frozen_string_literal: true
 
-require 'rainbow'
-require 'rexml/document'
-require_relative '../logger'
-require_relative '../data/code'
+require "rexml/document"
+require_relative "../logger"
+require_relative "../data/code"
 
-# Read XML info about Code input data
 module CodeLoader
   ##
   # Load XML data about Code object
   # @param xmldata (XML Object)
   # @param filepath (String)
   # @return Code object
-  def self.load(xmldata, filepath)
+  def self.call(xmldata, filepath)
     data = read_codedata_from_xml(xmldata, File.basename(filepath))
     code = Code.new(File.dirname(filepath), data[:path], data[:type])
     code.features << data[:features]
     code
   end
 
-  ##
-  # Read Code data from XML content
-  # @param xmldata (XML Object)
-  # @param filename (String) File name that contains data
-  # @return Code object
   private_class_method def self.read_codedata_from_xml(xmldata, filename)
-    data = { path: '?', type: '?', features: [] }
+    data = {path: "?", type: "?", features: []}
     xmldata.elements.each do |i|
-      data[:path] = i.text if i.name == 'path'
-      data[:type] = i.text.to_sym if i.name == 'type'
-      data[:features] << read_features(i, filename) if i.name == 'features'
+      data[:path] = i.text if i.name == "path"
+      data[:type] = i.text.to_sym if i.name == "type"
+      data[:features] << read_features(i, filename) if i.name == "features"
     end
     data
   end
 
-  ##
-  # Read features data from XML input
-  # @param xmldata (XML object)
-  # @return Array with features (Strings)
   private_class_method def self.read_features(xmldata, filename)
     features = []
     xmldata.elements.each do |i|
-      if i.name == 'row'
+      if i.name == "row"
         features << i.text
       else
-        msg = Rainbow("[ERROR] features/#{i.name} from #{filename}").color(:red)
-        Logger.verboseln msg
+        Logger.error "CodeLoader: features/#{i.name} from #{filename}"
       end
     end
     features

data/lib/asker/loader/content_loader.rb

@@ -1,100 +1,93 @@
-require "rainbow"
 require "rexml/document"
 require_relative "code_loader"
+require_relative "problem_loader"
 require_relative "../data/concept"
 require_relative "../data/project_data"
+require_relative "../lang/lang_factory"
+require_relative "../logger"
 
-# Define methods that load data from XML contents
 module ContentLoader
   ##
   # Load XML content into Asker data objects
   # @param filepath (String) File path
   # @param content (String) XML plane text content
-  def self.load(filepath, content)
-    concepts = []
-    codes = []
+  def self.call(filepath, content)
     begin
       xmlcontent = REXML::Document.new(content)
     rescue REXML::ParseException
       raise_error_with(filepath, content)
     end
+    codes = []
+    concepts = []
+    problems = []
     lang = read_lang_attribute(xmlcontent)
     context = read_context_attribute(xmlcontent)
 
     xmlcontent.root.elements.each do |xmldata|
       case xmldata.name
-      when "concept"
-        concepts << read_concept(xmldata, filepath, lang, context)
       when "code"
         codes << read_code(xmldata, filepath)
+      when "concept"
+        concepts << read_concept(xmldata, filepath, lang, context)
+      when "problem"
+        problems << read_problem(xmldata, filepath, lang, context)
       else
-        puts Rainbow("[ERROR] Unkown tag: #{xmldata.name}").red
-        puts Rainbow("[INFO ] Only 'concept' and 'code' are available at this level").red
+        Logger.warn "ContentLoader: Unknown tag (#{xmldata.name}) Use concept, code or problem."
       end
     end
 
-    { concepts: concepts, codes: codes }
+    {concepts: concepts, codes: codes, problems: problems}
   end
 
-  ##
-  # Read lang attr from input XML data
-  # @param xmldata (XML Object)
   private_class_method def self.read_lang_attribute(xmldata)
     begin
-      lang = xmldata.root.attributes["lang"]
-    rescue StandardError
-      lang = ProjectData.instance.lang
-      puts Rainbow("[WARN ] Default lang: #{lang}").yellow
+      lang_code = xmldata.root.attributes["lang"]
+    rescue itself
+      lang_code = ProjectData.instance.lang
+      Logger.warn "ContentLoader: Applying default lang (#{lang_code})"
     end
-    lang
+    LangFactory.instance.get(lang_code)
   end
 
-  ##
-  # Read context attr from input XML data
-  # @param xmldata (XML Object)
   private_class_method def self.read_context_attribute(xmldata)
     begin
-      context = xmldata.root.attributes["context"]
-    rescue StandardError
-      context = "unknown"
-      puts Rainbow("[WARN ] Default context: #{context}").yellow
+      context = xmldata.root.attributes["context"].split(",")
+      context.collect!(&:strip)
+    rescue itself
+      context = ["unknown"]
+      Logger.warn "ContentLoader: Context is empty!"
     end
     context
   end
 
-  ##
-  # Read concept from input XML data
-  # @param xmldata (XML Object)
-  # @param filepath (String)
-  # @param lang
-  # @param context
   private_class_method def self.read_concept(xmldata, filepath, lang, context)
     project = ProjectData.instance
-    c = Concept.new(xmldata, filepath, lang, context)
-    c.process = true if [File.basename(filepath), :default].include? project.get(:process_file)
-    c
+    concept = Concept.new(xmldata, filepath, lang, context)
+    cond = [File.basename(filepath), :default].include? project.get(:process_file)
+    concept.process = true if cond
+    concept
   end
 
-  ##
-  # Read code from input XML data
-  # @param xmldata (XML Object)
-  # @param filepath (String)
   private_class_method def self.read_code(xmldata, filepath)
     project = ProjectData.instance
-    c = CodeLoader.load(xmldata, filepath)
-    c.process = true if [File.basename(filepath), :default].include? project.get(:process_file)
-    c
+    code = CodeLoader.call(xmldata, filepath)
+    cond =  [File.basename(filepath), :default].include? project.get(:process_file)
+    code.process = true if cond
+    code
+  end
+
+  private_class_method def self.read_problem(xmldata, filepath, lang, context)
+    project = ProjectData.instance
+    problem = ProblemLoader.new(lang, context).call(xmldata, filepath)
+    cond = [File.basename(filepath), :default].include? project.get(:process_file)
+    problem.process = true if cond
+    problem
   end
 
-  ##
-  # Raise error and save content into error.file
-  # @param filepath (String)
-  # @param content (String)
   private_class_method def self.raise_error_with(filepath, content)
-    msg =  "[ERROR] ContentLoader: Format error in #{filepath}\n"
-    msg += "        Take a look at ouput/error.xml"
-    puts Rainbow(msg).red.bright
-    f = File.open('output/error.xml', 'w')
+    Logger.error "ContentLoader: Format error (#{filepath})"
+    Logger.error "             : Revise output file (ouput/error.xml)"
+    f = File.open("output/error.xml", "w")
     f.write(content)
     f.close
     raise msg

data/lib/asker/loader/directory_loader.rb

@@ -1,29 +1,25 @@
 # frozen_string_literal: true
 
-require_relative 'file_loader'
+require_relative "file_loader"
+require_relative "../logger"
 
-# Load input data from one directory
 module DirectoryLoader
   ##
-  # Load input data from directory
+  # Load input data from one directory
   # @param dirname (String) Directory name
-  def self.load(dirname)
+  def self.call(dirname)
     DirectoryLoader.check_dir(dirname)
-    files = (Dir.new(dirname).entries - ['.', '..']).sort
+    files = (Dir.new(dirname).entries - [".", ".."]).sort
     # Accept only HAML or XML files
     accepted = files.select { |f| %w[.xml .haml].include? File.extname(f) }
     DirectoryLoader.load_files(accepted, dirname)
   end
 
-  ##
-  # Check directory
-  # @param dirname (String) Directory name
   def self.check_dir(dirname)
     return if Dir.exist? dirname
 
-    msg = Rainbow("[ERROR] #{dirname} directory dosn't exist!").color(:red)
-    puts msg
-    raise msg
+    Logger.error "DirectoryLoader: #{dirname} directory dosn't exist!"
+    exit 1
   end
 
   ##
@@ -31,13 +27,14 @@ module DirectoryLoader
   # @param filenames (Array) File name list
   # @param dirname (String) Base directory
   def self.load_files(filenames, dirname)
-    output = { concepts: [], codes: [] }
+    data = {concepts: [], codes: [], problems: []}
     filenames.each do |filename|
       filepath = File.join(dirname, filename)
-      data = FileLoader.load(filepath)
-      output[:concepts] += data[:concepts]
-      output[:codes] += data[:codes]
+      loaded = FileLoader.call(filepath)
+      data[:concepts] += loaded[:concepts]
+      data[:codes] += loaded[:codes]
+      data[:problems] += loaded[:problems]
     end
-    output
+    data
   end
 end

data/lib/asker/loader/embedded_file.rb

@@ -1,4 +1,5 @@
 require "base64"
+require_relative "../logger"
 
 # Methods to load embedded files defined into asker input data file
 # Example:
@@ -15,35 +16,34 @@ module EmbeddedFile
     return load_video(value, localdir) if is_video? value
 
     if is_url? value
-      Logger.verbose Rainbow("[ERROR] EmbebbedFile. Unkown URL: #{value}").red.bright
+      Logger.error "EmbebbedFile: Unknown URL type (#{value})"
       exit 1
     end
 
     filepath = File.join(localdir, value)
     unless File.exist?(filepath)
-      Logger.verbose Rainbow("[ERROR] EmbeddedFile. File does not exist!: #{filepath}").red.bright
-      # return { text: "URI error", file: :none, type: :unkown }
+      Logger.error "EmbeddedFile: File does not exist (#{filepath})"
       exit 1
     end
 
     # Suposse that filename is TEXT file
-    return {text: "<pre>#{File.read(filepath)}</pre>", file: :none, type: :text}
+    {text: "<pre>#{File.read(filepath)}</pre>", file: :none, type: :text}
   end
 
   def self.is_audio?(filename)
-    extens = [ ".mp3", ".ogg", ".wav"]
-    extens.each {|ext| return true if filename.downcase.end_with?(ext) }
+    extens = [".mp3", ".ogg", ".wav"]
+    extens.each { |ext| return true if filename.downcase.end_with?(ext) }
     false
   end
 
   def self.is_image?(filename)
-    extens = [ ".jpg", ".jpeg", ".png" ]
+    extens = [".jpg", ".jpeg", ".png"]
     extens.each { |ext| return true if filename.downcase.end_with?(ext) }
     false
   end
 
   def self.is_video?(filename)
-    extens = [ ".mp4", ".ogv" ]
+    extens = [".mp4", ".ogv"]
     extens.each { |ext| return true if filename.downcase.end_with?(ext) }
     false
   end
@@ -55,7 +55,7 @@ module EmbeddedFile
   end
 
   def self.load_audio(value, localdir)
-    output = { text: :error, file: :none, type: :audio}
+    output = {text: :error, file: :none, type: :audio}
 
     if is_url? value
       output[:text] = "<audio src=\"#{value}\" controls></audio>"
@@ -66,14 +66,14 @@ module EmbeddedFile
 
     filepath = File.join(localdir, value)
     unless File.exist?(filepath)
-      Logger.verbose Rainbow("[ERROR] Audio file no exists!: #{filepath}").red.bright
+      Logger.error "EmbebbedFile: Audio file no exists (#{filepath})"
       exit 1
     end
     output[:text] = '<audio controls><source src="@@PLUGINFILE@@/' + File.basename(filepath) \
                     + '">Your browser does not support the audio tag.</audio>'
     output[:file] = '<file name="' + File.basename(filepath) \
                     + '" path="/" encoding="base64">' \
-                    + Base64.strict_encode64(File.open(filepath, 'rb').read) \
+                    + Base64.strict_encode64(File.open(filepath, "rb").read) \
                     + "</file>"
     output[:type] = :audio
     output
@@ -91,14 +91,14 @@ module EmbeddedFile
 
     filepath = File.join(localdir, value)
     unless File.exist?(filepath)
-      Logger.verbose Rainbow("[ERROR] Unknown file! #{filepath}").red.bright
+      Logger.error "EmbeddedFile: Unknown file (#{filepath})"
       exit 1
     end
     output[:text] = '<img src="@@PLUGINFILE@@/' + File.basename(filepath) \
                     + '" alt="imagen" class="img-responsive atto_image_button_text-bottom">'
     output[:file] = '<file name="' + File.basename(filepath) \
                     + '" path="/" encoding="base64">' \
-                    + Base64.strict_encode64(File.open(filepath, 'rb').read) \
+                    + Base64.strict_encode64(File.open(filepath, "rb").read) \
                     + "</file>"
     output[:type] = :image
     output
@@ -116,7 +116,7 @@ module EmbeddedFile
 
     filepath = File.join(localdir, value)
     unless File.exist?(filepath)
-      Logger.verbose Rainbow("[ERROR] Unknown file! #{filepath}").red.bright
+      Logger.error "Unknown file (#{filepath})"
       exit 1
     end
     output[:text] = '<video controls><source src="@@PLUGINFILE@@/' \