asker-tool 2.1.3 → 2.2.0

data/lib/asker/data/concept.rb

@@ -3,20 +3,37 @@
 require 'rainbow'
 require 'rexml/document'
 
-require_relative '../project'
+require_relative '../application'
+require_relative '../logger'
 require_relative '../lang/lang_factory'
+require_relative '../loader/embedded_file'
 require_relative 'table'
 require_relative 'data_field'
 
+##
 # Store Concept information
+# rubocop:disable Metrics/ClassLength
+# rubocop:disable Style/ClassVars
 class Concept
-  attr_reader :id, :lang, :context
-  attr_reader :names, :type, :filename
-  attr_reader :data
-  attr_accessor :process
-
-  @@id = 0
-
+  attr_reader :id        # Unique identifer (Integer)
+  attr_reader :lang      # Lang code (By default is the same as map lang)
+  attr_reader :context   # Context inherits from map
+  attr_reader :names     # Names used to identify or name this concept
+  attr_reader :type      # type = text -> Name values are only text
+  attr_reader :filename  # Filename where this concept is defined
+  attr_reader :data      # Data about this concept
+  attr_accessor :process # (Boolean) if it is necesary generate questions
+
+  @@id = 0 # Global Concept counter
+
+  ##
+  # Initilize Concept
+  # @param xml_data (XML)
+  # @param filename (String)
+  # @param lang_code (String)
+  # @param context (Array)
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
   def initialize(xml_data, filename, lang_code = 'en', context = [])
     @@id += 1
     @id = @@id
@@ -38,16 +55,17 @@ class Concept
 
     @data = {}
     @data[:tags] = []
-    @data[:texts] = []
-    @data[:images] = []         # TODO: By now, We'll treat images separated from texts
-    @data[:textfile_paths] = [] # TODO: By now, We'll treat this separated from texts
+    @data[:texts] = []          # Used by standard def inputs
+    @data[:images] = []         # Used by [type => file and type => image_url] def inputs
     @data[:tables] = []
     @data[:neighbors] = []
     @data[:reference_to] = []
     @data[:referenced_by] = []
 
-	  read_data_from_xml(xml_data)
+    read_data_from_xml(xml_data)
   end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
 
   def name(option = :raw)
     DataField.new(@names[0], @id, @type).get(option)
@@ -71,46 +89,84 @@ class Concept
     @data[:neighbors].reverse!
   end
 
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/CyclomaticComplexity
   def calculate_nearness_to_concept(other)
-    weights = Project.instance.formula_weights
+    a = Application.instance.config['ai']['formula_weights']
+    weights = a.split(',').map(&:to_f)
 
-    li_max1 = @context.count
-    li_max2 = @data[:tags].count
-    li_max3 = @data[:tables].count
+    max1 = @context.count
+    max2 = @data[:tags].count
+    max3 = @data[:tables].count
 
-    lf_alike1 = lf_alike2 = lf_alike3 = 0.0
+    alike1 = alike2 = alike3 = 0.0
 
     # check if exists this items from concept1 into concept2
-    @context.each { |i| lf_alike1 += 1.0 unless other.context.index(i).nil? }
-    @data[:tags].each { |i| lf_alike2 += 1.0 unless other.tags.index(i).nil? }
-    @data[:tables].each { |i| lf_alike3 += 1.0 unless other.tables.index(i).nil? }
+    @context.each { |i| alike1 += 1.0 unless other.context.index(i).nil? }
+    @data[:tags].each { |i| alike2 += 1.0 unless other.tags.index(i).nil? }
+    @data[:tables].each { |i| alike3 += 1.0 unless other.tables.index(i).nil? }
 
-    lf_alike = (lf_alike1 * weights[0] + lf_alike2 * weights[1] + lf_alike3 * weights[2])
-    li_max = (li_max1 * weights[0] + li_max2 * weights[1] + li_max3 * weights[2])
-    (lf_alike * 100.0 / li_max)
+    alike = (alike1 * weights[0] + alike2 * weights[1] + alike3 * weights[2])
+    max = (max1 * weights[0] + max2 * weights[1] + max3 * weights[2])
+    (alike * 100.0 / max)
   end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/CyclomaticComplexity
 
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
   def try_adding_references(other)
     reference_to = 0
