asker-tool 2.1.5 → 2.2.1

data/lib/asker/ai/stages/stage_t.rb

@@ -1,170 +1,211 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'set'
 require_relative 'base_stage'
 require_relative '../question'
 
+##
+# StageT create questions based con Table data
+# range t1-t9
+# rubocop:disable Metrics/ClassLength
 class StageT < BaseStage
-  #range t1-t9...c1-c9
-
-  def run(pTable, pRow, pList) #process_tableXfields
+  # process_tableXfields
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  def run(table, row, list)
     questions = []
-    return questions unless type=="text"
-
-    if pTable.fields.count>1 then
-      questions = questions + process_table2fields(pTable, pRow, pList, 0, 1)
-    elsif pTable.fields.count>2 then
-      questions = questions + process_table2fields(pTable, pRow, pList, 0, 2)
-      questions = questions + process_table2fields(pTable, pRow, pList, 1, 2)
-    elsif pTable.fields.count>3 then
-      questions = questions + process_table2fields(pTable, pRow, pList, 0, 3)
-      questions = questions + process_table2fields(pTable, pRow, pList, 1, 3)
-      questions = questions + process_table2fields(pTable, pRow, pList, 2, 3)
+    return questions unless concept.type == 'text'
+
+    if table.fields.count == 2
+      questions += process_table2fields(table, row, list, 0, 1)
+    elsif table.fields.count == 3
+      questions += process_table2fields(table, row, list, 0, 1)
+      questions += process_table2fields(table, row, list, 0, 2)
+    elsif table.fields.count == 4
+      questions += process_table2fields(table, row, list, 0, 1)
+      questions += process_table2fields(table, row, list, 0, 2)
+      questions += process_table2fields(table, row, list, 0, 3)
     end
 
-    return questions
+    questions
   end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+
+  private
 
-private
-  def process_table2fields(lTable, lRow, pList, pCol1, pCol2)
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/PerceivedComplexity
+  def process_table2fields(table, row, list, col1, col2)
     questions = []
-    #create gift questions
-
-    # Using the column #0
-    s=Set.new [ lRow[:data][0] , lang.text_for(:none) ]
-    pList.each { |i| s.add( i[:data][0] ) }
-    a=s.to_a
-
-    if s.count>3 then
-      q=Question.new
-      q.name="#{name}-#{num.to_s}-t1table-#{lTable.name}"
-      q.text=lang.text_for(:t1table, name, lTable.fields[0].capitalize, lTable.fields[1].capitalize, lRow[:data][1])
-      q.good=lRow[:data][0]
+    lang = concept.lang
+    # create questions
+
+    # Question choice: Using the column #0
+    s = Set.new [row[:data][col1], lang.text_for(:none)]
+    list.each { |i| s.add(i[:data][col1]) }
+    a = s.to_a
+
+    if s.count > 3
+      q = Question.new
+      q.name = "#{name}-#{num}-t1table-#{table.name}"
+      q.text = random_image_for(name) \
+             + lang.text_for(:t1table, name, table.fields[col1].capitalize, \
+                             table.fields[col2].capitalize, row[:data][col2])
+      q.good = row[:data][col1]
       q.bads << lang.text_for(:none)
       q.bads << a[2]
       q.bads << a[3]
       questions << q
     end
 
-    s=Set.new [ lRow[:data][0], lang.text_for(:none) ]
-    pList.each { |i| s.add( i[:data][0] ) }
-    a=s.to_a
-
-    if s.count>4 then
-      q=Question.new
-      q.name="#{name}-#{num.to_s}-t2table-#{lTable.name}"
-      q.text=lang.text_for(:t2table, name, lTable.fields[0].capitalize, lTable.fields[1].capitalize, lRow[:data][1])
-      q.good=lang.text_for(:none)
+    s = Set.new [row[:data][col1], lang.text_for(:none)]
+    list.each { |i| s.add(i[:data][col1]) }
+    a = s.to_a
+
+    if s.count > 4
+      q = Question.new
+      q.name = "#{name}-#{num}-t2table-#{table.name}"
+      q.text = random_image_for(name) \
+             + lang.text_for(:t2table, name, table.fields[col1].capitalize, \
+                             table.fields[col2].capitalize, row[:data][col2])
+      q.good = lang.text_for(:none)
       q.bads << a[2]
       q.bads << a[3]
       q.bads << a[4]
       questions << q
     end
 
