asker-tool 2.1.3 → 2.2.0

data/lib/asker/lang/lang.rb

@@ -3,6 +3,7 @@
 require 'erb'
 require 'yaml'
 require_relative 'text_actions'
+require_relative '../logger'
 
 # Lang#lang
 class Lang
@@ -22,21 +23,26 @@ class Lang
   private
 
   def load_files
-    dirbase = File.dirname(__FILE__)
-    filename = File.join(dirbase, 'locales', @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')
+    @connectors = load_yaml_file(filepath)
+    filepath = File.join(dirbase, @code, 'mistakes.yaml')
+    @mistakes = load_yaml_file(filepath)
+  end
+
+  # rubocop:disable Security/YAMLLoad
+  def load_yaml_file(filepath)
     begin
-      @templates = YAML.load(File.new(filename))
+      content = YAML.load(File.new(filepath))
     rescue StandardError => e
-      p = Project.instance
-      p.vervose "[ERROR] lang.initialize(): Reading YAML file <#{filename}>"
-      p.vervose "[ADVISE] Revise apostrophe into string without \\ char\n"
+      Logger.verboseln '[ERROR] Lang.initialize():' \
+                       " Reading YAML file <#{filepath}>"
+      Logger.verboseln '[ADVISE] Revise apostrophe into string without \ symbol'
       raise e
     end
-    filename = File.join(dirbase, 'locales', @code, 'connectors.yaml')
-    @connectors = YAML.load(File.new(filename))
-
-    filename = File.join(dirbase, 'locales', @code, 'mistakes.yaml')
-    @mistakes = YAML.load(File.new(filename))
+    content
   end
-
+  # rubocop:enable Security/YAMLLoad
 end

data/lib/asker/lang/lang_factory.rb

@@ -2,18 +2,45 @@
 
 require 'singleton'
 require_relative 'lang'
-require_relative '../project'
+require_relative '../application'
 
-# LangFactory#get
+##
+# 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
     @langs = {}
-    Project.instance.locales.each { |i| @langs[i] = Lang.new(i) }
+    Application.instance.config['languages'].each_pair do |key, value|
+      code = key.downcase
+      next if code == 'default'
+
+      @langs[code] = Lang.new(code) if value.downcase == 'yes'
+    end
+  end
+
+  ##
+  # Return Lang object associated to code
+  # @param code (String)
+  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
+    exit 1
   end
 
-  def get(locale)
-    @langs[locale]
+  ##
+  # Return default Lang object
+  def default
+    get(@default)
   end
 end

data/lib/asker/lang/text_actions.rb

@@ -1,134 +1,152 @@
 # encoding: utf-8
 
+##
+# Set of functions used by Lang class
 module TextActions
-
-  def text_for(pOption, pText1="",pText2="",pText3="",pText4="",pText5="",pText6="",pText7="")
-    text1=pText1
-    text2=pText2
-    text3=pText3
-    text4=pText4
-    text5=pText5
-    text6=pText6
-    text7=pText7
-
-	  # TODO: check if exists pOption before use it
-    renderer = ERB.new(@templates[pOption])
-    output = renderer.result(binding)
-    return output
+  ##
+  # Return text indicated by lang code...
+  def text_for(option, *input)
+    text1 = input[0]
+    text2 = input[1]
+    text3 = input[2]
+    text4 = input[3]
+    text5 = input[4]
+    text6 = input[5]
+    text7 = input[6]
+
+    # Check if exists option before use it
+    raise "[ERROR] Unkown template #{option}" if @templates[option].nil?
+
+    renderer = ERB.new(@templates[option])
+    renderer.result(binding)
   end
 
-  def text_filter_connectors(pText, pFilter)
-    input_lines = pText.split(".")
+  ##
+  # Convert input text into output text struct
+  # @param input (String) Input text
+  # @param filter (Boolean) true => apply filter, false => dont filter
+  # @return Array
+  def text_filter_connectors(input, filter)
+    input_lines = input.split('.')
     output_lines = []
     output_words = []
     input_lines.each_with_index do |line, rowindex|
-	    row=[]
+	    row = []
       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>
 	      # if <word> isn't a conector and <pFilter>==true and <word>.length>1 Then Choose this <word>
-        if (flag and pFilter) || (!flag and !pFilter and word.length>1)
-		      output_words << {:word => word,
-                           :row => rowindex,
-                           :col => colindex }
+        if (flag and filter) || (!flag and !filter and word.length > 1)
+		      output_words << {:word => word, :row => rowindex, :col => colindex }
 		      row << (output_words.size-1)
 	      else
 		      row << word
-		    end
+        end
 	    end
 	    row << '.'
 	    output_lines << row
-	  end
+    end
 
     indexes = []
-    exclude = ['[', ']', '(', ')', "\"" ]
+    exclude = ['[', ']', '(', ')', '"']
     output_words.each_with_index do |item, index|
       flag = true
-      exclude.each { |e| flag = false if (item[:word].include?(e)) }
+      exclude.each { |e| flag = false if item[:word].include? e }
       indexes << index if flag
     end
 
-	  result={ :lines => output_lines, :words => output_words, :indexes => indexes }
-	  return result
+    { lines: output_lines, words: output_words, indexes: indexes }
   end
 
+  ##
+  # Return text with connectors
   def text_with_connectors(text)
 	  text_filter_connectors(text, false)
   end
 
+  ##
+  # Return text without connectors
   def text_without_connectors(text)
-	  text_filter_connectors(text, true)
+    text_filter_connectors(text, true)
   end
 
-  def build_text_from_filtered(pStruct, pIndexes)
-    lines    = pStruct[:lines]
-    lIndexes = pIndexes.sort
-    counter  = 1
-    lText    = ''
+  def build_text_from_filtered(input_struct, input_indexes)
+    lines = input_struct[:lines]
+    indexes = input_indexes.sort
+    counter = 1
+    text = ''
 
     lines.each do |line|
       line.each do |value|
         if value.class == String
-          lText += (' ' + value)
+          text += (' ' + value)
         elsif value == value.to_i
           # INFO: ruby 2.4 unifies Fixnum and Bignum into Integer
           #       Avoid using deprecated classes.
-          if lIndexes.include? value
-            lText   += " [#{counter.to_s}]"
+          if indexes.include? value
+            text += " [#{counter}]"
             counter += 1
           else
-            lword = pStruct[:words][value][:word]
-            lText += (' ' + lword)
+            word = input_struct[:words][value][:word]
+            text += (' ' + word)
           end
         end
       end
     end
-    lText.gsub!(' .', '.')
-    lText.gsub!(' ,', ',')
-    lText = lText[1, lText.size] if lText[0] == ' '
-    lText
+    text.gsub!(' .', '.')
+    text.gsub!(' ,', ',')
+    text = text[1, text.size] if text[0] == ' '
+    text
   end
 
-  def count_words(pInputText)
-    return 0 if pInputText.nil?
-
-    t = pInputText.clone
-    t.gsub!("\n"," ")
-    t.gsub!("/"," ")
-    #t.gsub!("-"," ")
-    t.gsub!("."," ")
-    t.gsub!(","," ")
-    t.gsub!("   "," ")
-    t.gsub!("  "," ")
-    t.split(" ").count
+  ##
+  # Count words
+  # @param input (String)
+  # @return Integer
+  def count_words(input)
+    return 0 if input.nil?
+
+    t = input.clone
+    t.gsub!("\n", ' ')
+    t.gsub!('/', ' ')
+    # t.gsub!("-"," ")
+    t.gsub!('.', ' ')
+    t.gsub!(',', ' ')
+    t.gsub!('   ', ' ')
+    t.gsub!('  ', ' ')
+    t.split(' ').count
   end
 
-  def do_mistake_to(pText = '')
-    lText = pText.dup
+  ##
+  # Do mistake to input
+  # @param input (String)
+  # @return String
+  def do_mistake_to(input = '')
+    text = input.dup
     keys = @mistakes.keys
 
     # Try to do mistake with one item from the key list
     keys.shuffle!
     keys.each do |key|
-      if lText.include? key.to_s
-         values = @mistakes[key].split(',')
-         values.shuffle!
-         lText = lText.sub(key.to_s,values[0].to_s)
-         return lText
-      end
+      next unless text.include? key.to_s
+
+      values = @mistakes[key].split(',')
+      values.shuffle!
+      text = text.sub(key.to_s, values[0].to_s)
+      return text
     end
 
     # Force mistake by swapping letters
-    if lText.size > 1
-      i = rand(lText.size - 2)
-      aux = lText[i]
-      lText[i] = lText[i + 1]
-      lText[i + 1] = aux
+    if text.size > 1
+      i = rand(text.size - 2)
+      aux = text[i]
+      text[i] = text[i + 1]
+      text[i + 1] = aux
     end
-    return lText if lText != pText
+    return text if text != input
 
-    lText + 's'
+    text + 's'
   end
 
   def hide_text(input_text)

data/lib/asker/loader/code_loader.rb

@@ -3,7 +3,7 @@
 require 'rainbow'
 require 'rexml/document'
 require_relative '../logger'
-require_relative '../code/code'
+require_relative '../data/code'
 
 # Read XML info about Code input data
 module CodeLoader
@@ -24,7 +24,7 @@ module CodeLoader
   # @param xmldata (XML Object)
   # @param filename (String) File name that contains data
   # @return Code object
-  def self.read_codedata_from_xml(xmldata, filename)
+  private_class_method def self.read_codedata_from_xml(xmldata, filename)
     data = { path: '?', type: '?', features: [] }
     xmldata.elements.each do |i|
       data[:path] = i.text if i.name == 'path'
@@ -38,14 +38,14 @@ module CodeLoader
   # Read features data from XML input
   # @param xmldata (XML object)
   # @return Array with features (Strings)
-  def self.read_features(xmldata, filename)
+  private_class_method def self.read_features(xmldata, filename)
     features = []
     xmldata.elements.each do |i|
       if i.name == 'row'
         features << i.text
       else
         msg = Rainbow("[ERROR] features/#{i.name} from #{filename}").color(:red)
-        Logger.verbose msg
+        Logger.verboseln msg
       end
     end
     features

data/lib/asker/loader/content_loader.rb

@@ -13,6 +13,8 @@ module ContentLoader
   # Load XML content into Asker data objects
   # @param filepath (String) File path
   # @param content (String) XML plane text content
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
   def self.load(filepath, content)
     concepts = []
     codes = []
@@ -37,11 +39,13 @@ module ContentLoader
 
     { concepts: concepts, codes: codes }
   end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
 
   ##
   # Read lang attr from input XML data
   # @param xmldata (XML Object)
-  def self.read_lang_attribute(xmldata)
+  private_class_method def self.read_lang_attribute(xmldata)
     begin
       lang = xmldata.root.attributes['lang']
     rescue StandardError
@@ -53,7 +57,7 @@ module ContentLoader
   ##
   # Read context attr from input XML data
   # @param xmldata (XML Object)
-  def self.read_context_attribute(xmldata)
+  private_class_method def self.read_context_attribute(xmldata)
     begin
       context = xmldata.root.attributes['context']
     rescue StandardError
@@ -68,12 +72,10 @@ module ContentLoader
   # @param filepath (String)
   # @param lang
   # @param context
-  def self.read_concept(xmldata, filepath, lang, context)
+  private_class_method def self.read_concept(xmldata, filepath, lang, context)
     project = Project.instance
     c = Concept.new(xmldata, filepath, lang, context)
-    if [ File.basename(filepath), :default ].include? project.process_file
-      c.process = true
-    end
+    c.process = true if [File.basename(filepath), :default].include? project.get(:process_file)
     c
   end
 
@@ -81,18 +83,20 @@ module ContentLoader
   # Read code from input XML data
   # @param xmldata (XML Object)
   # @param filepath (String)
-  def self.read_code(xmldata, filepath)
+  private_class_method def self.read_code(xmldata, filepath)
     project = Project.instance
     c = CodeLoader.load(xmldata, filepath)
-    if [ File.basename(filepath), :default ].include? project.process_file
-      c.process = true
-    end
+    c.process = true if [File.basename(filepath), :default].include? project.get(:process_file)
     c
   end
 
-  def self.raise_error_with(filepath, content)
+  ##
+  # 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 = Rainbow("[ERROR] ContentLoader: Format error in #{filepath}").red.bright
-    Logger.verbose msg
+    Logger.verboseln msg
     f = File.open('output/error.xml', 'w')
     f.write(content)
     f.close

data/lib/asker/loader/directory_loader.rb

@@ -13,7 +13,7 @@ module DirectoryLoader
     files = (Dir.new(dirname).entries - ['.', '..']).sort
     # Accept only HAML or XML files
     accepted = files.select { |f| %w[.xml .haml].include? File.extname(f) }
-    Logger.verbose " * Input directory  = #{Rainbow(dirname).bright}"
+    Logger.verboseln " * Input directory  = #{Rainbow(dirname).bright}"
     DirectoryLoader.load_files(accepted, dirname)
   end
 
@@ -49,9 +49,9 @@ module DirectoryLoader
   # @param last (Boolean) True if it is the last filename
   def self.load_file(filepath, last = false)
     if last
-      Logger.verbose "   └── Input file   = #{Rainbow(filepath).bright}"
+      Logger.verboseln "   └── Input file   = #{Rainbow(filepath).bright}"
     else
-      Logger.verbose "   ├── Input file   = #{Rainbow(filepath).bright}"
+      Logger.verboseln "   ├── Input file   = #{Rainbow(filepath).bright}"
     end
     FileLoader.load(filepath)
   end

data/lib/asker/loader/embedded_file.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+# Methods to load embedded files defined into asker input data file
+# Example:
+# * def line with :type = :image_url used to link external file as https://..."
+# * def line with :type = :file used to load local file as image.png or file.txt"
+module EmbeddedFile
+  ##
+  # @param value (String)
+  # @param localdir (String) Input file base folder
+  # @return Hash
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  def self.load(value, localdir)
+    # When filename is an URL
+    if value.start_with?('https://') || value.start_with?('http://')
+      return { text: "<img src=\"#{value}\" alt=\"image\" width=\"400\" height=\"300\">", file: :none }
+    end
+
+    filepath = File.join(localdir, value)
+    unless File.exist?(filepath)
+      # When filename is unkown!
+      Logger.verbose Rainbow("[ERROR] Unknown file! #{filepath}").red.bright
+      exit 1
+    end
+    # When filename is PNG, JPG o JPEG
+    if ['.png', '.jpg', '.jpeg'].include? File.extname(filepath)
+      # converts image into base64 strings
+      text = '<img src="@@PLUGINFILE@@/' + File.basename(filepath) \
+             + '" alt="imagen" class="img-responsive atto_image_button_text-bottom">'
+      data = '<file name="' + File.basename(filepath) + '" path="/" encoding="base64">' \
+             + Base64.strict_encode64(File.open(filepath, 'rb').read) + '</file>'
+      return { text: text, file: data }
+    end
+    # Suposse that filename is TXT file
+    return { text: "<pre>#{File.read(filepath)}</pre>", file: :none } if File.exist?(filepath)
+  end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+end

data/lib/asker/loader/file_loader.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'haml'
 require_relative 'content_loader'
+require_relative 'haml_loader'
 require_relative '../logger'
 
 # Methods that load a filename and return list of concepts
@@ -11,23 +11,14 @@ module FileLoader
   # @param filename (String) File name to be load
   def self.load(filename)
     if File.extname(filename).casecmp('.haml').zero?
-      file_content = load_haml filename
+      file_content = HamlLoader.load filename
     elsif File.extname(filename).casecmp('.xml').zero?
       file_content = File.read(filename)
     else
       msg = "[ERROR] FileLoader: Format error #{filename}"
-      Logger.verbose msg
+      Logger.verboseln msg
       raise msg
     end
     ContentLoader.load(filename, file_content)
   end
-
-  ##
-  # Load HAML file name
-  # @param filename (String) HAML file name
-  def self.load_haml(filename)
-    template = File.read(filename)
-    haml_engine = Haml::Engine.new(template)
-    haml_engine.render
-  end
 end

data/lib/asker/loader/haml_loader.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'haml'
+
+# HAML file loader
+module HamlLoader
+  ##
+  # Load HAML file name
+  # @param filename (String) HAML file name
+  def self.load(filename)
+    template = File.read(filename)
+    haml_engine = Haml::Engine.new(template)
+    haml_engine.render
+  end
+end

data/lib/asker/loader/image_url_loader.rb

@@ -1,8 +1,8 @@
 
 require 'net/http'
 require 'uri'
-require_relative '../project'
 require_relative '../application'
+require_relative '../logger'
 
 # Search URL images on Internet
 # Methods:
@@ -12,9 +12,6 @@ require_relative '../application'
 module ImageUrlLoader
   # Search "input" images on Google and return URL
   def self.load(input = [])
-    param = Application.instance.config['global']['internet'] || 'yes'
-    return [] unless param == 'yes'
-
     filters = []
     if input.class == String
       filters += sanitize_string(input.clone)
@@ -39,20 +36,21 @@ module ImageUrlLoader
         end
       end
     rescue
-      Project.instance.verboseln '[ERROR] ImageUrlLoader'
-      Project.instance.verboseln " => #{search_url}"
-      Project.instance.verboseln ' => Check Internet connections'
-      Project.instance.verboseln ' => Ensure URL is well formed'
+      Logger.verboseln '[ERROR] ImageUrlLoader'
+      Logger.verboseln " => #{search_url}"
+      Logger.verboseln ' => Check Internet connections'
+      Logger.verboseln ' => 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.each { |item| input.gsub!(item[0], item[1]) }
+    r.each { |item| text.gsub!(item[0], item[1]) }
     r = ['-', '_', ',', '"']
-    r.each { |item| input.gsub!(item, ' ') }
-    input.split(' ')
+    r.each { |item| text.gsub!(item, ' ') }
+    text.split(' ')
   end
 
   def self.sanitize_array(input)

data/lib/asker/loader/input_loader.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative 'directory_loader'
+require_relative '../ai/concept_ai'
+require_relative '../data/world'
 require_relative '../logger'
 
 # Load DATA defined into our Project
@@ -9,16 +11,30 @@ module InputLoader
   # Load input data from every input directory
   # @param inputdirs (Array)
   def self.load(inputdirs)
-    output = { concepts: [], codes: [] }
-    Logger.verbose "\n[INFO] Loading input data"
-
-    # inputdirs = project.inputdirs.split(',')
+    data = { concepts: [], codes: [], world: nil,
+             concepts_ai: [], codes_ai: [] }
+    Logger.verboseln "\n[INFO] Loading input data"
     inputdirs.each do |dirname|
-      data = DirectoryLoader.load(dirname)
-      output[:concepts] += data[:concepts]
-      output[:codes] += data[:codes]
+      temp = DirectoryLoader.load(dirname)
+      data[:concepts] += temp[:concepts]
+      data[:codes] += temp[:codes]
     end
+    create_questions(data)
+  end
 
-    output
+  private_class_method def self.create_questions(data)
+    # Create World data
+    # * Calculate concept neighbours
+    # * TO-DO: Calculate code neighbours
+    data[:world] = World.new(data[:concepts])
+    # 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
+    data
   end
 end