asker-tool 2.1.5 → 2.1.6

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,41 @@ 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
+  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
+
+  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/world.rb

@@ -1,50 +1,31 @@
+# frozen_string_literal: true
 
 require_relative '../loader/image_url_loader'
 require_relative '../project'
 require_relative '../logger'
 
+##
+# World data
 class World
   attr_reader :concepts, :filenames, :contexts, :image_urls
 
-  def initialize(concepts, show_progress=true)
+  ##
+  # Initialize World object
+  # @param concepts (Array)
+  # @param show_progress (Boolean)
+  def initialize(concepts, show_progress = true)
     find_neighbors_for_every_concept(concepts)
-
-    @concepts   = {}
-    @filenames  = []
-    @contexts   = []
-    @image_urls = {}
-
-    concepts.each do |c|
-      if c.process
-        @concepts[c.name] = c
-        @filenames << c.filename
-        @contexts  << c.context
-      end
-    end
-    @filenames.uniq!
-    @contexts.uniq!
-
-    Logger.verbose "\n[INFO] Loading data from Internet" if show_progress
-    threads = []
-    concepts.each do |c|
-      print('.') if show_progress
-      # puts "[DEBUG] #{c.name}\n"
-      # filter = [ c.name.clone ] + c.context.clone
-      filter = c.name.clone
-      threads << Thread.new { @image_urls[c.name] = ImageUrlLoader::load(filter) }
-    end
-    @contexts.each do |filter|
-      print('.') if show_progress
-      threads << Thread.new { @image_urls[ filter.join('.').to_s ] = ImageUrlLoader::load(filter) }
-    end
-    threads.each { |t| t.join } # wait for all threads to finish
-    print("\n") if show_progress
+    @concepts, @filenames, @contexts = get_lists_from(concepts)
+    @image_urls = find_url_images_from_internet(show_progress)
   end
 
+  ##
+  # For every concept... find its neighbors
+  # @param concepts (Array)
   def find_neighbors_for_every_concept(concepts)
     concepts.each do |i|
       concepts.each do |j|
-        if (i.id!=j.id) then
+        if i.id != j.id
           i.try_adding_neighbor(j)
           i.try_adding_references(j)
         end
@@ -52,4 +33,47 @@ class World
     end
   end
 
+  private
+
+  # rubocop:disable Metrics/MethodLength
+  def get_lists_from(input)
+    concepts = {}
+    filenames = []
+    contexts = []
+    input.each do |c|
+      next unless c.process
+
+      concepts[c.name] = c
+      filenames << c.filename
+      contexts  << c.context
+    end
+    filenames.uniq!
+    contexts.uniq!
+    [concepts, filenames, contexts]
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  def find_url_images_from_internet(show_progress)
+    param = Application.instance.config['global']['internet'] || 'yes'
+    return {} unless param == 'yes'
+
+    Logger.verbose "\n[INFO] Loading data from Internet" if show_progress
+    threads = []
+    searchs = []
+    urls = {}
+
+    @concepts&.each_key { |key| searchs << key }
+    @contexts.each { |filter| searchs << filter.join(' ').to_s }
+    searchs.each do |search|
+      print('.') if show_progress
+      threads << Thread.new { urls[search] = ImageUrlLoader.load(search) }
+    end
+    threads.each(&:join) # wait for all threads to finish
+    print("\n") if show_progress
+    urls
+  end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
 end