asker-tool 2.1.2

data/lib/asker/data/row.rb

@@ -0,0 +1,93 @@
+
+require_relative 'column'
+
+class Row
+  attr_reader :table, :index, :id
+  attr_reader :langs, :types, :raws, :columns
+  attr_reader :simple
+
+  def initialize( table, index, xml_data )
+    @table   = table
+    @index   = index
+    @id      = @table.id + "." + @index.to_s
+    @langs   = @table.langs
+    @types   = @table.types
+    @raws    = []
+    @columns = []
+    @simple  = { :lang => true, :type => true }
+    read_data_from_xml(xml_data)
+  end
+
+  def simple_off(option)
+    @simple[option]=false
+    @table.simple_off(option)
+  end
+
+private
+
+  def read_data_from_xml(pXMLdata)
+    if pXMLdata.elements.count==0 then
+      build_row_with_1_column(pXMLdata)
+    else
+      build_row_with_N_columns(pXMLdata)
+    end
+
+    raise "[ERROR] Row: #{pXMLdata}" if @columns.size!=@table.fields.size
+  end
+
+  def build_row_with_1_column(pXMLdata)
+    # 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
+
+    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
+  end
+
+  def build_row_with_N_columns(pXMLdata)
+    pXMLdata.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
+      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)
+        @raws << i.text.to_s
+      end
+    end
+  end
+
+end

data/lib/asker/data/table.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+
+require_relative 'row'
+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 :simple
+
+  def initialize(concept, xml_data)
+    @concept = concept
+
+    # read attributes from XML data
+    t = xml_data.attributes['fields'].to_s.strip.split(',')
+    t.each { |i| i.strip! }
+    @fields = t || []
+    @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
+    read_data_from_xml(xml_data)
+    @rows = @datarows.map { |r| r.raws }
+  end
+
+  def to_s
+    @name.to_s
+  end
+
+  def sequence?
+    @sequence.size > 0
+  end
+
+  def types(index = :all)
+    @types = (['text'] * @fields.size) if @types.nil?
+    return @types if index == :all
+    @types[index]
+  end
+
+  def simple_off(option)
+    @simple[option] = false
+  end
+
+  private
+
+  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
+      when 'row'
+        @datarows << Row.new(self, @datarows.size, i)
+      when 'sequence'
+        @sequence = i.text.split(',')
+      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
+      else
+        puts Rainbow("[ERROR] concept/table#xml_data with #{i.name}").red.bright
+      end
+    end
+  end
+end

data/lib/asker/data/template.rb

@@ -0,0 +1,65 @@
+
+require 'rexml/document'
+require_relative 'row'
+
+# This class process "template" tag used by Tables
+class Template
+  attr_reader :datarows
+
+  def initialize(table, index, xml)
+    @mode = :simple
+    vars = load_vars_from(xml)
+    template = load_template_from(xml)
+    data_string = apply_vars_to_template(vars, template)
+    @datarows = read_rows_from(table, index, data_string)
+  end
+
+  def load_vars_from(xml)
+    vars = {}
+    v = xml.attributes
+    v.keys.each do |i|
+      if i == 'mode'
+        @mode = v[i].to_sym
+      else
+        vars[i] = v[i].split(',')
+      end
+    end
+    # fill_vars_values(vars,mode)
+    vars
+  end
+
+  def fill_vars_values(vars, mode)
+    # create sizes array
+  end
+
+  def load_template_from(xml)
+    template = ''
+    xml.elements.each { |i| template << i.to_s + "\n" }
+    template
+  end
+
+  def apply_vars_to_template(vars, template)
+    output = ''
+    return if vars.size.zero?
+    max = vars.first[1].size
+    (1..max).each do |index|
+      t = template.dup
+      vars.each_pair { |k, v| t.gsub!(k, v[index - 1]) }
+      output += t
+    end
+    output
+  end
+
+  def read_rows_from(table, index, data_string)
+    datarows = []
+    data = "<template>\n#{data_string}\n</template>"
+    xml = REXML::Document.new(data)
+    xml.root.elements.each do |i|
+      if i.name == 'row'
+        datarows << Row.new(table, index, i)
+        index += 1
+      end
+    end
+    datarows
+  end
+end

data/lib/asker/data/world.rb

@@ -0,0 +1,53 @@
+
+require_relative '../loader/image_url_loader'
+require_relative '../project'
+
+class World
+  attr_reader :concepts, :filenames, :contexts, :image_urls
+
+  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!
+
+    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
+  end
+
+  def find_neighbors_for_every_concept(concepts)
+    concepts.each do |i|
+      concepts.each do |j|
+        if (i.id!=j.id) then
+          i.try_adding_neighbor(j)
+          i.try_adding_references(j)
+        end
+      end
+    end
+  end
+
+end

data/lib/asker/exporter/code_gift_exporter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../project'
+require_relative '../formatter/question_gift_formatter'
+
+# UNDER DEVELOPMENT
+# Use to export questions from Code to gift format
+module CodeGiftExporter
+  def self.export_all(codes)
+    codes.each do |code|
+      code.make_questions
+      export code
+    end
+  end
+
+  def self.export(code)
+    return false unless code.process?
+
+    file = Project.instance.outputfile
+    file.write head(code)
+
+    code.questions.each do |question|
+      file.write QuestionGiftFormatter.to_s(question)
+    end
+    true
+  end
+
+  def self.head(code)
+    s = "\n"
+    s += '// ' + '=' * 50 + "\n"
+    s += "// Code #{code.type}: #{code.filename} (#{code.questions.size})\n"
+    s += '// ' + '=' * 50 + "\n"
+    s
+  end
+end

