asker-tool 2.1.3 → 2.2.0

data/lib/asker/loader/project_loader.rb

@@ -2,6 +2,7 @@
 
 require 'yaml'
 require_relative '../project'
+require_relative '../logger'
 
 # Load params into Project class using arg input
 # * load
@@ -10,62 +11,73 @@ require_relative '../project'
 # * load_from_directory
 # * load_error
 module ProjectLoader
-  def self.load(args = {})
+  ##
+  # Load project from args
+  # @param args (String or Hash)
+  # rubocop:disable Metrics/MethodLength
+  def self.load(args)
     project = Project.instance
 
     if args.class == Hash
       project.param.merge!(args)
-      return true
+      project.open
+      return project
     elsif args.class == String
       ProjectLoader.load_from_string(args)
-      return true
+      project.open
+      return project
     end
 
     msg = '[ERROR] ProjectLoader:'
     msg += "Configuration params format is <#{pArgs.class}>!"
-    project.verbose Rainbow(msg).red
+    Logger.verboseln Rainbow(msg).red
     raise msg
   end
+  # rubocop:enable Metrics/MethodLength
 
-  def self.load_from_string(arg)
+  ##
+  # Load project from filepath. Options:
+  # * HAML filepath
+  # * XML filepath
+  # * YAML filepath
+  # @param filepath (String)
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  def self.load_from_string(filepath)
     project = Project.instance
-    unless File.exist?(arg)
-      msg = Rainbow("[WARN] ProjectLoader.load: #{arg} dosn't exists!").yellow.bright
-      project.verbose msg
-      raise msg
+    unless File.exist?(filepath)
+      msg = Rainbow("[ERROR] #{filepath} not found!").red.bright
+      Logger.verboseln msg
+      exit 1
     end
 
-    if File.extname(arg) == '.haml' || File.extname(arg) == '.xml'
-      project.set(:inputdirs, File.dirname(arg))
-      project.set(:process_file, File.basename(arg))
-    elsif File.extname(arg) == '.yaml'
-      load_from_yaml(arg)
-    elsif File.directory?(arg)
-      load_from_directory(arg)
-    else
-      load_error(arg)
+    if File.extname(filepath) == '.haml' || File.extname(filepath) == '.xml'
+      project.set(:inputdirs, File.dirname(filepath))
+      project.set(:process_file, File.basename(filepath))
+      return project
+    elsif File.extname(filepath) == '.yaml'
+      return load_from_yaml(filepath)
     end
+    error_loading(filepath)
   end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
 
+  # rubocop:disable Security/YAMLLoad
   def self.load_from_yaml(arg)
     project = Project.instance
     project.param.merge!(YAML.load(File.open(arg)))
     project.set(:configfilename, arg)
     project.set(:projectdir, File.dirname(arg))
+    project
   end
+  # rubocop:enable Security/YAMLLoad
 
-  def self.load_from_directory(dirpath)
-    msg = Rainbow('[WARN] ProjectLoader.load: Directory input ').yellow
-    msg += Rainbow(dirpath).bright.yellow
-    msg += Rainbow(' not implemented!').yellow
-    Project.instance.verbose msg
+  ##
+  # Error found and exit application.
+  def self.error_loading(arg)
+    msg = Rainbow("[ERROR] Loading... #{arg}").red.bright
+    Logger.verboseln msg
     exit 1
   end
-
-  def self.load_error(arg)
-    msg = Rainbow('[ERR ] ProjectLoader: Input ').red
-    msg += Rainbow(arg).red.bright + Rainbow(' unkown').red
-    Project.instance.verbose msg
-    raise msg
-  end
 end

data/lib/asker/logger.rb

@@ -1,16 +1,21 @@
 # frozen_string_literal: true
 
-require_relative 'project'
+require 'singleton'
+require_relative 'application'
 
 # Display and log project messages
-module Logger
+class Logger
+  include Singleton
+
+  def initialize
+    @logfile = null
+  end
+
   ##
   # Display and log text
   def self.verbose(msg)
