asker-tool 2.1.2

data/lib/asker/code/ai/sql_code_ai.rb

@@ -0,0 +1,69 @@
+
+require_relative '../../lang/lang_factory'
+require_relative '../../ai/question'
+require_relative 'base_code_ai'
+
+class SQLCodeAI < BaseCodeAI
+  def initialize(data_object)
+    @data_object = data_object
+    @lines = data_object.lines
+    @lang = LangFactory.instance.get('sql')
+    @num = 0
+    @questions = []
+  end
+
+  def make_comment_error
+    error_lines = []
+    questions = []
+    @lines.each_with_index do |line,index|
+      if line.include?('//')
+        lines = clone_array @lines
+        lines[index].sub!('//','').strip!
+
+        q = Question.new(:short)
+        q.name = "#{name}-#{num}-code1uncomment"
+        q.text = @lang.text_for(:code1,lines_to_html(lines))
+        q.shorts << (index+1)
+        q.feedback = 'Comment symbol removed'
+        questions << q
+      elsif line.strip.size>0
+        lines = clone_array @lines
+        lines[index]='// ' + lines[index]
+
+        q = Question.new(:short)
+        q.name = "#{name}-#{num}-code1comment"
+        q.text = @lang.text_for(:code1,lines_to_html(lines))
+        q.shorts << (index+1)
+        q.feedback = 'Comment symbol added'
+        questions << q
+      end
+    end
+    questions
+  end
+
+  def make_keyword_error
+    error_lines = []
+    questions = []
+
+    @lang.mistakes.each_pair do |key,values|
+      v = values.split(',')
+      v.each do |value|
+        @lines.each_with_index do |line,index|
+          error_lines << index if line.include?(key.to_s)
+        end
+
+        error_lines.each do |index|
+          lines = clone_array @lines
+          lines[index].sub!(key.to_s, value)
+          q = Question.new(:short)
+          q.name = "#{name}-#{num}-code1keyword"
+          q.text = @lang.text_for(:code1,lines_to_html(lines))
+          q.shorts << (index+1)
+          q.feedback = "Keyword error: '#{value}' must be '#{key}'"
+          questions << q
+        end
+      end
+    end
+    questions
+  end
+end

data/lib/asker/code/code.rb

@@ -0,0 +1,53 @@
+require_relative 'ai/code_ai_factory'
+require_relative '../project'
+require_relative '../formatter/code_string_formatter'
+
+# Contains code data input
+class Code
+  attr_reader :dirname, :filename, :type
+  attr_accessor :process, :features
+  attr_reader :lines, :questions
+
+  def initialize(dirname, filename, type)
+    @dirname = dirname
+    @filename = filename
+    @type = type
+    @filepath = File.join(@dirname, @filename)
+    @process = false
+    @features = []
+    @lines = load(@filepath)
+    @questions = []
+    @code_ai = CodeAIFactory.get(self)
+  end
+
+  def process?
+    @process
+  end
+
+  def make_questions
+    return unless process?
+    @questions += @code_ai.make_questions
+  end
+
+  def lines_to_s(lines)
+    out = ''
+    lines.each_with_index do |line, index|
+      out << format("%2d| #{line}\n", (index + 1))
+    end
+    out
+  end
+
+  def debug
+    out = CodeStringFormatter.to_s(self)
+    p = Project.instance
+    p.verbose out
+  end
+
+  private
+
+  def load(filepath)
+    return if filepath.nil?
+    content = File.read(filepath)
+    content.split("\n")
+  end
+end

data/lib/asker/data/column.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Contain data information for every column
+# Params:
+# * +pRow+ - Parent row for this column
+# * +index+ - Sequence order (Integer)
+# * +xml_data+ - XML input data
+class Column
+  attr_reader :row, :index, :id, :raw, :lang, :type, :simple
+
+  def initialize(row, index, xml_data)
+    @row    = row
+    @index  = index
+    @id     = @row.id + '.' + @index.to_s
+    @raw    = ''
+    @lang   = @row.langs[@index]
+    @type   = @row.types[@index]
+    @simple = { lang: true, type: true }
+    read_data_from_xml(xml_data)
+  end
+
+  def to_html
+    case @type
+    when 'text'
+      return @raw
+    when 'image_url'
+      return "<img src=\"#{raw}\" alt\=\"image\">"
+    when 'textfile_path'
+      return "<pre>#{raw}</pre>"
+    else
+      return "ERROR type #{@type}"
+    end
+  end
+
+  private
+
+  def read_data_from_xml(xml_data)
+    raise '[ERROR] Column XML data with elements!' if xml_data.elements.count.positive?
+
+    @raw = xml_data.text.strip.to_s
+
+    # read attributes from XML input data
+    if xml_data.attributes['lang']
+      code = xml_data.attributes['lang'].strip
+      if code != @lang.code
+        @lang = LangFactory.instance.get(code)
+        @simple[:lang] = false
+        @row.simple_off(:lang)
+      end
+    end
+
+    if xml_data.attributes['type']
+      type = xml_data.attributes['type'].strip
+      if type != @type.to_s
+        @type = type
+        @simple[:type] = false
+        @row.simple_off(:type)
+      end
+    end
+  end
+end

