asker-tool 2.5.9 → 2.7.0

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: Unkown 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 "base64"
+require_relative "../logger"
 
 # Methods to load embedded files defined into asker input data file
 # Example:
@@ -15,46 +16,46 @@ 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: Unkown URL (#{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.each {|ext| return true if filename.downcase.end_with?(ext) }
+    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.each {|ext| return true if filename.downcase.end_with?(ext) }
+    extens = [".mp4", ".ogv"]
+    extens.each { |ext| return true if filename.downcase.end_with?(ext) }
     false
   end
 
   def self.is_url?(value)
-    return true if value.start_with?('https://') || value.start_with?('http://')
+    return true if value.start_with?("https://", "http://")
+
     false
   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>"
@@ -65,20 +66,21 @@ 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) + '</file>'
+                    + Base64.strict_encode64(File.open(filepath, "rb").read) \
+                    + "</file>"
     output[:type] = :audio
     output
   end
 
   def self.load_image(value, localdir)
-    output = { text: :error, file: :none, type: :image}
+    output = {text: :error, file: :none, type: :image}
 
     if is_url? value
       output[:text] = "<img src=\"#{value}\" alt=\"image\" width=\"400\" height=\"300\">"
@@ -89,21 +91,21 @@ 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) + '</file>'
+                    + Base64.strict_encode64(File.open(filepath, "rb").read) \
+                    + "</file>"
     output[:type] = :image
     output
   end
 
   def self.load_video(value, localdir)
-    output = { text: :error, file: :none, type: :video}
-
+    output = {text: :error, file: :none, type: :video}
     if is_url? value
       output[:text] = "<video controls width=\"400\" height=\"300\">" \
                       + "<source src=\"#{value}\"/></video>"
@@ -114,14 +116,17 @@ 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@@/' + File.basename(filepath) \
+    output[:text] = '<video controls><source src="@@PLUGINFILE@@/' \
+                    + File.basename(filepath) \
                     + '"/>Your browser does not support the video tag.</video>'
-    output[:file] = '<file name="' + File.basename(filepath) \
+    output[:file] = '<file name="' \
+                    + File.basename(filepath) \
                     + '" path="/" encoding="base64">' \
-                    + Base64.strict_encode64(File.open(filepath, 'rb').read) + '</file>'
+                    + Base64.strict_encode64(File.open(filepath, "rb").read) \
+                    + "</file>"
     output[:type] = :video
     output
   end

data/lib/asker/loader/file_loader.rb

@@ -1,19 +1,20 @@
 require_relative "content_loader"
 require_relative "haml_loader"
+require_relative "../logger"
 
 ##
 # Load a filename and return a Hash with concepts list and code list
 # return { concepts: [], codes: [] }
 module FileLoader
-  def self.load(filename)
-    if File.extname(filename).casecmp('.haml').zero?
+  def self.call(filename)
+    if File.extname(filename).casecmp(".haml").zero?
       file_content = HamlLoader.load filename
-    elsif File.extname(filename).casecmp('.xml').zero?
+    elsif File.extname(filename).casecmp(".xml").zero?
       file_content = File.read(filename)
     else
-      puts "[ERROR] FileLoader: Format error #{filename}"
-      raise msg
+      Logger.error "FileLoader: HAML or XML required (#{filename})"
+      exit 1
     end
-    ContentLoader.load(filename, file_content)
+    ContentLoader.call(filename, file_content)
   end
 end

data/lib/asker/loader/haml_loader.rb

@@ -1,4 +1,5 @@
 require "haml"
+require_relative "../logger"
 
 module HamlLoader
   def self.load(filename)
@@ -6,13 +7,13 @@ module HamlLoader
     begin
       # INFO <haml 5.1> 20221223
       haml_engine = Haml::Engine.new(template)
-      return haml_engine.render
       # INFO <haml 6.1> 20221226
       # return Haml::Template.new { template }.render
-    rescue StandardError => e
-      puts "[ERROR] HamlLoader: Can't load <#{filename}> file!"
-      puts "  => #{e}"
-      exit 0
+    rescue => e
+      Logger.error "HamlLoader: Can't load file (#{filename})"
+      Logger.error "          : #{e}"
+      exit 1
     end
+    haml_engine.render
   end
 end

data/lib/asker/loader/image_url_loader.rb

@@ -1,6 +1,6 @@
-
-require 'net/http'
-require 'uri'
+require "net/http"
+require "uri"
+require_relative "../logger"
 
 # Search URL images on Internet
 # Methods:
@@ -11,44 +11,47 @@ module ImageUrlLoader
   # Search "input" images on Google and return URL
   def self.load(input = [])
     filters = []
-    if input.class == String
+    if input.instance_of? String
       filters += sanitize_string(input.clone)
-    elsif input.class == Array
+    elsif input.instance_of? Array
       filters = sanitize_array(input.clone)
     else
