asker-tool 2.1.5 → 2.2.1

data/lib/asker/{checker.rb → input_checker.rb}

@@ -1,40 +1,41 @@
+# frozen_string_literal: true
 
 require 'rainbow'
 
 ##
 # Check HAML file syntax
-module Checker
-  ##
-  # Check:
-  # * file exist
-  # * filename extension
-  # * and HAML syntax
-  # @param filepath (String)
-  def self.check(filepath)
+module InputChecker
+
+  def self.check(filepath, verbose = true)
+    exist = check_file_exist(filepath, verbose)
+    return false unless exist
+    check_file_content(filepath, verbose)
+  end
+
+  def self.check_file_exist(filepath, verbose = true)
     unless File.exist? filepath
-      puts Rainbow("File not found!").red.bright
+      puts Rainbow('File not found!').red.bright if verbose
       return false
     end
     unless File.extname(filepath) == '.haml'
-      puts Rainbow("Only check HAML files!").yellow.bright
+      puts Rainbow('Only check HAML files!').yellow.bright if verbose
       return false
     end
-    check_filepath(filepath)
+    true
   end
 
-  ##
-  # Check HAML syntax
-  # @param filepath (String)
-  def self.check_filepath(filepath)
+  def self.check_file_content(filepath, verbose = true)
     data = Data.new(filepath)
     data.check
-    data.show_errors
-    data.is_ok?
+    data.show_errors if verbose
+    data.ok?
   end
 
+  # rubocop:disable Metrics/ClassLength
   class Data
-    attr_reader :inputs
-    attr_reader :outputs
+    attr_reader :inputs, :outputs
+
+    # rubocop:disable Metrics/MethodLength
     def initialize(filepath)
       @inputs = File.read(filepath).split("\n")
       @outputs = []
@@ -49,8 +50,9 @@ module Checker
       end
       @ok = false
     end
+    # rubocop:enable Metrics/MethodLength
 
-    def is_ok?
+    def ok?
       @ok
     end
 
@@ -62,16 +64,31 @@ module Checker
 
     def show_errors
       errors = 0
+      # puts "Line : Error description"
       @outputs.each do |i|
         next if i[:state] == :ok
+
         errors += 1
-        puts "%02d" % i[:id] + ": %s." % i[:msg] + " => #{i[:source][0,40]}" if errors < 11
-        puts "..." if errors == 11
+        if errors < 11
+          data = { id: i[:id], msg: i[:msg], source: i[:source][0, 40] }
+          order = i[:id] + 1
+          data = { order: order, msg: i[:msg], source: i[:source][0, 40] }
+          puts format(' %<order>03d : %<msg>s. => %<source>s', data)
+        end
+        puts '...' if errors == 11
+      end
+
+      if errors.positive?
+        puts Rainbow("[ERROR] #{errors} errors " \
+                     "from #{@inputs.size} lines!").red.bright
       end
-      puts Rainbow("[ERROR] #{errors} errors from #{@inputs.size} lines!").red.bright if errors > 0
-      puts Rainbow("Syntax OK!").green if errors == 0
+      puts Rainbow('Syntax OK!').green if errors.zero?
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
     def check
       @ok = true
       @inputs.each_with_index do |line, index|
@@ -95,19 +112,23 @@ module Checker
       end
       @ok
     end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
 
     private
 
     def check_empty_lines(line, index)
-      if line.strip.size.zero? or line.start_with? '#'
-        @outputs[index][:type] = :empty
-        @outputs[index][:level] = -1
-        @outputs[index][:state] = :ok
-      end
+      return unless line.strip.size.zero? || line.start_with?('#')
+
+      @outputs[index][:type] = :empty
+      @outputs[index][:level] = -1
+      @outputs[index][:state] = :ok
     end
 
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
     def check_map(line, index)
-      if index == 0
+      if index.zero?
         @outputs[index][:type] = :map
         if line.start_with?('%map{')
           @outputs[index][:state] = :ok
@@ -115,13 +136,17 @@ module Checker
           @outputs[index][:state] = :err
           @outputs[index][:msg] = 'Start with %map{'
         end
-      elsif index > 0 and line.include?('%map{')
+      elsif index.positive? && line.include?('%map{')
         @outputs[index][:state] = :err
         @outputs[index][:type] = :map
         @outputs[index][:msg] = 'Write %map on line 0'
       end
     end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
 
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
     def check_concept(line, index)
       return unless @outputs[index][:state] == :none
       return unless line.include? '%concept'
@@ -137,7 +162,11 @@ module Checker
         @outputs[index][:msg] = 'Write 2 spaces before %concept'
       end
     end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
     def check_names(line, index)
       return unless @outputs[index][:state] == :none
       return unless line.include? '%names'