-    project = Project.instance
-    puts msg if project.get(:verbose)
-    project.get(:logfile).write("#{msg}\n") if project.get(:logfile)
-    # project.get(:logfile)&.project.get(:logfile).write("#{msg}\n")
+    print msg if Application.instance.config['global']['verbose'] == 'yes'
+    @logfile&.write(msg)
   end
 
   ##
@@ -18,4 +23,23 @@ module Logger
   def self.verboseln(msg)
     verbose(msg + "\n")
   end
+
+  ##
+  # Create or reset logfile
+  def self.create(project)
+    @logfile = File.open(project.get(:logpath), 'w')
+    @logfile.write('=' * 50 + "\n")
+    @logfile.write("Created by : #{Application::NAME}")
+    @logfile.write(" (version #{Application::VERSION})\n")
+    @logfile.write("File       : #{project.get(:logname)}\n")
+    @logfile.write("Time       : #{Time.new}\n")
+    @logfile.write("Author     : David Vargas Ruiz\n")
+    @logfile.write('=' * 50 + "\n\n")
+  end
+
+  ##
+  # Close Log file
+  def self.close
+    @logfile.close
+  end
 end

data/lib/asker/project.rb

@@ -2,8 +2,8 @@
 
 require 'singleton'
 require 'rainbow'
-require 'fileutils'
 require_relative 'application'
+require_relative 'logger'
 
 # Contains Project data and methods
 class Project
@@ -20,16 +20,8 @@ class Project
   # Reset project params
   def reset
     @default = { inputbasedir: FileUtils.pwd,
-                outputdir: 'output',
-                category: :none,
-                formula_weights: [1, 1, 1],
-                lang: 'en',
-                locales: %w[en es javascript math python ruby sql],
-                show_mode: :default,
-                verbose: true,
-                stages: { d: true, b: true, f: true, i: true, s: true, t: true },
-                threshold: 0.5,
-                color_output: true }
+                 stages: { d: true, b: true, f: true, i: true, s: true, t: true },
+                 threshold: 0.5 }
     @param = {}
   end
 
@@ -54,117 +46,36 @@ class Project
   # Open new project
   # * setting new params and
   # * creating output files
-  # IMPORTANT: We need at least theses values
+  # IMPORTANT: We need at least these values
   # * process_file
   # * inputdirs
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
   def open
-    ext = '.haml'
-    @param[:process_file] = @param[:process_file] ||
-                            get(:projectdir).split(File::SEPARATOR).last + ext
+    config = Application.instance.config
+    ext = File.extname(@param[:process_file]) || '.haml'
     @param[:projectname] = @param[:projectname] ||
                            File.basename(@param[:process_file], ext)
-    @param[:inputdirs] = @param[:inputdirs] ||
-                         File.join(get(:inputbasedir), @param[:projectdir])
 
