teuton 0.0.1

data/lib/teuton/case_manager/dsl.rb

@@ -0,0 +1,31 @@
+require_relative '../application'
+require_relative 'case_manager'
+
+def use(filename)
+  filename += '.rb'
+  app = Application.instance
+  rbfiles = File.join(app.project_path, "**", filename)
+  files = Dir.glob(rbfiles)
+  findfiles = []
+  files.sort.each { |f| findfiles << f if f.include?(filename) }
+  require_relative findfiles.first
+  app.uses << File.basename(findfiles.first)
+end
+
+def define_check(name, *args, &block)
+  Application.instance.checks[name] = { args: args, block: block }
+end
+alias definecheck define_check
+alias def_check define_check
+alias defcheck define_check
+alias dcheck define_check
+
+def group(name, &block)
+  Application.instance.groups << { name: name, block: block }
+end
+alias task group
+
+def play(&block)
+  CaseManager.instance.play(&block)
+end
+alias start play

data/lib/teuton/case_manager/export_manager.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../application'
+
+# ExportManager#run
+module ExportManager
+  def self.run(main_report, cases, args)
+    # default :mode=>:all, :format=>:txt
+    format = args[:format] || Application.instance.default[:format]
+    mode = args[:mode] || :all
+    # Export case reports
+    if %i[details all].include? mode
+      threads = []
+      cases.each { |c| threads << Thread.new { c.export format } }
+      threads.each(&:join)
+    end
+    # Export resume report
+    main_report.export_resume format if %i[resume all].include? mode
+  end
+end

data/lib/teuton/case_manager/hall_of_fame.rb

@@ -0,0 +1,28 @@
+
+require_relative '../application'
+
+class CaseManager
+
+  private
+
+  def build_hall_of_fame
+    celebrities = {}
+
+    @cases.each do |c|
+      grade = c.grade # report.tail[:grade]
+      if celebrities[grade]
+        label = celebrities[grade] + '*'
+      else
+        label = '*'
+      end
+      celebrities[grade] = label unless c.skip
+    end
+
+    a = celebrities.sort_by { |key, _value| key }
+    list = a.reverse
+
+    app = Application.instance
+    app.options[:case_number] = @cases.size
+    app.hall_of_fame = list
+  end
+end

data/lib/teuton/case_manager/main.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'check_cases'
+require_relative 'hall_of_fame'
+require_relative 'report'
+require_relative 'show'

data/lib/teuton/case_manager/report.rb

@@ -0,0 +1,52 @@
+
+class CaseManager
+
+  private
+
+  def open_main_report(p_config_filename)
+    app = Application.instance
+
+    @report.head[:tt_title] = "Executing [#{app.name}] (version #{Application::VERSION})"
+    @report.head[:tt_scriptname] = app.script_path
+    @report.head[:tt_configfile] = p_config_filename
+    @report.head[:tt_debug] = true if @debug
+    # @report.head[:tt_uses] = app.uses.join(', ')
+    @report.head.merge!(app.global)
+
+    verboseln ' '
+    verboseln '=' * @report.head[:tt_title].length
+    verboseln @report.head[:tt_title]
+  end
+
+  def close_main_report(start_time)
+    finish_time = Time.now
+    @report.tail[:start_time] = start_time
+    @report.tail[:finish_time] = finish_time
+    @report.tail[:duration] = finish_time - start_time
+
+    verbose "\n[INFO] Duration = #{format('%3.3f',(finish_time - start_time))}"
+    verboseln "    (#{finish_time})"
+    verboseln '=' * @report.head[:tt_title].length
+    verboseln ' '
+
+    app = Application.instance
+    @cases.each do |c|
+      line = {}
+      if c.skip?
+        line = { skip: true, id: '-', grade: 0.0, letter: '',
+                members: '-', conn_status: {},
+                moodle_id: '', moodle_feedback: '' }
+      else
+        line[:skip] = false
+        line[:id] = format('case_%02d', c.id.to_i)
+        line[:letter] = app.letter[:error] if c.grade < 50.0
+        line[:grade] = c.grade.to_f #format('  %3d', c.grade.to_f)
+        line[:members] = c.members
+        line[:conn_status] = c.conn_status
+        line[:moodle_id] = c.get(:tt_moodle_id)
+        line[:moodle_feedback] = "\"Filename: #{c.filename}. Date: #{Time.now}\""
+      end
+      @report.lines << line
+    end
+  end
+end