@@ -153,7 +182,11 @@ module Checker
         @outputs[index][:msg] = 'Write 4 spaces before %names'
       end
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
     def check_tags(line, index)
       return unless @outputs[index][:state] == :none
       return unless line.include? '%tags'
@@ -169,7 +202,11 @@ module Checker
         @outputs[index][:msg] = 'Write 4 spaces before %tags'
       end
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
     def check_def(line, index)
       return unless @outputs[index][:state] == :none
       return unless line.include? '%def'
@@ -185,7 +222,11 @@ module Checker
         @outputs[index][:msg] = 'Write 4 spaces before %def'
       end
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
     def check_table(line, index)
       return unless @outputs[index][:state] == :none
       return unless line.include? '%table'
@@ -201,7 +242,11 @@ module Checker
         @outputs[index][:msg] = 'Write 4 spaces before %table'
       end
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
     def check_row(line, index)
       return unless @outputs[index][:state] == :none
       return unless line.include? '%row'
@@ -209,14 +254,15 @@ module Checker
       @outputs[index][:type] = :row
       @outputs[index][:state] = :ok
 
-      if count_spaces(line) == 6
+      case count_spaces(line)
+      when 6
         @outputs[index][:level] = 3
         parent = find_parent(index)
-        unless [:table, :features].include? parent
+        unless %i[table features].include? parent
           @outputs[index][:state] = :err
           @outputs[index][:msg] = 'Parent(table/features) not found!'
         end
-      elsif count_spaces(line) == 8
+      when 8
         @outputs[index][:level] = 4
         if find_parent(index) != :template
           @outputs[index][:state] = :err
@@ -227,20 +273,25 @@ module Checker
         @outputs[index][:msg] = 'Write 6 or 8 spaces before %row'
       end
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
     def check_col(line, index)
       return unless @outputs[index][:state] == :none
       return unless line.include? '%col'
 
       @outputs[index][:type] = :col
       @outputs[index][:state] = :ok
-      if count_spaces(line) == 8
+      case count_spaces(line)
+      when 8
         @outputs[index][:level] = 4
         if find_parent(index) != :row
           @outputs[index][:state] = :err
           @outputs[index][:msg] = 'Parent(row) not found!'
         end
-      elsif count_spaces(line) == 10
+      when 10
         @outputs[index][:level] = 5
         if find_parent(index) != :row
           @outputs[index][:state] = :err
@@ -250,8 +301,26 @@ module Checker
         @outputs[index][:state] = :err
         @outputs[index][:msg] = 'Write 8 or 10 spaces before %col'
       end
+      check_text(line, index)
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
+
+    def check_text(line, index)
+      return unless @outputs[index][:state] == :ok
+
+      ok = ''
+      %w[< >].each do |char|
+        ok = char if line.include? char
+      end
+      return if ok == ''
+
+      @outputs[index][:state] = :err
+      @outputs[index][:msg] = "Char #{ok} not allow!"
     end
 
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
     def check_template(line, index)
       return unless @outputs[index][:state] == :none
       return unless line.include? '%template'
@@ -267,7 +336,11 @@ module Checker
         @outputs[index][:msg] = 'Write 6 spaces before %template'
       end
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
     def check_code(line, index)
       return unless @outputs[index][:state] == :none
       return unless line.include? '%code'
@@ -283,7 +356,11 @@ module Checker
         @outputs[index][:msg] = 'Write 2 spaces before %code'
       end
     end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
 
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
     def check_type(line, index)
       return unless @outputs[index][:state] == :none
       return unless line.include? '%type'
@@ -299,7 +376,11 @@ module Checker
         @outputs[index][:msg] = 'Write 4 spaces before %type'
       end
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
     def check_path(line, index)
       return unless @outputs[index][:state] == :none
       return unless line.include? '%path'
@@ -315,7 +396,11 @@ module Checker
         @outputs[index][:msg] = 'Write 4 spaces before %type'
       end
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
     def check_features(line, index)
       return unless @outputs[index][:state] == :none
       return unless line.include? '%features'
@@ -331,6 +416,8 @@ module Checker
         @outputs[index][:msg] = 'Write 4 spaces before %features'
       end
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
     def check_unknown(line, index)
       return unless @outputs[index][:state] == :none
@@ -355,19 +442,9 @@ module Checker
     end
 
     def count_spaces(line)
-      return 0 if line.start_with? '%'
-      return 1 if line.start_with? ' %'
-      return 2 if line.start_with? '  %'
-      return 3 if line.start_with? '   %'
-      return 4 if line.start_with? '    %'
-      return 5 if line.start_with? '     %'
-      return 6 if line.start_with? '      %'
-      return 7 if line.start_with? '       %'
-      return 8 if line.start_with? '        %'
-      return 9 if line.start_with? '         %'
-      return 10 if line.start_with? '          %'
-
-      -1
+      a = line.split('%')
+      a[0].count(' ')
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

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,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)