-    # Using the column #1
-    s=Set.new [ lRow[:data][1], lang.text_for(:none) ]
-    pList.each { |i| s.add( i[:data][1] ) }
-    a=s.to_a
-
-    if s.count>3 then
-      q=Question.new
-      q.name="#{name}-#{num.to_s}-t3table-#{lTable.name}"
-      q.text=lang.text_for(:t3table, name, lTable.fields[0].capitalize, lRow[:data][0], lTable.fields[1].capitalize)
-      q.good=a[0]
+    # Question choice: Using the column #1
+    s = Set.new [row[:data][col2], lang.text_for(:none)]
+    list.each { |i| s.add(i[:data][col2]) }
+    a = s.to_a
+
+    if s.count > 3
+      q = Question.new
+      q.name = "#{name}-#{num}-t3table-#{table.name}"
+      q.text = random_image_for(name) \
+            +  lang.text_for(:t3table, name, table.fields[col1].capitalize, \
+                             row[:data][col1], table.fields[col2].capitalize)
+      q.good = a[0]
       q.bads << lang.text_for(:none)
       q.bads << a[2]
       q.bads << a[3]
       questions << q
     end
 
-    s=Set.new [ lRow[:data][1], lang.text_for(:none) ]
-    pList.each { |i| s.add( i[:data][1] ) }
-    a=s.to_a
-
-    if s.count>4 then
-      q=Question.new
-      q.name="#{name}-#{num.to_s}-t4table-#{lTable.name}"
-      q.text=lang.text_for(:t4table, name, lTable.fields[0].capitalize, lRow[:data][0], lTable.fields[1].capitalize)
-      q.good=lang.text_for(:none)
+    s = Set.new [row[:data][col2], lang.text_for(:none)]
+    list.each { |i| s.add(i[:data][col2]) }
+    a = s.to_a
+
+    if s.count > 4
+      q = Question.new
+      q.name = "#{name}-#{num}-t4table-#{table.name}"
+      q.text = random_image_for(name) \
+             + lang.text_for(:t4table, name, table.fields[col1].capitalize, \
+                             row[:data][col1], table.fields[col2].capitalize)
+      q.good = lang.text_for(:none)
       q.bads << a[2]
       q.bads << a[3]
       q.bads << a[4]
       questions << q
     end
 
-    # Boolean association TRUE
-    q=Question.new
+    # Question Boolean: TRUE
+    q = Question.new
     q.set_boolean
-    q.name="#{name}-#{num.to_s}t5table-#{lTable.name}"
-    q.text=lang.text_for(:t5table, name, lTable.fields[0].capitalize, lRow[:data][0] ,lTable.fields[1].capitalize, lRow[:data][1] )
-    q.good="TRUE"
+    q.name = "#{name}-#{num}t5table-#{table.name}"
+    q.text = random_image_for(name) \
+           + lang.text_for(:t5table, name, table.fields[col1].capitalize, \
+                           row[:data][col1], table.fields[col2].capitalize, row[:data][col2])
+    q.good = 'TRUE'
     questions << q
 
-    # Boolean association FALSE
-    s=Set.new [ lRow[:data][1] ]
-    pList.each { |i| s.add( i[:data][1] ) }
-    a=s.to_a
+    # Question Boolean: FALSE
+    s = Set.new [row[:data][col2]]
+    list.each { |i| s.add(i[:data][col2]) }
+    a = s.to_a
 
-    if s.count>1 then
-      q=Question.new
+    if s.count > 1
+      q = Question.new
       q.set_boolean
