teuton 3.2.0 → 3.3.0

data/lib/teuton/cli/app.rb

@@ -0,0 +1,123 @@
+require "thor"
+require_relative "../version"
+require_relative "../../teuton"
+
+module Teuton
+  module CLI
+    class App < Thor
+      map ["h", "-h", "--help"] => "help"
+
+      map ["n", "-n", "--new"] => "new"
+      desc "new DIRECTORY", "Create skeleton for a new project"
+      long_desc <<-LONGDESC
+      Create files for a new project.
+      LONGDESC
+      def new(projectpath)
+        Teuton.create(projectpath)
+      end
+
+      map ["c", "-c", "--check"] => "check"
+      option :onlyconfig, type: :boolean
+      option :color, type: :boolean
+      option :cname, type: :string
+      option :cpath, type: :string
+      desc "check [OPTIONS] DIRECTORY", "Check test and config file content"
+      long_desc <<~LONGDESC
+
+        (1) teuton check PATH/TO/DIR , Check content of start.rb and config.yaml files.
+
+        (2) teuton check PATH/TO/DIR --cname=demo , Check content of start.rb and demo.yaml files:
+
+        (3) teuton check PATH/TO/DIR --onlyconfig  , Only show config file recomendations
+
+        (4) teuton check PATH/TO/DIR/foo.rb , Check content of foo.rb and foo.yaml files.
+
+        (5) teuton check PATH/TO/DIR/foo.rb --cname=demo , Check content of foo.rb and demo.yaml files.
+
+      LONGDESC
+      def check(projectpath)
+        Teuton.check(projectpath, options)
+      end
+
+      map ["co", "-co", "--config"] => "config"
+      desc "config DIRECTORY", "Suggest configuration."
+      long_desc <<~LONGDESC
+        config DIRECTORY, "Suggest the content of the configuration file based on the test"
+      LONGDESC
+      def config(projectpath)
+        # Check Test: suggest the content of the configuration file based on the test
+        opt = {"onlyconfig" => true}
+        Teuton.check(projectpath, opt)
+      end
+
+      map ["--readme"] => "readme"
+      option :lang, type: :string
+      desc "readme DIRECTORY", "Show README extracted from test 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.
+      LONGDESC
+
+      def readme(projectpath)
+        Teuton.readme(projectpath, options)
+      end
+
+      map ["--run", "run"] => "play"
+      option :export, type: :string
+      option :cname, type: :string
+      option :cpath, type: :string
+      option :case, type: :string
+      option :color, type: :boolean
+      option :quiet, type: :boolean
+      desc "[run] [OPTIONS] DIRECTORY", "Run test 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 run foo, same as (1).
+
+      (3) teuton run --export=json foo, run challenge and export using json format.
+      Others output formats availables are: txt, html, yaml, json and colored_text.
+
+      (4) teuton run --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(filepath)
+        Teuton.run(filepath, options)
+      end
+
+      map ["v", "-v", "--version"] => "version"
+      desc "version", "Show the program version"
+      def version
+        puts "#{Teuton::APPNAME} version #{Teuton::VERSION}"
+      end
+
+      ##
+      # These inputs are equivalents:
+      # * teuton dir/foo
+      # * teuton run dir/foo
+      def method_missing(method, *_args, &_block)
+        play(method.to_s)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        # Respond to missing methods name
+        super
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+    end
+  end
+end

data/lib/teuton/cli/run.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require_relative "app"
+
+module Teuton::CLI
+  def self.run(argv)
+    begin
+      Teuton::CLI::App.start(argv)
+      exit 0
+    rescue Interrupt
+      puts "\nExecution cancelled by the user."
+      exit 130
+    rescue Teuton::CaseManagerDslError => e
+      lines = e.message.split("\n")
+      head = lines.shift
+      warn "Error | #{head}"
+      lines.each { |line| warn Rainbow("Error| #{line}").white }
+    rescue Teuton::ConfigFileError => e
+      lines = e.message.split("\n")
+      head = lines.shift
+      warn "Error | #{head}"
+      lines.each { |line| warn Rainbow("Error| #{line}").white }
+    rescue Teuton::MainScriptNotFoundError => e
+      warn "Error | #{e.message}"
+    rescue Teuton::Error => e
+      warn "Controlled error: #{e.message}"
+      e.backtrace&.first(3)&.each do |line|
+        warn Rainbow("Error |   #{line}").white
+      end
+    rescue => e
+      warn "Unexpected error: #{e.message}"
+      raise e if ENV["DEBUG"]
+
+      e.backtrace&.first(3)&.each { |line| warn Rainbow("Error |   #{line}").white }
+    end
+    exit 1
+  end
+end