-    @data[:tags].each { |i| reference_to += 1 unless other.names.index(i.downcase).nil? }
+    @data[:tags].each do |i|
+      reference_to += 1 unless other.names.index(i.downcase).nil?
+    end
     @data[:texts].each do |t|
       text = t.clone
       text.split(' ').each do |word|
         reference_to += 1 unless other.names.index(word.downcase).nil?
       end
     end
-    if reference_to.positive?
-      @data[:reference_to] << other.name
-      other.data[:referenced_by] << name
-    end
+    return unless reference_to.positive?
+
+    @data[:reference_to] << other.name
+    other.data[:referenced_by] << name
+  end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+
+  def tags
+    @data[:tags]
+  end
+
+  def texts
+    @data[:texts]
+  end
+
+  def images
+    @data[:images]
+  end
+
+  def tables
+    @data[:tables]
   end
 
-  def method_missing(method)
-    @data[method]
+  def neighbors
+    @data[:neighbors]
+  end
+
+  def reference_to
+    @data[:reference_to]
+  end
+
+  def referenced_by
+    @data[:referenced_by]
   end
 
   private
 
+  # rubocop:disable Metrics/MethodLength
   def read_data_from_xml(xml_data)
     xml_data.elements.each do |i|
       case i.name
@@ -118,24 +174,17 @@ class Concept
         process_names(i)
       when 'tags'
         process_tags(i)
-      when 'context'
-        # DEPRECATED: Don't use xml tag <context>
-        # instead define it as attibute of root xml tag
-        process_context(i)
-      when 'text'
-        # DEPRECATED: Use xml tag <def> instead of <text>
-        process_text(i)
       when 'def'
         process_def(i)
       when 'table'
         @data[:tables] << Table.new(self, i)
       else
-        text = "   [ERROR] <#{i.name}> unkown XML attribute for concept #{name}"
-        msg = Rainbow(text).color(:red)
-        Project.instance.verbose msg
+        text = "   [ERROR] Concept #{name} with unkown attribute: #{i.name}"
+        Logger.verboseln Rainbow(text).color(:red)
       end
     end
   end
+  # rubocop:enable Metrics/MethodLength
 
   def process_names(value)
     @names = []
@@ -145,39 +194,33 @@ class Concept
   end
 
   def process_tags(value)
-    raise '[Error] tags label empty!' if value.text.nil? || value.text.size.zero?
+    if value.text.nil? || value.text.size.zero?
+      Logger.verboseln Rainbow("[ERROR] Concept #{name} has tags empty!").red.briht
+      exit 1
+    end
+
     @data[:tags] = value.text.split(',')
     @data[:tags].collect!(&:strip)
   end
 
-  def process_context(value)
-    msg = '   │  ' + Rainbow(' [DEPRECATED] Concept ').yellow
-    msg += Rainbow(name).yellow.bright
-    msg += Rainbow(' move <context> tag info to <map>.').yellow
-    Project.instance.verbose msg
-    @context = value.text.split(',')
-    @context.collect!(&:strip)
-  end
-
-  def process_text(value)
-    msg = '   │  ' + Rainbow(' [DEPRECATED] Concept ').yellow
-    msg += Rainbow(name).yellow.bright
-    msg += Rainbow(' replace <text> tag by <def>.').yellow
-    Project.instance.verbose msg
-    @data[:texts] << value.text.strip
-  end
-
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/MethodLength
   def process_def(value)
     case value.attributes['type']
-    when 'image'
-      msg = "[DEBUG] Concept#read_xml: image #{Rainbow(value.text).bright}"
-      Project.instance.verbose Rainbow(msg).yellow
     when 'image_url'
-      @data[:images] << value.text.strip
-    when 'textfile_path'
-      @data[:textfile_paths] << value.text.strip
-    else
+      @data[:images] << EmbeddedFile.load(value.text.strip, File.dirname(@filename))
+    when 'file'
+      @data[:images] << EmbeddedFile.load(value.text.strip, File.dirname(@filename))
+    when nil
       @data[:texts] << value.text.strip
+    else
+      msg = "[ERROR] Unknown type: #{value.attributes['type']}"
+      Logger.verboseln Rainbow(msg).red.bright
+      exit 1
     end
   end
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/MethodLength
 end
+# rubocop:enable Metrics/ClassLength
+# rubocop:enable Style/ClassVars

