asker-tool 2.1.5 → 2.1.6

data/lib/asker/displayer/concept_ai_displayer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'terminal-table'
+require_relative '../application'
 require_relative '../logger'
 
 # Display ConceptAI stat on screen
@@ -9,10 +10,18 @@ class ConceptAIDisplayer
   # Display ConceptAI stat on screen
   # @param concepts_ai (Array)
   def self.show(concepts_ai)
+    stages = Application.instance.config['questions']['stages']
     # Create table HEAD
     screen_table = Terminal::Table.new do |st|
-      st << ['Concept','Questions','Entries','xFactor',
-             'd','b','f','i','s','t']
+      title = ['Concept', 'Questions', 'Entries', 'xFactor']
+      %w[d b f i s t].each do |i|
+        if stages.include? i.to_sym
+          title << i
+          next
+        end
+        title << Rainbow(i).yellow.bright
+      end
+      st << title
       st << :separator
     end
     # Create table BODY
@@ -22,32 +31,37 @@ class ConceptAIDisplayer
     total[:si] = total[:ss] = total[:st] = 0
 
     concepts_ai.each do |concept_ai|
-      if concept_ai.process?
-        e = concept_ai.texts.size
-        concept_ai.tables.each { |t| e += t.fields.size * t.rows.size }
+      next unless concept_ai.process?
 
-        sd = concept_ai.questions[:d].size
-        sb = concept_ai.questions[:b].size
-        sf = concept_ai.questions[:f].size
-        si = concept_ai.questions[:i].size
-        ss = concept_ai.questions[:s].size
-        st = concept_ai.questions[:t].size
-        t = sd + sb + sf + si + ss + st
+      e = concept_ai.texts.size
+      concept_ai.tables.each { |t| e += t.fields.size * t.rows.size }
 
-        if e == 0
-          factor = 'Unkown'
-        else
-          factor = (t.to_f/e.to_f).round(2).to_s
-        end
-        screen_table.add_row [Rainbow(concept_ai.name(:screen)).green.bright,
-          t, e, factor, sd, sb, sf, si, ss, st]
+      sd = sb = sf = 0
+      si = ss = st = 0
+      sd = concept_ai.questions[:d].size if stages.include? :d
+      sb = concept_ai.questions[:b].size if stages.include? :b
+      sf = concept_ai.questions[:f].size if stages.include? :f
+      si = concept_ai.questions[:i].size if stages.include? :i
+      ss = concept_ai.questions[:s].size if stages.include? :s
+      st = concept_ai.questions[:t].size if stages.include? :t
+      t = sd + sb + sf + si + ss + st
 
-        total[:q] += t ; total[:e] += e; total[:c] += 1
-        total[:sd] += sd; total[:sb] += sb; total[:sf] += sf
-        total[:si] += si; total[:ss] += ss; total[:st] += st
-      end
+      factor = 'Unkown'
+      factor = (t.to_f / e).round(2).to_s unless e.zero?
+      screen_table.add_row [Rainbow(concept_ai.name(:screen)).green.bright,
+                            t, e, factor, sd, sb, sf, si, ss, st]
+
+      total[:q] += t
+      total[:e] += e
+      total[:c] += 1
+      total[:sd] += sd
+      total[:sb] += sb
+      total[:sf] += sf
+      total[:si] += si
+      total[:ss] += ss
+      total[:st] += st
     end
-    return if total[:c] == 0 # No concepts to be process?
+    return if total[:c].zero? # No concepts to be process?
 
     # Add row with excluded questions
     export_excluded_questions(screen_table, concepts_ai)
@@ -57,7 +71,7 @@ class ConceptAIDisplayer
     screen_table.add_row [Rainbow("TOTAL = #{total[:c]}").bright,
                           Rainbow(total[:q].to_s).bright,
                           Rainbow(total[:e].to_s).bright,
-                          Rainbow((total[:q].to_f/total[:e].to_f).round(2)).bright,
+                          Rainbow((total[:q].to_f / total[:e]).round(2)).bright,
                           total[:sd], total[:sb], total[:sf],
                           total[:si], total[:ss], total[:st]]
     export_notes