data/lib/teuton/errors.rb

@@ -0,0 +1,94 @@
+module Teuton
+  class Error < StandardError; end
+
+  class CaseManagerDslError < Error
+    attr_reader :original_error, :filename
+
+    def initialize(original_error, filename)
+      @original_error = original_error
+      @filename = filename
+      super(build_message)
+    end
+
+    private
+
+    def build_message
+      <<~MSG.strip
+        case_manager/dsl: #{@original_error}
+        File not found! Fix line <use '#{@filename}'>
+      MSG
+    end
+  end
+
+  class ConfigurationError < Error; end
+
+  class ConfigFileError < Error
+    attr_reader :filepath, :original_error
+
+    def initialize(filepath, original_error)
+      @filepath = filepath
+      @original_error = original_error
+      super(build_message)
+    end
+
+    private
+
+    def build_message
+      <<~MSG.strip
+        Reading configurations file:
+        - File : #{@filepath}
+        - Type : #{@original_error}
+      MSG
+    end
+  end
+
+  class InputError < Error; end
+  class ExecutionError < Error; end
+
+  class ExportArgumentError < Error
+    attr_reader :args
+
+    def initialize(args)
+      @args = args
+      super(build_message)
+    end
+
+    private
+
+    def build_message
+      <<~MSG.strip
+        ExportManager: argument error!
+        - Fix line <export #{@args}>
+        - Replace by <export format: 'txt'>
+      MSG
+    end
+  end
+
+  class MainScriptNotFoundError < Error
+    attr_reader :script_path
+
+    def initialize(script_path)
+      @script_path = script_path
+      super(build_message)
+    end
+
+    private
+
+    def build_message
+      <<~MSG.strip
+        Main script file not found!
+        - File: #{script_path}
+      MSG
+    end
+  end
+
+  class UnexpectedSequenceTypeError < Error
+    attr_reader :received_class
+
+    def initialize(value_class)
+      super("expect_sequence #{value_class}")
+    end
+  end
+
+  class UploadArgumentError < ArgumentError; end
+end

data/lib/teuton/readme/action.rb

@@ -0,0 +1,29 @@
+class Readme
+  class Action
+    attr_reader :id
+    attr_accessor :description, :weight, :readme, :host, :exec
+
+    def initialize
+      @id = 0
+      @description = nil
+      @host = nil
+      @readme = []
+    end
+
+    def reset
+      @id += 1
+      @description = nil
+      @host = nil
+      @readme = []
+      self
+    end
+
+    def to_h
+      {
+        id: id,
+        description: description, weight: weight, readme: readme,
+        host: host, exec: exec
+      }
+    end
+  end
+end

data/lib/teuton/readme/dsl/all.rb

@@ -6,21 +6,32 @@ require_relative "run"
 
 module ReadmeDSL
   def readme(text)
-    if @action[:target].nil?
+    if @action.description.nil?
       @current[:readme] << text # It's a group readme
     else
-      @action[:readme] << text # It's a target readme
+      @action.readme << text # It's a target readme
     end
   end
 
   def target(desc, args = {})
-    previous_host = @action[:host]
-    @action = {target: desc, host: previous_host, readme: []}
+    previous_host = @action.host
+    @action.description = desc
+    @action.host = previous_host
+    @action.readme = []
     weight = 1.0
     weight = args[:weight].to_f if args[:weight]
-    @action[:weight] = weight
+    @action.weight = weight
+  end
+
+  def goal(...)
+    Logger.warn("Keyword deprecated: Replace 'goal' by 'target'.")
+    target(...)
+  end
+
+  def event(*args, &block)
+    # TODO
+    # args = on: XXX, when: XXX
   end
-  alias_method :goal, :target
 
   def unique(_key, _value)
     # Nothing to do

data/lib/teuton/readme/dsl/expect.rb

@@ -2,7 +2,7 @@
 
 module ReadmeDSL
   def expect(_cond, _args = {})