data/lib/teuton/case_manager/show.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+require_relative '../application'
+
+# CaseManager#show
+class CaseManager
+  def show(mode = :resume)
+    return if Application.instance.quiet?
+
+    @report.show if %i[resume all].include? mode
+
+    return unless %i[details all].include? mode
+
+    @cases.each do |c|
+      puts '____'
+      c.show
+    end
+    puts '.'
+  end
+end

data/lib/teuton/case_manager/utils.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../application'
+
+# Define general use methods
+module Utils
+  # Create the directory if it dosn't exist.
+  def ensure_dir(dirname)
+    unless Dir.exist?(dirname)
+      FileUtils.mkdir_p(dirname)
+      return false
+    end
+    true
+  end
+
+  def encode_and_split(encoding, text)
+    # Convert text to UTF-8 deleting unknown chars
+    text = text || '' # Ensure text is not nil
+    flag = [:default, 'UTF-8'].include? encoding
+    return text.encode('UTF-8', invalid: :replace).split("\n") if flag
+
+    # Convert text from input ENCODING to UTF-8
+    ec = Encoding::Converter.new(encoding.to_s, 'UTF-8')
+    begin
+      text = ec.convert(text)
+    rescue StandardError => e
+      puts "[ERROR] #{e}: Declare text encoding..."
+      puts "        goto :host, :exec => 'command', :encoding => 'ISO-8859-1'"
+    end
+
+    text.split("\n")
+  end
+
+  def my_execute(cmd, encoding = 'UTF-8')
+    return { exitstatus: 0, content: '' } if Application.instance.debug
+
+    begin
+      text = `#{cmd}`
+      exitstatus = $CHILD_STATUS.exitstatus
+    rescue StandardError => e # rescue Exception => e
+      verbose '!'
+      puts("[ERROR] #{e}: Local exec: #{cmd}")
+    end
+    content = encode_and_split(encoding, text)
+    { exitstatus: exitstatus, content: content }
+  end
+
+  def verboseln(text)
+    verbose(text + "\n")
+  end
+
+  def verbose(text)
+    return if Application.instance.quiet?
+
+    print text
+  end
+end

data/lib/teuton/command/create.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../project/project_creator.rb'
+
+# Teuton#create
+class Teuton < Thor
+  map ['c', '-c', '--create'] => 'create'
+  desc 'create DIRECTORY', 'Create skeleton for a new project'
+  long_desc <<-LONGDESC
+  Create files for a new project: foo.rb, foo.yaml and .gitignore
+
+  Example:
+
+  #{$PROGRAM_NAME} create foo/demo
+
+  LONGDESC
+  def create(path_to_new_dir)
+    ProjectCreator.create(path_to_new_dir)
+  end
+end

data/lib/teuton/command/download.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+
+# Class method Teuton#download
+class Teuton < Thor
+  map ['-dc', '--dc', '--download'] => 'download'
+  desc 'download', 'Download Teuton challenges from git repo'
+  long_desc <<-LONGDESC
+  - Download Teuton challenges from git repo.
+
+  - Same as:
+    git clone https://github.com/teuton-software/teuton-challenges.git
+
+  Example:
+
+  #{$PROGRAM_NAME} download
+
+  LONGDESC
+  def download
+    repo = 'teuton-challenges'
+    puts "[INFO] Downloading <#{repo}> repo..."
+    system("git clone https://github.com/teuton-software/#{repo}.git")
+    puts "[INFO] Your files are into <#{Rainbow(repo).bright}> directory..."
+  end
+end

