asker-tool 2.1.7 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 180880dc684b6b39dabf66bf31366cee9e8b9793af6e92d256948edf36f5fcc7
-  data.tar.gz: 9c6cd45c7b3ec9b9dbde3d720092a8eabcbc98f3dd4056a413247cdd0d7b3a2e
+  metadata.gz: 04d190919a7d7b95571b648c9c265903acdeae0ca4b698139218de32cfe0ee3c
+  data.tar.gz: fcb0b10af1a109958c8ff04dde61ff484ffbed75443a41898b97b9d633d915f3
 SHA512:
-  metadata.gz: 1238e0b8c18a6a37f0731479d39039559c1f2adb7b3c8372c1965f81bb9e946ed37637e7e420d6e188a0811d9da9f652eda53b6c8dd67d4d7f6a79bebf7bb2b7
-  data.tar.gz: fbefae58aa69fd054a900945867c88082548042d7306227fedb1f553b48773e4fb0354913ff5bfa029c206679b7d38f4562212798dd7814de98f319d0ae71d63
+  metadata.gz: 022d75e6c3d4a2fedb183e60d86d64ab3b6494decd2ca5e1e8741824947bc2e3dadc902e6f7543978666d1833a29b7305794b33a84bfcfc07da6139c95f3009f
+  data.tar.gz: 713a78b38a4155700ad1e11cb562638b43bbbc479d2ffa2ef9726befa1b5e6b49283795cd141aee5871a8dbd37e04652c51cd98c1e0489b0c8cfa429b2002c42

data/README.md