-    @param[:logname] = @param[:logname] ||
-                       "#{@param[:projectname]}-log.txt"
-    @param[:outputname] = @param[:outputname] ||
-                          "#{@param[:projectname]}-gift.txt"
-    @param[:lessonname] = @param[:lessonname] ||
-                          "#{@param[:projectname]}-doc.txt"
-    @param[:yamlname] = @param[:yamlname] ||
-                        "#{@param[:projectname]}.yaml"
-
-    @param[:logpath] = @param[:logpath] ||
-                       File.join(get(:outputdir), @param[:logname])
-    @param[:outputpath] = @param[:outputpath] ||
-                          File.join(get(:outputdir), @param[:outputname])
-    @param[:lessonpath] = @param[:lessonpath] ||
-                          File.join(get(:outputdir), @param[:lessonname])
-    @param[:yamlpath] = @param[:yamlpath] ||
-                        File.join(get(:outputdir), @param[:yamlname])
-
-    Dir.mkdir(get(:outputdir)) unless Dir.exist?(get(:outputdir))
-    create_log_file
-    create_output_file
-    create_lesson_file
-    create_yaml_file
-  end
-
-  ##
-  # Close output files
-  def close
-    get(:logfile).close
-    get(:outputfile).close
-    get(:lessonfile).close
-    get(:yamlfile).close
-  end
-
-  ##
-  # Display and log text
-  def verbose(msg)
-    puts msg if get(:verbose)
-    get(:logfile).write(msg.to_s + "\n") if get(:logfile)
-  end
-
-  ##
-  # Display and log text line
-  def verboseln(msg)
-    verbose(msg + "\n")
-  end
-
-  def method_missing(method, *_args, &_block)
-    get(method)
-  end
-
-  private
-
-  # create or reset logfile
-  def create_log_file
-    @param[:logfile] = File.open(get(:logpath), 'w')
-    f = get(:logfile)
-    f.write('=' * 50 + "\n")
-    f.write("Created by : #{Application::NAME}")
-    f.write(" (version #{Application::VERSION})\n")
-    f.write("File       : #{get(:logname)}\n")
-    f.write("Time       : #{Time.new}\n")
-    f.write("Author     : David Vargas Ruiz\n")
-    f.write('=' * 50 + "\n\n")
-
-    verbose '[INFO] Project open'
-    verbose '   ├── inputdirs    = ' + Rainbow(get(:inputdirs)).bright
-    verbose '   └── process_file = ' + Rainbow(get(:process_file)).bright
-  end
-
-  # Create or reset output file
-  def create_output_file
-    @param[:outputfile] = File.open(get(:outputpath), 'w')
-    f = get(:outputfile)
-    f.write('// ' + ('=' * 50) + "\n")
-    f.write("// Created by : #{Application::NAME}")
-    f.write(" (version #{Application::VERSION})\n")
-    f.write("// File       : #{get(:outputname)}\n")
-    f.write("// Time       : #{Time.new}\n")
-    f.write("// Author     : David Vargas Ruiz\n")
-    f.write('// ' + ('=' * 50) + "\n\n")
-    f.write("$CATEGORY: $course$/#{get(:category)}\n") unless get(:category) == :none
-  end
-
-  # Create or reset lesson file
-  def create_lesson_file
-    @param[:lessonfile] = File.new(get(:lessonpath), 'w')
-    f = get(:lessonfile)
-    f.write('=' * 50 + "\n")
-    f.write("Created by : #{Application::NAME}")
-    f.write(" (version #{Application::VERSION})\n")
-    f.write("File       : #{get(:lessonname)}\n")
-    f.write("Time       : #{Time.new}\n")
-    f.write("Author     : David Vargas Ruiz\n")
-    f.write('=' * 50 + "\n")
-  end
-
-  # Create or reset yaml file
-  def create_yaml_file
-    @param[:yamlfile] = File.open(get(:yamlpath), 'w')
+    @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 = config['output']['folder']
+    @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)
+    Logger.create(self) # Create log file where to save log messages
+    Logger.verboseln '[INFO] Project open'
+    Logger.verboseln '   ├── inputdirs    = ' + Rainbow(get(:inputdirs)).bright
+    Logger.verboseln '   └── process_file = ' + Rainbow(get(:process_file)).bright
   end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
 end

data/lib/asker/skeleton.rb

@@ -2,6 +2,7 @@
 
 require 'fileutils'
 require 'rainbow'
+require_relative 'application'
 
 # Skeleton: create skeleton for asker input files
 # * create
@@ -10,27 +11,38 @@ require 'rainbow'
 # * create_dirs
 # * copyfile
 module Skeleton
-  def self.create(dirpath)
-    puts "\n[INFO] Creating #{Rainbow(dirpath).bright} project skeleton"
+  ##
+  # Create skeleton for asker input files
+  # @param inputpath (String)
+  # rubocop:disable Metrics/MethodLength
+  def self.create_input(inputpath)
+    puts "\n[INFO] Creating example input #{Rainbow(inputpath).bright}"
+    if File.extname(inputpath) == '.haml'
+      dirpath = File.dirname(inputpath)
+      filename = File.basename(inputpath)
+    else
+      dirpath = inputpath
+      filename = 'example-concept.haml'
+    end
     create_dir dirpath
