class ZenTest

# File lib/zentest.rb, line 581
def self.autotest(*klasses)
  zentest = ZenTest.new
  klasses.each do |klass|
    zentest.process_class(klass)
  end

  zentest.analyze

  zentest.missing_methods.each do |klass,methods|
    methods.each do |method,x|
      warn "autotest generating #{klass}##{method}"
    end
  end

  zentest.generate_code
  code = zentest.result
  puts code if $DEBUG

  Object.class_eval code
end

# File lib/zentest.rb, line 568
def self.fix(*files)
  ZenTest.usage_with_exit if files.empty?
  zentest = ZenTest.new
  zentest.scan_files(*files)
  zentest.analyze
  zentest.generate_code
  return zentest.result
end

# File lib/zentest.rb, line 80
def initialize
  @result = []
  @test_klasses = {}
  @klasses = {}
  @error_count = 0
  @inherited_methods = Hash.new { |h,k| h[k] = {} }
  # key = klassname, val = hash of methods => true
  @missing_methods = Hash.new { |h,k| h[k] = {} }
end

# File lib/zentest.rb, line 525
  def self.usage
    puts <<-EO_USAGE
usage: #{File.basename $0} [options] test-and-implementation-files...

ZenTest scans your target and unit-test code and writes your missing
code based on simple naming rules, enabling XP at a much quicker
pace. ZenTest only works with Ruby and Minitest or Test::Unit.

ZenTest uses the following rules to figure out what code should be
generated:

* Definition:
  * CUT = Class Under Test
  * TC = Test Class (for CUT)
* TC's name is the same as CUT w/ "Test" prepended at every scope level.
  * Example: TestA::TestB vs A::B.
* CUT method names are used in CT, with "test_" prependend and optional "_ext" extensions for differentiating test case edge boundaries.
  * Example:
    * A::B#blah
    * TestA::TestB#test_blah_normal
    * TestA::TestB#test_blah_missing_file
* All naming conventions are bidirectional with the exception of test extensions.

options:
  -h display this information
  -v display version information
  -r Reverse mapping (ClassTest instead of TestClass)
  -e (Rapid XP) eval the code generated instead of printing it
  -t test/unit generation (default is minitest).

    EO_USAGE
  end

# File lib/zentest.rb, line 559
def self.usage_with_exit
  self.usage
  exit 0
end

# File lib/zentest.rb, line 326
def add_missing_method(klassname, methodname)
  @result.push "# ERROR method #{klassname}\##{methodname} does not exist (1)" if $DEBUG and not $TESTING
  @error_count += 1
  @missing_methods[klassname][methodname] = true
end

# File lib/zentest.rb, line 442
def analyze
  # walk each known class and test that each method has a test method
  @klasses.each_key do |klassname|
    self.analyze_impl(klassname)
  end

  # now do it in the other direction...
  @test_klasses.each_key do |testklassname|
    self.analyze_test(testklassname)
  end
end