-      q.name="#{name}-#{num.to_s}-t6table-#{lTable.name}"
-      q.text=lang.text_for(:t6table, name, lTable.fields[0].capitalize, lRow[:data][0], lTable.fields[1].capitalize, a[1] )
-      q.good="FALSE"
+      q.name = "#{name}-#{num}-t6table-#{table.name}"
+      q.text = random_image_for(name) \
+             + lang.text_for(:t6table, name, table.fields[col1].capitalize, \
+                             row[:data][col1], table.fields[col2].capitalize, a[1])
+      q.good = 'FALSE'
       questions << q
     end
 
-    s=Set.new [ lRow[:data][0] ]
-    pList.each { |i| s.add( i[:data][0] ) }
-    a=s.to_a
+    s = Set.new [row[:data][col1]]
+    list.each { |i| s.add(i[:data][col1]) }
+    a = s.to_a
 
-    if s.count>1 then
-      q=Question.new
+    if s.count > 1
+      q = Question.new
       q.set_boolean
-      q.name="#{name}-#{num.to_s}t7table-#{lTable.name}"
-      q.text=lang.text_for(:t7table, name, lTable.fields[0].capitalize, a[1], lTable.fields[1].capitalize, lRow[:data][1] )
-      q.good="FALSE"
+      q.name = "#{name}-#{num}t7table-#{table.name}"
+      q.text = random_image_for(name) \
+             + lang.text_for(:t7table, name, table.fields[col1].capitalize, \
+                             a[1], table.fields[col2].capitalize, row[:data][col2])
+      q.good = 'FALSE'
       questions << q
     end
 
-    # Short answer with column #0, 1 word
-    if lang.count_words(lRow[:data][0])==1 then
-      q=Question.new
+    # Question Short: column #0, 1 word
+    if lang.count_words(row[:data][col1]) == 1
+      q = Question.new
       q.set_short
-      q.name="#{name}-#{num.to_s}t8table-#{lTable.name}"
-      q.text=lang.text_for(:t8table, name, lTable.fields[1].capitalize, lRow[:data][1], lTable.fields[0].capitalize)
-      q.shorts << lRow[:data][0]
-      q.shorts << lRow[:data][0].gsub("-"," ").gsub("_"," ")
+      q.name = "#{name}-#{num}t8table-#{table.name}"
+      q.text = random_image_for(name) \
+             + lang.text_for(:t8table, name, table.fields[col2].capitalize, \
+                             row[:data][col2], table.fields[col1].capitalize)
+      q.shorts << row[:data][col1]
+      q.shorts << row[:data][col1].gsub('-', ' ').gsub('_', ' ')
       questions << q
-    elsif lang.count_words(lRow[:data][0])==2 then
-      q=Question.new
+    elsif lang.count_words(row[:data][col1]) == 2
+      q = Question.new
       q.set_short
-      q.name="#{name}-#{num.to_s}t9table-#{lTable.name}"
-      q.text=lang.text_for(:t9table, name, lTable.fields[1].capitalize, lRow[:data][1], lTable.fields[0].capitalize, "[#{lang.hide_text(lRow[:data][0])}]", lang.count_words(lRow[:data][0]) )
-      q.shorts << lRow[:data][0]
-      q.shorts << lRow[:data][0].gsub("-"," ").gsub("_"," ")
+      q.name = "#{name}-#{num}t9table-#{table.name}"
+      q.text = random_image_for(name) \
+             + lang.text_for(:t9table, name, table.fields[col2].capitalize, \
+                             row[:data][col2], table.fields[col1].capitalize, \
+                             "[#{lang.hide_text(row[:data][col1])}]", lang.count_words(row[:data][col1]))
+      q.shorts << row[:data][col1]
+      q.shorts << row[:data][col1].gsub('-', ' ').gsub('_', ' ')
       questions << q
     end
 
-    # Short answer with column #1, 1 word
-    if lang.count_words(lRow[:data][1])==1 then
-      q=Question.new
+    # Question Short: column #1, 1 word
+    if lang.count_words(row[:data][col2]) == 1
+      q = Question.new
       q.set_short