data/lib/asker/data/data_field.rb

@@ -8,12 +8,19 @@
 class DataField
   attr_reader :id, :type
 
+  ##
+  # initialize DataField
   def initialize(data, id, type)
     @data = data
     @id   = id.to_i # TODO: revise where it comes from? Is it unique value?
     @type = type.to_sym
   end
 
+  ##
+  # Return internal data
+  # @param option (Symbol)
+  # @return String
+  # rubocop:disable Metrics/MethodLength
   def get(option = :raw)
     case @type
     when :text
@@ -27,6 +34,7 @@ class DataField
     end
     raise ".get: data=#{@data}, type=#{@type}, option=#{option}"
   end
+  # rubocop:enable Metrics/MethodLength
 
   private
 
@@ -36,6 +44,7 @@ class DataField
     @data
   end
 
+  # rubocop:disable Metrics/MethodLength
   def get_textfile_path(option)
     case option
     when :raw
@@ -50,7 +59,9 @@ class DataField
     end
     raise ".get_textfile_path: data=#{@data}, type=#{@type}, option=#{option}"
   end
+  # rubocop:enable Metrics/MethodLength
 
+  # rubocop:disable Metrics/MethodLength
   def get_textfile_url(option)
     case option
     when :raw
@@ -64,7 +75,9 @@ class DataField
     end
     raise ".get_textfile_url: data=#{@data}, type=#{@type}, option=#{option}"
   end
+  # rubocop:enable Metrics/MethodLength
 
+  # rubocop:disable Metrics/MethodLength
   def get_image_url(option)
     case option
     when :raw
@@ -78,6 +91,7 @@ class DataField
     end
     raise ".get_image_url: data=#{@data}, type=#{@type}, option=#{option}"
   end
+  # rubocop:enable Metrics/MethodLength
 
   def to_screen(text)
     return text[0, 7] + '...' + text[-15, 15] if text.size > 25

data/lib/asker/data/row.rb

@@ -1,93 +1,116 @@
+# frozen_string_literal: true
 
 require_relative 'column'
 
+##
+# Row objects
 class Row
   attr_reader :table, :index, :id
   attr_reader :langs, :types, :raws, :columns
   attr_reader :simple
 
-  def initialize( table, index, xml_data )
+  ##
+  # Initialize Row Object
+  # @param table (Table)
+  # @param index (Integer)
+  # @param xml_data (XML)
+  def initialize(table, index, xml_data)
     @table   = table
     @index   = index
-    @id      = @table.id + "." + @index.to_s
+    @id      = "#{@table.id}.#{@index}"
     @langs   = @table.langs
     @types   = @table.types
     @raws    = []
     @columns = []
-    @simple  = { :lang => true, :type => true }
+    @simple  = { lang: true, type: true }
     read_data_from_xml(xml_data)
   end
 
   def simple_off(option)
-    @simple[option]=false
+    @simple[option] = false
     @table.simple_off(option)
   end
 
-private
+  private
 
-  def read_data_from_xml(pXMLdata)
-    if pXMLdata.elements.count==0 then
-      build_row_with_1_column(pXMLdata)
+  def read_data_from_xml(xml_data)
+    if xml_data.elements.count.zero?
+      build_row_with_1_column(xml_data)
     else
-      build_row_with_N_columns(pXMLdata)
+      build_row_with_n_columns(xml_data)
     end
 
-    raise "[ERROR] Row: #{pXMLdata}" if @columns.size!=@table.fields.size
+    raise "[ERROR] Row: #{xml_data}" unless @columns.size == @table.fields.size
   end
 
-  def build_row_with_1_column(pXMLdata)
+  def build_row_with_1_column(xml_data)
     # When row tag only has text, we add this text as one value array
     # This is usefull for tables with only one columns
-    @columns = [ Column.new( self, @raws.size, pXMLdata) ]
-    @raws    = [ pXMLdata.text.strip.to_s ]
-
-    #read attributes from XML data
-    if pXMLdata.attributes['lang'] then
-      code = pXMLdata.attributes['lang'].strip
-      if code != @langs[0].code then
-        @langs = [ LangFactory.instance.get(code) ]
-        @simple[:lang]= false
-        @table.simple_off(:lang)
-      end
-    end
+    @columns = [Column.new(self, @raws.size, xml_data)]
+    @raws    = [xml_data.text.strip.to_s]
 
