asker-tool 2.1.5 → 2.2.1

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

data/lib/asker/data/world.rb

@@ -1,50 +1,23 @@
+# frozen_string_literal: true
 
 require_relative '../loader/image_url_loader'
-require_relative '../project'
-require_relative '../logger'
 
 class World
   attr_reader :concepts, :filenames, :contexts, :image_urls
 
-  def initialize(concepts, show_progress=true)
+  def initialize(concepts, internet = 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(internet)
   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 +25,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
+  # rubocop:disable Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/PerceivedComplexity
+  def find_url_images_from_internet(internet)
+    return {} unless internet
+
+    threads = []
+    searchs = []
+    urls = {}
+
+    @concepts&.each_key { |key| searchs << key }
+    @contexts.each { |filter| searchs << filter.join(' ').to_s }
+    searchs.each do |search|
+      threads << Thread.new { urls[search] = ImageUrlLoader.load(search) }
+    end
+    threads.each(&:join) # wait for all threads to finish
+    urls
+  end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/CyclomaticComplexity
+  # rubocop:enable Metrics/PerceivedComplexity
 end

data/lib/asker/displayer/code_displayer.rb

@@ -5,6 +5,11 @@ require_relative '../logger'
 
 # Export Code into Screen
 module CodeDisplayer
+  ##
+  # Show all "code" data on screen
+  # @param codes (Array) List of "code" data
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/MethodLength
   def self.show(codes)
     return if codes.nil? || codes.size.zero?
 
@@ -42,4 +47,6 @@ module CodeDisplayer
     Logger.verboseln "\n[INFO] Showing CODE statistics"
     Logger.verboseln my_screen_table.to_s
   end
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/MethodLength
 end

data/lib/asker/displayer/concept_ai_displayer.erb

@@ -0,0 +1,10 @@
+
+[INFO] Showing CONCEPT statistics
+ * Exclude questions: <%= exclude_questions %>
+ * Annotations:
+   ├── (d) Definitions     <= Concept.def
+   ├── (b) Table Matching  <= Concept.table.rows.columns
+   ├── (f) Tables 1 Field  <= Concept.table.fields.size==1
+   ├── (i) Images URL      <= Concept.def{:type => 'file'}
+   ├── (s) Sequences       <= Concept.table{:sequence => '...'}
+   └── (t) Table Rows&Cols <= Concept.table.rows.columns

data/lib/asker/displayer/concept_ai_displayer.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+require 'erb'
 require 'terminal-table'
+require_relative '../application'
 require_relative '../logger'
 
 # Display ConceptAI stat on screen
@@ -8,11 +10,23 @@ class ConceptAIDisplayer
   ##
   # Display ConceptAI stat on screen
   # @param concepts_ai (Array)
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/PerceivedComplexity
   def self.show(concepts_ai)
+    stages = Application.instance.config['questions']['stages']
     # Create table HEAD
     screen_table = Terminal::Table.new do |st|
-      st << ['Concept','Questions','Entries','xFactor',
-             'd','b','f','i','s','t']
+      title = %w[Concept Questions Entries xFactor]
+      %w[d b f i s t].each do |i|
+        if stages.include? i.to_sym
+          title << i
+          next
+        end
+        title << Rainbow(i).yellow.bright
+      end
+      st << title
       st << :separator
     end
     # Create table BODY
@@ -22,32 +36,38 @@ class ConceptAIDisplayer
     total[:si] = total[:ss] = total[:st] = 0
 
     concepts_ai.each do |concept_ai|
-      if concept_ai.process?
-        e = concept_ai.texts.size
-        concept_ai.tables.each { |t| e += t.fields.size * t.rows.size }
+      next unless concept_ai.concept.process?
 
-        sd = concept_ai.questions[:d].size
-        sb = concept_ai.questions[:b].size
-        sf = concept_ai.questions[:f].size
-        si = concept_ai.questions[:i].size
-        ss = concept_ai.questions[:s].size
-        st = concept_ai.questions[:t].size
-        t = sd + sb + sf + si + ss + st
+      e = concept_ai.concept.texts.size
+      e += concept_ai.concept.images.size
+      concept_ai.concept.tables.each { |t| e += t.fields.size * t.rows.size }
 
-        if e == 0
-          factor = 'Unkown'
-        else
-          factor = (t.to_f/e.to_f).round(2).to_s
-        end
-        screen_table.add_row [Rainbow(concept_ai.name(:screen)).green.bright,
-          t, e, factor, sd, sb, sf, si, ss, st]
+      sd = sb = sf = 0
+      si = ss = st = 0
+      sd = concept_ai.questions[:d].size if stages.include? :d
+      sb = concept_ai.questions[:b].size if stages.include? :b
+      sf = concept_ai.questions[:f].size if stages.include? :f
+      si = concept_ai.questions[:i].size if stages.include? :i
+      ss = concept_ai.questions[:s].size if stages.include? :s
+      st = concept_ai.questions[:t].size if stages.include? :t
+      t = sd + sb + sf + si + ss + st
 
-        total[:q] += t ; total[:e] += e; total[:c] += 1
-        total[:sd] += sd; total[:sb] += sb; total[:sf] += sf
-        total[:si] += si; total[:ss] += ss; total[:st] += st
-      end
+      factor = 'Unkown'
+      factor = (t.to_f / e).round(2).to_s unless e.zero?
+      screen_table.add_row [Rainbow(concept_ai.concept.name(:screen)).green.bright,
+                            t, e, factor, sd, sb, sf, si, ss, st]
+
+      total[:q] += t
+      total[:e] += e
+      total[:c] += 1
+      total[:sd] += sd
+      total[:sb] += sb
+      total[:sf] += sf
+      total[:si] += si
+      total[:ss] += ss
+      total[:st] += st
     end
-    return if total[:c] == 0 # No concepts to be process?
+    return if total[:c].zero? # No concepts to be process?
 
     # Add row with excluded questions
     export_excluded_questions(screen_table, concepts_ai)
@@ -57,13 +77,19 @@ class ConceptAIDisplayer
     screen_table.add_row [Rainbow("TOTAL = #{total[:c]}").bright,
                           Rainbow(total[:q].to_s).bright,
                           Rainbow(total[:e].to_s).bright,
-                          Rainbow((total[:q].to_f/total[:e].to_f).round(2)).bright,
+                          Rainbow((total[:q].to_f / total[:e]).round(2)).bright,
                           total[:sd], total[:sb], total[:sf],
                           total[:si], total[:ss], total[:st]]
     export_notes
-    Logger.verbose "#{screen_table}\n"
+    Logger.verboseln "#{screen_table}\n"
   end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/CyclomaticComplexity
+  # rubocop:enable Metrics/PerceivedComplexity
 
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
   private_class_method def self.export_excluded_questions(screen_table, concepts_ai)
     # Create table BODY
     total = {}
@@ -72,19 +98,24 @@ class ConceptAIDisplayer
     total[:si] = total[:ss] = total[:st] = 0
 
     concepts_ai.each do |concept_ai|
-      if concept_ai.process?
-        sd = concept_ai.excluded_questions[:d].size
-        sb = concept_ai.excluded_questions[:b].size
-        sf = concept_ai.excluded_questions[:f].size
-        si = concept_ai.excluded_questions[:i].size
-        ss = concept_ai.excluded_questions[:s].size
-        st = concept_ai.excluded_questions[:t].size
-        t = sd + sb + sf + si + ss + st
+      next unless concept_ai.concept.process?
 
-        total[:q] += t ; total[:c] += 1
-        total[:sd] += sd; total[:sb] += sb; total[:sf] += sf
-        total[:si] += si; total[:ss] += ss; total[:st] += st
-      end
+      sd = concept_ai.excluded_questions[:d].size
+      sb = concept_ai.excluded_questions[:b].size
+      sf = concept_ai.excluded_questions[:f].size
+      si = concept_ai.excluded_questions[:i].size
+      ss = concept_ai.excluded_questions[:s].size
+      st = concept_ai.excluded_questions[:t].size
+      t = sd + sb + sf + si + ss + st
+
+      total[:q] += t
+      total[:c] += 1
+      total[:sd] += sd
+      total[:sb] += sb
+      total[:sf] += sf
+      total[:si] += si
+      total[:ss] += ss
+      total[:st] += st
     end
     screen_table.add_row [Rainbow('Excluded questions').yellow.bright,
                           total[:q], '-', '-',
@@ -92,22 +123,12 @@ class ConceptAIDisplayer
                           total[:sf], total[:si],
                           total[:ss], total[:st]]
   end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
 
   private_class_method def self.export_notes
-    Logger.verbose "\n[INFO] Showing CONCEPT statistics\n"
-    Logger.verbose ' * Exclude questions: ' +
-                   Application.instance.config['questions']['exclude'].to_s
-    Logger.verbose ' * Annotations:'
-    Logger.verbose '   ├── (d) Definitions     <= Concept.def'
-    Logger.verbose '   ├── (b) Table Matching  <= ' \
-                   'Concept.table.rows.columns'
-    Logger.verbose '   ├── (f) Tables 1 Field  <= Concept.table.fields.size==1'
-    Logger.verbose '   ├── (i) Images URL      <= ' \
-                   "Concept.def{:type => 'image_url'}"
-    Logger.verbose '   ├── (s) Sequences       <= ' \
-                   "Concept.table{:sequence => '...'}"
-    Logger.verbose '   └── (t) Table Rows&Cols <= ' \
-                  'Concept.table.rows.columns'
-    Logger.verbose "\n"
+    exclude_questions = Application.instance.config['questions']['exclude'].to_s
+    renderer = ERB.new(File.read(File.join(File.dirname(__FILE__), 'concept_ai_displayer.erb')))
+    Logger.verboseln renderer.result(binding)
   end
 end

data/lib/asker/displayer/concept_displayer.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 
+require_relative '../application'
 require_relative '../formatter/concept_string_formatter'
 require_relative '../logger'
 
@@ -6,22 +8,27 @@ require_relative '../logger'
 module ConceptDisplayer
   ##
   # Show concepts on screen
-  # @param concepts (Array)
-  # @param show_mode (Symbol)
-  def self.show(concepts, show_mode = :default)
-    return if show_mode == :none
+  # @param concepts (Array) List of concept data
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/MethodLength
+  def self.show(concepts)
+    show_mode = Application.instance.config['global']['show_mode']
+    return unless show_mode
+
     msg = "\n[INFO] Showing concept data (#{Rainbow(show_mode).bright})"
-    Logger.verbose msg
+    Logger.verboseln msg
     case show_mode
-    when :resume
+    when 'resume'
       s = "* Concepts (#{concepts.count}): "
       concepts.each { |c| s += c.name + ', ' }
-      Logger.verbose s
-    when :default
+      Logger.verboseln s
+    when 'default'
       # Only show Concepts with process attr true
       concepts.each do |c|
-        Logger.verbose ConceptStringFormatter.to_s(c) if c.process?
+        Logger.verboseln ConceptStringFormatter.to_s(c) if c.process?
       end
     end
   end
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/MethodLength
 end

data/lib/asker/displayer/stats_displayer.rb

@@ -1,13 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../application'
 require_relative 'concept_ai_displayer'
 require_relative 'code_displayer'
 
 # Display Stats on screen.
+# * Display all "Concept AI"
+# * Display all "Code"
 module StatsDisplayer
-  def self.show(data, show_mode)
-    return if show_mode == :none
+  # Display Stats on screen.
+  # * Display all "Concept AI"
+  # * Display all "Code"
+  # @param data (Hash) With concept_ai list and code list
+  def self.show(data)
+    return unless Application.instance.config['global']['show_mode']
 
     # show_final_results
     ConceptAIDisplayer.show(data[:concepts_ai])
-    CodeDisplayer.show(data[:codes])
+    CodeDisplayer.show(data[:codes_ai])
   end
 end

data/lib/asker/exporter/concept_ai_gift_exporter.rb

@@ -1,29 +1,37 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require_relative '../project'
 require_relative '../formatter/question_gift_formatter'
 
 # Export ConceptIA data to gift to outputfile
 module ConceptAIGiftExporter
   ##
-  # Export list of ConceptAI into outpufile
-  def self.export_all(concepts_ai, project)
-    concepts_ai.each { |concept_ai| export(concept_ai, project) }
+  # Export an array of ConceptAI objects from Project into GIFT outpufile
+  # @param concepts_ai (Array)
+  # @param file (File)
+  def self.export_all(concepts_ai, file)
+    concepts_ai.each { |concept_ai| export(concept_ai, file) }
   end
 
-  def self.export(concept_ai, project)
-    return unless concept_ai.process?
+  ##
+  # Export 1 concept_ai from project
+  # @param concept_ai (ConceptAI)
+  # @param file (File)
+  private_class_method def self.export(concept_ai, file)
+    return unless concept_ai.concept.process?
 
-    file = project.get(:outputfile)
-    file.write head(concept_ai.name)
-    project.stages.each_key do |stage|
+    file.write head(concept_ai.concept.name)
+    Application.instance.config['questions']['stages'].each do |stage|
       concept_ai.questions[stage].each do |question|
         file.write(QuestionGiftFormatter.to_s(question))
       end
     end
   end
 
-  def self.head(name)
+  ##
+  # Convert Concept name into gift format head
+  # @param name (String)
+  # @return String
+  private_class_method def self.head(name)
     s = "\n"
     s += '// ' + '=' * 50 + "\n"
     s += "// Concept name: #{name}\n"