-    @current[:actions] << @action
+    @current[:actions] << @action.to_h
     result.reset
   end
   alias_method :expect_any, :expect
@@ -12,7 +12,7 @@ module ReadmeDSL
   alias_method :expect_one, :expect
 
   def expect_fail
-    @current[:actions] << @action
+    @current[:actions] << @action.to_h
     result.reset
   end
   alias_method :expect_ok, :expect_fail
@@ -23,7 +23,7 @@ module ReadmeDSL
   alias_method :expect_nothing, :expect_none
 
   def expect_sequence(&block)
-    @current[:actions] << @action
+    @current[:actions] << @action.to_h
     result.reset
   end
 end

data/lib/teuton/readme/dsl/run.rb

@@ -3,30 +3,24 @@ module ReadmeDSL
     unless host == :localhost
       b = {}
       a = :"#{host}_ip"
-      if @config[:global][a].nil? && !@setted_params.include?(a)
-        @cases_params << a
-      end
+      @cases_params << a if @config[:global][a].nil? && !@setted_params.include?(a)
       b[:ip] = @config[:global][a] if @config[:global][a]
       b[:ip] = @setted_params[a] if @setted_params[a]
 
       a = :"#{host}_username"
-      if @config[:global][a].nil? && !@setted_params.include?(a)
-        @cases_params << a
-      end
+      @cases_params << a if @config[:global][a].nil? && !@setted_params.include?(a)
       b[:username] = @config[:global][a] if @config[:global][a]
       b[:username] = @setted_params[a] if @setted_params[a]
 
       a = :"#{host}_password"
-      if @config[:global][a].nil? && !@setted_params.include?(a)
-        @cases_params << a
-      end
+      @cases_params << a if @config[:global][a].nil? && !@setted_params.include?(a)
       b[:password] = @config[:global][a] if @config[:global][a]
       b[:password] = @setted_params[a] if @setted_params[a]
 
       @required_hosts[host.to_s] = b
     end
-    @action[:host] = host
-    @action[:exec] = args[:exec] || "noexec"
+    @action.host = host
+    @action.exec = args[:exec] || "noexec"
   end
 
   def run(command, args = {})

data/lib/teuton/readme/main.rb

@@ -12,16 +12,23 @@ def use(filename)
 end
 
 def define_macro(name, *args, &block)
-  Project.value[:macros][name] = {args: args, block: block}
+  Project.value[:macros][name] = { args: args, block: block }
 end
 
 def group(name, &block)
-  Project.value[:groups] << {name: name, block: block}
+  Project.value[:groups] << { name: name, block: block }
 end
-alias task group
 
-def start(&block)
+def task(...)
+  Logger.warn "Keyword deprecated: Replace 'task' by 'group'"
+  group(...)
+end
+
+def play(&block)
   # don't do nothing
 end
-# alias_method "play", "start" # REVISE THIS
-alias play start
+
+def start(...)
+  Logger.warn "Keyword deprecated: Replace `start' by' play'"
+  play(...)
+end

data/lib/teuton/readme/readme.rb

@@ -3,12 +3,13 @@ require_relative "../utils/project"
 require_relative "../utils/config_file_reader"
 require_relative "../case/dsl/macro"
 require_relative "../version"
+require_relative "action"
 require_relative "dsl/all"
 require_relative "lang"
 require_relative "result"
 
 class Readme
-  include DSL
+  include DSL # Used by case/dsl/macro
   include ReadmeDSL
 
   attr_reader :result, :data
@@ -39,7 +40,7 @@ class Readme
     @data[:macros] = []
     @data[:groups] = []
     @data[:play] = []
-    reset_action
+    @action = Action.new
     @setted_params = {}
     @cases_params = []
     @global_params = {}
@@ -50,15 +51,11 @@ class Readme
     Project.value[:groups].each do |group|
       @current = {name: group[:name], readme: [], actions: []}
       @data[:groups] << @current
-      reset_action
+      @action.reset
       instance_eval(&group[:block])
     end
   end
 
-  def reset_action
-    @action = {readme: []}
-  end
-
   def show_head
     puts "```"
     puts format(Lang.get(:date), Time.now)
@@ -96,16 +93,16 @@ class Readme
       puts "\n## #{group[:name].capitalize}\n"
       group[:readme].each { |line| puts "#{line}\n" }
       previous_host = nil
