asker-tool 2.1.2

data/lib/asker/lang/lang.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'yaml'
+require_relative 'text_actions'
+
+# Lang#lang
+class Lang
+  include TextActions
+
+  attr_reader :code, :mistakes
+
+  def initialize(code = 'en')
+    @code = code.to_s
+    load_files
+  end
+
+  def lang
+    @code
+  end
+
+  private
+
+  def load_files
+    dirbase = File.dirname(__FILE__)
+    filename = File.join(dirbase, 'locales', @code, 'templates.yaml')
+    begin
+      @templates = YAML.load(File.new(filename))
+    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"
+      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))
+  end
+
+end

data/lib/asker/lang/lang_factory.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require_relative 'lang'
+require_relative '../project'
+
+# LangFactory#get
+class LangFactory
+  include Singleton
+
+  def initialize
+    @langs = {}
+    Project.instance.locales.each { |i| @langs[i] = Lang.new(i) }
+  end
+
+  def get(locale)
+    @langs[locale]
+  end
+end

data/lib/asker/lang/text_actions.rb

@@ -0,0 +1,150 @@
+# encoding: utf-8
+
+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
+  end
+
+  def text_filter_connectors(pText, pFilter)
+    input_lines = pText.split(".")
+    output_lines = []
+    output_words = []
+    input_lines.each_with_index do |line, rowindex|
+	    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 }
+		      row << (output_words.size-1)
+	      else
+		      row << word
+		    end
+	    end
+	    row << '.'
+	    output_lines << row
+	  end
+
+    indexes = []
+    exclude = ['[', ']', '(', ')', "\"" ]
+    output_words.each_with_index do |item, index|
+      flag = true
+      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
+  end
+
+  def text_with_connectors(text)
+	  text_filter_connectors(text, false)
+  end
+
+  def text_without_connectors(text)
+	  text_filter_connectors(text, true)
+  end
+
+  def build_text_from_filtered(pStruct, pIndexes)
+    lines    = pStruct[:lines]
+    lIndexes = pIndexes.sort
+    counter  = 1
+    lText    = ''
+
+    lines.each do |line|
+      line.each do |value|
+        if value.class == String
+          lText += (' ' + 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}]"
+            counter += 1
+          else
+            lword = pStruct[:words][value][:word]
+            lText += (' ' + lword)
+          end
+        end
+      end
+    end
+    lText.gsub!(' .', '.')
+    lText.gsub!(' ,', ',')
+    lText = lText[1, lText.size] if lText[0] == ' '
+    lText
+  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
+  end
+
+  def do_mistake_to(pText = '')
+    lText = pText.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
+    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
+    end
+    return lText if lText != pText
+
+    lText + 's'
+  end
+
+  def hide_text(input_text)
+    input = input_text.clone
+    if count_words(input) < 2 && input.size < 10
+      output = '[*]'
+    else
+      output = ''
+      input.each_char do |char|
+        if ' !|"@#$%&/()=?¿¡+*(){}[],.-_<>'.include? char
+          output += char
+        else
+          output += '?'
+        end
+      end
+    end
+    output
+  end
+end

data/lib/asker/loader/code_loader.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+require 'rexml/document'
+require_relative '../logger'
+require_relative '../code/code'
+
+# Read XML info about Code input data
+module CodeLoader
+  ##
+  # Load XML data about Code object
+  # @param xmldata (XML Object)
+  # @param filepath (String)
+  # @return Code object
+  def self.load(xmldata, filepath)
+    data = read_codedata_from_xml(xmldata, File.basename(filepath))
+    code = Code.new(File.dirname(filepath), data[:path], data[:type])
+    code.features << data[:features]
+    code
+  end
+
+  ##
+  # Read Code data from XML content
+  # @param xmldata (XML Object)
+  # @param filename (String) File name that contains data
+  # @return Code object
+  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'
+      data[:type] = i.text.to_sym if i.name == 'type'
+      data[:features] << read_features(i, filename) if i.name == 'features'
+    end
+    data
+  end
+
+  ##
+  # Read features data from XML input
+  # @param xmldata (XML object)
+  # @return Array with features (Strings)
+  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
+      end
+    end
+    features
+  end
+end