-      q.name="#{name}-#{num.to_s}t8table-#{lTable.name}"
-      q.text=lang.text_for(:t8table, name, lTable.fields[0].capitalize, lRow[:data][0], lTable.fields[1].capitalize)
-      q.shorts << lRow[:data][1]
-      q.shorts << lRow[:data][1].gsub("-"," ").gsub("_"," ")
+      q.name = "#{name}-#{num}t8table-#{table.name}"
+      q.text = random_image_for(name) \
+             + lang.text_for(:t8table, name, table.fields[col1].capitalize, \
+                             row[:data][col1], table.fields[col2].capitalize)
+      q.shorts << row[:data][col2]
+      q.shorts << row[:data][col2].gsub('-', ' ').gsub('_', ' ')
       questions << q
-    elsif lang.count_words(lRow[:data][1])==2 then
-      q=Question.new
+    elsif lang.count_words(row[:data][col2]) == 2
+      q = Question.new
       q.set_short
-      q.name="#{name}-#{num.to_s}t9table-#{lTable.name}"
-      q.text=lang.text_for(:t9table, name, lTable.fields[0].capitalize, lRow[:data][0], lTable.fields[1].capitalize, "[#{lang.hide_text(lRow[:data][1])}]", lang.count_words(lRow[:data][1]) )
-      q.shorts << lRow[:data][1]
-      q.shorts << lRow[:data][1].gsub("-"," ").gsub("_"," ")
+      q.name = "#{name}-#{num}t9table-#{table.name}"
+      q.text = random_image_for(name) \
+             + lang.text_for(:t9table, name, table.fields[col1].capitalize, \
+                             row[:data][col1], table.fields[col2].capitalize, \
+                             "[#{lang.hide_text(row[:data][col2])}]", lang.count_words(row[:data][col2]))
+      q.shorts << row[:data][col2]
+      q.shorts << row[:data][col2].gsub('-', ' ').gsub('_', ' ')
       questions << q
     end
-    return questions
+    questions
   end
-
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/CyclomaticComplexity
+  # rubocop:enable Metrics/PerceivedComplexity
 end
+# rubocop:enable Metrics/ClassLength

data/lib/asker/application.rb

@@ -2,29 +2,37 @@
 
 require 'singleton'
 require 'inifile'
+require 'rainbow'
 
 # Global parameters
 class Application
   include Singleton
 
-  VERSION = '2.1.5'    # Application version
-  NAME = 'asker'       # Application name
-  GEM = 'asker-tool' # Gem name
+  VERSION = '2.2.1'
+  NAME = 'asker'
+  GEM = 'asker-tool'
+  CONFIGFILE = 'asker.ini'
   attr_reader :config
 
-  ##
-  # Initialize Application singleton
   def initialize
     reset
   end
 
-  ##
-  # Initialize config values from external "config.ini" file.
   def reset
-    filename = File.join(Dir.pwd, 'config.ini')
-    unless File.exist? filename
-      filename = File.join(File.dirname(__FILE__), 'files', 'config.ini')
+    filename = File.join(Dir.pwd, CONFIGFILE)
+    filename = File.join(File.dirname(__FILE__), 'files', CONFIGFILE) unless File.exist? filename
+
+    begin
+      @config = IniFile.load(filename)
+    rescue StandardError => e
+      puts e.display
+      puts Rainbow('[ERROR] Revise configuration file:').red.bright
+      puts Rainbow("        #{filename}").red.bright
+      exit 1
     end
-    @config = IniFile.load(filename)
+    stages = @config['questions']['stages'].split(',')
+    @config['questions']['stages'] = stages.map(&:to_sym)
+    Rainbow.enabled = false
+    Rainbow.enabled = true if @config['global']['color'].downcase == 'yes'
   end
 end

data/lib/asker/cli.rb

@@ -8,66 +8,38 @@ require_relative '../asker'
 ##
 # Command Line User Interface
 class CLI < Thor
-  map ['h', '-h', '--help'] => 'help'
+  map ['--help'] => 'help'
 