-      group[:actions].each_with_index do |item, index|
-        item[:host] = group[:actions][0][:host] if item[:host].nil? && index.positive?
-        if previous_host.nil? || item[:host] != previous_host
-          previous_host = item[:host] || "null"
+      group[:actions].each_with_index do |a, index|
+        a[:host] = group[:actions][0][:host] if a[:host].nil? && index.positive?
+        if previous_host.nil? || a[:host] != previous_host
+          previous_host = a[:host] || "null"
           puts format(Lang.get(:goto), previous_host.upcase)
         end
-        weight = "(x#{item[:weight]}) "
-        last = item[:target].end_with?(".", ":") ? "" : "."
-        puts "* #{weight}#{item[:target]}#{last}"
-        item[:readme].each { |line| puts "    * #{line}\n" }
+        weight = "(x#{a[:weight]}) "
+        last = a[:description].end_with?(".", ":") ? "" : "."
+        puts "* #{weight}#{a[:description]}#{last}"
+        a[:readme].each { |line| puts "    * #{line}\n" }
       end
     end
   end

data/lib/teuton/report/formatter/default/array.rb

@@ -33,45 +33,31 @@ class ArrayFormatter < BaseFormatter
     groups = []
     title = nil
     targets = []
-    @lines.each do |i|
-      unless i.instance_of? Hash
-        @data[:logs] << i.to_s # Add log line
+    @lines.each do |line|
+      unless line.instance_of? Hash
+        @data[:logs] << line.to_s # Add log line
         next
       end
 
-      value = 0.0
-      value = i[:weight] if i[:check]
-      if i[:groupname] != title
+      # value = 0.0
+      # value = line[:weight] if line[:check]
+      if line[:groupname] != title
         # Add currentgroup
         groups << {title: title, targets: targets} unless title.nil?
         # Create new group
-        title = i[:groupname]
+        title = line[:groupname]
         targets = []
       end
-
-      target = {}
-      target[:target_id] = format("%<id>02d", id: i[:id])
-      target[:check] = i[:check]
-      target[:score] = value
-      target[:weight] = i[:weight]
-      target[:description] = i[:description]
-
-      target[:conn_type] = i[:conn_type]
-      target[:duration] = i[:duration]
-
-      target[:command] = i[:command]
-      target[:output] = i[:output]
-      target[:alterations] = i[:alterations]
-      target[:expected] = i[:expected]
-      target[:result] = i[:result]
+      target = line
+      target[:target_id] = format("%<id>02d", id: line[:id])
 
       if options[:feedback] == false
-        target[:command] = "*" * i[:command].size
-        i[:output] = "" if i[:output].nil?
-        target[:output] = "*" * i[:output].size
-        target[:alterations] = "*" * i[:alterations].size
-        target[:expected] = "*" * i[:expected].size
-        target[:result] = "*" * i[:result].size
+        target[:command] = "*" * line[:command].size
+        line[:output] = "" if line[:output].nil?
+        target[:output] = "*" * line[:output].size
+        target[:alterations] = "*" * line[:alterations].size
+        target[:expected] = "*" * line[:expected].size
+        target[:result] = "*" * line[:result].size
       end
 
       targets << target

data/lib/teuton/report/formatter/default/txt.rb

@@ -23,44 +23,43 @@ class TXTFormatter < ArrayFormatter
   private
 
   def process_config
-    w "#{colorize("CONFIGURATION", :bg_blue)}\n"
-    my_screen_table = Terminal::Table.new do |st|
-      @data[:config].sort.each do |key, value|
-        st.add_row [key.to_s, value.to_s]
-      end
+    w "#{colorize(" CONFIGURATION", :bg_blue)}\n"
+    table = Terminal::Table.new do |t|
+      t.style = {border: :unicode}
+      @data[:config].sort.each { |key, value| t.add_row [key.to_s, value.to_s] }
     end
-    w "#{my_screen_table}\n\n"
+    w "#{table}\n\n"
   end
 
   def process_logs
     return if @data[:logs].empty?
 
-    w "#{colorize("LOGS", :bg_blue)}\n"
-    @data[:logs].each { |line| w "    #{line}\n" }
+    w "#{colorize(" LOGS", :bg_blue)}\n"
+    @data[:logs].each { |line| w "   #{line}\n" }
   end
 
   def process_groups
     return if @data[:groups].empty?
 