-    copy_files_into(dirpath)
+    source = File.join(File.dirname(__FILE__), 'files/example-concept.haml')
+    copyfile(source, File.join(dirpath, filename))
   end
+  # rubocop:enable Metrics/MethodLength
 
-  def self.copy_files_into(project_dir)
-    # Directory and files: Ruby script, Configfile, gitignore
-    items = [
-      { source: 'files/example-concept.haml', target: 'example-concept.haml' }
-#      { source: 'files/example-code.haml', target: 'example-code.haml' },
-    ]
-    source_basedir = File.join(File.dirname(__FILE__))
-    items.each do |item|
-      source = File.join(source_basedir, item[:source])
-      target = File.join(project_dir, item[:target])
-      copyfile(source, target)
-    end
+  ##
+  # Create default configuration files
+  def self.create_configuration
+    puts "\n[INFO] Creating configuration files"
+    src = File.join(File.dirname(__FILE__), 'files', Application::CONFIGFILE)
+    dst = File.join(Application::CONFIGFILE)
+    copyfile(src, dst)
   end
 
-  def self.create_dir(dirpath)
+  ##
+  # Create folder
+  # @param dirpath (String)
+  private_class_method def self.create_dir(dirpath)
     if Dir.exist? dirpath
       puts "* Exists dir!       => #{Rainbow(dirpath).yellow}"
     else
@@ -43,21 +55,20 @@ module Skeleton
     end
   end
 
-  def self.create_dirs(*args)
-    args.each { |arg| create_dir arg }
-  end
-
-  def self.copyfile(target, dest)
+  ##
+  # Copy target file to dest
+  # @param target (String)
+  # @param dest (String)
+  private_class_method def self.copyfile(target, dest)
     if File.exist? dest
       puts "* Exists file!      => #{Rainbow(dest).yellow}"
-    else
-      puts "* File not found!   => #{Rainbow(target).yellow}" unless File.exist? target
-      begin
-        FileUtils.cp(target, dest)
-        puts "* Create file       => #{Rainbow(dest).green}"
-      rescue StandardError
-        puts "* Create file ERROR => #{Rainbow(dest).red}"
-      end
+      return true
+    end
+    begin
+      FileUtils.cp(target, dest)
+      puts "* Create file       => #{Rainbow(dest).green}"
+    rescue StandardError
+      puts "* Create file ERROR => #{Rainbow(dest).red}"
     end
   end
 end

data/lib/asker.rb

@@ -2,63 +2,29 @@
 
 require 'rainbow'
 
-require_relative 'asker/project'
-require_relative 'asker/data/concept'
-require_relative 'asker/data/world'
-require_relative 'asker/ai/concept_ai'
-require_relative 'asker/formatter/concept_string_formatter'
-require_relative 'asker/exporter/main'
+require_relative 'asker/displayer/concept_displayer'
+require_relative 'asker/displayer/stats_displayer'
+require_relative 'asker/exporter/output_file_exporter'
 require_relative 'asker/loader/project_loader'
 require_relative 'asker/loader/input_loader'
 require_relative 'asker/checker'
+require_relative 'asker/logger'
 require_relative 'asker/skeleton'
 
-# This class does all the job
-# * start
-# * load_input_data
-# * create_output_files, show_create_output_files
-# * create_questions
-# * show_final_results
+##
+# Asker main class
 class Asker
-  # Initialize atributes
-  def initialize
-    @concepts_ai = []
-    @concepts = []
-    @codes = []
-  end
-
   ##
-  # Start working
-  # @param args (Hash)
-  def start(args = {})
-    load_input_data(args)
-    create_output_files
-    show_final_results
-  end
-
-  ##
-  # Load input data
-  # @param args (Hash)
-  def load_input_data(args)
-    ProjectLoader.load(args)
-    Project.instance.open
-    data = InputLoader.load(Project.instance.get(:inputdirs).split(','))
-    @concepts = data[:concepts]
-    @codes = data[:codes]
-    Project.instance.verbose "\n[INFO] Loading data from Internet"
-    @world = World.new(@concepts)
-    ConceptScreenExporter.export_all(@concepts)
+  # Create asker input demo files
+  # @param dirpath (String)
+  def self.create_input(dirpath)
+    Skeleton.create_input(dirpath)
   end
 
   ##
