rcodetools 0.4.0.0

data/lib/rcodetools/xmptestunitfilter.rb

@@ -0,0 +1,197 @@
+require 'rcodetools/xmpfilter'
+class XMPTestUnitFilter < XMPFilter
+  def initialize(opts = {})
+    super
+    @output_stdout = false
+    mod = @parentheses ? :WithParentheses : :Poetry
+    extend self.class.const_get(mod) 
+  end
+
+  private
+  def annotated_line(line, expression, runtime_data, idx)
+    indent =  /^\s*/.match(line)[0]
+    assertions(expression.strip, runtime_data, idx).map{|x| indent + x}.join("\n")
+  end
+
+  def prepare_line(expr, idx)
+    basic_eval = prepare_line_annotation(expr, idx)
+    %|begin; #{basic_eval}; rescue Exception; $stderr.puts("#{MARKER}[#{idx}] ~> " + $!.class.to_s); end|
+  end
+
+  def assertions(expression, runtime_data, index)
+    exceptions = runtime_data.exceptions
+    ret = []
+
+    unless (vars = runtime_data.bindings[index]).empty?
+      vars.each{|var| ret << equal_assertion(var, expression) }
+    end
+    if !(wanted = runtime_data.results[index]).empty? || !exceptions[index]
+      case (wanted[0][1] rescue 1)
+      when "nil"
+        ret.concat nil_assertion(expression)
+      else
+        case wanted.size
+        when 1
+          ret.concat _value_assertions(wanted[0], expression)
+        else
+          # discard values from multiple runs
+          ret.concat(["#xmpfilter: WARNING!! extra values ignored"] + 
+                     _value_assertions(wanted[0], expression))
+        end
+      end
+    else
+      ret.concat raise_assertion(expression, exceptions, index)
+    end
+
+    ret
+  end
+
+  OTHER = Class.new
+  def _value_assertions(klass_value_txt_pair, expression)
+    klass_txt, value_txt = klass_value_txt_pair
+    value = eval(value_txt) || OTHER.new
+    # special cases
+    value = nil if value_txt.strip == "nil"
+    value = false if value_txt.strip == "false"
+    value_assertions klass_txt, value_txt, value, expression
+  rescue Exception
+    return object_assertions(klass_txt, value_txt, expression)
+  end
+
+  def raise_assertion(expression, exceptions, index)
+    ["assert_raise(#{exceptions[index][0]}){#{expression}}"]
+  end
+
+  module WithParentheses
+    def nil_assertion(expression)
+      ["assert_nil(#{expression})"]
+    end
+
+    def value_assertions(klass_txt, value_txt, value, expression)
+      case value
+      when Float
+        ["assert_in_delta(#{value.inspect}, #{expression}, 0.0001)"]
+      when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
+        ["assert_equal(#{value_txt}, #{expression})"]
+      else
+        object_assertions(klass_txt, value_txt, expression)
+      end
+    end
+
+    def object_assertions(klass_txt, value_txt, expression)
+      [ "assert_kind_of(#{klass_txt}, #{expression})",
+        "assert_equal(#{value_txt.inspect}, #{expression}.inspect)" ]
+    end
+
+    def equal_assertion(expected, actual)
+      "assert_equal(#{expected}, #{actual})"
+    end
+  end
+
+  module Poetry
+    def nil_assertion(expression)
+      ["assert_nil #{expression}"]
+    end
+
+    def value_assertions(klass_txt, value_txt, value, expression)
+      case value
+      when Float
+        ["assert_in_delta #{value.inspect}, #{expression}, 0.0001"]
+      when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
+        ["assert_equal #{value_txt}, #{expression}"]
+      else
+        object_assertions klass_txt, value_txt, expression
+      end
+    end
+
+    def object_assertions(klass_txt, value_txt, expression)
+      [ "assert_kind_of #{klass_txt}, #{expression} ",
+        "assert_equal #{value_txt.inspect}, #{expression}.inspect" ] 
+    end
+
+    def equal_assertion(expected, actual)
+      "assert_equal #{expected}, #{actual}"
+    end
+  end
+end
+
+class XMPRSpecFilter < XMPTestUnitFilter
+  private
+  def execute(code)
+    codefile = "xmpfilter.rspec_tmpfile_#{Process.pid}.rb"
+    File.open(codefile, "w"){|f| f.puts code}
+    path = File.expand_path(codefile)
+    at_exit { File.unlink path if File.exist? path}
+    stdout, stderr = (1..2).map do |i|
+      fname = "xmpfilter.rspec_tmpfile_#{Process.pid}-#{i}.rb"
+      fullname = File.expand_path(fname)
+      at_exit { File.unlink fullname if File.exist? fullname}
+      File.open(fname, "w+")
+    end
+    args = *(interpreter_command << %["#{codefile}"] << "2>" << 
+             %["#{stderr.path}"] << ">" << %["#{stdout.path}"])
+    system(args.join(" "))
+    [stdout, stderr]
+  end
+
+  def interpreter_command
+    [@interpreter] + @libs.map{|x| "-r#{x}"}
+  end
+
+  def raise_assertion(expression, exceptions, index)
+    ["lambda{#{expression}}.should_raise #{exceptions[index][0]}"]
+  end
+
+  module WithParentheses
+    def nil_assertion(expression)
+      ["(#{expression}).should_be_nil"]
+    end
+    
+    def value_assertions(klass_txt, value_txt, value, expression)
+      case value
+      when Float
+        ["(#{expression}).should_be_close #{value.inspect}, 0.0001"]
+      when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
+        ["(#{expression}).should_equal #{value_txt}"]
+      else
+        object_assertions klass_txt, value_txt, expression
+      end
+    end
+
+    def object_assertions(klass_txt, value_txt, expression)
+      [ "(#{expression}).should_be_a_kind_of #{klass_txt}",
+        "(#{expression}.inspect).should_equal #{value_txt.inspect}" ]
+    end
+
+    def equal_assertion(expected, actual)
+      "(#{actual}).should_equal #{expected}"
+    end
+  end
+
+  module Poetry
+    def nil_assertion(expression)
+      ["#{expression}.should_be_nil"]
+    end
+
+    def value_assertions(klass_txt, value_txt, value, expression)
+      case value
+      when Float
+        ["#{expression}.should_be_close #{value.inspect}, 0.0001"]
+      when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
+        ["#{expression}.should_equal #{value_txt}"]
+      else
+        object_assertions klass_txt, value_txt, expression
+      end
+    end
+
+    def object_assertions(klass_txt, value_txt, expression)
+      [ "#{expression}.should_be_a_kind_of #{klass_txt}",
+        "#{expression}.inspect.should_equal #{value_txt.inspect}" ]
+    end
+
+    def equal_assertion(expected, actual)
+      "#{actual}.should_equal #{expected}"
+    end
+  end
+end
+

