#!/usr/bin/env ruby
# This code comes from http://ruby-it.org/pages/Ruby+ed+Emacs
# Check the page for copyright notice and explanations



  (require 'ruby-ext)

  (load-file "/path/to/ruby-ext.el")

  ;;; ruby-ext.el --- utility functions for Ruby mode
  
  ;; Copyright (C) 2003 Massimiliano Mirra (mmirra [at] sanniolug [dot] org)
  
  ;; This file is not part of GNU Emacs.
  
  ;; This file is free software; you can redistribute it and/or modify
  ;; it under the terms of the GNU General Public License as published by
  ;; the Free Software Foundation; either version 2, or (at your option)
  ;; any later version.
  
  ;; This file is distributed in the hope that it will be useful,
  ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  ;; GNU General Public License for more details.
  
  ;; You should have received a copy of the GNU General Public License
  ;; along with GNU Emacs; see the file COPYING.  If not, write to
  ;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  ;; Boston, MA 02111-1307, USA.
  
  ;;; Commentary:
  
  ;; Extensions for ruby-mode.el.
  
  (defvar ruby-calling-buffer nil
    "Buffer that ruby-run was called from.")
  
  (defmacro comint-run-and-return (name program calling-buffer-var &rest switches)
    (let ((buffer-name (concat "*" name "*")))
      `(save-excursion
         (setq ,calling-buffer-var (current-buffer))
         (pop-to-buffer
        (if (comint-check-proc ,buffer-name)
            ,buffer-name
          (let ((process-buffer (make-comint ,name ,program nil ,@switches)))
            (set-process-sentinel (get-buffer-process ,buffer-name)
                                  (lambda (process event) 
                                    (when (string= (buffer-name) ,buffer-name)
                                      (end-of-buffer)
                                      (insert "\nProcess: " event "\n")
                                      (insert "----------------------------------------------------------------------\n"))
                                    (pop-to-buffer ,calling-buffer-var)))
            process-buffer))))))
  
  (defun close-block ()
    (interactive)
    (indent-according-to-mode)
    (end-of-line)
    (when block-initial-delimiter
      (skip-chars-backward " \t")
      (insert block-initial-delimiter))
    (newline)
    (insert block-final-delimiter)
    (indent-according-to-mode)
    (beginning-of-line)
    (open-line 1)
    (indent-according-to-mode))
  
  (defun ruby-run ()
    "Run current buffer through Ruby in a comint buffer."
    (interactive)
    (let ((modp (buffer-modified-p))
          (original-file-name (buffer-file-name))
          (original-buffer-name (buffer-name))
          (temp-directory-name (concat "/tmp/ruby-" (getenv "USER")))
          (ruby-path (expand-file-name default-directory)))
      (unless (file-accessible-directory-p temp-directory-name) 
        (make-directory temp-directory-name))
      (let ((temp-file-name (make-temp-file (concat temp-directory-name "/src"))))
        (set-visited-file-name temp-file-name)
        (save-buffer)
        (comint-run-and-return "ruby running" "ruby" ruby-calling-buffer "-I" ruby-path "-w" temp-file-name)
        (set-visited-file-name original-file-name)
        (rename-buffer original-buffer-name)
        (set-buffer-modified-p modp))))
  
  (defun ruby-custom-setup ()
    (define-key ruby-mode-map "\C-cj" 'close-block)
    (define-key ruby-mode-map "\C-c\C-c" 'ruby-run)
    (setq tab-width 2
          indent-tabs-mode nil
          ruby-deep-arglist nil
          ruby-deep-indent-paren nil)
    (set (make-variable-buffer-local 'block-initial-delimiter) nil)
    (set (make-variable-buffer-local 'block-final-delimiter) "end")
    (set (make-variable-buffer-local 'parens-require-spaces) nil))
  
  (add-hook 'ruby-mode-hook 'ruby-custom-setup)
  (provide 'ruby-ext)

    if __FILE__ == $0 or (defined? $TESTING and $TESTING == true)
      require "test/unit"
    
    
    end

    if __FILE__ == $0 or (defined? $TESTING and $TESTING == true)
      require "test/unit"
    
  +   class TestCalculator < Test::Unit::TestCase
  +      
  +   end
    end

    if __FILE__ == $0 or (defined? $TESTING and $TESTING == true)
      require "test/unit"
    
      class TestCalculator < Test::Unit::TestCase
  +     def test_addition
  +       calc = Calculator.new
  +       result = calc.add(1, 2)
  +       assert_equal 3, result
  +     end
      end
    end

  NameError: uninitialized constant TestCalculator::Calculator

  + class Calculator
  +   
  + end
    
    if __FILE__ == $0 or (defined? $TESTING and $TESTING == true)
      require "test/unit"
    
      class TestCalculator < Test::Unit::TestCase
        def test_addition
          calc = Calculator.new
          result = calc.add(1, 2)
          assert_equal 3, result
        end
      end
    end

    NoMethodError: undefined method `add' for #<Calculator:0x403164fc>

    class Calculator
  +   def add
  +     
  +   end
    end

    ArgumentError: wrong number of arguments (2 for 0)

  #
    class Calculator
  !   def add(a, b)
   
      end
    end

    <3> expected but was
    <nil>.

    class Calculator
      def add(a, b)
        return a + b
      end
    end

    1 tests, 1 assertions, 0 failures, 0 errors

  #
    class TestCalculator < Test::Unit::TestCase
      def test_addition
        calc = Calculator.new
        result = calc.add(1, 2)
        assert_equal 3, result
      end
    
  +   def test_calculator_tells_how_long_it_has_been_running
  +     calc = Calculator.new
  +     sleep 1
  +     seconds = calc.uptime
  +     assert seconds >= 1
  +   end
  + end

test_calculator_tells_how_long_it_has_been_running(TestCalculator):
    NoMethodError: undefined method `uptime' for #<Calculator:0x40315c14>

  #!/usr/bin/ruby

  $TESTING = true

  require "calculator"
  require "spreadsheet"
  require "database"