dtf 0.2.1 → 0.2.2

data/lib/dtf/active_patches.rb

@@ -1,21 +0,0 @@
-unless String.method_defined? :blank?
-  String.class_eval do
-    def blank?
-      self == ""
-    end
-  end
-end
-unless Array.method_defined? :blank?
-  Array.class_eval do
-    def blank?
-      size == 0
-    end
-  end
-end
-unless NilClass.method_defined? :blank?
-  NilClass.class_eval do
-    def blank?
-      true
-    end
-  end
-end

data/lib/dtf/plugins.rb

@@ -1,102 +0,0 @@
-class DTF::Plugins
-  include Singleton
-
-  def initialize
-    detect
-    @additional_plugins = []
-    @input_plugins = []
-    @output_plugins = []
-    @test_plugins = []
-  end
-
-  def detect
-    @plugins = Gem.find_files('plugins/dtf/*.rb')
-  end
-
-  def add plugin
-    @additional_plugins << plugin
-  end
-
-  def delete plugin
-    @additional_plugins.delete plugin
-  end
-
-  def file_to_class item
-    File.basename(item,'.rb').capitalize.gsub(/_(.)/){ $1.upcase }
-  end
-
-  def list pattern=nil
-    # collect to lists
-    _list = @plugins + @additional_plugins
-    # filter by pattern if given
-    _list = _list.select{|item| item.match("_#{pattern}.rb$") } unless pattern.nil?
-    # get path and class name
-    _list.map!{|item| [ item, file_to_class(item), pattern ] }
-    # TODO: limit plugin versions (highest || use bundler)
-    _list.each{|item, klass, type| require item }
-    _list
-  end
-
-  def load wanted
-    [ :input, :test, :output ].each do |type|
-      _list = list(type)
-      if ! wanted.include?("all") && ! wanted.include?("all_#{type}")
-        _list = _list.select{|item, klass, _type| wanted.include?(klass) }
-      end
-      _list.each{|item, klass, _type|
-        klass = DTF.const_get(klass)
-        instance_variable_get("@#{type}_plugins".to_sym) << klass.new
-      }
-    end
-  end
-
-  def match_arg_klass arg, klass, type
-    klass = DTF.const_get(klass)
-    return nil unless klass.respond_to? :argument_matches?
-    matches = klass.argument_matches? arg
-    return nil if matches.nil?
-    matches.each do |match|
-      case match
-      when :load
-        instance_variable_get("@#{type}_plugins".to_sym) << klass.new
-      when :input
-        @input_files << [klass.new, arg]
-      else
-        return nil
-      end
-    end
-    return matches
-  rescue NameError
-    return nil
-  end
-
-  def parse_args args
-    @input_files, not_processed = [], []
-    available_plugins = [ :input, :test, :output ].map{ |type| list(type) }.flatten(1)
-    args.each do |arg|
-      matched = available_plugins.map do |item, klass, type|
-        match_arg_klass arg, klass, type
-      end.flatten.reject(&:nil?)
-      if matched.empty?
-        not_processed << arg
-      end
-    end
-    [ @input_files, not_processed ]
-  end
-
-  def input_plugins
-    @input_plugins
-  end
-
-  def output_plugins *args
-    if args.empty?
-      @output_plugins
-    else
-      @output_plugins.each{|plugin| plugin.send(*args) }
-    end
-  end
-
-  def test_plugins
-    @test_plugins
-  end
-end

data/lib/plugins/dtf/comment_test_input.rb