data/rcodetools.el

@@ -0,0 +1,162 @@
+;;; rcodetools.el -- annotation / accurate completion / browsing documentation
+
+;;; Copyright (c) 2006 rubikitch <rubikitch@ruby-lang.org>
+;;;
+;;; Use and distribution subject to the terms of the Ruby license.
+
+(defvar xmpfilter-command-name "ruby -S xmpfilter"
+  "The xmpfilter command name.")
+(defvar rct-doc-command-name "ruby -S rct-doc"
+  "The rct-doc command name.")
+(defvar rct-complete-command-name "ruby -S rct-complete"
+  "The rct-complete command name.")
+(defvar rct-option-history nil)                ;internal
+(defvar rct-option-local nil)     ;internal
+(make-variable-buffer-local 'rct-option-local)
+
+(defadvice comment-dwim (around rct-hack activate)
+  "If comment-dwim is successively called, add => mark."
+  (if (and (eq major-mode 'ruby-mode)
+           (eq last-command 'comment-dwim)
+           ;; TODO =>check
+           )
+      (insert "=>")
+    ad-do-it))
+;; To remove this advice.
+;; (progn (ad-disable-advice 'comment-dwim 'around 'rct-hack) (ad-update 'comment-dwim)) 
+
+(defun rct-current-line ()
+  "Return the vertical position of point..."
+  (+ (count-lines (point-min) (point))
+     (if (= (current-column) 0) 1 0)))
+
+(defun rct-save-position (proc)
+  "Evaluate proc with saving current-line/current-column/window-start."
+  (let ((line (rct-current-line))
+        (col  (current-column))
+        (wstart (window-start)))
+    (funcall proc)
+    (goto-char (point-min))
+    (forward-line (1- line))
+    (move-to-column col)
+    (set-window-start (selected-window) wstart)))
+
+(defun rct-interactive ()
+  "All the rcodetools-related commands with prefix args read rcodetools' common option. And store option into buffer-local variable."
+  (list
+   (let ((option (or rct-option-local "")))
+     (if current-prefix-arg
+         (setq rct-option-local
+               (read-from-minibuffer "rcodetools option: " option nil nil 'rct-option-history))
+       option))))  
+
+(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))))
+
+(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))))
+
+;;;; Completion
+(defvar rct-method-completion-table nil) ;internal
+(defvar rct-complete-symbol-function 'rct-complete-symbol--normal
+  "Function to use rct-complete-symbol.")
+;; (setq rct-complete-symbol-function 'rct-complete-symbol--icicles)
+
+(defun rct-complete-symbol ()
+  "Perform ruby method and class completion on the text around point.
+This command only calls a function according to `rct-complete-symbol-function'.
+See also `rct-interactive', `rct-complete-symbol--normal', and `rct-complete-symbol--icicles'."
+  (interactive)
+  (call-interactively rct-complete-symbol-function))
+
+(defun rct-complete-symbol--normal (&optional option)
+  "Perform ruby method and class completion on the text around point.
+See also `rct-interactive'."
+  (interactive (rct-interactive))
+  (let ((end (point)) beg
+	pattern
+	completion)
+    (setq completion (rct-try-completion)) ; set also pattern / completion
+    (save-excursion
+      (search-backward pattern)
+      (setq beg (point)))
+    (cond ((eq completion t)            ;sole completion
+           (message "%s" "Sole completion"))
+	  ((null completion)            ;no completions
+	   (message "Can't find completion for \"%s\"" pattern)
+	   (ding))
+	  ((not (string= pattern completion)) ;partial completion
+           (delete-region beg end)      ;delete word
+	   (insert completion)
+           (message ""))
+	  (t
+	   (message "Making completion list...")
+	   (with-output-to-temp-buffer "*Completions*"
+	     (display-completion-list
+	      (all-completions pattern rct-method-completion-table)))
+	   (message "Making completion list...%s" "done")))))
+
+;; (define-key ruby-mode-map "\M-\C-i" 'rct-complete-symbol)
+
+(defun rct-exec-and-eval (command opt)
+  "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)
+     (format "%s %s %s --line=%d --column=%d"
+             command opt (or rct-option-local "")
+             (rct-current-line) (current-column))
+     eval-buffer)
+    (message "")
+    (eval (with-current-buffer eval-buffer
+            (goto-char 1)
+            (read (current-buffer))))))
+
+(defun rct-try-completion ()
+  "Evaluate the output of rct-complete."
+  (rct-exec-and-eval rct-complete-command-name "--completion-emacs"))
+
+;;;; TAGS or Ri
+(autoload 'ri "ri-ruby" nil t)
+(defvar rct-find-tag-if-available t
+  "If non-nil and the method location is in TAGS, go to the location instead of show documentation.")
+(defun rct-ri (&optional option)
+  "Browse Ri document at the point.
+If `rct-find-tag-if-available' is non-nil, search the definition using TAGS.
+
+See also `rct-interactive'. "
+  (interactive (rct-interactive))
+  (rct-exec-and-eval
+   rct-doc-command-name
+   (concat "--ri-emacs --use-method-analyzer "
+           (if (buffer-file-name)
+               (concat "--filename=" (buffer-file-name))
+             ""))))
+
+(defun rct-find-tag-or-ri (fullname)
+  (if (not rct-find-tag-if-available)
+      (ri fullname)
+    (condition-case err
+        (let ()
+          (visit-tags-table-buffer)
+          (find-tag-in-order (concat "::" fullname) 'search-forward '(tag-exact-match-p) nil  "containing" t))
+      (error
+       (ri fullname)))))
+
+(provide 'rcodetools)

data/rcodetools.vim

@@ -0,0 +1,118 @@
+" Copyright (C) 2006    Mauricio Fernandez <mfp@acm.org>
+" rcodetools support plugin
+"
+
+if exists("loaded_rcodetools")
+    finish
+endif
+
+let loaded_rcodetools = 1
+let s:save_cpo = &cpo
+set cpo&vim
+
+"{{{ set s:sid
+
+map <SID>xx <SID>xx
+let s:sid = maparg("<SID>xx")
+unmap <SID>xx
+let s:sid = substitute(s:sid, 'xx', '', '')
+
+"{{{ function: s:spellgetoption(name, default)
+" grab a user-specified option to override the default provided.  options are
+" searched in the window, buffer, then global spaces.
+function! s:GetOption(name, default)
+    if exists("w:{&filetype}_" . a:name)
+        execute "return w:{&filetype}_".a:name
+    elseif exists("w:" . a:name)
+        execute "return w:".a:name
+    elseif exists("b:{&filetype}_" . a:name)
+        execute "return b:{&filetype}_".a:name
+    elseif exists("b:" . a:name)
+        execute "return b:".a:name
+    elseif exists("g:{&filetype}_" . a:name)
+        execute "return g:{&filetype}_".a:name
+    elseif exists("g:" . a:name)
+        execute "return g:".a:name
+    else
+        return a:default
+    endif
+endfunction
+
+"{{{ IsOptionSet
+function! s:IsOptionSet(name)
+    let bogus_val = "df hdsoi3y98 hjsdfhdkj"
+    return s:GetOption(a:name, bogus_val) == bogus_val ? 0 : 1
+endfunction
+
+
+"{{{ RCT_completion function
+let s:rct_completion_col = 0
+let s:rct_tmpfile = ""
+
+function! <SID>RCT_completion(findstart, base)
+    if a:findstart
+	let s:rct_completion_col = col('.') - 1
+	let s:rct_tmpfile = "tmp-rcodetools" . strftime("Y-%m-%d-%T.rb")
+        silent exec ":w " . s:rct_tmpfile
+	return strridx(getline('.'), '.', col('.')) + 1
+    else
+	let line    = line('.')
+	let column  = s:rct_completion_col
+	let command = "rct-complete --line=" . line . " --column=" . column . " " . s:rct_tmpfile
+	let ret = split(system(command))
+	call delete(s:rct_tmpfile)
+	return ret
+    endif
+endfunction
+
+"{{{ ri functions
+
+function! <SID>RCT_new_ri_window()
+  execute "new"
+  execute "set bufhidden=delete buftype=nofile noswapfile nobuflisted"
+  execute 'nmap <buffer><silent> <C-T> 2u'
+  execute 'nmap <buffer><silent> <C-]> :call' . s:sid . 'RCT_execute_ri(expand("<cWORD>"))<cr>'
+endfunction
+
+function! <SID>RCT_execute_ri(query_term)
+  silent %delete _
+  let term = matchstr(a:query_term, '\v[^,.;]+')
+  let cmd = s:GetOption("RCT_ri_cmd", "fri -f plain ")
+  let text = system(cmd . "'" . term . "'")
+  call append(0, split(text, "\n"))
+  normal gg
+endfunction
+
+function! RCT_find_tag_or_ri(fullname)
+    " rubikitch: modified for rtags-compatible tags
+    let tagname = '::' . a:fullname
+    let tagresults = taglist(tagname)
+    if len(tagresults) != 0
+	execute "tjump " . tagname
+    else
+        call <SID>RCT_new_ri_window()
+        call <SID>RCT_execute_ri(a:fullname)
+    endif
+endfunction
+
+function! <SID>RCT_smart_ri()
+  let tmpfile = "tmp-rcodetools" . strftime("Y-%m-%d-%T.rb")
+  silent exec ":w " . tmpfile
+
+  let line    = line('.')
+  let column  = col('.') - 1
+  let command = "rct-doc --ri-vim --line=" . line . " --column=" . column . " " . tmpfile
+  "let term = matchstr(system(command), "\\v[^\n]+")
+  exec system(command)
+  call delete(tmpfile)
+  "call RCT_find_tag_or_ri(term)
+endfunction
+
+"{{{ bindings and au
+
+execute "au Filetype ruby setlocal completefunc=" . s:sid . "RCT_completion"
+execute 'au Filetype ruby nmap <buffer><silent> <C-]> :exec "call ' .
+         \ 'RCT_find_tag_or_ri(''" . expand("<cword>") . "'')"<cr>'
+execute 'au Filetype ruby nmap <buffer><silent>' . s:GetOption("RCT_ri_binding", "<LocalLeader>r") . 
+        \ ' :call ' .  s:sid . 'RCT_smart_ri()<cr>'
+let &cpo = s:save_cpo