-    w "\n#{colorize("GROUPS", :bg_blue)}\n"
+    w "\n#{colorize(" GROUPS", :bg_blue)}\n"
     @data[:groups].each { |g| process_group g }
   end
 
   def process_results
-    w "\n#{colorize("RESULTS", :bg_blue)}\n"
-    my_screen_table = Terminal::Table.new do |st|
-      @data[:results].each do |key, value|
-        st.add_row [key.to_s, value.to_s]
-      end
+    w "\n#{colorize(" RESULTS", :bg_blue)}\n"
+    table = Terminal::Table.new do |t|
+      t.style = {border: :unicode}
+      @data[:results].each { |key, value| t.add_row [key.to_s, value.to_s] }
     end
-    w "#{my_screen_table}\n"
+    w "#{table}\n"
   end
 
   def process_hof
     return if @data[:hall_of_fame].empty?
 
-    w "\n#{colorize("HALL OF FAME", :bg_blue)}\n"
-    my_screen_table = Terminal::Table.new do |st|
+    w "\n#{colorize(" HALL OF FAME", :bg_blue)}\n"
+    my_screen_table = Terminal::Table.new do |t|
+      t.style = {border: :unicode}
       @data[:hall_of_fame].each do |line|
         color = :green
         color = :red if line[0] < 50
@@ -70,7 +69,7 @@ class TXTFormatter < ArrayFormatter
           text1 = colorize(text1, :bright)
           text2 = colorize(text2, :bright)
         end
-        st.add_row [text1, text2]
+        t.add_row [text1, text2]
       end
     end
     w "#{my_screen_table}\n"
@@ -80,21 +79,33 @@ class TXTFormatter < ArrayFormatter
 
   def process_group(group)
     tab = "  "
-    w "- #{colorize(group[:title], :blue_bright)}\n"
+    w " \u{25B6} #{colorize(group[:title], :blue_bright)}\n"
+    corner = nil
     group[:targets].each do |i|
-      color = :red
-      color = :green if i[:check]
-      w tab * 2 + format("%02d", i[:target_id].to_i)
+      if i[:check]
+        color = :green
+        symbol = Settings.letter[:ok]
+      else
+        color = :red
+        symbol = Settings.letter[:cross]
+      end
+      w tab * 1 + format(" #{symbol} %02d", i[:target_id].to_i)
       text = "#{i[:score]}/#{i[:weight]}"
-      w " (#{colorize(text, color)})\n"
-      w "#{tab * 4}Description : #{i[:description]}\n"
-      w "#{tab * 4}Command     : #{i[:command]}\n"
-      w "#{tab * 4}Output      : #{i[:output]}\n"
-      w "#{tab * 4}Duration    : #{i[:duration]} (#{i[:conn_type]})\n"
-      w "#{tab * 4}Alterations : #{i[:alterations]}\n"
-      w "#{tab * 4}Expected    : #{i[:expected]}\n"
-      w "#{tab * 4}Result      : #{i[:result]}\n"
+      corner = if corner.nil?
+        "┌──"
+      else
+        "├──"
+      end
+      w " (#{colorize(text, color)})   #{corner}\n"
+      w "#{tab * 4}Description │ #{i[:description]}\n"
+      w "#{tab * 4}Command     │ #{i[:command]}\n"
+      w "#{tab * 4}Output      │ #{i[:output]}\n"
+      w "#{tab * 4}Duration    │ #{i[:duration]} (#{i[:conn_type]})\n"
+      w "#{tab * 4}Alterations │ #{i[:alterations]}\n"
+      w "#{tab * 4}Expected    │ #{i[:expected]}\n"
+      w "#{tab * 4}Result      │ #{i[:result]}\n"
     end
+    w "#{tab * 10}└──"
   end
 
   def colorize(text, option)
@@ -112,8 +123,8 @@ class TXTFormatter < ArrayFormatter
     when :red
       Rainbow(text).color(:red)
     else
-      puts Rainbow("[ERROR] TXTFormatter#colorize option=#{option}").bright.red
-      exit 1
+      Logger.warn "[TXTFormatter] colorize option=#{option}"
+      text
     end
   end
 end