-  map ['v', '-v', '--version'] => 'version'
+  map ['--version'] => 'version'
   desc 'version', 'Show the program version'
-  ##
-  # Show current version
   def version
-    print Rainbow(Application::NAME).bright.blue
-    puts  " (version #{Rainbow(Application::VERSION).green})"
+    puts "#{Application::NAME} version #{Application::VERSION}"
   end
 
   map ['f', '-f', '--file'] => 'file'
-  desc 'file NAME', 'Build output files, from HAML/XML input file.'
-  option :color, type: :boolean
+  desc '[file] FILEPATH', 'Build output files, from HAML/XML input file.'
   long_desc <<-LONGDESC
-  Create output files, from input file (HAML/XML format).
 
   Build questions about contents defined into input file specified.
 
-  Examples:
+  Create output files, from input file (HAML/XML format).
 
-  (1) #{Rainbow('asker input/foo/foo.haml').yellow}, Build questions from HAML file.
+  Examples:
 
-  (2) #{Rainbow('asker input/foo/foo.xml').yellow}, Build questions from XML file.
+  (1) #{Rainbow('asker input/foo/foo.haml').aqua}, Build questions from HAML file.
 
-  (3) #{Rainbow('asker file --no-color input/foo/foo.haml').yellow}, Same as (1) but without colors.
+  (2) #{Rainbow('asker input/foo/foo.xml').aqua}, Build questions from XML file.
 
-  (4) #{Rainbow('asker projects/foo/foo.yaml').yellow}, Build questions from YAML project file.
+  (3) #{Rainbow('asker projects/foo/foo.yaml').aqua}, Build questions from YAML project file.
 
   LONGDESC
-  ##
-  # Create questions from input file
-  # @param filename (String) Path to input file
   def file(filename)
-    # Enable/disable color output
-    Rainbow.enabled = false if options['color'] == false
     # Asker start processing input file
     Asker.start(filename)
   end
 
-  map ['i', '-i', '--init'] => 'init'
-  desc 'init', 'Create default INI config fie'
-  ##
-  # Create default INI config file
-  def init
-    src = File.join(File.dirname(__FILE__), 'files', 'config.ini')
-    dst = File.join(Dir.pwd, 'config.ini')
-    if File.exist? dst
-      puts "[WARN] Exists file! => #{Rainbow(File.basename(dst)).yellow.bright}"
-    else
-      FileUtils.cp(src, dst)
-      puts "[ OK ] Create file  => #{Rainbow(File.basename(dst)).green}"
-    end
-  end
-
-  map ['c', '-c', '--check'] => 'check'
-  desc 'check', 'Check input HAML file syntax'
-  ##
-  # Check input file syntax
-  # @param filename (String) Path to input file
+  map ['--check'] => 'check'
+  desc 'check FILEPATH', 'Check input HAML file syntax'
   def check(filename)
     # Enable/disable color output
     Rainbow.enabled = false if options['color'] == false
@@ -75,14 +47,19 @@ class CLI < Thor
     Asker.check(filename)
   end
 
-  map ['n', '-b', '--new', 'new'] => 'create_skeleton'
-  desc 'new', 'Create Asker demo input files'
+  map ['--init'] => 'init'
+  desc 'init', 'Create default INI config file'
+  def init
+    Asker.init
+  end
+
+  map ['new','--new'] => 'new_input'
+  desc 'new DIRPATH', 'Create Asker demo input files'
   ##
   # Create Asker demo input files
   # @param dirname (String) Path to folder
-  def create_skeleton(dirname)
-    # Asker start processing input file
-    Asker.create_skeleton(dirname)
+  def new_input(dirname)
+    Asker.new_input(dirname)
   end
 
   ##
@@ -92,4 +69,14 @@ class CLI < Thor
   def method_missing(method, *_args, &_block)
     file(method.to_s)
   end
+
+  def respond_to_missing?(_method_name)
+    true
+  end
+
+  ##
+  # Thor stop and show messages on screen on failure
+  def self.exit_on_failure?
+    true
+  end
 end

