asker-tool 2.1.5 → 2.2.1

data/lib/asker/data/concept.rb

@@ -3,20 +3,35 @@
 require 'rainbow'
 require 'rexml/document'
 
-require_relative '../project'
 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 (concept identifier)
+
+  ##
+  # 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 +53,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 +87,85 @@ 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 = ProjectData.instance.get(:weights)
+    #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 +173,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}"
+        puts Rainbow(text).color(:red)
       end
     end
   end
+  # rubocop:enable Metrics/MethodLength
 
   def process_names(value)
     @names = []
@@ -145,39 +193,35 @@ 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?
+      puts 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
+      # Link with remote image
+      @data[:images] << EmbeddedFile.load(value.text.strip, File.dirname(@filename))
+    when 'file'
+      # Load local images and text files
+      @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']}"
+      puts 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/project_data.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+class ProjectData
+  include Singleton
+  attr_reader :default, :param
+
+  def initialize
+    reset
+  end
+
+  def reset
+    @default = { inputbasedir: FileUtils.pwd,
+                 stages: { d: true, b: true, f: true, i: true, s: true, t: true },
+                 threshold: 0.5,
+                 outputdir: 'output',
+                 weights: '1, 1, 1' }
+    @param = {}
+  end
+
+  def get(key)
+    return @param[key] unless @param[key].nil?
+
+    @default[key]
+  end
+
+  def set(key, value)
+    @param[key] = value
+  end
+
+  ##
+  # Open new project
+  # * setting new params and
+  # * creating output files
+  # IMPORTANT: We need at least these values
+  # * process_file
+  # * inputdirs
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  def open
+    ext = File.extname(@param[:process_file]) || '.haml'
+    @param[:projectname] = @param[:projectname] ||
+                           File.basename(@param[:process_file], ext)
+
+    @param[:logname] = "#{@param[:projectname]}-log.txt"
+    @param[:outputname] = "#{@param[:projectname]}-gift.txt"
+    @param[:lessonname] = "#{@param[:projectname]}-doc.txt"
+    @param[:yamlname] = "#{@param[:projectname]}.yaml"
+    @param[:moodlename] = "#{@param[:projectname]}-moodle.xml"
+
+    outputdir = get(:outputdir)
+    @param[:logpath] = File.join(outputdir, get(:logname))
+    @param[:outputpath] = File.join(outputdir, get(:outputname))
+    @param[:lessonpath] = File.join(outputdir, get(:lessonname))
+    @param[:yamlpath] = File.join(outputdir, get(:yamlname))
+    @param[:moodlepath] = File.join(outputdir, get(:moodlename))
+
+    Dir.mkdir(outputdir) unless Dir.exist?(outputdir)
+  end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+end

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