# File lib/zentest.rb, line 342
def analyze_impl(klassname)
  testklassname = self.convert_class_name(klassname)
  if @test_klasses[testklassname] then
    _, testmethods = methods_and_tests(klassname, testklassname)

    # check that each method has a test method
    @klasses[klassname].each_key do | methodname |
      testmethodname = normal_to_test(methodname)
      unless testmethods[testmethodname] then
        begin
          unless testmethods.keys.find { |m| m =~ /#{testmethodname}(_\w+)+$/ } then
            self.add_missing_method(testklassname, testmethodname)
          end
        rescue RegexpError
          puts "# ERROR trying to use '#{testmethodname}' as a regex. Look at #{klassname}.#{methodname}"
        end
      end # testmethods[testmethodname]
    end # @klasses[klassname].each_key
  else # ! @test_klasses[testklassname]
    puts "# ERROR test class #{testklassname} does not exist" if $DEBUG
    @error_count += 1

    @klasses[klassname].keys.each do | methodname |
      self.add_missing_method(testklassname, normal_to_test(methodname))
    end
  end # @test_klasses[testklassname]
end

# File lib/zentest.rb, line 373
def analyze_test(testklassname)
  klassname = self.convert_class_name(testklassname)

  # CUT might be against a core class, if so, slurp it and analyze it
  if $stdlib[klassname] then
    self.process_class(klassname, true)
    self.analyze_impl(klassname)
  end

  if @klasses[klassname] then
    methods, testmethods = methods_and_tests(klassname,testklassname)

    # check that each test method has a method
    testmethods.each_key do | testmethodname |
      if testmethodname =~ /^test_(?!integration_)/ then

        # try the current name
        methodname = test_to_normal(testmethodname, klassname)
        orig_name = methodname.dup

        found = false
        until methodname == "" or methods[methodname] or @inherited_methods[klassname][methodname] do
            # try the name minus an option (ie mut_opt1 -> mut)
          if methodname.sub!(/_[^_]+$/, '') then
            if methods[methodname] or @inherited_methods[klassname][methodname] then
              found = true
            end
          else
            break # no more substitutions will take place
          end
        end # methodname == "" or ...

        unless found or methods[methodname] or methodname == "initialize" then
          self.add_missing_method(klassname, orig_name)
        end

      else # not a test_.* method
        unless testmethodname =~ /^util_/ then
          puts "# WARNING Skipping #{testklassname}\##{testmethodname}" if $DEBUG
        end
      end # testmethodname =~ ...
    end # testmethods.each_key
  else # ! @klasses[klassname]
    puts "# ERROR class #{klassname} does not exist" if $DEBUG
    @error_count += 1

    @test_klasses[testklassname].keys.each do |testmethodname|
      @missing_methods[klassname][test_to_normal(testmethodname)] = true
    end
  end # @klasses[klassname]
end

# File lib/zentest.rb, line 190
def convert_class_name(name)
  name = name.to_s

  if self.is_test_class(name) then
    if $r then
      name = name.gsub(/Test($|::)/, '\1') # FooTest::BlahTest => Foo::Blah
    else
      name = name.gsub(/(^|::)Test/, '\1') # TestFoo::TestBlah => Foo::Blah
    end
  else
    if $r then
      name = name.gsub(/($|::)/, 'Test\1') # Foo::Blah => FooTest::BlahTest
    else
      name = name.gsub(/(^|::)/, '\1Test') # Foo::Blah => TestFoo::TestBlah
    end
  end

  return name
end

# File lib/zentest.rb, line 428
def create_method(indentunit, indent, name)
  meth = []
  meth.push indentunit*indent + "def #{name}"
  meth.last << "(*args)" unless name =~ /^test/
  indent += 1
  meth.push indentunit*indent + "raise NotImplementedError, 'Need to write #{name}'"
  indent -= 1
  meth.push indentunit*indent + "end"
  return meth
end

# File lib/zentest.rb, line 458
def generate_code
  @result.unshift "# Code Generated by ZenTest v. #{VERSION}"

  if $DEBUG then
    @result.push "# found classes: #{@klasses.keys.join(', ')}"
    @result.push "# found test classes: #{@test_klasses.keys.join(', ')}"
  end

  if @missing_methods.size > 0 then
    @result.push ""
    if $t then
      @result.push "require 'test/unit/testcase'"
      @result.push "require 'test/unit' if $0 == __FILE__"
    else
      @result.push "require 'minitest/autorun'"
    end
    @result.push ""
  end

  indentunit = "  "

  @missing_methods.keys.sort.each do |fullklasspath|
    methods = @missing_methods[fullklasspath]
    cls_methods = methods.keys.grep(/^(self\.|test_class_)/)
    methods.delete_if {|k,v| cls_methods.include? k }

    next if methods.empty? and cls_methods.empty?

    indent = 0
    is_test_class = self.is_test_class(fullklasspath)

    clsname = $t ? "Test::Unit::TestCase" : "Minitest::Test"
    superclass = is_test_class ? " < #{clsname}" : ''

    @result.push indentunit*indent + "class #{fullklasspath}#{superclass}"
    indent += 1

    meths = []

    cls_methods.sort.each do |method|
      meth = create_method(indentunit, indent, method)
      meths.push meth.join("\n")
    end

    methods.keys.sort.each do |method|
      next if method =~ /pretty_print/
      meth = create_method(indentunit, indent, method)
      meths.push meth.join("\n")
    end

    @result.push meths.join("\n\n")

    indent -= 1
    @result.push indentunit*indent + "end"
    @result.push ''
  end

  @result.push "# Number of errors detected: #{@error_count}"
  @result.push ''
end

# File lib/zentest.rb, line 106
def get_class(klassname)
  klass = nil
  begin
    klass = klassname.split(/::/).inject(Object) { |k,n| k.const_get n }
    puts "# found class #{klass.name}" if $DEBUG
  rescue NameError
  end

  if klass.nil? and not $TESTING then
    puts "Could not figure out how to get #{klassname}..."
    puts "Report to support-zentest@zenspider.com w/ relevant source"
  end

  return klass
end

# File lib/zentest.rb, line 155
def get_inherited_methods_for(klass, full)
  klass = self.get_class(klass) if klass.kind_of? String

  klassmethods = {}
  if (klass.class.method_defined?(:superclass)) then
    superklass = klass.superclass
    if superklass then
      the_methods = superklass.instance_methods(true)

      # generally we don't test Object's methods...
      unless full then
        the_methods -= Object.instance_methods(true)
        the_methods -= Kernel.methods # FIX (true) - check 1.6 vs 1.8
      end

      the_methods.each do |meth|
        klassmethods[meth.to_s] = true
      end
    end
  end
  return klassmethods
end

# File lib/zentest.rb, line 127
def get_methods_for(klass, full=false)
  klass = self.get_class(klass) if klass.kind_of? String

  # WTF? public_instance_methods: default vs true vs false = 3 answers
  # to_s on all results if ruby >= 1.9
  public_methods = klass.public_instance_methods(false)
  public_methods -= Kernel.methods unless full
  public_methods.map! { |m| m.to_s }
  public_methods -= %w(pretty_print pretty_print_cycle)

  klass_methods = klass.singleton_methods(full)
  klass_methods -= Class.public_methods(true)
  klass_methods = klass_methods.map { |m| "self.#{m}" }
  klass_methods  -= %w(self.suite new)

  result = {}
  (public_methods + klass_methods).each do |meth|
    puts "# found method #{meth}" if $DEBUG
    result[meth] = true
  end

  return result
end

# File lib/zentest.rb, line 180
def is_test_class(klass)
  klass = klass.to_s
  klasspath = klass.split(/::/)
  a_bad_classpath = klasspath.find do |s| s !~ ($r ? /Test$/ : /^Test/) end
  return a_bad_classpath.nil?
end

# File lib/zentest.rb, line 91
def load_file(file)
  puts "# loading #{file} // #{$0}" if $DEBUG

  unless file == $0 then
    begin
      require file
    rescue LoadError => err
      puts "Could not load #{file}: #{err}"
    end
  else
    puts "# Skipping loading myself (#{file})" if $DEBUG
  end
end

# File lib/zentest.rb, line 335
def methods_and_tests(klassname, testklassname)
  return @klasses[klassname], @test_klasses[testklassname]
end

# File lib/zentest.rb, line 77
def missing_methods; raise "Something is wack"; end

# File lib/zentest.rb, line 215
def process_class(klassname, full=false)
  klass = self.get_class(klassname)
  raise "Couldn't get class for #{klassname}" if klass.nil?
  klassname = klass.name # refetch to get full name

  is_test_class = self.is_test_class(klassname)
  target = is_test_class ? @test_klasses : @klasses

  # record public instance methods JUST in this class
  target[klassname] = self.get_methods_for(klass, full)

  # record ALL instance methods including superclasses (minus Object)
  # Only minus Object if full is true.
  @inherited_methods[klassname] = self.get_inherited_methods_for(klass, full)
  return klassname
end

# File lib/zentest.rb, line 520
def result
  return @result.join("\n")
end

# File lib/zentest.rb, line 237
def scan_files(*files)
  assert_count = Hash.new(0)
  method_count = Hash.new(0)
  klassname = nil

  files.each do |path|
    is_loaded = false

    # if reading stdin, slurp the whole thing at once
    file = (path == "-" ? $stdin.read : File.new(path))

    file.each_line do |line|

      if klassname then
        case line
        when /^\s*def/ then
          method_count[klassname] += 1
        when /assert|flunk/ then
          assert_count[klassname] += 1
        end
      end

      if line =~ /^\s*(?:class|module)\s+([\w:]+)/ then
        klassname = $1

        if line =~ /\#\s*ZenTest SKIP/ then
          klassname = nil
          next
        end

        full = false
        if line =~ /\#\s*ZenTest FULL/ then
          full = true
        end

        unless is_loaded then
          unless path == "-" then
            self.load_file(path)
          else
            eval file, TOPLEVEL_BINDING
          end
          is_loaded = true
        end

        begin
          klassname = self.process_class(klassname, full)
        rescue
          puts "# Couldn't find class for name #{klassname}"
          next
        end

        # Special Case: ZenTest is already loaded since we are running it
        if klassname == "TestZenTest" then
          klassname = "ZenTest"
          self.process_class(klassname, false)
        end

      end # if /class/
    end # IO.foreach
  end # files

  result = []
  method_count.each_key do |classname|

    entry = {}

    next if is_test_class(classname)
    testclassname = convert_class_name(classname)
    a_count = assert_count[testclassname]
    m_count = method_count[classname]
    ratio = a_count.to_f / m_count.to_f * 100.0

    entry['n'] = classname
    entry['r'] = ratio
    entry['a'] = a_count
    entry['m'] = m_count

    result.push entry
  end

  sorted_results = result.sort { |a,b| b['r'] <=> a['r'] }

  @result.push sprintf("# %25s: %4s / %4s = %6s%%", "classname", "asrt", "meth", "ratio")
  sorted_results.each do |e|
    @result.push sprintf("# %25s: %4d / %4d = %6.2f%%", e['n'], e['a'], e['m'], e['r'])
  end
end