data/lib/teuton/command/main.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'create'
+require_relative 'download'
+require_relative 'play'
+require_relative 'readme'
+require_relative 'test'
+require_relative 'update'
+require_relative 'version'

data/lib/teuton/command/play.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Teuton#play
+class Teuton < Thor
+  map ['p', '-p', 'play', '--play'] => 'play'
+  option :export, type: :string
+  option :cname, type: :string
+  option :cpath, type: :string
+  option :case, type: :string
+  option :quiet, type: :boolean
+  desc '[play] [OPTIONS] DIRECTORY',
+       'Run challenge from directory'
+  long_desc <<-LONGDESC
+  This function execute challenge from specified directory.
+  By default, show progress on the screen.
+
+  Let's see others options:
+
+  (1) teuton foo, run challenge from foo/start.rb with foo/config.yaml config file.
+
+  (2) teuton play foo, same as (1).
+
+  (3) teuton play --export=json foo, run challenge and export using json format.
+  Others output formats availables are: txt, colored_text, json, yaml.
+
+  (4) teuton play --cname=demo foo, run challenge from foo/start.rb with foo/demo.yaml config file.
+
+  (5) teuton foo/demo.rb, Run challenge from foo/demo.rb with foo/demo.yaml config file.
+
+  LONGDESC
+  def play(path_to_rb_file)
+    Project.play(path_to_rb_file, options)
+  end
+end

data/lib/teuton/command/readme.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Teuton#readme
+class Teuton < Thor
+  map ['r', '-r', '--readme'] => 'readme'
+  option :lang, type: :string
+  desc 'readme DIRECTORY',
+       'Create README.md file from challenge contents'
+  long_desc <<-LONGDESC
+
+  (1) teuton readme foo
+  , Create README.md from foo/start.rb.
+
+  (2) teuton readme foo/demo.rb
+  , Create README.md from foo/demo.rb.
+
+  By default lang=es, but It's available lang=en too.
+
+  LONGDESC
+  def readme(path_to_rb_file)
+    Project.readme(path_to_rb_file, options)
+  end
+end

data/lib/teuton/command/test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Teuton#test
+class Teuton < Thor
+  map ['t', '-t', '--test'] => 'test'
+  option :c, type: :boolean
+  option :cname, type: :string
+  option :cpath, type: :string
+  desc 'test [OPTIONS] DIRECTORY',
+       'Test or check challenge contents'
+  long_desc <<-LONGDESC
+
+  (1) teuton test path/to/dir/foo
+  , Test content of start.rb and config.yaml files.
+
+  (2) teuton test path/to/dir/foo -c
+  , Only test CONFIG information from config.yaml.
+
+  (3) teuton test path/to/dir/foo --cname=demo
+  , Test content of start.rb and demo.yaml files.
+
+  (4) teuton test path/to/file/foo.rb
+  , Test content of foo.rb and foo.yaml files.
+
+  (5) teuton test path/to/file/foo.rb -c
+  , Only test CONFIG information from foo.yaml.
+
+  (6) teuton test path/to/file/foo.rb --cname=demo
+  , Test content of foo.rb and demo.yaml files.
+
+  LONGDESC
+  def test(path_to_rb_file)
+    Project.test(path_to_rb_file, options)
+  end
+end

data/lib/teuton/command/update.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+
+# Class method Teuton#update
+class Teuton < Thor
+  map ['--update', '-u', 'u'] => 'update'
+  desc 'update', 'Update TEUTON from git repo'
+  long_desc <<-LONGDESC
+  Update TEUTON project, downloading files from git repo.
+  Execute "cd PATH/TO/TEUTON/DIR && git pull".
+
+  Alias: teuton u, teuton -u, teuton --update
+
+  LONGDESC
+  def update
+    dir = File.absolute_path(File.join(File.dirname(__FILE__), '..', '..'))
+    ok = system("cd #{dir} && git pull")
+    if ok
+      puts Rainbow('[ OK ] teuton update').green.bright
+      exit(0)
+    else
+      puts Rainbow('[FAIL] teuton update').red.bright
+      exit(1)
+    end
+  end
+end