data/lib/asker/exporter/code_screen_exporter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'terminal-table'
+
+# Export Code into Screen
+module CodeScreenExporter
+  def self.export_all(codes)
+    project = Project.instance
+    return if project.show_mode == :none || codes.nil? || codes.size.zero?
+
+    total_c = total_q = total_e = 0
+    my_screen_table = Terminal::Table.new do |st|
+      st << %w[Filename Type Questions Lines xFactor]
+      st << :separator
+    end
+
+    codes.each do |code|
+      next unless code.process?
+
+      e = code.lines.size
+      q = code.questions.size
+      factor = 'Unkown'
+      factor = (q.to_f / e).round(2).to_s unless e.zero?
+      my_screen_table.add_row [Rainbow(File.basename(code.filename)).green,
+                               code.type,
+                               q,
+                               e,
+                               factor]
+      total_c += 1
+      total_q += q
+      total_e += e
+    end
+
+    my_screen_table.add_separator
+    my_screen_table.add_row [Rainbow("TOTAL = #{total_c}").bright,
+                             ' ',
+                             Rainbow(total_q.to_s).bright,
+                             Rainbow(total_e.to_s).bright,
+                             Rainbow((total_q / total_e.to_f).round(2)).bright]
+    return unless total_c.positive?
+
+    project.verboseln "\n[INFO] Showing CODE statistics"
+    project.verboseln my_screen_table.to_s
+  end
+end

data/lib/asker/exporter/concept_ai_gift_exporter.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require_relative '../project'
+require_relative '../formatter/question_gift_formatter'
+
+# Use to export data from ConceptIA to gift format
+module ConceptAIGiftExporter
+  def self.export_all(concepts_ai)
+    concepts_ai.each { |concept_ai| export(concept_ai) }
+  end
+  
+  def self.export(concept_ai)
+    return unless concept_ai.process?
+
+    file = Project.instance.outputfile
+    file.write head(concept_ai.name)
+
+    stages = Project.instance.stages
+    stages.each_key do |stage|
+      concept_ai.questions[stage].each do |question|
+        file.write(QuestionGiftFormatter.to_s(question))
+      end
+    end
+  end
+
+  def self.head(name)
+    s = "\n"
+    s += '// ' + '=' * 50 + "\n"
+    s += "// Concept name: #{name}\n"
+    s += '// ' + '=' * 50 + "\n"
+    s
+  end
+end

data/lib/asker/exporter/concept_ai_screen_exporter.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'terminal-table'
+
+# Show ConceptAI info on screen
+class ConceptAIScreenExporter
+  def self.export_all(concepts_ai)
+    @concepts_ai = concepts_ai
+	  project = Project.instance
+    return if project.show_mode == :none
+
+    # Create table HEAD
+    screen_table = Terminal::Table.new do |st|
+      st << ['Concept','Questions','Entries','xFactor',
+             'd','b','f','i','s','t']
+      st << :separator
+    end
+
+    # Create table BODY
+    total = {}
+    total[:q] = total[:e] = total[:c] = 0
+    total[:sd] = total[:sb] = total[:sf] = 0
+    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 }
+
+        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
+
+        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]
+
+        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
+    end
+    return if total[:c] == 0 # No concepts to be process?
+
+    # Add row with excluded questions
+    export_excluded_questions(screen_table, @concepts_ai)
+
+    # Create table TAIL
+    screen_table.add_separator
+    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,
+                          total[:sd], total[:sb], total[:sf],
+                          total[:si], total[:ss], total[:st]]
+    export_notes
+    project.verbose screen_table.to_s + "\n"
+  end
+
+  def self.export_excluded_questions(screen_table, concepts_ai)
+    # Create table BODY
+    total = {}
+    total[:q] = total[:c] = 0
+    total[:sd] = total[:sb] = total[:sf] = 0
+    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
+
+        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
+    end
+    screen_table.add_row [Rainbow('Excluded questions').yellow.bright,
+                          total[:q], '-', '-',
+                          total[:sd], total[:sb],
+                          total[:sf], total[:si],
+                          total[:ss], total[:st]]
+  end
+
+  def self.export_notes
+    p = Project.instance
+    p.verbose "\n[INFO] Showing CONCEPT statistics\n"
+    p.verbose ' * Exclude questions: ' +
+              Application.instance.config['questions']['exclude'].to_s
+    p.verbose ' * Annotations:'
+    p.verbose '   ├── (d) Definitions     <= Concept.def'
+    p.verbose '   ├── (b) Table Matching  <= ' \
+              'Concept.table.rows.columns'
+    p.verbose '   ├── (f) Tables 1 Field  <= Concept.table.fields.size==1'
+    p.verbose '   ├── (i) Images URL      <= ' \
+              "Concept.def{:type => 'image_url'}"
+    p.verbose '   ├── (s) Sequences       <= ' \
+              "Concept.table{:sequence => '...'}"
+    p.verbose '   └── (t) Table Rows&Cols <= ' \
+              'Concept.table.rows.columns'
+    p.verbose "\n"
+  end
+end