rcodetools 0.7.0.0 → 0.8.0.0

data/lib/rcodetools/xmptestunitfilter.rb

@@ -2,12 +2,13 @@ require 'rcodetools/xmpfilter'
 
 module Rcodetools
 
+FLOAT_TOLERANCE = 0.0001
 class XMPTestUnitFilter < XMPFilter
   def initialize(opts = {})
     super
     @output_stdout = false
     mod = @parentheses ? :WithParentheses : :Poetry
-    extend self.class.const_get(mod) 
+    extend self.class.const_get(mod) unless opts[:_no_extend_module]
   end
 
   private
@@ -73,7 +74,7 @@ class XMPTestUnitFilter < XMPFilter
     def value_assertions(klass_txt, value_txt, value, expression)
       case value
       when Float
-        ["assert_in_delta(#{value.inspect}, #{expression}, 0.0001)"]
+        ["assert_in_delta(#{value.inspect}, #{expression}, #{FLOAT_TOLERANCE})"]
       when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
         ["assert_equal(#{value_txt}, #{expression})"]
       else
@@ -99,7 +100,7 @@ class XMPTestUnitFilter < XMPFilter
     def value_assertions(klass_txt, value_txt, value, expression)
       case value
       when Float
-        ["assert_in_delta #{value.inspect}, #{expression}, 0.0001"]
+        ["assert_in_delta #{value.inspect}, #{expression}, #{FLOAT_TOLERANCE}"]
       when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
         ["assert_equal #{value_txt}, #{expression}"]
       else
@@ -119,26 +120,36 @@ class XMPTestUnitFilter < XMPFilter
 end
 
 class XMPRSpecFilter < XMPTestUnitFilter
-  private
-  alias :execute :execute_script
-
-  def interpreter_command
-    [@interpreter] + @libs.map{|x| "-r#{x}"}
+  def initialize(x={})
+    super(x.merge(:_no_extend_module => true))
+    load_rspec
+    specver = (Spec::VERSION::STRING rescue "1.0.0")
+    api_module = specver >= "0.8.0" ? NewAPI : OldAPI
+    mod = @parentheses ? :WithParentheses : :Poetry
+    extend api_module.const_get(mod) 
+    extend api_module
   end
 
-  begin
-    require 'spec/version'
-  rescue LoadError
-    require 'rubygems'
+  private
+  def load_rspec
     begin
       require 'spec/version'
-    rescue LoadError # if rspec isn't available, use most recent conventions
-      module Spec::VERSION; STRING = "1.0.0" end
+    rescue LoadError
+      require 'rubygems'
+      begin
+        require 'spec/version'
+      rescue LoadError # if rspec isn't available, use most recent conventions
+      end
     end
   end
 
-  if Spec::VERSION::STRING >= "0.8.0"
+  alias :execute :execute_script
 
+  def interpreter_command
+    [@interpreter] + @libs.map{|x| "-r#{x}"}
+  end
+
+  module NewAPI
     def raise_assertion(expression, exceptions, index)
       ["lambda{#{expression}}.should raise_error(#{exceptions[index][0]})"]
     end
@@ -151,7 +162,7 @@ class XMPRSpecFilter < XMPTestUnitFilter
       def value_assertions(klass_txt, value_txt, value, expression)
         case value
         when Float
-          ["(#{expression}).should be_close(#{value.inspect}, 0.0001)"]
+          ["(#{expression}).should be_close(#{value.inspect}, #{FLOAT_TOLERANCE})"]
         when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
           ["(#{expression}).should == (#{value_txt})"]
         else
@@ -177,7 +188,7 @@ class XMPRSpecFilter < XMPTestUnitFilter
       def value_assertions(klass_txt, value_txt, value, expression)
         case value
         when Float
-          ["#{expression}.should be_close(#{value.inspect}, 0.0001)"]
+          ["#{expression}.should be_close(#{value.inspect}, #{FLOAT_TOLERANCE})"]
         when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
           ["#{expression}.should == #{value_txt}"]
         else
@@ -194,7 +205,9 @@ class XMPRSpecFilter < XMPTestUnitFilter
         "#{actual}.should == #{expected}"
       end
     end
-  else
+  end
+
+  module OldAPI
     # old rspec, use deprecated syntax
     def raise_assertion(expression, exceptions, index)
       ["lambda{#{expression}}.should_raise_error(#{exceptions[index][0]})"]
@@ -208,7 +221,7 @@ class XMPRSpecFilter < XMPTestUnitFilter
       def value_assertions(klass_txt, value_txt, value, expression)
         case value
         when Float