data/lib/asker/data/code.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative '../ai/code/code_ai_factory'
+
+class Code
+  attr_reader :dirname, :filename, :type
+  attr_accessor :process, :features
+  attr_reader :lines, :questions
+
+  def initialize(dirname, filename, type)
+    @dirname = dirname
+    @filename = filename
+    @type = type
+    @filepath = File.join(@dirname, @filename)
+    @process = false
+    @features = []
+    @lines = load(@filepath)
+    @questions = []
+  end
+
+  def process?
+    @process
+  end
+
+  def lines_to_s(lines)
+    out = ''
+    lines.each_with_index do |line, index|
+      out << format("%2d| #{line}\n", (index + 1))
+    end
+    out
+  end
+
+  private
+
+  def load(filepath)
+    return if filepath.nil?
+
+    unless File.exist? filepath
+      puts Rainbow("[ERROR] Unkown file #{filepath}").red.bright
+      return
+    end
+    content = File.read(filepath)
+    encode_and_split(content)
+  end
+
+  def encode_and_split(text, encoding = :default)
+    # Convert text to UTF-8 deleting unknown chars
+    text ||= '' # Ensure text is not nil
+    flag = [:default, 'UTF-8'].include? encoding
+    return text.encode('UTF-8', invalid: :replace).split("\n") if flag
+
+    # Convert text from input ENCODING to UTF-8
+    ec = Encoding::Converter.new(encoding.to_s, 'UTF-8')
+    begin
+      text = ec.convert(text)
+    rescue StandardError => e
+      puts "[ERROR] Encoding: #{e}"
+    end
+
+    text.split("\n")
+  end
+end

data/lib/asker/data/column.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 # Contain data information for every column
 # Params:
@@ -9,10 +8,15 @@
 class Column
   attr_reader :row, :index, :id, :raw, :lang, :type, :simple
 
+  ##
+  # initialize Column
+  # @param row (Row)
+  # @param index (Integer)
+  # @param xml_data (XMLdata)
   def initialize(row, index, xml_data)
     @row    = row
     @index  = index
-    @id     = @row.id + '.' + @index.to_s
+    @id     = "#{@row.id}.#{@index}"
     @raw    = ''
     @lang   = @row.langs[@index]
     @type   = @row.types[@index]
@@ -28,35 +32,41 @@ class Column
       return "<img src=\"#{raw}\" alt\=\"image\">"
     when 'textfile_path'
       return "<pre>#{raw}</pre>"
-    else
-      return "ERROR type #{@type}"
     end
+    "ERROR type #{@type}"
   end
 
   private
 
   def read_data_from_xml(xml_data)
-    raise '[ERROR] Column XML data with elements!' if xml_data.elements.count.positive?
+    raise '[ERROR] Column with elements!' if xml_data.elements.count.positive?
 
     @raw = xml_data.text.strip.to_s
 
     # read attributes from XML input data
-    if xml_data.attributes['lang']
-      code = xml_data.attributes['lang'].strip
-      if code != @lang.code
-        @lang = LangFactory.instance.get(code)
-        @simple[:lang] = false
-        @row.simple_off(:lang)
-      end
-    end
+    read_lang_from_xml(xml_data)
+    read_type_from_xml(xml_data)
+  end
 
-    if xml_data.attributes['type']
-      type = xml_data.attributes['type'].strip
-      if type != @type.to_s
-        @type = type
-        @simple[:type] = false
-        @row.simple_off(:type)
-      end
-    end
+  def read_lang_from_xml(xml_data)
+    return unless xml_data.attributes['lang']
+
+    code = xml_data.attributes['lang'].strip
+    return if code == @lang.code
+
+    @lang = LangFactory.instance.get(code)
+    @simple[:lang] = false
+    @row.simple_off(:lang)
+  end
+
+  def read_type_from_xml(xml_data)
+    return unless xml_data.attributes['type']
+
+    type = xml_data.attributes['type'].strip
+    return if type == @type.to_s
+
+    @type = type
+    @simple[:type] = false
+    @row.simple_off(:type)
   end
 end