asker-tool 2.1.2 → 2.1.7

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,7 +38,7 @@ 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'

data/lib/asker/loader/content_loader.rb

@@ -41,7 +41,7 @@ module ContentLoader
   ##
   # 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 +53,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,7 +68,7 @@ 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
@@ -81,7 +81,7 @@ 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
@@ -90,7 +90,11 @@ module ContentLoader
     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
     f = File.open('output/error.xml', 'w')

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,7 +11,7 @@ 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
@@ -21,13 +21,4 @@ module FileLoader
     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,10 +36,10 @@ 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

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: [] }
+    data = { concepts: [], codes: [], world: nil,
+             concepts_ai: [], codes_ai: [] }
     Logger.verbose "\n[INFO] Loading input data"
-
-    # inputdirs = project.inputdirs.split(',')
     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

data/lib/asker/loader/project_loader.rb

@@ -2,6 +2,7 @@
 
 require 'yaml'
 require_relative '../project'
+require_relative '../logger'
 
 # Load params into Project class using arg input
 # * load
@@ -10,40 +11,48 @@ require_relative '../project'
 # * load_from_directory
 # * load_error
 module ProjectLoader
-  def self.load(args = {})
+  ##
+  # Load project from args
+  # @param args (String or Hash)
+  def self.load(args)
     project = Project.instance
 
     if args.class == Hash
       project.param.merge!(args)
-      return true
+      return project
     elsif args.class == String
       ProjectLoader.load_from_string(args)
-      return true
+      return project
     end
 
     msg = '[ERROR] ProjectLoader:'
     msg += "Configuration params format is <#{pArgs.class}>!"
-    project.verbose Rainbow(msg).red
+    Logger.verbose Rainbow(msg).red
     raise msg
   end
 
-  def self.load_from_string(arg)
+  ##
+  # Load project from filepath. Options:
+  # * HAML filepath
+  # * XML filepath
+  # * YAML filepath
+  # @param filepath (String)
+  def self.load_from_string(filepath)
     project = Project.instance
-    unless File.exist?(arg)
-      msg = Rainbow("[WARN] ProjectLoader.load: #{arg} dosn't exists!").yellow.bright
-      project.verbose msg
-      raise msg
+    unless File.exist?(filepath)
+      msg = Rainbow("[ERROR] #{filepath} not found!").red.bright
+      Logger.verbose msg
+      exit 1
     end
 
-    if File.extname(arg) == '.haml' || File.extname(arg) == '.xml'
-      project.set(:inputdirs, File.dirname(arg))
-      project.set(:process_file, File.basename(arg))
-    elsif File.extname(arg) == '.yaml'
-      load_from_yaml(arg)
-    elsif File.directory?(arg)
-      load_from_directory(arg)
+    if File.extname(filepath) == '.haml' || File.extname(filepath) == '.xml'
+      project.set(:inputdirs, File.dirname(filepath))
+      project.set(:process_file, File.basename(filepath))
+      return project
+    elsif File.extname(filepath) == '.yaml'
+      return load_from_yaml(filepath)
     else
-      load_error(arg)
+      error_loading(filepath)
     end
   end
 
@@ -52,20 +61,14 @@ module ProjectLoader
     project.param.merge!(YAML.load(File.open(arg)))
     project.set(:configfilename, arg)
     project.set(:projectdir, File.dirname(arg))
+    project
   end
 
-  def self.load_from_directory(dirpath)
-    msg = Rainbow('[WARN] ProjectLoader.load: Directory input ').yellow
-    msg += Rainbow(dirpath).bright.yellow
-    msg += Rainbow(' not implemented!').yellow
-    Project.instance.verbose msg
+  ##
+  # Error found and exit application.
+  def self.error_loading(arg)
+    msg = Rainbow("[ERROR] Loading... #{arg}").red.bright
+    Logger.verbose msg
     exit 1
   end
-
-  def self.load_error(arg)
-    msg = Rainbow('[ERR ] ProjectLoader: Input ').red
-    msg += Rainbow(arg).red.bright + Rainbow(' unkown').red
-    Project.instance.verbose msg
-    raise msg
-  end
 end