data/lib/asker/data/concept.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+require 'rexml/document'
+
+require_relative '../project'
+require_relative '../lang/lang_factory'
+require_relative 'table'
+require_relative 'data_field'
+
+# Store Concept information
+class Concept
+  attr_reader :id, :lang, :context
+  attr_reader :names, :type, :filename
+  attr_reader :data
+  attr_accessor :process
+
+  @@id = 0
+
+  def initialize(xml_data, filename, lang_code = 'en', context = [])
+    @@id += 1
+    @id = @@id
+
+    @filename = filename
+    @process = false
+    @lang = LangFactory.instance.get(lang_code)
+
+    if context.class == Array
+      @context = context
+    elsif context.nil?
+      @context = []
+    else
+      @context = context.split(',')
+      @context.collect!(&:strip)
+    end
+    @names = ['concept.' + @id.to_s]
+    @type  = 'text'
+
+    @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[:tables] = []
+    @data[:neighbors] = []
+    @data[:reference_to] = []
+    @data[:referenced_by] = []
+
+	  read_data_from_xml(xml_data)
+  end
+
+  def name(option = :raw)
+    DataField.new(@names[0], @id, @type).get(option)
+  end
+
+  def text
+    @data[:texts][0] || '...'
+  end
+
+  def process?
+    @process
+  end
+
+  def try_adding_neighbor(other)
+    p = calculate_nearness_to_concept(other)
+    return if p.zero?
+
+    @data[:neighbors] << { concept: other, value: p }
+    # Sort neighbors list
+    @data[:neighbors].sort! { |a, b| a[:value] <=> b[:value] }
+    @data[:neighbors].reverse!
+  end
+
+  def calculate_nearness_to_concept(other)
+    weights = Project.instance.formula_weights
+
+    li_max1 = @context.count
+    li_max2 = @data[:tags].count
+    li_max3 = @data[:tables].count
+
+    lf_alike1 = lf_alike2 = lf_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? }
+
+    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)
+  end
+
+  def try_adding_references(other)
+    reference_to = 0
+    @data[:tags].each { |i| reference_to += 1 unless other.names.index(i.downcase).nil? }
+    @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
+  end
+
+  def method_missing(method)
+    @data[method]
+  end
+
+  private
+
+  def read_data_from_xml(xml_data)
+    xml_data.elements.each do |i|
+      case i.name
+      when 'names'
+        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
+      end
+    end
+  end
+
+  def process_names(value)
+    @names = []
+    j = value.text.split(',')
+    j.each { |k| @names << k.strip }
+    @type = value.attributes['type'].strip if value.attributes['type']
+  end
+
+  def process_tags(value)
+    raise '[Error] tags label empty!' if value.text.nil? || value.text.size.zero?
+    @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
+
+  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[:texts] << value.text.strip
+    end
+  end
+end

data/lib/asker/data/data_field.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# Contain data information for every field
+# Params:
+# * +data+ - Data (Text). This is the field content
+# * +id+ - Identifier (Integer)
+# * +type+ - May be "text", "textfile_path", "textfile_url" or "image_url"
+class DataField
+  attr_reader :id, :type
+
+  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
+
+  def get(option = :raw)
+    case @type
+    when :text
+      return get_text(option)
+    when :textfile_path
+      return get_textfile_path(option)
+    when :textfile_url
+      return get_textfile_url(option)
+    when :image_url
+      return get_image_url(option)
+    end
+    raise ".get: data=#{@data}, type=#{@type}, option=#{option}"
+  end
+
+  private
+
+  def get_text(option)
+    return to_screen(@data) if option == :screen
+
+    @data
+  end
+
+  def get_textfile_path(option)
+    case option
+    when :raw
+      return @data
+    when :id
+      return "textfile_path.#{@id}"
+    when :decorated
+      content = File.new(@data).read
+      return "<pre>\n#{content}</pre>"
+    when :screen
+      return to_screen(@data)
+    end
+    raise ".get_textfile_path: data=#{@data}, type=#{@type}, option=#{option}"
+  end
+
+  def get_textfile_url(option)
+    case option
+    when :raw
+      return @data
+    when :id
+      return "textfile_url.#{@id}"
+    when :decorated
+      return "<a href=\"#{@data}\">Textfile URL</a>"
+    when :screen
+      return to_screen(@data)
+    end
+    raise ".get_textfile_url: data=#{@data}, type=#{@type}, option=#{option}"
+  end
+
+  def get_image_url(option)
+    case option
+    when :raw
+      return @data
+    when :id
+      return "image_url.#{@id}"
+    when :decorated
+      return "<img src=\"#{@data}\" alt=\"image\">"
+    when :screen
+      return to_screen(@data)
+    end
+    raise ".get_image_url: data=#{@data}, type=#{@type}, option=#{option}"
+  end
+
+  def to_screen(text)
+    return text[0, 7] + '...' + text[-15, 15] if text.size > 25
+
+    text
+  end
+end