quick_exam 1.0.0

data/lib/quick_exam/analyst/base_text.rb

@@ -0,0 +1,53 @@
+require 'quick_exam/format'
+require 'quick_exam/record'
+require 'quick_exam/record_collection'
+require 'quick_exam/analyst/common'
+
+module QuickExam
+  module Analyst
+    class BaseText
+      include QuickExam::Format
+      attr_reader :records, :total_line
+
+      def initialize(file_path, f_ques:'' , f_corr:'')
+        raise ErrorAnalyze.new('No such file') unless File.exist? file_path
+        @file_path = file_path
+        @f_ques = f_ques
+        @f_corr = f_corr
+        @records = QuickExam::RecordCollection.new()
+      end
+
+      def analyze
+        data_standardize
+        self
+      rescue => e
+        raise ErrorAnalyze.new('Data can not analyze')
+      end
+
+      private
+
+      include QuickExam::Analyst::Common
+
+      def data_standardize
+        file = File.open(@file_path, 'r')
+        @total_line = File.foreach(file).count
+        @object = QuickExam::Record.new()
+
+        file.each_line.with_index do |row, idx|
+          idx += 1 # The first row is 1
+
+          if end_of_line?(idx) || end_of_one_ticket_for_next_question?(row)
+            get_answer(row) # if the last line is answer then will get answer
+            collect_object_ticket
+          end
+
+          next if row.__blank?
+
+          next if get_answer(row)
+          next if get_question(row)
+        end
+        records
+      end
+    end
+  end
+end

data/lib/quick_exam/analyst/common.rb