-    if pXMLdata.attributes['type'] then
-      type = pXMLdata.attributes['type'].strip
-      if type != @types[0] then
-        @types = [ type ]
-        @simple[:type]= false
-        @table.simple_off(:type)
-      end
-    end
+    # read attributes from XML data
+    read_lang_from_xml(xml_data)
+    read_type_from_xml(xml_data)
   end
 
-  def build_row_with_N_columns(pXMLdata)
-    pXMLdata.elements.each do |i|
+  def read_lang_from_xml(xml_data)
+    return unless xml_data.attributes['lang']
+
+    code = xml_data.attributes['lang'].strip
+    return if code == @langs[0].code
+
+    @langs = [LangFactory.instance.get(code)]
+    @simple[:lang] = false
+    @table.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 == @types[0]
+
+    @types = [type]
+    @simple[:type] = false
+    @table.simple_off(:type)
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  def build_row_with_n_columns(xml_data)
+    xml_data.elements.each do |i|
       case i.name
       when 'lang'
-        j = i.text.split(",")
-        codes = @langs.map {|i| i.code  }
-
-        if j.join(",")!=codes.join(",")
-          @langs = []
-          j.each { |k| @langs << LangFactory.instance.get(k.strip.to_s) }
-          @simple[:lang]=false
-          @table.simple_off(:lang)
-        end
+        read_langs_from_xml(i)
       when 'type'
-        j = i.text.split(",")
-        if j.join(",")!=@types.join(",") then
-          @types = []
-          j.each { |k| @types << k.strip.to_s }
-          @simple[:type]=false
-          @table.simple_off(:type)
-        end
-      when 'col' # When row tag has several columns, we add every value to the array
-        #Column Objects
-        @columns << Column.new( self, @raws.size, i)
+        read_types_from_xml(i)
+      when 'col'
+        # When row has several columns, we add every value to the array
+        @columns << Column.new(self, @raws.size, i) # Column Objects
         @raws << i.text.to_s
       end
     end
   end
+  # rubocop:enable Metrics/MethodLength
+
+  def read_langs_from_xml(xml_data)
+    j = xml_data.text.split(',')
+    codes = @langs.map(&:code)
+    return if j.join(',') == codes.join(',')
+
+    @langs = []
+    j.each { |k| @langs << LangFactory.instance.get(k.strip.to_s) }
+    @simple[:lang] = false
+    @table.simple_off(:lang)
+  end
 
+  def read_types_from_xml(xml_data)
+    j = xml_data.text.split(',')
+    return if j.join(',') == @types.join(',')
+
+    @types = []
+    j.each { |k| @types << k.strip.to_s }
+    @simple[:type] = false
+    @table.simple_off(:type)
+  end
 end

data/lib/asker/data/table.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require_relative 'row'
 require_relative 'template'
@@ -6,75 +6,96 @@ require_relative 'template'
 # Contains data table information
 class Table
   attr_reader :name, :id
-  attr_reader :fields, :langs, :types, :sequence
-  attr_reader :datarows, :rows
+  attr_reader :fields, :sequence
+  attr_reader :langs
+  attr_reader :datarows # DEV: experimental replace for Row objects
+  attr_reader :rows     # Row objects are Datarows.raws values
+  # Table is simple when all their rows and col has the same lang and type value
   attr_reader :simple
 
+  ##
+  # initialize Table object
+  # @param concept (Concept)
+  # @param xml_data (XML)
   def initialize(concept, xml_data)
     @concept = concept
+    read_attributes_from_xml(xml_data)
 
-    # read attributes from XML data
-    t = xml_data.attributes['fields'].to_s.strip.split(',')
-    t.each { |i| i.strip! }
-    @fields = t || []
+    @simple = { lang: true, type: true }
     @types  = ['text']        * @fields.size
     @langs  = [@concept.lang] * @fields.size
 
-    @name   = ''
-    @fields.each { |i| @name=@name + '$' + i.to_s.strip.downcase}
-    @id     = @concept.name.to_s + '.' + @name
-    @simple = { lang: true, type: true }
-
-    @sequence = []
-    if xml_data.attributes['sequence']
-      t = xml_data.attributes['sequence'].to_s || ""
-      @sequence = t.split(",")
-      # puts "[DEPRECATED] sequence attr on table <#{@name}>"
-    end
-
-    @datarows = [] #DEV experiment replace row data with row objects
+    @datarows = [] # DEV experiment replace row data with row objects
     read_data_from_xml(xml_data)