-          ["(#{expression}).should_be_close(#{value.inspect}, 0.0001)"]
+          ["(#{expression}).should_be_close(#{value.inspect}, #{FLOAT_TOLERANCE})"]
         when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
           ["(#{expression}).should_equal(#{value_txt})"]
         else
@@ -234,7 +247,7 @@ class XMPRSpecFilter < XMPTestUnitFilter
       def value_assertions(klass_txt, value_txt, value, expression)
         case value
         when Float
-          ["#{expression}.should_be_close #{value.inspect}, 0.0001"]
+          ["#{expression}.should_be_close #{value.inspect}, #{FLOAT_TOLERANCE}"]
         when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
           ["#{expression}.should_equal #{value_txt}"]
         else
@@ -253,6 +266,48 @@ class XMPRSpecFilter < XMPTestUnitFilter
     end
   end
 
-end
 
 end
+
+class XMPExpectationsFilter < XMPTestUnitFilter
+  def initialize(x={})
+    super(x.merge(:_no_extend_module => true))
+    @warnings = false
+  end
+  
+  def expectation(expected, actual)
+    <<EOE
+expect #{expected} do
+    #{actual}
+  end
+EOE
+  end
+  alias :equal_assertion :expectation
+
+  def raise_assertion(expression, exceptions, index)
+    [ expectation(exceptions[index][0], expression) ]
+  end
+  
+  def nil_assertion(expression)
+    [ expectation("nil", expression) ]
+  end
+  
+  def value_assertions(klass_txt, value_txt, value, expression)
+    case value
+    when Float
+      min = "%.4f" % [value - FLOAT_TOLERANCE]
+      max = "%.4f" % [value + FLOAT_TOLERANCE]
+      [ expectation("#{min}..#{max}", expression) ]
+    when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
+      [ expectation(value_txt, expression) ]
+    else
+      object_assertions klass_txt, value_txt, expression 
+    end
+  end
+  
+  def object_assertions(klass_txt, value_txt, expression)
+    [ expectation(klass_txt, expression),
+      expectation(value_txt.inspect, "#{expression}.inspect") ]
+  end
+end                             # /XMPExpectationsFilter
+end                             # /Rcodetools

data/lib/ruby_toggle_file.rb

@@ -35,7 +35,7 @@ class RubyToggleFile
     run_hooks_with_args_until_success %r/^implementation_file_/, test, m&&(m.pre_match+"/"), m&&m[1], m&&m[2]
   end
 
-  private
+#  private
   def exist(file)
     file if File.exist? file
   end

data/rcodetools.el

@@ -1,10 +1,10 @@
 ;;; rcodetools.el -- annotation / accurate completion / browsing documentation
 
-;;; Copyright (c) 2006 rubikitch <rubikitch@ruby-lang.org>
+;;; Copyright (c) 2006-2008 rubikitch <rubikitch@ruby-lang.org>
 ;;;
 ;;; Use and distribution subject to the terms of the Ruby license.
 
-(defvar xmpfilter-command-name "ruby -S xmpfilter --dev --detect-rbtest"
+(defvar xmpfilter-command-name "ruby -S xmpfilter --dev --fork --detect-rbtest"
   "The xmpfilter command name.")
 (defvar rct-doc-command-name "ruby -S rct-doc --dev --fork --detect-rbtest"
   "The rct-doc command name.")
@@ -12,6 +12,7 @@
   "The rct-complete command name.")
 (defvar ruby-toggle-file-command-name "ruby -S ruby-toggle-file"
   "The ruby-toggle-file command name.")
+(defvar rct-fork-command-name "ruby -S rct-fork")
 (defvar rct-option-history nil)                ;internal
 (defvar rct-option-local nil)     ;internal
 (make-variable-buffer-local 'rct-option-local)
@@ -55,26 +56,47 @@
                (read-from-minibuffer "rcodetools option: " option nil nil 'rct-option-history))
        option))))  
 