data/lib/teuton/command/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+
+# Class method Teuton#version
+class Teuton < Thor
+  map ['v', '-v', '--version'] => 'version'
+  desc 'version', 'Show the program version'
+  def version
+    print Rainbow(Application::NAME).bright.blue
+    puts  ' (version ' + Rainbow(Application::VERSION).green + ')'
+  end
+end

data/lib/teuton/files/start.rb

@@ -0,0 +1,13 @@
+
+group "GROUP NAME" do
+
+  target "TARGET-1 DESCRIPTION"
+  goto :localhost, :exec => "COMMAND-1"
+  expect "TEXT-1"
+
+end
+
+play do
+  show
+  export
+end

data/lib/teuton/project/configfile_reader.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'json'
+
+# Functions that read data from ConfigFile using formats YAML and JSON
+# * read
+# * read_yaml
+# * read_json
+module ConfigFileReader
+  def self.read(filepath)
+    unless File.exist?(filepath)
+      data = {}
+      data[:global] = {}
+      data[:alias] = {}
+      data[:cases] = [{ tt_members: 'anonymous' }]
+      return data
+    end
+    return read_yaml(filepath) if File.extname(filepath) == '.yaml'
+
+    return read_json(filepath) if File.extname(filepath) == '.json'
+
+    raise "[ERROR] ConfigFileReader: #{filepath}"
+  end
+
+  def self.read_yaml(filepath)
+    begin
+      data = YAML.load(File.open(filepath))
+    rescue StandardError => e
+      puts "\n" + ('=' * 80)
+      puts "[ERROR] ConfigFileReader#read <#{filepath}>"
+      puts '        I suggest to revise file format!'
+      puts "        #{e.message}\n" + ('=' * 80)
+      raise "[ERROR] ConfigFileReader <#{e}>"
+    end
+    data[:global] = data[:global] || {}
+    data[:alias] = data[:alias] || {}
+    data[:cases] = data[:cases] || []
+    data
+  end
+
+  def self.read_json(filepath)
+    data = JSON.parse(File.read(filepath), symbolize_names: true)
+    data[:global] = data[:global] || {}
+    data[:alias] = data[:alias] || {}
+    data[:cases] = data[:cases] || []
+    data
+  end
+end

data/lib/teuton/project/laboratory/builtin.rb

@@ -0,0 +1,23 @@
+
+class Builtin
+  attr_accessor :param
+
+  def initialize(parent)
+    @parent = parent
+  end
+
+  def method_missing(method)
+    @parent.log "BUILTIN #{method}"
+  end
+end
+
+# Laboratory
+# * service
+class Laboratory
+  def service(param)
+    log "BUILTIN service(#{param})"
+    @builtin = @builtin || Builtin.new(self)
+    @builtin.param = param
+    @builtin
+  end
+end

data/lib/teuton/project/laboratory/dsl.rb