-    @rows = @datarows.map { |r| r.raws }
+    @rows = @datarows.map(&:raws)
   end
 
+  ##
+  # Return table name
   def to_s
     @name.to_s
   end
 
+  ##
+  # Return true if table has a sequence defined
   def sequence?
-    @sequence.size > 0
+    @sequence.size.positive?
   end
 
+  ##
+  # Return fields type:
+  # * types(:all)  => Return an Array with all field types
+  # * types(index) => Return type for fields[index]
+  # @param index (Integer)
   def types(index = :all)
     @types = (['text'] * @fields.size) if @types.nil?
     return @types if index == :all
+
     @types[index]
   end
 
+  ##
+  # Set table to simple off
+  # * simple_off(:lang) => Set table simple lang FALSE
+  # * simple_off(:type) => Set table simple type FALSE
+  # @param option (Symbol)
   def simple_off(option)
     @simple[option] = false
   end
 
   private
 
+  ##
+  # Fill:fields, name and id from XML input
+  # @param xml_data (XML)
+  # rubocop:disable Metrics/AbcSize
+  def read_attributes_from_xml(xml_data)
+    # read attributes from XML data
+    t = xml_data.attributes['fields'].to_s.strip.split(',')
+    t.each(&:strip!)
+    @fields = t || []
+
+    @name = ''
+    @fields.each { |i| @name = "#{@name}$#{i.to_s.strip.downcase}" }
+    @id = "#{@concept.name}.#{@name}"
+
+    @sequence = []
+    return unless xml_data.attributes['sequence']
+
+    @sequence = xml_data.attributes['sequence'].to_s.split(',')
+  end
+  # rubocop:enable Metrics/AbcSize
+
+  ##
+  # Build table data from xml input
+  # @param xml_data (XML)
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
   def read_data_from_xml(xml_data)
     xml_data.elements.each do |i|
       case i.name
       when 'lang'
-        j = i.text.split(',')
-        codes = @langs.map(&:code)
-
-        if j.join(',') != codes.join(',')
-          simple_off(:lang)
-          @langs = []
-          j.each do |k|
-            if k.strip == '*' || k.strip == ''
-              @langs << @concept.lang
-            else
-              @langs << LangFactory.instance.get(k.strip.to_s)
-            end
-          end
-        end
+        read_lang_from_xml(i)
       when 'row'
         @datarows << Row.new(self, @datarows.size, i)
       when 'sequence'
@@ -82,15 +103,43 @@ class Table
       when 'template'
         @datarows += Template.new(self, @datarows.size, i).datarows
       when 'type'
-        j = i.text.split(',')
-        if j.join(',') != @types.join(',')
-          simple_off(:type)
-          @types = []
-          j.each { |k| @types << k.strip.to_s }
-        end
+        read_type_from_xml(i)
       else
         puts Rainbow("[ERROR] concept/table#xml_data with #{i.name}").red.bright
       end
     end
   end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Style/ConditionalAssignment
+  def read_lang_from_xml(xml_data)
+    j = xml_data.text.split(',')
+    codes = @langs.map(&:code)
+    return if j.join(',') == codes.join(',')
+
+    simple_off(:lang)
+    @langs = []
+    j.each do |k|
+      if ['*', ''].include? k.strip
+        @langs << @concept.lang
+      else
+        @langs << LangFactory.instance.get(k.strip.to_s)
+      end
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Style/ConditionalAssignment
+
+  def read_type_from_xml(xml_data)
+    j = xml_data.text.split(',')
+    return if j.join(',') == @types.join(',')
+
+    simple_off(:type)
+    @types = []
+    j.each { |k| @types << k.strip.to_s }
+  end
 end

data/lib/asker/data/template.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 
 require 'rexml/document'
 require_relative 'row'
@@ -40,7 +41,8 @@ class Template
 
   def apply_vars_to_template(vars, template)
     output = ''
-    return if vars.size.zero?
+    return output if vars.size.zero?
+
     max = vars.first[1].size
     (1..max).each do |index|
       t = template.dup