-  # Create output files
-  # * Gift
-  # * YAML
-  # * TXT Doc
-  def create_output_files
-    show_create_output_files
-    create_questions
-    ConceptDocExporter.new(@concepts).export
+  # Create asker configuration files
+  def self.create_configuration
+    Skeleton.create_configuration
   end
 
   ##
@@ -69,43 +35,66 @@ class Asker
   end
 
   ##
-  # Create asker input demo files
-  # @param dirpath (String)
-  def self.create_skeleton(dirpath)
-    Skeleton.create(dirpath)
+  # Start working
+  # @param filepath (String) HAML or XML filepath
+  def self.start(filepath)
+    project, data = load_input(filepath)
+    ConceptDisplayer.show(data[:concepts])
+    create_output(project, data)
   end
 
-  private
-
-  def show_create_output_files
-    p = Project.instance
-    p.verbose "\n[INFO] Creating output files"
-    p.verbose "   ├── Gift questions file => #{Rainbow(p.outputpath).bright}"
-    p.verbose "   ├── YAML questions file => #{Rainbow(p.yamlpath).bright}"
-    p.verbose "   └── Lesson file         => #{Rainbow(p.lessonpath).bright}"
+  ##
+  # Load input data
+  # @param args (Hash)
+  private_class_method def self.load_input(args)
+    project = ProjectLoader.load(args)
+    data = InputLoader.load(project.get(:inputdirs).split(','))
+    [project, data]
   end
 
   ##
-  # Create questions for every "concept"
-  # Export output to:
-  # * GIFT format file
-  # * YAML format file
-  # Create questions for every "code"
-  # Export output to GIFT format file
-  def create_questions
-    @concepts.each do |concept|
-      concept_ai = ConceptAI.new(concept, @world)
-      concept_ai.make_questions
-      @concepts_ai << concept_ai
-    end
-    ConceptAIGiftExporter.export_all(@concepts_ai)
-    ConceptAIYAMLExporter.export_all(@concepts_ai)
-    CodeGiftExporter.export_all(@codes) # UNDER DEVELOPMENT
-  end
+  # Create output files: Gift, YAML, TXT Doc
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/PerceivedComplexity
+  private_class_method def self.create_output(project, data)
+    Logger.verboseln "\n[INFO] Creating output files"
+    m = '   ├── Gift questions file => '
+    m += if Application.instance.config['output']['gift'] == 'yes'
+           Rainbow(project.get(:outputpath)).bright
+         else
+           "#{project.get(:outputpath)} (No)"
+         end
+    Logger.verboseln m
+
+    m = '   ├── Lesson file         => '
+    m += if Application.instance.config['output']['doc'] == 'yes'
+           Rainbow(project.get(:lessonpath)).bright
+         else
+           "#{project.get(:lessonpath)} (No)"
+         end
+    Logger.verboseln m
+
+    m = '   ├── YAML questions file => '
+    m += if Application.instance.config['output']['yaml'] == 'yes'
+           Rainbow(project.get(:yamlpath)).bright
+         else
+           "#{project.get(:yamlpath)} (No)"
+         end
+    Logger.verboseln m
 
-  def show_final_results
-    ConceptAIScreenExporter.export_all(@concepts_ai)
-    CodeScreenExporter.export_all(@codes)
-    Project.instance.close
+    m = '   └── Moodle XML file     => '
+    m += if Application.instance.config['output']['moodle'] == 'yes'
+           Rainbow(project.get(:moodlepath)).bright
+         else
+           "#{project.get(:moodlepath)} (No)"
+         end
+    Logger.verboseln m
+    OutputFileExporter.export(data, project)
+    StatsDisplayer.show(data)
+    Logger.close
   end
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/PerceivedComplexity
 end