data/lib/asker/loader/content_loader.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+require 'rexml/document'
+require_relative '../data/concept'
+require_relative 'code_loader'
+require_relative '../logger'
+require_relative '../project'
+
+# Define methods that load data from XML contents
+module ContentLoader
+  ##
+  # Load XML content into Asker data objects
+  # @param filepath (String) File path
+  # @param content (String) XML plane text content
+  def self.load(filepath, content)
+    concepts = []
+    codes = []
+    begin
+      xmlcontent = REXML::Document.new(content)
+    rescue REXML::ParseException
+      raise_error_with(filepath, content)
+    end
+    lang = read_lang_attribute(xmlcontent)
+    context = read_context_attribute(xmlcontent)
+
+    xmlcontent.root.elements.each do |xmldata|
+      case xmldata.name
+      when 'concept'
+        concepts << read_concept(xmldata, filepath, lang, context)
+      when 'code'
+        codes << read_code(xmldata, filepath)
+      else
+        Logger.verboseln Rainbow("[ERROR] Unkown tag <#{xmldata.name}>").red
+      end
+    end
+
+    { concepts: concepts, codes: codes }
+  end
+
+  ##
+  # Read lang attr from input XML data
+  # @param xmldata (XML Object)
+  def self.read_lang_attribute(xmldata)
+    begin
+      lang = xmldata.root.attributes['lang']
+    rescue StandardError
+      lang = Project.instance.lang
+    end
+    lang
+  end
+
+  ##
+  # Read context attr from input XML data
+  # @param xmldata (XML Object)
+  def self.read_context_attribute(xmldata)
+    begin
+      context = xmldata.root.attributes['context']
+    rescue StandardError
+      context = 'unknown'
+    end
+    context
+  end
+
+  ##
+  # Read concept from input XML data
+  # @param xmldata (XML Object)
+  # @param filepath (String)
+  # @param lang
+  # @param context
+  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
+  end
+
+  ##
+  # Read code from input XML data
+  # @param xmldata (XML Object)
+  # @param filepath (String)
+  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
+  end
+
+  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')
+    f.write(content)
+    f.close
+    raise msg
+  end
+end

data/lib/asker/loader/directory_loader.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'file_loader'
+require_relative '../logger'
+
+# Load input data from one directory
+module DirectoryLoader
+  ##
+  # Load input data from directory
+  # @param dirname (String) Directory name
+  def self.load(dirname)
+    DirectoryLoader.check_dir(dirname)
+    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}"
+    DirectoryLoader.load_files(accepted, dirname)
+  end
+
+  ##
+  # Check directory
+  # @param dirname (String) Directory name
+  def self.check_dir(dirname)
+    return if Dir.exist? dirname
+
+    msg = Rainbow("[ERROR] #{dirname} directory dosn't exist!").color(:red)
+    Logger.verboseln msg
+    raise msg
+  end
+
+  ##
+  # Load accepted files from dirname directory
+  # @param filenames (Array) File name list
+  # @param dirname (String) Base directory
+  def self.load_files(filenames, dirname)
+    output = { concepts: [], codes: [] }
+    filenames.each do |filename|
+      filepath = File.join(dirname, filename)
+      data = DirectoryLoader.load_file(filepath, filename == filenames.last)
+      output[:concepts] += data[:concepts]
+      output[:codes] += data[:codes]
+    end
+    output
+  end
+
+  ##
+  # Load one input file
+  # @param filepath (String) Path to input file
+  # @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}"
+    else
+      Logger.verbose "   ├── Input file   = #{Rainbow(filepath).bright}"
+    end
+    FileLoader.load(filepath)
+  end
+end

data/lib/asker/loader/file_loader.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'haml'
+require_relative 'content_loader'
+require_relative '../logger'
+
+# Methods that load a filename and return list of concepts
+module FileLoader
+  ##
+  # Load asker data from file
+  # @param filename (String) File name to be load
+  def self.load(filename)
+    if File.extname(filename).casecmp('.haml').zero?
+      file_content = load_haml filename
+    elsif File.extname(filename).casecmp('.xml').zero?
+      file_content = File.read(filename)
+    else
+      msg = "[ERROR] FileLoader: Format error #{filename}"
+      Logger.verbose 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