rubydoctest 0.2.1 → 1.0.0

data/config/hoe.rb

@@ -1,15 +1,13 @@
 require 'rubydoctest/version'
 
-AUTHOR = ['Tom Locke', 'Dr Nic Williams']  # can also be an array of Authors
-EMAIL = "drnicwilliams@gmail.com"
+AUTHOR = ['Duane Johnson', 'Tom Locke', 'Dr Nic Williams']  # can also be an array of Authors
+EMAIL = "duane.johnson@gmail.com"
 DESCRIPTION = "Ruby version of Python's doctest tool, but a bit different."
 GEM_NAME = 'rubydoctest' # what ppl will type to install your gem
 RUBYFORGE_PROJECT = 'rubydoctest' # The unix name for your project
 HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
 DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
-EXTRA_DEPENDENCIES = [
-#  ['activesupport', '>= 1.3.1']
-]    # An array of rubygem dependencies [name, version]
+EXTRA_DEPENDENCIES = []
 
 @config_file = "~/.rubyforge/user-config.yml"
 @config = nil

data/lib/code_block.rb

@@ -0,0 +1,68 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'statement'
+require 'result'
+
+module RubyDocTest
+  # A +CodeBlock+ is a group of one or more ruby statements, followed by an optional result.
+  # For example:
+  #  >> a = 1 + 1
+  #  >> a - 3
+  #  => -1
+  class CodeBlock
+    attr_reader :statements, :result, :passed
+    
+    def initialize(statements = [], result = nil)
+      @statements = statements
+      @result = result
+    end
+    
+    # === Tests
+    # doctest: Single statement with result should pass
+    # >> ss = [RubyDocTest::Statement.new([">> a = 1"])]
+    # >> r = RubyDocTest::Result.new(["=> 1"])
+    # >> cb = RubyDocTest::CodeBlock.new(ss, r)
+    # >> cb.pass?
+    # => true
+    #
+    # doctest: Single statement without result should pass by default
+    # >> ss = [RubyDocTest::Statement.new([">> a = 1"])]
+    # >> cb = RubyDocTest::CodeBlock.new(ss)
+    # >> cb.pass?
+    # => true
+    #
+    # doctest: Multi-line statement with result should pass
+    # >> ss = [RubyDocTest::Statement.new([">> a = 1"]),
+    #          RubyDocTest::Statement.new([">> 'a' + a.to_s"])]
+    # >> r = RubyDocTest::Result.new(["=> 'a1'"])
+    # >> cb = RubyDocTest::CodeBlock.new(ss, r)
+    # >> cb.pass?
+    # => true
+    def pass?
+      if @computed
+        @passed
+      else
+        @computed = true
+        @passed =
+          begin
+            actual_results = @statements.map{ |s| s.evaluate }
+            @result ? @result.matches?(actual_results.last) : true
+          end
+      end
+    end
+    
+    def actual_result
+      @statements.last.actual_result
+    end
+    
+    def expected_result
+      @result.expected_result
+    end
+    
+    def lines
+      @statements.map{ |s| s.lines }.flatten +
+      @result.lines
+    end
+  end
+end

data/lib/doctest_require.rb

@@ -0,0 +1,3 @@
+def is_doctest_require_successful?
+  true
+end

data/lib/lines.rb