@@ -1,9 +1,12 @@
-# ASKER (version 2.1)
+[![Gem Version](https://badge.fury.io/rb/asker-tool.svg)](https://badge.fury.io/rb/asker-tool)
+![GitHub](https://img.shields.io/github/license/dvarrui/asker)
+![Gem](https://img.shields.io/gem/dv/asker-tool/2.2.1)
 
-Generate a lot of questions from an _input file_ base on your own _definitions_.
+# ASKER (devel 2.3)
 
----
-# Description
+Generate a lot of questions from an _input_ text file with on your own _definitions_. In a way, this _input file_ is a concept map.
+
+![logo](./docs/images/logo.png)
 
 ASKER helps trainers to create a huge amount of questions, from a definitions (_conceptual entities_) input file.
 
@@ -11,32 +14,29 @@ ASKER helps trainers to create a huge amount of questions, from a definitions (_
 * Multiplatform.
 * Ruby program.
 
----
-# Installation
+## Installation
 
 1. Install Ruby on your system.
 2. `gem install asker-tool`
 
----
-# Usage
+## Usage
 
 Steps:
 
 1. Create an input file with your definitions (_conceptual entities_).
 1. Run _asker_ and get the results into `output` directory.
 
-Example: Running `asker` with our example input file as argument (`jedi.haml`):
+Example: Running `asker` with our example input file as argument (`acdc.haml`):
 
 ```
-asker docs/examples/starwars/jedi.haml
+asker docs/examples/bands/acdc.haml
 ```
 
 * Output files created into the `output` folder.
-* More [example input files](https://github.com/dvarrui/asker/tree/devel/docs/examples).
+* More [example input files](./docs/examples).
 * More asker input files at `github/dvarrui/asker-inputs` repository.
 
----
-# Documentation
+## Documentation
 
 * [Installation](https://github.com/dvarrui/asker/blob/devel/docs/install/README.md)
 * [Inputs](https://github.com/dvarrui/asker/blob/devel/docs/inputs/README.md)
@@ -45,8 +45,7 @@ asker docs/examples/starwars/jedi.haml
 * [Base idea](https://github.com/dvarrui/asker/blob/devel/docs/idea.md)
 * [History](https://github.com/dvarrui/asker/blob/devel/docs/history.md)
 
----
-# Contact
+## Contact
 
 * **Email**: `teuton.software@protonmail.com`
 * **Twitter**: `@SoftwareTeuton`

data/bin/asker

@@ -1,4 +1,4 @@
-#!/usr/bin/ruby
+#!/usr/bin/env ruby
 require 'asker/cli'
 
 # Start Asker command line interface

data/lib/asker/ai/ai.rb

@@ -6,14 +6,14 @@ require_relative 'ai_calculate'
 # Description: Method to be included into every ConceptAI instance.
 # * make_questions: use AI to fill @questions Array
 module AI
-  include AI_calculate
+  include AICalculate
 
   def make_questions
-    return unless process?
+    return unless concept.process?
 
     make_questions_stages_di
     # Process every table of this concept
-    tables.each do |tab|
+    concept.tables.each do |tab|
       list1, list2 = get_list1_and_list2_from(tab)
       make_questions_stages_bsf(tab, list1, list2)
       make_questions_stages_t(tab, list1, list2)
@@ -23,11 +23,13 @@ module AI
     exclude_questions
   end
 
+  # Make questions for states D and I
   def make_questions_stages_di
     @questions[:d] = StageD.new(self).run  # Process every def{type=text}
     @questions[:i] = StageI.new(self).run  # Process every def{type=image_url}
   end
 
+  # Make questions for stages B, S and F
   def make_questions_stages_bsf(tab, list1, list2)
     # Stage B: process table to make match questions
     @questions[:b] += StageB.new(self).run(tab, list1, list2)
@@ -37,6 +39,7 @@ module AI
     @questions[:f] += StageF.new(self).run(tab, list1, list2)
   end
 
+  # Make questions for stage T
   def make_questions_stages_t(tab, list1, list2)
     # Stage T: process_tableXfields
     list3 = list1 + list2

data/lib/asker/ai/ai_calculate.rb

@@ -1,29 +1,39 @@
 # frozen_string_literal: true
 
 # Methods that calculate something
-module AI_calculate
-  def get_list1_and_list2_from(ltable)
+module AICalculate
+  ##
+  # Calculate and return list1 and list2
+  # * return list1 (Array) List with all the rows from the table
+  # * return list2 (Array) List with similar rows (same table name) from the neighbours tables
+  # @param p_table (Table)
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  def get_list1_and_list2_from(p_table)
     # create <list1> with all the rows from the table
     list1 = []
     count = 1
-    ltable.rows.each do |i|
+    p_table.rows.each do |i|
       list1 << { id: count, weight: 0, data: i }
       count += 1
     end
 
     # create a <list2> with similar rows (same table name) from the neighbours tables
     list2 = []
-    neighbors.each do |n|
+    concept.neighbors.each do |n|
       n[:concept].tables.each do |t2|
-        next if t2.name != ltable.name
+        next if t2.name != p_table.name
+
         t2.rows.each do |i|
           list2 << { id: count, weight: 0, data: i }
           count += 1
         end
       end
     end
-    return list1, list2
+    [list1, list2]
   end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
 
   def calculate_nearness_between_texts(text1, text2)
     return 0.0 if text2.nil? || text2.empty?
@@ -34,6 +44,8 @@ module AI_calculate
     (count * 100 / words.count)
   end
 
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
   def reorder_list_with_row(list, row)
     # evaluate every row of the list2
     list.each do |r|
@@ -52,4 +64,6 @@ module AI_calculate
     list.sort! { |a, b| a[:weight] <=> b[:weight] }
     list.reverse!
   end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
 end

data/lib/asker/ai/concept_ai.rb

@@ -17,15 +17,21 @@ class ConceptAI
   attr_reader :questions
   attr_reader :excluded_questions
 
+  ##
+  # Initialize ConcepAI
+  # @param concept (Concept)
+  # @param world (World)
   def initialize(concept, world)
     @concept = concept
     @world = world
     @questions = { d: [], b: [], f: [], i: [], s: [], t: [] }
     @excluded_questions = { d: [], b: [], f: [], i: [], s: [], t: [] }
-    @num = 0 # Used to add a unique number to every question
+    @num = 0 # Add a unique number to every question
     make_questions
   end
 
+  ##
+  # Generates and return new "num" value
   def num
     @num += 1
     @num.to_s
@@ -33,11 +39,14 @@ class ConceptAI
 
   # If a method call is missing, then delegate to concept parent.
   def method_missing(method, *args, &block)
+    raise "[DEBUG] ConceptAI.#{method}(#{args})"
     @concept.send(method, *args, &block)
   end
 
+  ##
+  # Generates random image URL
   def random_image_for(_conceptname)
-    return '' if rand <= Project.instance.get(:threshold)
+    return '' if rand <= ProjectData.instance.get(:threshold)
 
     keys = @world.image_urls.keys
     keys.shuffle!
@@ -45,6 +54,6 @@ class ConceptAI
     return '' if values.nil?
 
     values.shuffle!
-    "<img src=\"#{values[0]}\" alt\=\"image\"><br/>"
+    "<img src=\"#{values[0]}\" alt=\"image\"><br/>"
   end
 end

data/lib/asker/ai/question.rb

@@ -1,18 +1,31 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 require 'set'
 
 # Define Question class
 class Question
-  attr_accessor :name, :comment, :text
-  attr_accessor :good, :bads, :matching, :shorts
-  attr_accessor :feedback
-  attr_reader   :type
-  attr_accessor :tags, :lang
+  attr_accessor :name     # Question name used as identification
+  attr_accessor :comment  # Comments asociated
+  attr_accessor :text     # The real text of the question
+  attr_accessor :good     # The correct answer
+  attr_accessor :bads     # Bads answers used by choice type question
+  attr_accessor :matching # Matching answers used by match type question
+  attr_accessor :shorts   # Short answers used by short type question
+  attr_accessor :feedback # Question feedbak
+  attr_reader   :type     # Question type: :choice, :match, :boolean, :short
+  attr_accessor :tags
+  attr_accessor :lang     # Info used when export (YAML)
+  attr_accessor :encode   # image base64 content used when export Moodle xml
 
+  # Initialize object
+  # @param type (Symbol) Question type: choice, match, boolean, short
   def initialize(type = :choice)
     reset(type)
   end
 
+  # Reset attributes
+  # @param type (Symbol) Question type: choice, match, boolean, short
+  # rubocop:disable Metrics/MethodLength
   def reset(type = :choice)
     @name = ''
     @comment = ''
@@ -26,32 +39,41 @@ class Question
     shuffle_on
     @tags = Set.new
     @lang = nil
+    @encode = :none
   end
+  # rubocop:enable Metrics/MethodLength
 
+  # Set choice type
   def set_choice
     @type = :choice
   end
 
+  # Set match type
   def set_match
     @type = :match
   end
 
+  # Set boolean type
   def set_boolean
     @type = :boolean
   end
 
+  # Set short type
   def set_short
     @type = :short
   end
 
+  # Set shuffle off
   def shuffle_off
     @shuffle = false
   end
 
+  # Set shuffle on
   def shuffle_on
     @shuffle = true
   end
 
+  # Return shuffle value
   def shuffle?
     @shuffle
   end

data/lib/asker/ai/stages/base_stage.rb

@@ -1,16 +1,55 @@
+# frozen_string_literal: true
 
+# Base Stage class
 class BaseStage
+  #
+  # Initialize Stage with ConceptAI
+  # @param concept_ai (ConceptAI)
   def initialize(concept_ai)
     @concept_ai = concept_ai
   end
 
-  # If a method we call is missing, pass the call onto
-  # the object we delegate to.
-  def method_missing(m, *args, &block)
-    @concept_ai.send(m, *args, &block)
-  end
-
   def run
     raise 'Implement run method!'
   end
+
+  def concept
+    @concept_ai.concept
+  end
+
+  def name(option = :raw)
+    @concept_ai.concept.name(option)
+  end
+
+  def names
+    raise 'Change names by concept.names'
+  end
+
+  def num
+    @concept_ai.num
+  end
+
+  def lang
+    raise 'Change lang by concept.lang'
+  end
+
+  def type
+    raise 'Change type by concept.type'
+  end
+
+  def texts
+    raise 'Change texts by cocept.texts'
+  end
+
+  def images
+    raise 'Change images by cocept.images'
+  end
+
+  def neighbors
+    raise 'Change neighbors by concept.neighbors'
+  end
+
+  def random_image_for(option)
+    @concept_ai.random_image_for(option)
+  end
 end

data/lib/asker/ai/stages/stage_b.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'set'
 
@@ -6,82 +6,123 @@ require_relative 'base_stage'
 require_relative '../question'
 
 class StageB < BaseStage
+  ##
   # range b1
-
-  def run(pTable, pList1, pList2)
-    # process table match
+  # Process table data to generate match questions
+  # @param table (Table)
+  # @param list1 (Array) Rows that belong to this table
+  # @param list2 (Array) List with similar rows (same table name) from the neighbours tables
+  def run(table, list1, list2)
     questions = []
-    return questions if pTable.fields.count < 2
+    return questions if table.fields.count < 2
 
-    return questions unless type == 'text'
+    return questions unless concept.type == 'text'
 
-    if pTable.fields.count>1 then
-      questions += process_table_match2fields(pTable, pList1, pList2, 0, 1)
-    elsif pTable.fields.count>2 then
-      questions += process_table_match2fields(pTable, pList1, pList2, 0, 2)
-      questions += process_table_match2fields(pTable, pList1, pList2, 1, 2)
-    elsif pTable.fields.count>3 then
-      questions += process_table_match2fields(pTable, pList1, pList2, 0, 3)
-      questions += process_table_match2fields(pTable, pList1, pList2, 1, 3)
-      questions += process_table_match2fields(pTable, pList1, pList2, 2, 3)
+    if table.fields.count == 2
+      questions += process_table_match2fields(table, list1, list2, 0, 1)
+    elsif table.fields.count == 3
+      questions += process_table_match2fields(table, list1, list2, 0, 1)
+      questions += process_table_match2fields(table, list1, list2, 0, 2)
+    elsif table.fields.count == 4
+      questions += process_table_match2fields(table, list1, list2, 0, 1)
+      questions += process_table_match2fields(table, list1, list2, 0, 2)
+      questions += process_table_match2fields(table, list1, list2, 0, 3)
     end
 
     questions
   end
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/MethodLength
 
-  def process_table_match2fields(pTable, pList1, pList2, pIndex1, pIndex2)
+  ##
+  # Process table data to generate match questions
+  # @param p_table (Table)
+  # @param list1 (Array) Rows that belong to this table
+  # @param list2 (Array) List with similar rows (same table name) from the neighbours tables
+  # @param index1 (Integer) Use this field number
+  # @param index2 (Integer) Use this field number
+  def process_table_match2fields(p_table, list1, list2, index1, index2)
     questions = []
+    lang = concept.lang
 
-    if pList1.count>3
-      pList1.each_cons(4) do |e1,e2,e3,e4|
-        e = [ e1, e2, e3, e4 ]
+    if list1.count > 3
+      list1.each_cons(4) do |e1, e2, e3, e4|
+        e = [e1, e2, e3, e4]
 
-        #Question type <b1match>: match 4 items from the same table
+        # Question type <b1match>: match 4 items from the same table
         e.shuffle!
-        q=Question.new(:match)
-        q.name="#{name}-#{num.to_s}-b1match4x4-#{pTable.name}"
-        q.text= random_image_for(name) + lang.text_for(:b1, name, pTable.fields[pIndex1].capitalize, pTable.fields[pIndex2].capitalize )
-        q.matching << [ e[0][:data][pIndex1], e[0][:data][pIndex2] ]
-        q.matching << [ e[1][:data][pIndex1], e[1][:data][pIndex2] ]
-        q.matching << [ e[2][:data][pIndex1], e[2][:data][pIndex2] ]
-        q.matching << [ e[3][:data][pIndex1], e[3][:data][pIndex2] ]
+        q = Question.new(:match)
+        q.name = "#{name}-#{num}-b1match4x4-#{p_table.name}"
+        q.tags << 'match'
+        q.tags << 'random'
+        q.text = random_image_for(name) \
+                 + lang.text_for(:b1, name, p_table.fields[index1].capitalize, p_table.fields[index2].capitalize)
+        q.matching << [e[0][:data][index1], e[0][:data][index2]]
+        q.matching << [e[1][:data][index1], e[1][:data][index2]]
+        q.matching << [e[2][:data][index1], e[2][:data][index2]]
+        q.matching << [e[3][:data][index1], e[3][:data][index2]]
+        # Add an extra line
+        if list2.count.positive?
+          q.matching << ['', list2[0][:data][index2]]
+        else
+          q.tags << 'misspell'
+          q.matching << ['', lang.do_mistake_to(e[0][:data][index2])]
+        end
         questions << q
 
         # Question type <b1match>: match 3 items from table-A and 1 item with error
         e.shuffle!
-        q=Question.new(:match)
-        q.name="#{name}-#{num.to_s}-b1match3x1misspelled-#{pTable.name}"
-        q.text= random_image_for(name) + lang.text_for(:b1, name, pTable.fields[pIndex1].capitalize, pTable.fields[pIndex2].capitalize )
-        q.matching << [ e[0][:data][pIndex1], e[0][:data][pIndex2] ]
-        q.matching << [ e[1][:data][pIndex1], e[1][:data][pIndex2] ]
-        q.matching << [ e[2][:data][pIndex1], e[2][:data][pIndex2] ]
-        q.matching << [ lang.do_mistake_to(e[3][:data][pIndex1]), lang.text_for(:misspelling) ]
+        q = Question.new(:match)
+        q.name = "#{name}-#{num}-b1match3x1misspelled-#{p_table.name}"
+        q.tags << 'match'
+        q.tags << 'random'
+        q.text = random_image_for(name) \
+                 + lang.text_for(:b1, name, p_table.fields[index1].capitalize, p_table.fields[index2].capitalize)
+        q.matching << [e[0][:data][index1], e[0][:data][index2]]
+        q.matching << [e[1][:data][index1], e[1][:data][index2]]
+        q.matching << [e[2][:data][index1], e[2][:data][index2]]
+        q.matching << [lang.do_mistake_to(e[3][:data][index1]), lang.text_for(:misspelling)]
+        # Add an extra line
+        if list2.count.positive?
+          q.matching << ['', list2[0][:data][index2]]
+        else
+          q.tags << 'misspell'
+          q.matching << ['', lang.do_mistake_to(e[0][:data][index2])]
+        end
         questions << q
       end
     end
 
-    if pList1.count>2 and pList2.count>0
-      s=Set.new
-      pList1.each do |i|
-        s.add( i[:data][pIndex1]+"<=>"+i[:data][pIndex2] )
+    if list1.count > 2 && list2.count.positive?
+      s = Set.new
+      list1.each do |i|
+        s.add(i[:data][index1] + '<=>' + i[:data][index2])
       end
-      s.add( pList2[0][:data][pIndex1]+"<=>"+pList2[0][:data][pIndex2] )
-      a=s.to_a
+      s.add(list2[0][:data][index1] + '<=>' + list2[0][:data][index2])
 
       # Question 3 items from table-A, and 1 item from table-B
       if s.count > 3
-        q=Question.new(:match)
-        q.name="#{name}-#{num.to_s}-b1match3x1-#{pTable.name}"
-        q.text= random_image_for(name) + lang.text_for(:b1, name , pTable.fields[pIndex1].capitalize, pTable.fields[pIndex2].capitalize)
-        q.matching << [ pList1[0][:data][pIndex1], pList1[0][:data][pIndex2] ]
-        q.matching << [ pList1[1][:data][pIndex1], pList1[1][:data][pIndex2] ]
-        q.matching << [ pList1[2][:data][pIndex1], pList1[2][:data][pIndex2] ]
-        q.matching << [ pList2[0][:data][pIndex1], lang.text_for(:error) ]
+        q = Question.new(:match)
+        q.name = "#{name}-#{num}-b1match3x1-#{p_table.name}"
+        q.tags << 'match'
+        q.tags << 'random'
+        q.text = random_image_for(name) \
+                 + lang.text_for(:b1, name, p_table.fields[index1].capitalize, p_table.fields[index2].capitalize)
+        q.matching << [list1[0][:data][index1], list1[0][:data][index2]]
+        q.matching << [list1[1][:data][index1], list1[1][:data][index2]]
+        q.matching << [list1[2][:data][index1], list1[2][:data][index2]]
+        q.matching << [list2[0][:data][index1], lang.text_for(:error)]
+        q.matching << ['', lang.do_mistake_to(list1[0][:data][index2])]
         questions << q
       end
     end
 
-    return questions
+    questions
   end
-
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/CyclomaticComplexity
+  # rubocop:enable Style/ConditionalAssignment
+  # rubocop:enable Metrics/BlockLength
+  # rubocop:enable Metrics/PerceivedComplexity
 end