@@ -0,0 +1,117 @@
+# Laboratory
+# * target
+# * request (development)
+# * tempfile
+# * goto
+# * run
+# * expect
+# * get
+# * unique
+# * log
+# * set
+class Laboratory
+  def readme(_text)
+    # Usefull for "teuton reamde" action.
+  end
+
+  def target(desc, args = {})
+    @stats[:targets] += 1
+    @targetid += 1
+    weight = args[:weight] || 1.0
+    verboseln '(%03d' % @targetid + ") target      #{desc}"
+    verboseln "      weight      #{weight}"
+  end
+  alias goal target
+
+  def request(text)
+    @requests << text.to_s
+  end
+
+  def tempfile(_tempfile = nil)
+    'tempfile'
+  end
+
+  def goto(host = :localhost, args = {})
+    result.reset
+
+    if @hosts[host]
+      @hosts[host] += 1
+    else
+      @hosts[host] = 1
+    end
+    verboseln "      goto        #{host} and #{args}"
+  end
+
+  def run(command, args = {})
+    args[:exec] = command
+    goto(:localhost, args)
+  end
+
+  def expect(_cond, args = {})
+    #unless [ String, Array, Regexp].include? _cond.class
+    #  verboseln "[ERROR] expect #{_cond} (#{_cond.class})"
+    #  return
+    #end
+    verboseln "      alter       #{result.alterations}" unless result.alterations.empty?
+    #verboseln "      expect      #{result.expected} (#{result.expected.class})"
+    verboseln "      expect      #{_cond} (#{_cond.class})"
+    verboseln ''
+  end
+
+  def expect_one(_cond, args = {})
+    verboseln "      alter       #{result.alterations}" unless result.alterations.empty?
+    verboseln "      expect_one  #{_cond} (#{_cond.class})"
+    verboseln ''
+  end
+
+  def expect_none(_cond, args = {})
+    verboseln "      alter       #{result.alterations}" unless result.alterations.empty?
+    verboseln "      expect_none #{_cond} (#{_cond.class})"
+    verboseln ''
+  end
+
+  def get(varname)
+    @stats[:gets] += 1
+
+    if @gets[varname]
+      @gets[varname] += 1
+    else
+      @gets[varname] = 1
+    end
+
+    "get(#{varname})"
+  end
+
+  # If a method call is missing, then delegate to concept parent.
+  def method_missing(method)
+    a = method.to_s
+    instance_eval("get(:#{a[0, a.size - 1]})") if a[a.size - 1] == '?'
+  end
+
+  def gett(option)
+    value = get(option)
+    value
+  end
+
+  def unique(key, _value)
+    @stats[:uniques] += 1
+
+    verboseln "    ! Unique      value for <#{key}>"
+    verboseln ''
+  end
+
+  def log(text = '', type = :info)
+    @stats[:logs] += 1
+    verboseln "      log    [#{type}]: " + text.to_s
+  end
+
+  def set(key, value)
+    @stats[:sets] += 1
+
+    key = ':' + key.to_s if key.class == Symbol
+    value = ':' + value.to_s if value.class == Symbol
+
+    @sets[key] = value
+    "set(#{key},#{value})"
+  end
+end

data/lib/teuton/project/laboratory/laboratory.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'terminal-table'
+require 'rainbow'
+
+require_relative '../../application'
+require_relative '../../case_manager/case/result/result'
+require_relative 'show'
+require_relative 'dsl'
+require_relative 'builtin'
+
+def use(filename)
+  filename += '.rb'
+  app = Application.instance
+  rbfiles = File.join(app.project_path, "**", filename)
+  files = Dir.glob(rbfiles)
+  use = []
+  files.sort.each { |f| use << f if f.include?(filename) }
+  require_relative use[0]
+end
+
+def group(name, &block)
+  Application.instance.groups << { name: name, block: block }
+end
+alias task group
+
+def start(&block)
+  # don't do nothing
+end
+alias play start
+
+# Show objectives stats from RB script file
+class Laboratory
+  attr_reader :result
+
+  def initialize(script_path, config_path)
+    @path = {}
+    @path[:script]   = script_path
+    @path[:dirname]  = File.dirname(script_path)
+    @path[:filename] = File.basename(script_path, '.rb')
+    @path[:config]   = config_path
+    reset
+  end
+
+  def reset
+    @result = Result.new
+    @targetid = 0
+    @stats = { groups: 0, targets: 0, uniques: 0, gets: 0, logs: 0, sets: 0 }
+    @gets = {}
+    @sets = {}
+    @hosts = {}
+    @requests = []
+    @verbose = Application.instance.verbose
+  end
+end