@@ -0,0 +1,143 @@
+module RubyDocTest
+  # === Description
+  # Keeps track of which lines within a document belong to a group.  Line groups are
+  # determined by their indentation level, as in the Python programming language.
+  #
+  # === Example
+  #  This line and the next one
+  #    are part of the same group
+  #
+  #  But this line is separate from
+  #  this line.
+  #
+  # === Note
+  # This class also considers one '#' character (comment) as an indentation character,
+  # i.e. similar to how whitespace is treated.
+  class Lines
+    def initialize(doc_lines, line_index = 0)
+      @doc_lines, @line_index = doc_lines, line_index
+    end
+    
+    
+    def line_number
+      @line_index + 1
+    end
+    
+    # === Tests
+    # doctest: Return an array of 1 line if there is only one line
+    # >> l = RubyDocTest::Lines.new(["line 1"])
+    # >> l.lines
+    # => ["line 1"]
+    #
+    # doctest: Remove indentation from lines 2 to the end of this Lines group.
+    # >> l = RubyDocTest::Lines.new(["line 1", "  line 2", "  line 3", "    line 4"])
+    # >> l.lines
+    # => ["line 1", "line 2", "line 3", "  line 4"]
+    def lines
+      r = range
+      size = r.last - r.first + 1
+      if size > 1
+        # Remove indentation from all lines after the first,
+        # as measured from the 2nd line's indentation level
+        idt2 = indentation(@doc_lines, @line_index + 1)
+        [@doc_lines[range.first]] +
+        @doc_lines[(range.first + 1)..(range.last)].
+          map{ |l| $1 if l =~ /^#{Regexp.escape(idt2)}(.*)/ }
+      else
+        @doc_lines[range]
+      end
+    end
+    
+    
+    # === Description
+    # Calculate the range of python-like indentation within this Lines group
+    #
+    # === Tests
+    # >> l = RubyDocTest::Lines.new([])
+    #
+    # doctest: Return a range of one line when there is only one line to begin with
+    # >> l.range %w(a), 0
+    # => 0..0
+    #
+    # doctest: Return a range of one line when there are two lines, side by side
+    # >> l.range %w(a b), 0
+    # => 0..0
+    # >> l.range %w(a b), 1
+    # => 1..1
+    #
+    # doctest: Return a range of two lines when there are two lines, the second blank
+    # >> l.range ["a", ""], 0
+    # => 0..1
+    #
+    # doctest: Return a range of two lines when the second is indented
+    # >> l.range ["a", " b"], 0
+    # => 0..1
+    #
+    # doctest: Indentation can also include the ?> marker
+    # >> l.range [">> 1 +", "?> 2"], 0
+    # => 0..1
+    def range(doc_lines = @doc_lines, start_index = @line_index)
+      end_index = start_index
+      idt = indentation(doc_lines, start_index)
+      # Find next lines that are blank, or have indentation more than the first line
+      remaining_lines(doc_lines, start_index + 1).each do |current_line|
+        if current_line =~ /^(#{Regexp.escape(idt)}(\s+|\?>\s)|\s*$)/
+          end_index += 1
+        else
+          break
+        end
+      end
+      # Compute the range from what we found
+      start_index..end_index
+    end
+    
+    def inspect
+      "#<#{self.class} lines=#{lines.inspect}>"
+    end
+    
+    protected
+    
+    # === Tests
+    # >> l = RubyDocTest::Lines.new([])
+    #
+    # doctest: Get a whitespace indent from a line with whitespace
+    # >> l.send :indentation, [" a"], 0
+    # => " "
+    #
+    # doctest: Get a whitespace and '#' indent from a comment line
+    # >> l.send :indentation, [" # a"], 0
+    # => " # "
+    def indentation(doc_lines = @doc_lines, line_index = @line_index)
+      if doc_lines[line_index]
+        doc_lines[line_index][/^(\s*#\s*|\s*)(\?>\s)?/]
+      else
+        ""
+      end
+    end
+    
+    
+    # === Description
+    # Get lines from +start_index+ up to the end of the document.
+    #
+    # === Tests
+    # >> l = RubyDocTest::Lines.new([])
+    # 
+    # doctest: Return an empty array if start_index is out of bounds
+    # >> l.send :remaining_lines, [], 1
+    # => []
+    # >> l.send :remaining_lines, [], -1
+    # => []
+    #
+    # doctest: Return the specified line at start_index, up to and including the
+    #          last line of +doc_lines+.
+    # >> l.send :remaining_lines, %w(a b c), 1
+    # => %w(b c)
+    # >> l.send :remaining_lines, %w(a b c), 2
+    # => %w(c)
+    #
+    def remaining_lines(doc_lines = @doc_lines, start_index = @line_index)
+      return [] if start_index < 0 or start_index >= doc_lines.size
+      doc_lines[start_index..-1]
+    end
+  end
+end

data/lib/result.rb

@@ -0,0 +1,63 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'lines'
+
+module RubyDocTest
+  class Result < Lines
+    
+    def normalize_result(s)
+      s.gsub(/:0x[a-f0-9]{8}>/, ':0xXXXXXXXX>').strip
+    end
+    
+    def expected_result
+      @expected_result ||=
+        begin
+          lines.first =~ /^#{Regexp.escape(indentation)}=>\s(.*)$/
+          ([$1] + (lines[1..-1] || [])).join("\n")
+        end
+    end
+    
+    # === Tests
+    # doctest: Strings should match
+    # >> r = RubyDocTest::Result.new(["=> 'hi'"])
+    # >> r.matches? 'hi'
+    # => true
+    #
+    # >> r = RubyDocTest::Result.new(["=> \"hi\""])
+    # >> r.matches? "hi"
+    # => true
+    #
+    # doctest: Regexps should match
+    # >> r = RubyDocTest::Result.new(["=> /^reg.../"])
+    # >> r.matches? /^reg.../
+    # => true
+    #
+    # >> r = RubyDocTest::Result.new(["=> /^reg.../"])
+    # >> r.matches? /^regexp/
+    # => false
+    #
+    # doctest: Arrays should match
+    # >> r = RubyDocTest::Result.new(["=> [1, 2, 3]"])
+    # >> r.matches? [1, 2, 3]
+    # => true
+    #
+    # doctest: Arrays of arrays should match
+    # >> r = RubyDocTest::Result.new(["=> [[1, 2], [3, 4]]"])
+    # >> r.matches? [[1, 2], [3, 4]]
+    # => true
+    #
+    # doctest: Hashes should match
+    # >> r = RubyDocTest::Result.new(["=> {:one => 1, :two => 2}"])
+    # >> r.matches?({:two => 2, :one => 1})
+    # => true
+    def matches?(actual_result)
+      normalize_result(actual_result.inspect) ==
+      normalize_result(expected_result) \
+        or
+      actual_result == eval(expected_result, TOPLEVEL_BINDING)
+    rescue Exception
+      false
+    end
+  end
+end

data/lib/rubydoctest.rb

@@ -2,270 +2,28 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 require 'irb'
+require "runner"
 
-class RubyDocTest
+module RubyDocTest
   
   class << self
-    attr_accessor :trace
-  end
-
-  PROMPT_RX = /^[>?]>( |\s*$)/
-  
-  RESULT_RX = /^=> /
-  
-  CODE_LINE_RX = /^(    |\t)/
-  
-  def initialize(src, file_name)
-    @passed = 0
-    @block_count = 0
-    @failures = []
-    @src_lines = src.split("\n")
-    @line_num = 0
-    @file_name = file_name
+    attr_accessor :trace, :ignore_interactive
+    attr_writer :output_format
     
-    # next_line # get first line
-  end
-  
-  def run
-    run_file
-    print_report
-  end
-  
-  attr_accessor :passed, :failures, :current_line, :src_lines, :line_num, :block_count
-  
-  def environment
-    TOPLEVEL_BINDING
-  end
-  
-  def next_line
-    @line_num += 1
-    @current_line = src_lines.shift
-  end
-  
-  def next_line?
-    src_lines.any?
-  end
-  
-  def strip_prompt(s)
-    s.sub(PROMPT_RX, "")
-  end
-
-  def result_start?(s=current_line)
-    s =~ RESULT_RX
-  end
-  
-  def string_result_start?(s=current_line)
-    s =~ /^=>""/
-  end
-  
-  def statement_start?(s=current_line)
-    s =~ PROMPT_RX
-  end
-  
-  def strip_result_marker(s=current_line)
-    s.sub(RESULT_RX, "")
-  end
-  
-  def normalize_result(s)
-    s.gsub(/:0x[a-f0-9]{8}>/, ':0xXXXXXXXX>').strip
-  end
-  
-  def code_line?(s=current_line)
-    s =~ CODE_LINE_RX
-  end
-  
-  def code_block_start?(s=current_line)
-    l = unindent_code_line
-    code_line? && (statement_start?(l) || irb_interrupt?(l))
-  end
-  
-  def blank_line?(s=current_line)
-    s =~ /^\s*$/
-  end
-  
-  def irb_interrupt?(line)
-    line =~ /!!!/
-  end
-  
-  def run_file
-    # run_code_block if code_block_start?
-    while next_line
-      run_code_block if code_block_start?
-    end
-    failures.length == 0
-  end
-  
-  def unindent_code_line(s=current_line)
-    s.sub(CODE_LINE_RX, "")
-  end
-  
-  
-  def get_code_lines
-    lines = []
-    while blank_line? || code_line?
-      lines << [unindent_code_line, line_num]
-      next_line
-    end
-    lines.pop while blank_line?(lines.last)
-    lines
-  end
-  
-  
-  def run_code_block
-    self.block_count += 1
-    
-    lines = get_code_lines
-    
-    reading = :statement
-
-    result = nil
-    statement = ""
-    statement_line = lines.first.last
-    lines.each do |line, line_num|
-      
-      if irb_interrupt?(line)
-        evaluate(statement, statement_line) unless statement == ""
-        
-        puts statement unless statement.blank?
-        puts "=> #{result}" unless result.blank?
-        puts
-        
-        start_irb
-        line = nil
-        
-      elsif string_result_start?(line)
-        reading = :string_result
-        line = nil
-        result = ""
-        
-      elsif result_start?(line)
-        reading = :ruby_result
-        line = strip_result_marker(line)
-        result = ""
-
-      elsif statement_start?(line)
-        if result
-          # start of a new statement
-          if reading == :string_result
-            # end of a string result statement
-            result.chomp!
-            run_statement(statement, result, statement_line, true)
-          else
-            run_statement(statement, result, statement_line)
-          end
-          statement_line = line_num
-          statement = ""
-          result = nil
-        end
-        reading = :statement
-      end
-      
-      if reading == :statement
-        # The statement has a prompt on every line
-        if line
-          line = strip_prompt(line)
-          statement << line + "\n" 
-        end
+    def output_format
+      if @output_format == :ansi or (@output_format.nil? and STDOUT.tty?)
+        :ansi
+      elsif @output_format == :html
+        :html
       else
-        # There's only one result marker - stripped above
-        result << line + "\n" if line
+        :plain
       end
-      
-    end
-    
-    if result.nil?
-      # The block ends with a statement - just evaluate it
-      evaluate(statement, statement_line)
-    else
-      run_statement(statement, result, statement_line)
-    end
-  end
-  
-  
-  def start_irb
-    IRB.init_config(nil)
-    IRB.conf[:PROMPT_MODE] = :SIMPLE
-    irb = IRB::Irb.new(IRB::WorkSpace.new(environment))
-    IRB.conf[:MAIN_CONTEXT] = irb.context
-    irb.eval_input
-  end
-  
-  
-  def run_statement(statement, expected_result, statement_line, string_comparison=false)
-    actual_result = evaluate(statement, statement_line)
-    
-    if result_matches?(expected_result, actual_result, string_comparison)
-      self.passed += 1
-    else
-      actual_result = actual_result.inspect unless string_comparison
-      failures << [statement, actual_result, expected_result, statement_line]
-    end
-  end
-  
-  
-  def result_matches?(expected_result, actual_result, string_comparison)
-    if string_comparison
-      actual_result == expected_result
-    else
-      actual_result = actual_result.inspect
-      normalize_result(expected_result) == normalize_result(actual_result) or
-          # If the expected result looks like a literal, see if they eval to equal objects - this will often fail
-          if expected_result =~ /^[:\[{A-Z'"%\/]/
-            begin
-              eval(expected_result) == eval(actual_result)
-            rescue Exception
-              false
-            end
-          end
     end
-  end
-  
-  
-  def evaluate(statement, line_num)
-    statement.gsub!("__FILE__", @file_name.inspect)
-    eval(statement, environment, __FILE__, __LINE__)
-  rescue SyntaxError => e
-    puts "Syntax error in statement on line #{line_num}:"
-    puts indent(statement)
-    puts e.to_s
-    puts
-    exit 1
-  rescue Exception => e
-    puts "Exception in statement on line #{line_num}:"
-    puts indent(statement)
-    puts e.backtrace
     
-    if RubyDocTest.trace
-      raise
-    else
-      puts e.to_s
-      puts
-      exit 1      
+    def indent(s, level=4)
+      spaces = " " * level
+      spaces + s.split("\n").join("\n#{spaces}")
     end
   end
   
-  
-  def number_run
-    passed + failures.length
-  end
-  
-  def indent(s, level=4)
-    spaces = " " * level
-    spaces + s.split("\n").join("\n#{spaces}")
-  end
-  
-  def print_report
-    statements_per_block = number_run.to_f / block_count
-    puts("%d blocks, %d tests (avg. %.1f/block), %d failures\n\n" %
-         [block_count, number_run, statements_per_block, failures.length])
-    
-    failures.each do |statement, actual, expected, lnum|
-      puts "Failure line #{lnum}"
-      puts "  Statement:", indent(statement)
-      puts "  Expected:",  indent(expected)
-      puts "  Got:\n",     indent(actual)
-      puts
-    end
-  end
-
 end