@@ -0,0 +1,125 @@
+module QuickExam
+  module Analyst
+    module Common
+      def get_question(str)
+        return if @object.answers.__present?
+        @object.question += question(str)
+      end
+
+      def get_answer(str)
+        return if @object.question.__blank?
+        return unless answer?(str)
+
+        # Get answer
+        @object.answers << answer(str)
+        get_correct_indexes_answer(str)
+      end
+
+      def get_correct_indexes_answer(str)
+        return unless correct_answer?(str)
+        @object.correct_indexes << @object.answers.size - 1
+      end
+
+      def end_of_one_ticket_for_next_question?(str)
+        str = Sanitize.fragment(str)
+        @object.answers.__present? && @object.question.__present? && question?(str)
+      end
+
+      def end_of_line?(num_row)
+        num_row == @total_line
+      end
+
+      def collect_object_ticket
+        @records << clean_object
+        reset_object_ticket
+      end
+
+      def clean_object
+        @object.question.strip!
+        @object.answers.map(&:strip!)
+        @object
+      end
+
+      def reset_object_ticket
+        @object = QuickExam::Record.new()
+      end
+
+      def correct_answer?(str)
+        str.downcase.include?(correct_mark(@f_corr).downcase)
+      end
+
+      def question?(str)
+        str = rid_non_ascii!(str)
+        str = Sanitize.fragment(str).__squish
+        str[(regex_question_mark)].__present?
+      end
+
+      def answer?(str)
+        str = rid_non_ascii!(str)
+        str = Sanitize.fragment(str).__squish
+        str[(regex_answer_mark)].__present?
+      end
+
+      # TODO: Regex get clean answer
+      # i: case insensitive
+      # x: ignore whitespace in regex
+      # ?= : positive lookahead
+      def answer(str)
+        corr_mark = correct_mark(@f_corr, safe: true)
+        ans_with_mark_correct = /(#{regex_answer_sentence}(?=#{corr_mark}))/
+        ans_without_mark_correct = regex_answer_sentence
+        str[(/#{ans_with_mark_correct}|#{regex_answer_sentence}/ix)].__presence || str
+      end
+
+      # TODO: Regex get clean question
+      # i: case insensitive
+      # m: make dot match newlines
+      # ?<= : positive lookbehind
+      def question(str)
+        letter_question = Regexp.quote(str.match(regex_question_mark).to_a.last.to_s)
+        str[(/(?<=#{letter_question}).+/im)].__presence || str
+      end
+
+      # TODO: Regex match question mark
+      # Format question: Q1: , q1. , q1) , Q1/
+      # @return: Question mark
+      #
+      # i: case insensitive
+      # m: make dot match newlines
+      # x: ignore whitespace in regex
+      def regex_question_mark
+        ques_mark = question_mark(@f_ques, safe: true)
+        /(^#{ques_mark}[\s]*\d+[:|\)|\.|\/])/ixm
+      end
+
+      # TODO: Regex match answer sentence
+      # Format question: A) , a. , 1/
+      # @return: Answer sentence without answer mark
+      #
+      # ?<= : positive lookbehind
+      def regex_answer_sentence
+        /(?<=#{regex_answer_mark}).*/
+      end
+
+      # TODO: Regex match answer mark
+      # Format question: A) , a. , 1/
+      # @return: Answer mark
+      def regex_answer_mark
+        /(^\w[\.|\)|\/])/
+      end
+
+      # TODO: Remove non-unicode character
+      # Solutions:
+      #   Ref: https://stackoverflow.com/a/26411802/14126700
+      #   Ref: https://www.regular-expressions.info/posixbrackets.html
+      #   [:print:] : Visible characters and spaces (anything except control characters)
+      def rid_non_ascii!(str)
+        # Solution 1: str.chars.reject { |char| char.ascii_only? and (char.ord < 32 or char.ord == 127) }.join
+        non_utf8 = str.slice(str[/[^[:print:]]/].to_s)
+        return str if non_utf8 == "\n" || non_utf8 == "\t"
+        str.slice!(str[/[^[:print:]]/].to_s)
+        str
+      end
+    end
+  end
+end

data/lib/quick_exam/analyzer.rb

@@ -0,0 +1,64 @@
+require 'quick_exam/format'
+require 'quick_exam/analyst/base_text'
+require 'quick_exam/analyst/base_docx'
+require 'quick_exam/analyst/base_html'
+
+module QuickExam
+  class Analyzer
+    include QuickExam::Format
+    attr_reader :records, :total_line, :f_ques, :f_corr
+
+    def initialize(file_path, f_ques:'' , f_corr:'')
+      raise ErrorAnalyze.new('No such file') unless File.exist? file_path
+      @file_path = file_path
+      @f_ques = f_ques.__presence || QUESTION_MARK
+      @f_corr = f_corr.__presence || CORRECT_MARK
+    end
+
+    def analyze
+      case
+      when txt? then process_base_text
+      when docx? then process_base_docx
+      when html? then process_base_html
+      end
+    end
+
+    def txt?
+      File.extname(@file_path) == '.txt'
+    end
+
+    def html?
+      File.extname(@file_path) == '.html'
+    end
+
+    def docx?
+      File.extname(@file_path) == '.docx'
+    end
+
+    private
+
+    def process_base_text
+      text_analyzer = QuickExam::Analyst::BaseText.new(@file_path, f_ques: @f_ques, f_corr: @f_corr)
+      text_analyzer.analyze
+      @records = text_analyzer.records
+      @total_line = text_analyzer.total_line
+      self
+    end
+
+    def process_base_html
+      html_analyzer = QuickExam::Analyst::BaseHTML.new(@file_path, f_ques: @f_ques, f_corr: @f_corr)
+      html_analyzer.analyze
+      @records = html_analyzer.records
+      @total_line = html_analyzer.total_line
+      self
+    end
+
+    def process_base_docx
+      docx_analyzer = QuickExam::Analyst::BaseDocx.new(@file_path, f_ques: @f_ques, f_corr: @f_corr)
+      docx_analyzer.analyze
+      @records = docx_analyzer.records
+      @total_line = docx_analyzer.total_line
+      self
+    end
+  end
+end

data/lib/quick_exam/cli.rb

@@ -0,0 +1,82 @@
+require 'thor'
+require 'pry'
+require 'quick_exam'
+
+module QuickExam
+  class CLI < Thor
+    desc 'help export', 'Help'
+    def self.help(shell, subcommand = false)
+      list = printable_commands(true, subcommand)
+      Thor::Util.thor_classes_in(self).each do |klass|
+        list += klass.printable_commands(false)
+      end
+
+      # Remove this line to disable alphabetical sorting
+      list.sort! { |a, b| a[0] <=> b[0] }
+
+      # Add this line to remove the help-command itself from the output
+      # list.reject! {|l| l[0].split[1] == 'help'}
+      if defined?(@package_name) && @package_name
+        shell.say "#{@package_name} commands:"
+      else
+        shell.say "Commands:"
+      end
+
+      shell.print_table(list, :indent => 2, :truncate => true)
+      shell.say
+      class_options_help(shell)
+
+      # Add this line if you want to print custom text at the end of your help output.
+      # (similar to how Rails does it)
+      shell.say 'All commands can be run with -h (or --help) for more information.'
+    end
+
+    def self.define_exec_options
+      option :shuffle_question, type: :string,  aliases: ['-q'],  default: 'true',  desc: 'Shuffle the question',                      banner: 'true|false'
+      option :shuffle_answer,   type: :string,  aliases: ['-a'],  default: 'false', desc: 'Shuffle the answer',                        banner: 'true|false'
+      option :same_answer,      type: :string,  aliases: ['-s'],  default: 'false', desc: 'The same answer for all questionnaires',    banner: 'false'
+      option :f_ques,           type: :string,  aliases: ['-Q'], default: 'Q',     desc: 'Question format. Just prefix the question', banner: 'Q'
+      option :f_corr,           type: :string,  aliases: ['-C'], default: '!!!T',  desc: 'Correct answer format',                     banner: '!!!T'
+      option :count,            type: :string,  aliases: ['-c'],  default: '2',     desc: 'Number of copies to created',               banner: '2'
+      option :dest,             type: :string,  aliases: ['-d'],  default: '',      desc: 'File storage path after export',            banner: '~/quick_exam_export/'
+    end
+
+    desc 'export FILE_PATH [options]', 'shuffle or randomize quiz questions and answers then export file'
+    define_exec_options
+    def export(file_path)
+      shuffle_question = options[:shuffle_question] == 'true' ? true : false
+      shuffle_answer   = options[:shuffle_answer] == 'true' ? true : false
+      same_answer      = options[:same_answer] == 'true' ? true : false
+      f_ques           = options[:f_ques]
+      f_corr           = options[:f_corr]
+      count            = options[:count].to_i
+      dest             = options[:dest]
+
+      paths_export = QuickExam::Export.run(
+        file_path,
+        shuffle_question: shuffle_question,
+        shuffle_answer: shuffle_answer,
+        count: count,
+        dest: dest,
+        f_ques: f_ques,
+        f_corr: f_corr,
+        same_answer: same_answer
+      )
+      show_msg_after_export(paths_export)
+    end
+
+    map %w[--version -v] => :__print_version
+    desc '--version, -v', 'Show `quick_exam` version'
+    def __print_version
+      year = Time.now.year.to_s == '2020' ? '2020' : "2020 - #{Time.now.year}"
+      puts "quick_exam #{QuickExam::VERSION} (latest) (c) #{year} Tang Quoc Minh [vhquocminhit@gmail.com]"
+    end
+
+    private
+
+    def show_msg_after_export(paths_export)
+      puts '♥️ Congratulations on your successful export ♥️'
+      paths_export.each { |path| puts path }
+    end
+  end
+end

data/lib/quick_exam/core_ext.rb

@@ -0,0 +1,28 @@
+class Object
+  def __blank?
+    case self
+    when [], '', "\n", nil, false
+      true
+    else
+      false
+    end
+  end
+
+  def __present?
+    !__blank?
+  end
+
+  def __presence
+    self if __present?
+  end
+
+  def __squish
+    dup.__squish!
+  end
+
+  def __squish!
+    gsub!(/[[:space:]]+/, " ")
+    strip!
+    self
+  end
+end

data/lib/quick_exam/export.rb

@@ -0,0 +1,125 @@
+require 'fileutils'
+require 'quick_exam/format'
+
+module QuickExam
+  class Export
+    class << self
+      include QuickExam::Format
+      RUN_ARGS = %w(shuffle_question shuffle_answer same_answer count dest f_ques f_corr)
+
+      def run(file_path, options={})
+        @file = File.new(file_path)
+        arg = validate_arguments!(options)
+        count = arg[:count].__presence || 2
+
+        check_path(arg[:dest], file_path)
+        proccess_analyze(file_path, arg)
+        @f_ques = question_mark(arg[:f_ques])
+        @records = mixes(count, arg)
+        process_export_files
+      end
+
+      private
+
+      attr_reader :records, :object_qna, :dest, :analyzer, :file
+
+      def proccess_analyze(file_path, arg)
+        @analyzer = QuickExam::Analyzer.new(file_path, f_ques: arg[:f_ques] , f_corr: arg[:f_corr])
+        analyzer.analyze
+      end
+
+      def mixes(count, arg)
+        analyzer.records.mixes(
+          count,
+          shuffle_question: arg[:shuffle_question],
+          shuffle_answer: arg[:shuffle_answer],
+          same_answer: arg[:same_answer]
+        )
+      end
+
+      def check_path(dest_path, file_path)
+        if dest_path.__blank?
+          @dest = File.dirname(file_path) + "/#{FOLDER_NAME_EXPORT}/"
+        else
+          @dest = dest_path + "/#{FOLDER_NAME_EXPORT}/"
+        end
+
+        return raise ErrorExport.new('No such file') unless File.exist?(file_path)
+        FileUtils.mkdir_p(dest) unless Dir.exist? dest
+      end
+
+      def process_export_files
+        path_dest_files = []
+        records.each_with_index do |object_qna, i|
+          @object_qna = object_qna
+          i = i + 1
+          file_path_question = path_filename(i)
+          file_path_answer = path_filename(i, extra_name: '_answers')
+          export_question_sheet(file_path_question)
+          export_answer_sheet(file_path_answer)
+          path_dest_files << file_path_question << file_path_answer
+        end
+        path_dest_files
+      end
+
+      def export_question_sheet(path_filename)
+        File.open(path_filename, 'w') do |f|
+          object_qna.each_with_index do |ticket, i|
+            f.write question(ticket.question, i + 1)
+            f.write answers(ticket.answers)
+            analyzer.html? ? f.write("<br />") : f.write("\n")
+          end
+        end
+      end
+
+      def export_answer_sheet(path_filename)
+        File.open(path_filename, 'w') do |f|
+          object_qna.each_with_index do |ticket, i|
+            ans = ticket.correct_indexes.map { |ci| alphabets[ci] }.join(', ')
+            str = "#{@f_ques}#{i + 1}. #{ans}"
+            if analyzer.html?
+              f.write("<p>#{str}</p>")
+            else
+              f.write(str)
+              f.write("\n")
+            end
+          end
+        end
+      end
+
+      def path_filename(index_order, extra_name: '')
+        basename = File.basename(file.path, '.*')
+        basename = ("#{basename}_%.3i" % index_order) + extra_name
+        extname = analyzer.docx? ? '.docx.txt' : File.extname(file.path)
+        "#{dest}#{basename}#{extname}"
+      end
+
+      def question(str, index)
+        str = "#{@f_ques}#{index}. #{str}"
+        analyzer.html? ? "<p>#{str}</p>" : "#{str}\n"
+      end
+
+      def answers(data)
+        str_answer = ''
+        data.each_with_index do |str, i|
+          str = "#{alphabets[i]}. #{str}"
+          str_answer += analyzer.html? ? "<p>#{str}</p>" : "#{str}\n"
+        end
+        str_answer
+      end
+
+      def alphabets
+        @alphabets ||= ('A'..'Z').to_a
+      end
+
+      def validate_arguments!(args)
+        invalid_arg = args.detect{ |arg, _| !RUN_ARGS.include?(arg.to_s) }
+        raise ArgumentError.new("unknow keyword #{invalid_arg[0]}") if invalid_arg.__present?
+        RUN_ARGS.each_with_object({}) do |arg, memo|
+          arg = arg.to_sym
+          memo[arg] = args[arg]
+        end
+      end
+    end
+  end
+end