@@ -72,19 +86,24 @@ class ConceptAIDisplayer
     total[:si] = total[:ss] = total[:st] = 0
 
     concepts_ai.each do |concept_ai|
-      if concept_ai.process?
-        sd = concept_ai.excluded_questions[:d].size
-        sb = concept_ai.excluded_questions[:b].size
-        sf = concept_ai.excluded_questions[:f].size
-        si = concept_ai.excluded_questions[:i].size
-        ss = concept_ai.excluded_questions[:s].size
-        st = concept_ai.excluded_questions[:t].size
-        t = sd + sb + sf + si + ss + st
+      next unless concept_ai.process?
 
-        total[:q] += t ; total[:c] += 1
-        total[:sd] += sd; total[:sb] += sb; total[:sf] += sf
-        total[:si] += si; total[:ss] += ss; total[:st] += st
-      end
+      sd = concept_ai.excluded_questions[:d].size
+      sb = concept_ai.excluded_questions[:b].size
+      sf = concept_ai.excluded_questions[:f].size
+      si = concept_ai.excluded_questions[:i].size
+      ss = concept_ai.excluded_questions[:s].size
+      st = concept_ai.excluded_questions[:t].size
+      t = sd + sb + sf + si + ss + st
+
+      total[:q] += t
+      total[:c] += 1
+      total[:sd] += sd
+      total[:sb] += sb
+      total[:sf] += sf
+      total[:si] += si
+      total[:ss] += ss
+      total[:st] += st
     end
     screen_table.add_row [Rainbow('Excluded questions').yellow.bright,
                           total[:q], '-', '-',

data/lib/asker/displayer/concept_displayer.rb

@@ -1,4 +1,5 @@
 
+require_relative '../application'
 require_relative '../formatter/concept_string_formatter'
 require_relative '../logger'
 
@@ -7,17 +8,18 @@ module ConceptDisplayer
   ##
   # Show concepts on screen
   # @param concepts (Array)
-  # @param show_mode (Symbol)
-  def self.show(concepts, show_mode = :default)
-    return if show_mode == :none
+  def self.show(concepts)
+    show_mode = Application.instance.config['global']['show_mode']
+    return unless show_mode
+
     msg = "\n[INFO] Showing concept data (#{Rainbow(show_mode).bright})"
     Logger.verbose msg
     case show_mode
-    when :resume
+    when 'resume'
       s = "* Concepts (#{concepts.count}): "
       concepts.each { |c| s += c.name + ', ' }
       Logger.verbose s
-    when :default
+    when 'default'
       # Only show Concepts with process attr true
       concepts.each do |c|
         Logger.verbose ConceptStringFormatter.to_s(c) if c.process?

data/lib/asker/displayer/stats_displayer.rb

@@ -1,13 +1,14 @@
+require_relative '../application'
 require_relative 'concept_ai_displayer'
 require_relative 'code_displayer'
 
 # Display Stats on screen.
 module StatsDisplayer
-  def self.show(data, show_mode)
-    return if show_mode == :none
+  def self.show(data)
+    return unless Application.instance.config['global']['show_mode']
 
     # show_final_results
     ConceptAIDisplayer.show(data[:concepts_ai])
-    CodeDisplayer.show(data[:codes])
+    CodeDisplayer.show(data[:codes_ai])
   end
 end

data/lib/asker/exporter/concept_ai_gift_exporter.rb

@@ -6,17 +6,19 @@ require_relative '../formatter/question_gift_formatter'
 # Export ConceptIA data to gift to outputfile
 module ConceptAIGiftExporter
   ##
-  # Export list of ConceptAI into outpufile
+  # Export an array of ConceptAI objects from Project into GIFT outpufile
+  # @param concepts_ai (Array)
+  # @param project (Project)
   def self.export_all(concepts_ai, project)
     concepts_ai.each { |concept_ai| export(concept_ai, project) }
   end
 
-  def self.export(concept_ai, project)
+  private_class_method def self.export(concept_ai, project)
     return unless concept_ai.process?
 
     file = project.get(:outputfile)
     file.write head(concept_ai.name)
-    project.stages.each_key do |stage|
+    Application.instance.config['questions']['stages'].each do |stage|
       concept_ai.questions[stage].each do |question|
         file.write(QuestionGiftFormatter.to_s(question))
       end

data/lib/asker/exporter/concept_ai_yaml_exporter.rb

@@ -5,6 +5,10 @@ require_relative '../formatter/question_hash_formatter'
 
 # Use to export data from ConceptIA to YAML format
 module ConceptAIYAMLExporter
+  ##
+  # Export array of ConceptAI objects from Project to YAML output file
+  # @param concepts_ai (Array)
+  # @param project (Project)
   def self.export_all(concepts_ai, project)
     questions = []
     concepts_ai.each do |concept_ai|
@@ -16,11 +20,11 @@ module ConceptAIYAMLExporter
     project.get(:yamlfile).write(output.to_yaml)
   end
 
-  def self.get_questions_from(concept_ai)
+  private_class_method def self.get_questions_from(concept_ai)
     data = []
     return data unless concept_ai.process?
-    stages = Project.instance.stages
-    stages.each_key do |stage|
+
+    Application.instance.config['questions']['stages'].each do |stage|
       concept_ai.questions[stage].each do |question|
         question.lang = concept_ai.lang
         data << QuestionHashFormatter.to_hash(question)

data/lib/asker/exporter/output_file_exporter.rb

@@ -11,7 +11,7 @@ module OutputFileExporter
   def self.export(data, project)
     ConceptAIGiftExporter.export_all(data[:concepts_ai], project)
     # UNDER DEVELOPMENT
-    CodeGiftExporter.export_all(data[:codes], project.get(:outputfile))
+    CodeGiftExporter.export_all(data[:codes_ai], project.get(:outputfile))
     ConceptAIYAMLExporter.export_all(data[:concepts_ai], project)
     ConceptDocExporter.export_all(data[:concepts], project.get(:lessonfile))
   end

data/lib/asker/files/config.ini

@@ -3,7 +3,44 @@
 ; Accept yes|no
 internet = no
 
+; Output files will be save into output folder.
+outputdir = output
+
+; Display on screen messages about program progress
+; Accept yes|no
+verbose = yes
+color = yes
+
+; Accept resume|default
+show_mode = default
+
+[languages]
+; Default code language
+default = en
+
+; List of code languages to be loaded
+; Accept yes|no
+en = yes
+es = yes
+javascript = yes
+math = no
+python = yes
+ruby = yes
+sql = yes
+
+[ai]
+
+; Concept formula weights to find neighbors: context, tags, tables
+formula_weights = 1, 1, 1
+
 [questions]
+
+; List of values d,b,f,i,s,t
+stages = d,b,f,i,s,t
+
+; Questions category
+category =
+
 ; Exclude questions with this texts into their names.
 ; Accept Comma separated strings.
 exclude =

data/lib/asker/files/example-concept.haml

@@ -2,7 +2,6 @@
 
   %concept
     %names AC/DC, ACDC
-    %tags single, seat, leg, backrest
     %tags rock, band, australia
     %def Australian rock band formed by Scottish-born brothers Malcolm and Angus Young
     %table{ :fields => 'members'}

data/lib/asker/lang/lang.rb

@@ -23,19 +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
-      Logger.verboseln "[ERROR] lang.initialize(): Reading YAML file <#{filename}>"
-      Logger.verboseln "[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,39 @@
 
 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)
+    @langs[code]
   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)