@@ -1,40 +0,0 @@
-class DTF::CommentTestInput
-  def initialize
-  end
-
-  def self.argument_matches? argument
-    if argument =~ /_comment_test\.sh$/ && File.exist?(argument)
-      [:load, :input]
-    else
-      nil
-    end
-  end
-
-  def load file_name
-    lines = []
-    File.readlines(file_name).each{|line|
-      # Fix jruby-1.6.6-d19 bug with empty strings from files
-      line = "#{line}"
-      # remove human comments
-      line.sub!(/##.*$/,'')
-      # reject empty lines
-      line.strip!
-      next if line =~ /^$/
-      # extract command and tests
-      cmd, tests = line.split("#")
-      cmd.strip!
-      tests = if tests.blank?
-        []
-      else
-        tests.split(";").map(&:strip)
-      end
-      if cmd.blank?
-        lines.last[:tests] += tests unless lines.last.nil?
-      else
-        lines << { :cmd => cmd, :tests => tests }
-      end
-    }
-    name = file_name.gsub(/^.*\//,'').sub(/_comment_test\.sh$/,'')
-    { :name => name, :commands => lines }
-  end
-end

data/lib/plugins/dtf/env_match_test.rb

@@ -1,18 +0,0 @@
-class DTF::EnvMatchTest
-  MATCHER = /^env\[(.*)\]([!]?=)[~]?\/(.*)\//
-
-  def matches? test
-    test =~ DTF::EnvMatchTest::MATCHER
-  end
-
-  def execute test, _stdout, _stderr, _stdboth, _status, env
-    test =~ DTF::EnvMatchTest::MATCHER
-    variable, sign, value = $1.strip, $2, $3
-    var_val = env[ variable ]
-    if ( sign == "=" ) ^ ( Regexp.new(value) =~ "#{var_val}" )
-      [ false, "failed: env #{variable} #{sign} /#{value}/ # was '#{var_val}'" ]
-    else
-      [ true, "passed: env #{variable} #{sign} /#{value}/" ]
-    end
-  end
-end

data/lib/plugins/dtf/error_summary_output.rb

@@ -1,93 +0,0 @@
-class DTF::ErrorSummaryOutput
-  RED = `tput setaf 1`
-  GREEN = `tput setaf 2`
-  YELLOW = `tput setaf 3`
-  BLUE = `tput setaf 4`
-  RESET = `tput setaf 9`
-
-  def self.argument_matches? argument
-    [:load] if argument == "--dotted"
-  end
-
-  def initialize output=nil
-    @counts={}
-    @counts[:commands] = 0
-    @counts[:tests] = 0
-    @counts[:commands_started] = 0
-    @counts[:commands_finished] = 0
-    @counts[:tests_success] = 0
-    @counts[:tests_failure] = 0
-    @counter_id = 0
-    @summary = {}
-    @output = output || $stdout
-  end
-
-  def start_processing
-  end
-
-  def status
-    text = "#{BLUE}##### Processed commands #{@counts[:commands_finished]} of #{@counts[:commands]}"
-    if @counts[:tests_success] > 0
-      text += ", #{GREEN}success tests #{@counts[:tests_success]} of #{@counts[:tests]}"
-    end
-    if @counts[:tests_failure] > 0
-      text += ", #{RED}failure tests #{@counts[:tests_failure]} of #{@counts[:tests]}"
-    end
-    skipped = @counts[:tests] - @counts[:tests_success] - @counts[:tests_failure]
-    if skipped > 0
-      text += ", #{YELLOW}skipped tests #{skipped} of #{@counts[:tests]}"
-    end
-    text += ".#{RESET}"
-    text
-  end
-
-  def summary
-    @summary.sort{|a,b| ak,_=a ; bk,_=b ; ak <=> bk }.each{|k,v|
-      @output.puts "#{YELLOW}$ #{v[:cmd]}#{RESET}"
-      v[:failed_tests].each{|t| puts "#{RED}# #{t}#{RESET}" }
-    }
-    text = ""
-    text
-  end
-
-  def end_processing
-    @output.printf "\n"
-    @output.puts status
-    @output.puts summary
-  end
-
-  def start_test test, env
-    @counts[:commands] += test[:commands].size
-    tests_counts = test[:commands].map{|line| line[:tests].nil? ? 0 : line[:tests].size }
-    @counts[:tests] += tests_counts.empty? ? 0 : tests_counts.inject(&:+)
-  end
-
-  def end_test test
-  end
-
-  def start_command line
-    @counts[:commands_started] += 1
-    @current_line = line.merge(:counter_id => @counts[:commands_started])
-  end
-
-  def end_command line, status, env
-    @counts[:commands_finished] += 1
-  end
-
-  def command_out out
-  end
-
-  def command_err err
-  end
-
-  def test_processed test, status, msg
-    @output.printf status ? "." : "F"
-    if status
-      @counts[:tests_success] += 1
-    else
-      @counts[:tests_failure] += 1
-      @summary[@current_line[:counter_id]] ||= @current_line.merge({:failed_tests=>[]})
-      @summary[@current_line[:counter_id]][:failed_tests] << msg
-    end
-  end
-end

data/lib/plugins/dtf/output_match_test.rb

@@ -1,17 +0,0 @@
-class DTF::OutputMatchTest
-  MATCHER = /^match([!]?=)[~]?\/(.*)\//
-
-  def matches? test
-    test =~ DTF::OutputMatchTest::MATCHER
-  end
-
-  def execute test, _stdout, _stderr, _stdboth, _status, env
-    test =~ DTF::OutputMatchTest::MATCHER
-    sign, value = $1, $2
-    if ( sign == "=" ) ^ ( Regexp.new(value) =~ "#{_stdboth}" )
-      [ false, "failed: match #{sign} /#{value}/" ]
-    else
-      [ true, "passed: match #{sign} /#{value}/" ]
-    end
-  end
-end

data/lib/plugins/dtf/stats_output.rb

@@ -1,73 +0,0 @@
-class DTF::StatsOutput
-  RED = `tput setaf 1`
-  GREEN = `tput setaf 2`
-  YELLOW = `tput setaf 3`
-  BLUE = `tput setaf 4`
-  RESET = `tput setaf 9`
-
-  def self.argument_matches? argument
-    [:load] if argument == "--text"
-  end
-
-  def initialize
-    @counts={}
-    @counts[:commands] = 0
-    @counts[:tests] = 0
-    @counts[:commands_finished] = 0
-    @counts[:tests_success] = 0
-    @counts[:tests_failure] = 0
-  end
-
-  def start_processing
-  end
-
-  def status
-    text = "#{BLUE}##### Processed commands #{@counts[:commands_finished]} of #{@counts[:commands]}"
-    if @counts[:tests_success] > 0
-      text += ", #{GREEN}success tests #{@counts[:tests_success]} of #{@counts[:tests]}"
-    end
-    if @counts[:tests_failure] > 0
-      text += ", #{RED}failure tests #{@counts[:tests_failure]} of #{@counts[:tests]}"
-    end
-    skipped = @counts[:tests] - @counts[:tests_success] - @counts[:tests_failure]
-    if skipped > 0
-      text += ", #{YELLOW}skipped tests #{skipped} of #{@counts[:tests]}"
-    end
-    text += ".#{RESET}"
-    text
-  end
-
-  def end_processing
-    puts status
-  end
-
-  def start_test test, env
-    @counts[:commands] += test[:commands].size
-    tests_counts = test[:commands].map{|line| line[:tests].nil? ? 0 : line[:tests].size }
-    @counts[:tests] += tests_counts.empty? ? 0 : tests_counts.inject(&:+)
-  end
-
-  def end_test test
-  end
-
-  def start_command line
-  end
-
-  def end_command line, status, env
-    @counts[:commands_finished] += 1
-  end
-
-  def command_out out
-  end
-
-  def command_err err
-  end
-
-  def test_processed test, status, msg
-    if status
-      @counts[:tests_success] += 1
-    else
-      @counts[:tests_failure] += 1
-    end
-  end
-end

data/lib/plugins/dtf/status_test.rb

@@ -1,17 +0,0 @@
-class DTF::StatusTest
-  MATCHER = /^status([!]?=)([[:digit:]]+)$/
-
-  def matches? test
-    test =~ DTF::StatusTest::MATCHER
-  end
-
-  def execute test, _stdout, _stderr, _stdboth, _status, env
-    test =~ DTF::StatusTest::MATCHER
-    sign, value = $1, $2.to_i
-    if ( sign == "=" ) ^ ( _status == value )
-      [ false, "failed: status #{sign} #{value} # was #{_status}" ]
-    else
-      [ true, "passed: status #{sign} #{value}" ]
-    end
-  end
-end

data/lib/plugins/dtf/text_output.rb

@@ -1,52 +0,0 @@
-class DTF::TextOutput
-  RED = `tput setaf 1`
-  GREEN = `tput setaf 2`
-  YELLOW = `tput setaf 3`
-  BLUE = `tput setaf 4`
-  RESET = `tput setaf 9`
-
-  def self.argument_matches? argument
-    [:load] if argument == "--text"
-  end
-
-  def initialize
-  end
-
-  def start_processing
-  end
-
-  def end_processing
-  end
-
-  def start_test test, env
-    puts "#{BLUE}##### starting test #{test[:name]}.#{RESET}"
-  end
-
-  def end_test test
-    #puts "#{BLUE}##### finished test #{test[:name]}.#{RESET}"
-  end
-
-  def start_command line
-    puts "#{YELLOW}$ #{line[:cmd]}#{RESET}"
-  end
-
-  def end_command line, status, env
-    #puts ": $?=#{status}"
-  end
-
-  def command_out out
-    puts out
-  end
-
-  def command_err err
-    puts err
-  end
-
-  def test_processed test, status, msg
-    if status
-      puts "#{GREEN}# #{msg}#{RESET}"
-    else
-      puts "#{RED}# #{msg}#{RESET}"
-    end
-  end
-end