-      raise "[ERROR] ImageUrlLoader: Unkown type #{input.class}"
+      Logger.error "ImageUrlLoader: Unkown type (#{input.class})"
+      exit 1
     end
     # Search Image URLs from Google site, selected by <filters>
-    search_url = 'https://www.google.es/search?q='
-    search_url << filters.flatten.join('+').to_s
-    search_url << '&source=lnms&tbm=isch&sa=X&ved=2ahUKEwj_g8Wfst7nAhWpzoUKHf_wDbsQ_AUoAnoECBMQBA&biw=1280&bih=591'
+    search_url = "https://www.google.es/search?q="
+    search_url << filters.flatten.join("+").to_s
+    search_url << "&source=lnms&tbm=isch&sa=X&ved=2ahUKEwj_g8Wfst7nAhWpzoUKHf_wDbsQ_AUoAnoECBMQBA&biw=1280&bih=591"
     image_urls = []
     begin
       uri = URI.parse(search_url)
       response = Net::HTTP.get_response(uri)
 
-      r = response.body.split(' ')
+      r = response.body.split(" ")
       r.each do |line|
         if line.include? 'src="https'
           image_urls << line.delete('"')[4, line.size]
         end
       end
     rescue
-      puts '[ERROR] ImageUrlLoader'
-      puts " => #{search_url}"
-      puts ' => Check Internet connections'
-      puts ' => Ensure URL is well formed'
+      Logger.warn "ImageUrlLoader: Problems with URL (#{search_url})"
+      Logger.warn "                (a) Check Internet connections"
+      Logger.warn "                (b) Ensure URL is well formed"
     end
     image_urls
   end
 
   def self.sanitize_string(input)
     text = input.dup
-    r = [ ['á', 'a'], ['é', 'e'], ['í', 'i'], ['ó', 'o'], ['ú', 'u'], ['ñ', 'n'], ['Á', 'A'], ['É', 'E'], ['Í', 'I'], ['Ó', 'O'], ['Ú', 'U'], ['Ñ', 'N']]
+    r = [
+      %w[á a], %w[é e], %w[í i], %w[ó o], %w[ú u], %w[ñ n],
+      %w[Á A], %w[É E], %w[Í I], %w[Ó O], %w[Ú U], %w[Ñ N]
+    ]
     r.each { |item| text.gsub!(item[0], item[1]) }
-    r = ['-', '_', ',', '"']
-    r.each { |item| text.gsub!(item, ' ') }
-    text.split(' ')
+    r = %w[- _ , "]
+    r.each { |item| text.gsub!(item, " ") }
+    text.split(" ")
   end
 
   def self.sanitize_array(input)

data/lib/asker/loader/input_loader.rb

@@ -1,35 +1,48 @@
-require_relative 'directory_loader'
-require_relative '../ai/concept_ai'
-require_relative '../data/world'
+require_relative "directory_loader"
+require_relative "../ai/concept_ai"
+require_relative "../ai/code/code_ai_factory"
+require_relative "../ai/problem/problem_ai"
+require_relative "../data/world"
 
-module InputLoader
+class InputLoader
   ##
   # Load input data from every input directory
   # @param inputdirs (Array)
-  def self.load(inputdirs, internet = true)
-    data = { concepts: [], codes: [], world: nil,
-             concepts_ai: [], codes_ai: [] }
+  def call(inputdirs, internet = true)
+    data = {
+      world: nil,
+      concepts: [], codes: [], problems: [],
+      concepts_ai: [], codes_ai: []
+    }
     inputdirs.each do |dirname|
-      temp = DirectoryLoader.load(dirname)
-      data[:concepts] += temp[:concepts]
-      data[:codes] += temp[:codes]
+      loaded = DirectoryLoader.call(dirname)
+      data[:concepts] += loaded[:concepts]
+      data[:codes] += loaded[:codes]
+      data[:problems] += loaded[:problems]
     end
     create_questions(data, internet)
   end
 
-  private_class_method def self.create_questions(data, internet)
-    # Create World data
-    # * Calculate concept neighbours
-    # * TO-DO: Calculate code neighbours
+  private
+
+  def create_questions(data, internet)
+    # Create World data. Calculate concept neighbours
+    # TODO: Calculate code and problem neighbours
     data[:world] = World.new(data[:concepts], internet)
+
     # Create ConceptAI data (ConceptAI = concept + questions)
     data[:concepts].each do |concept|
       data[:concepts_ai] << ConceptAI.new(concept, data[:world])
     end
+
     # Create CodeAI data (CodeAI = code + questions)
     data[:codes].each do |code|
       data[:codes_ai] << CodeAIFactory.get(code)
     end
+
+    # Fill problem with questions
+    data[:problems].each { |problem| ProblemAI.new.call(problem) }
+
     data
   end
 end