+(defun rct-shell-command (command &optional buffer)
+  "Replacement for `(shell-command-on-region (point-min) (point-max) command buffer t' because of encoding problem."
+  (let ((input-rb (concat (make-temp-name "xmptmp-in") ".rb"))
+        (output-rb (concat (make-temp-name "xmptmp-out") ".rb"))
+        (coding-system-for-read buffer-file-coding-system))
+    (write-region (point-min) (point-max) input-rb nil 'nodisp)
+    (shell-command
+     (rct-debuglog (format "%s %s > %s" command input-rb output-rb))
+     t " *rct-error*")
+    (and buffer (set-buffer buffer))
+    (insert-file-contents output-rb nil nil nil t)
+    (delete-file input-rb)
+    (delete-file output-rb)))
+
+(defvar xmpfilter-command-function 'xmpfilter-command)
 (defun xmp (&optional option)
   "Run xmpfilter for annotation/test/spec on whole buffer.
 See also `rct-interactive'. "
   (interactive (rct-interactive))
   (rct-save-position
-   (lambda () (shell-command-on-region (point-min) (point-max) (xmpfilter-command option) t t " *rct-error*"))))
+   (lambda ()
+     (rct-shell-command (funcall xmpfilter-command-function option)))))
 
 (defun xmpfilter-command (&optional option)
   "The xmpfilter command line, DWIM."
   (setq option (or option ""))
-  (cond ((save-excursion
-           (goto-char 1)
-           (search-forward "< Test::Unit::TestCase" nil t))
-         (format "%s --unittest %s" xmpfilter-command-name option))
-        ((save-excursion
-           (goto-char 1)
-           (re-search-forward "^context.+do$" nil t))
-         (format "%s --spec %s" xmpfilter-command-name option))
-        (t
-         (format "%s %s" xmpfilter-command-name option))))
+  (flet ((in-block (beg-re)
+                   (save-excursion
+                     (goto-char (point-min))
+                     (when (re-search-forward beg-re nil t)
+                       (let ((s (point)) e)
+                         (when (re-search-forward "^end\n" nil t)
+                           (setq e (point))
+                           (goto-char s)
+                           (re-search-forward "# => *$" e t)))))))
+    (cond ((in-block "^class.+< Test::Unit::TestCase$")
+           (format "%s --unittest %s" xmpfilter-command-name option))
+          ((in-block "^\\(describe\\|context\\).+do$")
+           (format "%s --spec %s" xmpfilter-command-name option))
+          (t
+           (format "%s %s" xmpfilter-command-name option)))))
 
 ;;;; Completion
 (defvar rct-method-completion-table nil) ;internal
@@ -130,13 +152,12 @@ See also `rct-interactive'."
   "Execute rct-complete/rct-doc and evaluate the output."
   (let ((eval-buffer  (get-buffer-create " *rct-eval*")))
     ;; copy to temporary buffer to do completion at non-EOL.
-    (shell-command-on-region
-     (point-min) (point-max)
-     (rct-debuglog (format "%s %s %s --line=%d --column=%d %s"
-                           command opt (or rct-option-local "")
-                           (rct-current-line) (current-column)
-                           (if rct-use-test-script (rct-test-script-option-string) "")))
-     eval-buffer nil " *rct-error*")
+    (rct-shell-command
+     (format "%s %s %s --line=%d --column=%d %s"
+             command opt (or rct-option-local "")
+             (rct-current-line) (current-column)
+             (if rct-use-test-script (rct-test-script-option-string) ""))
+     eval-buffer)
     (message "")
     (eval (with-current-buffer eval-buffer
             (goto-char 1)
@@ -213,5 +234,177 @@ See also `rct-interactive'. "
   (find-file (shell-command-to-string
               (format "%s %s" ruby-toggle-file-command-name buffer-file-name))))
 
+;;;; rct-fork support
+(defun rct-fork (options)
+  "Run rct-fork.
+Rct-fork makes xmpfilter and completion MUCH FASTER because it pre-loads heavy libraries.
+When rct-fork is running, the mode-line indicates it to avoid unnecessary run.
+To kill rct-fork process, use \\[rct-fork-kill].
+"
+  (interactive "srct-fork options (-e CODE -I LIBDIR -r LIB): ")
+  (rct-fork-kill)
+  (rct-fork-minor-mode 1)
+  (start-process-shell-command
+   "rct-fork" "*rct-fork*" rct-fork-command-name options))
+(defun rct-fork-kill ()
+  "Kill rct-fork process invoked by \\[rct-fork]."
+  (interactive)
+  (when rct-fork-minor-mode
+    (rct-fork-minor-mode -1)
+    (interrupt-process "rct-fork")))
+(define-minor-mode rct-fork-minor-mode
+  "This minor mode is turned on when rct-fork is run.
+It is nothing but an indicator."
+  :lighter " <rct-fork>" :global t)
+
+;;;; unit tests
+(when (and (fboundp 'expectations))
+  (require 'ruby-mode)
+  (require 'el-mock nil t)
+  (expectations
+    (desc "comment-dwim advice")
+    (expect "# =>"
+      (with-temp-buffer
+        (ruby-mode)
+        (setq last-command nil)
+        (call-interactively 'comment-dwim)
+        (setq last-command 'comment-dwim)
+        (call-interactively 'comment-dwim)
+        (buffer-string)))
+    (expect (regexp "^1 +# =>")
+      (with-temp-buffer
+        (ruby-mode)
+        (insert "1")
+        (setq last-command nil)
+        (call-interactively 'comment-dwim)
+        (setq last-command 'comment-dwim)
+        (call-interactively 'comment-dwim)
+        (buffer-string)))
+
+    (desc "rct-current-line")
+    (expect 1
+      (with-temp-buffer
+        (rct-current-line)))
+    (expect 1
+      (with-temp-buffer
+        (insert "1")
+        (rct-current-line)))
+    (expect 2
+      (with-temp-buffer
+        (insert "1\n")
+        (rct-current-line)))
+    (expect 2
+      (with-temp-buffer
+        (insert "1\n2")
+        (rct-current-line)))
+
+    (desc "rct-save-position")
+    (expect (mock (set-window-start * 7) => nil)
+      (stub window-start => 7)
+      (with-temp-buffer
+        (insert "abcdef\nghi")
+        (rct-save-position #'ignore)))
+    (expect 2
+      (with-temp-buffer
+        (stub window-start => 1)
+        (stub set-window-start => nil)
+        (insert "abcdef\nghi")
+        (rct-save-position #'ignore)
+        (rct-current-line)))
+    (expect 3
+      (with-temp-buffer
+        (stub window-start => 1)
+        (stub set-window-start => nil)
+        (insert "abcdef\nghi")
+        (rct-save-position #'ignore)
+        (current-column)))
+
+    (desc "rct-interactive")
+    (expect '("read")
+      (let ((current-prefix-arg t))
+        (stub read-from-minibuffer => "read")
+        (rct-interactive)))
+    (expect '("-S ruby19")
+      (let ((current-prefix-arg nil)
+            (rct-option-local "-S ruby19"))
+        (stub read-from-minibuffer => "read")
+        (rct-interactive)))
+    (expect '("")
+      (let ((current-prefix-arg nil)
+            (rct-option-local))
+        (stub read-from-minibuffer => "read")
+        (rct-interactive)))
+
+    (desc "rct-shell-command")
+    (expect "1+1 # => 2\n"
+      (with-temp-buffer
+        (insert "1+1 # =>\n")
+        (rct-shell-command "xmpfilter")
+        (buffer-string)))
+
+    (desc "xmp")
+
+    (desc "xmpfilter-command")
+    (expect "xmpfilter --rails"
+      (let ((xmpfilter-command-name "xmpfilter"))
+        (with-temp-buffer
+          (insert "class TestFoo < Test::Unit::TestCase\n")
+          (xmpfilter-command "--rails"))))
+    (expect "xmpfilter "
+      (let ((xmpfilter-command-name "xmpfilter"))
+        (with-temp-buffer
+          (insert "context 'foo' do\n")
+          (xmpfilter-command))))
+    (expect "xmpfilter "
+      (let ((xmpfilter-command-name "xmpfilter"))
+        (with-temp-buffer
+          (insert "describe Array do\n")
+          (xmpfilter-command))))
+    (expect "xmpfilter --unittest --rails"
+      (let ((xmpfilter-command-name "xmpfilter"))
+        (with-temp-buffer
+          (insert "class TestFoo < Test::Unit::TestCase\n"
+                  "  def test_0\n"
+                  "    1 + 1 # =>\n"
+                  "  end\n"
+                  "end\n")
+          (xmpfilter-command "--rails"))))
+    (expect "xmpfilter --spec "
+      (let ((xmpfilter-command-name "xmpfilter"))
+        (with-temp-buffer
+          (insert "context 'foo' do\n"
+                  "  specify \"foo\" do\n"
+                  "    1 + 1 # =>\n"
+                  "  end\n"
+                  "end\n")
+          (xmpfilter-command))))
+    (expect "xmpfilter --spec "
+      (let ((xmpfilter-command-name "xmpfilter"))
+        (with-temp-buffer
+          (insert "describe Array do\n"
+                  "  it \"foo\" do\n"
+                  "    [1] + [1] # =>\n"
+                  "  end\n"
+                  "end\n")
+          (xmpfilter-command))))
+    (expect "xmpfilter "
+      (let ((xmpfilter-command-name "xmpfilter"))
+        (with-temp-buffer
+          (insert "1 + 2\n")
+          (xmpfilter-command))))
+
+    (desc "rct-fork")
+    (expect t
+      (stub start-process-shell-command => t)
+      (stub interrupt-process => t)
+      (rct-fork "-r activesupport")
+      rct-fork-minor-mode)
+    (expect nil
+      (stub start-process-shell-command => t)
+      (stub interrupt-process => t)
+      (rct-fork "-r activesupport")
+      (rct-fork-kill)
+      rct-fork-minor-mode)
+    ))
 
 (provide 'rcodetools)