teuton 2.8.0 → 2.9.1

data/lib/teuton/check/dsl.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-class Laboratory
-  # Include Teuton DSL keywords into Laboratory class
-  def readme(_text)
-    # Usefull for "teuton readme" command action.
-  end
-
-  def target(desc, args = {})
-    @stats[:targets] += 1
-    @targetid += 1
-    weight = args[:weight] || 1.0
-    verboseln format("(%03<targetid>d) target      %<desc>s", targetid: @targetid, desc: desc)
-    verboseln "      weight      #{weight}"
-  end
-  alias goal target
-
-  def expect(cond)
-    verboseln "      alter       #{result.alterations}" unless result.alterations.empty?
-    verboseln "      expect      #{cond} (#{cond.class})"
-    verboseln ""
-  end
-
-  def expect_first(cond)
-    verboseln "      alter        #{result.alterations}" unless result.alterations.empty?
-    verboseln "      expect_first #{cond} (#{cond.class})"
-    verboseln ""
-  end
-
-  def expect_last(cond)
-    verboseln "      alter        #{result.alterations}" unless result.alterations.empty?
-    verboseln "      expect_last #{cond} (#{cond.class})"
-    verboseln ""
-  end
-
-  def expect_none(cond)
-    verboseln "      alter       #{result.alterations}" unless result.alterations.empty?
-    verboseln "      expect_none #{cond} (#{cond.class})"
-    verboseln ""
-  end
-
-  def expect_one(cond)
-    verboseln "      alter       #{result.alterations}" unless result.alterations.empty?
-    verboseln "      expect_one  #{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
-
-  def run(command, args = {})
-    args[:exec] = command
-    host = :localhost
-    host = args[:on] if args[:on]
-    goto(host, args)
-  end
-
-  def goto(host = :localhost, args = {})
-    result.reset
-    args[:on] = host unless args[:on]
-
-    if @hosts[host]
-      @hosts[host] += 1
-    else
-      @hosts[host] = 1
-    end
-    verboseln "      run         '#{args[:exec]}' on #{args[:on]}"
-  end
-
-  # Check macros and _get_vars
-  def method_missing(method, *args, &block)
-    a = method.to_s
-    if args.nil? && block.nil?
-      instance_eval("get(:#{a[0, a.size - 1]})", __FILE__, __LINE__) if a[a.size - 1] == "?"
-    end
-  end
-
-  def gett(option)
-    get(option)
-  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.instance_of? Symbol
-    value = ":" + value.to_s if value.instance_of? Symbol
-
-    @sets[key] = value
-    "set(#{key},#{value})"
-  end
-end

data/lib/teuton/check/laboratory.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../utils/project"
-require_relative "../utils/result/result"
-require_relative "show"
-require_relative "dsl"
-require_relative "builtin"
-
-def use(filename)
-  filename += ".rb"
-  rbfiles = File.join(Project.value[:project_path], "**", filename)
-  files = Dir.glob(rbfiles)
-  use = []
-  files.sort.each { |f| use << f if f.include?(filename) }
-  require_relative use[0]
-  Project.value[:uses] << use[0]
-end
-
-def group(name, &block)
-  Project.value[:groups] << {name: name, block: block}
-end
-alias task group
-
-def define_macro(name, *args, &block)
-  Project.value[:macros][name] = {args: args, block: block}
-end
-alias def_macro define_macro
-alias defmacro define_macro
-
-
-def start(&block)
-  # Don't do nothing. We are checking test not running it
-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 = [] # REVISE this
-    @verbose = Project.value[:verbose]
-  end
-end

data/lib/teuton/readme/dsl.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-# Readme
-#   readme, target, goto, run
-#   expect,
-#   gett, set, unique, log
-class Readme
-  def readme(text)
-    if @action[:target].nil?
-      # It's a group readme
-      @current[:readme] << text
-    else
-      # It's a target readme
-      @action[:readme] << text
-    end
-  end
-
-  def target(desc, args = {})
-    previous_host = @action[:host]
-    @action = {target: desc, host: previous_host, readme: []}
-    weight = 1.0
-    weight = args[:weight].to_f if args[:weight]
-    @action[:weight] = weight
-  end
-  alias goal target
-
-  def goto(host = :localhost, args = {})
-    unless host == :localhost
-      b = {}
-      a = "#{host}_ip".to_sym
-      if @config[:global][a].nil? && !@setted_params.include?(a)
-        @cases_params << a
-      end
-      b[:ip] = @config[:global][a] if @config[:global][a]
-      b[:ip] = @setted_params[a] if @setted_params[a]
-
-      a = "#{host}_username".to_sym
-      if @config[:global][a].nil? && !@setted_params.include?(a)
-        @cases_params << a
-      end
-      b[:username] = @config[:global][a] if @config[:global][a]
-      b[:username] = @setted_params[a] if @setted_params[a]
-
-      a = "#{host}_password".to_sym
-      if @config[:global][a].nil? && !@setted_params.include?(a)
-        @cases_params << a
-      end
-      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"
-  end
-
-  def run(command, args = {})
-    args[:exec] = command
-    host = :localhost
-    host = args[:on] if args[:on]
-    goto(host, args)
-  end
-
-  def expect(_cond, _args = {})
-    @current[:actions] << @action
-    result.reset
-  end
-  alias expect_any expect
-  alias expect_first expect
-  alias expect_last expect
-  alias expect_none expect
-  alias expect_one expect
-
-  def get(value)
-    unless @config[:global][value].nil?
-      @global_params[value] = @config[:global][value]
-      return @config[:global][value]
-    end
-
-    return value.to_s.upcase if @setted_params.include? value
-
-    @cases_params << value
-    value.to_s.upcase
-  end
-
-  # If a method call is missing, then delegate to concept parent.
-  # def method_missing(method, args = {})
-  def method_missing(method, *args, &block)
-    m = method.to_s
-    if m[0] == "_"
-      instance_eval("get(:#{m[1, m.size - 1]})", __FILE__, __LINE__)
-    # elsif not Application.instance.macros[m].nil?
-    elsif not Project.value[:macros][m].nil?
-      puts "macro exec: #{m}"
-      code = ""
-      args[0].keys.each { |key| code += "set(:#{key}, '#{args[0][key]}')\n" }
-      puts code
-      # instance_eval(code)
-      # Application.instance.macros[m].call
-    end
-  end
-
-  def respond_to_missing?(method_name, include_private = false)
-    true
-  end
-
-  def gett(value)
-    a = get(value)
-    return "[#{value}](\#required-params)" if @cases_params.include? value
-    return "[#{value}](\#created-params)" if @setted_params[value]
-
-    "[#{a}](\#global-params)" if @global_params.include? value
-  end
-
-  def set(key, value)
-    @setted_params[key] = value
-  end
-
-  def unique(_key, _value)
-    # don't do nothing
-  end
-
-  def log(text = "", type = :info)
-    @data[:logs] << "[#{type}]: " + text.to_s
-  end
-end