rcodetools 0.7.0.0 → 0.8.0.0

data/bin/rct-complete

@@ -1,4 +1,4 @@
-#! /home/batsman/usr/bin/ruby
+#! /home/mfp/ruby1.8/bin/ruby
 require 'rcodetools/xmpfilter'
 require 'rcodetools/completion'
 require 'rcodetools/options'

data/bin/rct-doc

@@ -1,4 +1,4 @@
-#! /home/batsman/usr/bin/ruby
+#! /home/mfp/ruby1.8/bin/ruby
 require 'rcodetools/xmpfilter'
 require 'rcodetools/doc'
 require 'rcodetools/options'

data/bin/rct-meth-args

@@ -1,4 +1,4 @@
-#! /home/batsman/usr/bin/ruby
+#! /home/mfp/ruby1.8/bin/ruby
 # Copyright (c) 
 #  2006-2007 Mauricio Fernandez <mfp@acm.org>    http://eigenclass.org
 #  2006-2007 rubikitch <rubikitch@ruby-lang.org> http://www.rubyist.net/~rubikitch/
@@ -6,6 +6,7 @@
 # Use and distribution subject to the same conditions as Ruby.
 
 require 'rcodetools/options'
+include Rcodetools
 $VERBOSE = nil
 $__method_args_off = true
 
@@ -22,6 +23,7 @@ rct-meth-args [-Idirectory] [-i] [-m] [-c] [-n] <file> [<file> ...]
 
 -n            print the filename and line number with output lines
 -t            generate TAGS output
+--summarize   summary output sorted by method name
 
 The given files will be #require()d in order.
 Examples:
@@ -29,7 +31,7 @@ Examples:
    rct-meth-args thread
    rct-meth-args -c rubygems
 EOF
-  exit
+  exit                          # '
 end
 
 def debugprint(*args)
@@ -98,6 +100,33 @@ module MethodArgs
     end
   end
 
+  class SummarizePrinter
+    def initialize
+      @hash = Hash.new
+      at_exit { print_result }
+    end
+
+    def method_info(io, x)
+      @io = io
+      prefix = x[:location] ? "#{x[:location].filename}:#{x[:location].lineno}:" : ""
+      (@hash[x[:meth]]||=[]) << "#{prefix}#{x[:fullname]}#{x[:arg_desc]}" unless x[:klass].to_s == "<Struct>"
+    end
+
+    def included_location(io, x)
+      # not implemented
+    end
+
+    def print_result
+      @hash.keys.sort.each do |meth|
+        @io.puts meth
+        @hash[meth].each do |line|
+          @io.puts line
+        end
+        @io.puts
+      end
+    end
+  end
+
   class TagsPrinter
     def initialize
       @previous_filename = ""
@@ -129,6 +158,7 @@ module MethodArgs
     arg_desc = " " + arg_desc unless arg_desc.empty?
     flag = is_singleton ? "." : "#"
     x = { :arg_desc => arg_desc, :klass => klass,
+      :meth => meth.to_s,
       :fullname => [klass, flag, meth].join,
       :location => with_location && location,
     }
@@ -255,6 +285,7 @@ ARGV.each do |arg|
   case arg
   when "-n"; $__with_location = true
   when "-t"; $__printer = TagsPrinter.new; $__with_location = true
+  when "--summarize"; $__printer = SummarizePrinter.new
   when /-I(.+)$/; $:.unshift $1
   when "-I"; i_opt_p = true
   when "--dev"; OptionHandler.auto_include_paths($:, Dir.pwd)

data/bin/xmpfilter

@@ -1,4 +1,4 @@
-#! /home/batsman/usr/bin/ruby
+#! /home/mfp/ruby1.8/bin/ruby
 require 'rcodetools/xmpfilter'
 require 'rcodetools/options'
 
@@ -25,6 +25,10 @@ opts = OptionParser.new do |opts|
     klass = XMPRSpecFilter
     options[:interpreter] = "spec"
   end
+  opts.on("--expectations", "Complete expectations expectations.") do
+    require 'rcodetools/xmptestunitfilter'
+    klass = XMPExpectationsFilter
+  end
   opts.on("-m", "--markers", "Add # => markers.") do
     klass = XMPAddMarkers
   end

data/lib/rcodetools/compat.rb

@@ -0,0 +1,14 @@
+if RUBY_VERSION >= "1.9"
+  class String
+    alias :each :each_line
+    include Enumerable
+  end
+
+  module Enumerable
+    alias :enum_with_index :each_with_index
+  end
+
+  class Array
+    alias :to_s :join
+  end
+end

data/lib/rcodetools/completion.rb

@@ -81,8 +81,8 @@ module ProcessParticularLine
   def aref_or_aset?(right_stripped, last_char)
     if last_char == ?[
       case right_stripped
-      when /\]\s*=/: "[]="
-      when /\]/:     "[]"
+      when /\]\s*=/ then "[]="
+      when /\]/     then "[]"
       end
     end
   end
@@ -182,7 +182,7 @@ XXX
     code = <<-EOC
   #{result} = #{v}.method(#{meth}).inspect.match( %r[\\A#<(?:Unbound)?Method: (.*?)>\\Z] )[1].sub(/\\A.*?\\((.*?)\\)(.*)\\Z/){ "\#{$1}\#{$2}" }.sub(/#<Class:(.*?)>#/) { "\#{$1}." }
   #{result} = #{v}.to_s + ".new" if #{result} == 'Class#new' and #{v}.private_method_defined?(:initialize)
-  #{result} = "Object#" + #{meth} if #{result} =~ /^Kernel#/ and Kernel.instance_methods(false).include? #{meth}
+  #{result} = "Object#" + #{meth} if #{result} =~ /^Kernel#/ and Kernel.instance_methods(false).map{|x| x.to_s}.include? #{meth}
   #{result}
 EOC
   end
@@ -212,7 +212,9 @@ class XMPCompletionFilter < XMPFilter
 
   def methods_map_code(recv)
     # delimiter is \0
-    %Q[map{|m| "\#{m}\\0" + #{magic_help_code((recv), 'm')}}]
+    m = "#{VAR}_m"
+    mhc = magic_help_code((recv), m)
+    %Q[map{|%s| "\#{%s}\\0" + %s}] % [m, m, mhc]
   end
 
   def split_method_info(minfo)
@@ -235,7 +237,7 @@ class XMPCompletionFilter < XMPFilter
       %Q[#$1.constants + #$1.methods(true).#{methods_map_code($1)}]
     when /^[A-Z]\w*$/           # normal constants
       __prepare_line 'nil', 'Module.constants', '%n'
-    when /^(.*::.+)\.(.+)$/       # toplevel class methods
+    when /^(.*::.+)\.(.*)$/       # toplevel class methods
       @prefix = $2
       __prepare_line $1, "#$1.methods",
       %Q[%n.#{methods_map_code($1)}]
@@ -274,7 +276,7 @@ class XMPCompletionFilter < XMPFilter
     idx = 1
     oneline_ize(<<EOC)
 #{rcv} = (#{recv})
-#{v} = (#{all_completion_expr}).grep(/^#{Regexp.quote(@prefix)}/)
+#{v} = (#{all_completion_expr}).map{|x| x.to_s}.grep(/^#{Regexp.quote(@prefix)}/)
 #{rcv} = Module === #{rcv} ? #{rcv} : #{rcv}.class
 $stderr.puts("#{MARKER}[#{idx}] => " + #{rcv}.to_s  + " " + #{v}.join(" ")) || #{v}
 exit

data/lib/rcodetools/fork.rb

@@ -39,7 +39,7 @@ rct-fork and rct-fork-client (we) are originally ruby_fork/ruby_fork_client in Z
 Completion or document browsing in a script with heavy libraries such as Rails takes a significant latency.
 We eliminate constant overhead of loading heavy libraries.
 
-rct-fork loads libraries you want to pre-load and opens up a server socket and waits for connection. When a connection comes in rct-fork forks to make a copy of the environment.
+rct-fork loads libraries you want to pre-load and opens up a server socket and waits for connection. When a connection comes in rct-fork forks to make a copy of the environment. rct-fork loads rubygems at startup.
 
 rct-fork-client connects to the rct-fork server and runs script in server's environment.
 
@@ -89,10 +89,9 @@ XXX
     Process.setsid
     fork and exit!
 
-    # Rcodetools version does not have to reopen IOs because they are already reopened.
-#     STDIN.reopen io
-#     STDOUT.reopen io
-#     STDERR.reopen io
+    STDIN.reopen io
+    STDOUT.reopen io
+    STDERR.reopen io
 
     yield if block_given?
   end
@@ -170,6 +169,10 @@ XXX
   end
 
   def self.start_server(args = ARGV)
+    begin
+      require 'rubygems'
+    rescue LoadError
+    end
     write_pwd
     settings = parse_server_args args
     setup_environment settings
@@ -212,9 +215,13 @@ XXX
     settings[:extra_paths].flatten!
     settings[:extra_paths].each { |dir| $:.unshift dir }
 
-    settings[:requires].each { |file| require file }
-
-    settings[:code].each { |code| eval code }
+    begin
+      settings[:requires].each { |file| require file }
+      settings[:code].each { |code| eval code, TOPLEVEL_BINDING }
+    rescue Exception
+      $@.reject! {|s| s =~ %r!rcodetools/fork\.rb!}
+      raise
+    end
   end
 
 end

data/lib/rcodetools/options.rb

@@ -66,6 +66,12 @@ module OptionHandler
     on("--debug", "Write transformed source code to xmp-tmp.PID.rb.") do
       options[:dump] = "xmp-tmp.#{Process.pid}.rb"
     end
+    on("--tmpfile", "--tempfile", "Use tmpfile instead of open3. (non-windows)") do
+      options[:execute_ruby_tmpfile] = true
+    end
+    on("-w N", "--width N", Integer, "Set width of multi-line annotation. (xmpfilter only)") do |width|
+      options[:width] = width
+    end
     separator ""
     on("-h", "--help", "Show this message") do
       puts self
@@ -110,6 +116,7 @@ DEFAULT_OPTIONS = {
   :interpreter       => "ruby",
   :options => ["hoge"],
   :min_codeline_size => 50,
+  :width             => 79,
   :libs              => [],
   :evals             => [],
   :include_paths     => [],
@@ -124,5 +131,6 @@ DEFAULT_OPTIONS = {
   :detect_rct_fork   => false,
   :use_rbtest        => false,
   :detect_rbtest     => false,
+  :execute_ruby_tmpfile => false,
   }
 end                             # /Rcodetools

data/lib/rcodetools/xmpfilter.rb

@@ -1,14 +1,17 @@
 #!/usr/bin/env ruby
-# Copyright (c) 2005-2007 Mauricio Fernandez <mfp@acm.org> http://eigenclass.org
+# Copyright (c) 2005-2008 Mauricio Fernandez <mfp@acm.org> http://eigenclass.org
 #                         rubikitch <rubikitch@ruby-lang.org>
 # Use and distribution subject to the terms of the Ruby license.
 
+ENV['HOME'] ||= "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}"
 require 'rcodetools/fork_config'
+require 'rcodetools/compat'
+require 'tmpdir'
 
 module Rcodetools
 
 class XMPFilter
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 
   MARKER = "!XMP#{Time.new.to_i}_#{Process.pid}_#{rand(1000000)}!"
   XMP_RE = Regexp.new("^" + Regexp.escape(MARKER) + '\[([0-9]+)\] (=>|~>|==>) (.*)')
@@ -21,17 +24,18 @@ class XMPFilter
                      :include_paths => [], :warnings => true, 
                      :use_parentheses => true}
 
-  def self.windows?
+  def windows?
     /win|mingw/ =~ RUBY_PLATFORM && /darwin/ !~ RUBY_PLATFORM
   end
 
-  Interpreter = Struct.new(:options, :execute_method, :accept_debug, :chdir_proc)
+  Interpreter = Struct.new(:options, :execute_method, :accept_debug, :accept_include_paths, :chdir_proc)
   INTERPRETER_RUBY = Interpreter.new(["-w"],
-                                     windows? ? :execute_tmpfile : :execute_popen,
-                                     true, nil)
-  INTERPRETER_RBTEST = Interpreter.new(["-S", "rbtest"], :execute_script, false, nil)
-  INTERPRETER_FORK = Interpreter.new(["-S", "rct-fork-client"], :execute_tmpfile, false,
-                                     lambda { Fork::chdir_fork_directory })
+    :execute_ruby, true, true, nil)
+  INTERPRETER_RBTEST = Interpreter.new(["-S", "rbtest"],
+    :execute_script, false, false, nil)
+  INTERPRETER_FORK = Interpreter.new(["-S", "rct-fork-client"],
+    :execute_tmpfile, false, true,
+    lambda { Fork::chdir_fork_directory })
                                      
   def self.detect_rbtest(code, opts)
     opts[:use_rbtest] ||= (opts[:detect_rbtest] and code =~ /^=begin test./) ? true : false
@@ -58,7 +62,10 @@ class XMPFilter
     test_script = options[:test_script]
     test_method = options[:test_method]
     filename = options[:filename]
+    @execute_ruby_tmpfile = options[:execute_ruby_tmpfile]
     @postfix = ""
+    @stdin_path = nil
+    @width = options[:width]
     
     initialize_rct_fork if options[:detect_rct_fork]
     initialize_rbtest if options[:use_rbtest]
@@ -82,7 +89,7 @@ class XMPFilter
       basedir = common_path(test_script, filename)
       relative_filename = filename[basedir.length+1 .. -1].sub(%r!^lib/!, '')
       @evals << %Q!$LOADED_FEATURES << #{relative_filename.dump}!
-      @evals << %Q!require 'test/unit'!
+      @evals << safe_require_code('test/unit')
       @evals << %Q!load #{test_script.dump}!
     end
     test_method = get_test_method_from_lineno(test_script, test_method.to_i) if test_method =~ /^\d/
@@ -114,24 +121,30 @@ class XMPFilter
     ret
   end
 
+  SINGLE_LINE_RE = /^(?!(?:\s+|(?:\s*#.+)?)# ?=>)(.*) # ?=>.*/
+  MULTI_LINE_RE = /^(.*)\n(( *)# ?=>.*(?:\n|\z))(?: *#    .*\n)*/
   def annotate(code)
     idx = 0
-    newcode = code.gsub(/^(.*) # =>.*/){|l| prepare_line($1, idx += 1) }
-    if @dump
-      File.open(@dump, "w"){|f| f.puts newcode}
-    end
+    newcode = code.gsub(SINGLE_LINE_RE){ prepare_line($1, idx += 1) }
+    newcode.gsub!(MULTI_LINE_RE){ prepare_line($1, idx += 1, true)}
+    File.open(@dump, "w"){|f| f.puts newcode} if @dump
     stdout, stderr = execute(newcode)
     output = stderr.readlines
     runtime_data = extract_data(output)
     idx = 0
-    annotated = code.gsub(/^(.*) # =>.*/) do |l|
+    annotated = code.gsub(SINGLE_LINE_RE) { |l|
       expr = $1
       if /^\s*#/ =~ l
         l 
       else
         annotated_line(l, expr, runtime_data, idx += 1)
       end
-    end.gsub(/ # !>.*/, '').gsub(/# (>>|~>)[^\n]*\n/m, "");
+    }
+    annotated.gsub!(/ # !>.*/, '')
+    annotated.gsub!(/# (>>|~>)[^\n]*\n/m, "");
+    annotated.gsub!(MULTI_LINE_RE) { |l|
+      annotated_multi_line(l, $1, $3, runtime_data, idx += 1)
+    }
     ret = final_decoration(annotated, output)
     if @output_stdout and (s = stdout.read) != ""
       ret << s.inject(""){|s,line| s + "# >> #{line}".chomp + "\n" }
@@ -143,13 +156,28 @@ class XMPFilter
     "#{expression} # => " + (runtime_data.results[idx].map{|x| x[1]} || []).join(", ")
   end
   
-  def prepare_line_annotation(expr, idx)
+  def annotated_multi_line(line, expression, indent, runtime_data, idx)
+    pretty = (runtime_data.results[idx].map{|x| x[1]} || []).join(", ")
+    first, *rest = pretty.to_a
+    rest.inject("#{expression}\n#{indent}# => #{first}") {|s, l| s << "#{indent}#    " << l }
+  end
+  
+  def prepare_line_annotation(expr, idx, multi_line=false)
     v = "#{VAR}"
     blocal = "__#{VAR}"
     blocal2 = "___#{VAR}"
+    lastmatch = "____#{VAR}"
+    if multi_line
+      pp = safe_require_code "pp"
+      result = "((begin; #{lastmatch} = $~; PP.pp(#{v}, '', #{@width-5}).gsub(/\\r?\\n/, 'PPPROTECT'); ensure; $~ = #{lastmatch} end))"
+    else
+      pp = ''
+      result = "#{v}.inspect"
+    end
     oneline_ize(<<-EOF).chomp
+#{pp}
 #{v} = (#{expr})
-$stderr.puts("#{MARKER}[#{idx}] => " + #{v}.class.to_s + " " + #{v}.inspect) || begin
+$stderr.puts("#{MARKER}[#{idx}] => " + #{v}.class.to_s + " " + #{result}) || begin
   $stderr.puts local_variables
   local_variables.each{|#{blocal}|
     #{blocal2} = eval(#{blocal})
@@ -168,6 +196,17 @@ end || #{v}
   end
   alias_method :prepare_line, :prepare_line_annotation
 
+  def safe_require_code(lib)
+    oldverbose = "$#{VAR}_old_verbose"
+    "#{oldverbose} = $VERBOSE; $VERBOSE = false; require '#{lib}'; $VERBOSE = #{oldverbose}"
+  end
+  private :safe_require_code
+
+  def execute_ruby(code)
+    meth = (windows? or @execute_ruby_tmpfile) ? :execute_tmpfile : :execute_popen
+    __send__ meth, code
+  end
+
   def execute_tmpfile(code)
     ios = %w[_ stdin stdout stderr]
     stdin, stdout, stderr = (1..3).map do |i|
@@ -182,6 +221,7 @@ end || #{v}
     end
     stdin.puts code
     stdin.close
+    @stdin_path = File.expand_path stdin.path
     exe_line = <<-EOF.map{|l| l.strip}.join(";")
       $stdout.reopen('#{File.expand_path(stdout.path)}', 'w')
       $stderr.reopen('#{File.expand_path(stderr.path)}', 'w')
@@ -209,20 +249,25 @@ end || #{v}
   end
 
   def execute_script(code)
-    codefile = "xmpfilter.tmpfile_#{Process.pid}.rb"
-    File.open(codefile, "w"){|f| f.puts code}
-    path = File.expand_path(codefile)
+    path = File.expand_path("xmpfilter.tmpfile_#{Process.pid}.rb", Dir.tmpdir)
+    File.open(path, "w"){|f| f.puts code}
     at_exit { File.unlink path if File.exist? path}
-    stdout, stderr = (1..2).map do |i|
+    stdout_path, stderr_path = (1..2).map do |i|
       fname = "xmpfilter.tmpfile_#{Process.pid}-#{i}.rb"
-      fullname = File.expand_path(fname)
-      at_exit { File.unlink fullname if File.exist? fullname}
-      File.open(fname, "w+")
+      File.expand_path(fname, Dir.tmpdir)
     end
-    args = *(interpreter_command << %["#{codefile}"] << "2>" << 
-             %["#{stderr.path}"] << ">" << %["#{stdout.path}"])
+    args = *(interpreter_command << %["#{path}"] << "2>" << 
+      %["#{stderr_path}"] << ">" << %["#{stdout_path}"])
     system(args.join(" "))
-    [stdout, stderr]
+    
+    [stdout_path, stderr_path].map do |fullname|
+      f = File.open(fullname, "r")
+      at_exit {
+        f.close unless f.closed?
+        File.unlink fullname if File.exist? fullname
+      }
+      f
+    end
   end
 
   def execute(code)
@@ -232,7 +277,7 @@ end || #{v}
   def interpreter_command
     r = [ @interpreter ] + @interpreter_info.options
     r << "-d" if $DEBUG and @interpreter_info.accept_debug
-    r << "-I#{@include_paths.join(":")}" unless @include_paths.empty?
+    r << "-I#{@include_paths.join(":")}" if @interpreter_info.accept_include_paths and !@include_paths.empty?
     @libs.each{|x| r << "-r#{x}" } unless @libs.empty?
     (r << "-").concat @options unless @options.empty?
     r
@@ -247,7 +292,7 @@ end || #{v}
       case op
       when "=>"
         klass, value = /(\S+)\s+(.*)/.match(result).captures
-        results[result_id.to_i] << [klass, value]
+        results[result_id.to_i] << [klass, value.gsub(/PPPROTECT/, "\n")]
       when "~>"
         exceptions[result_id.to_i] << result
       when "==>"
@@ -273,14 +318,16 @@ end || #{v}
       end
     end
     output = output.reject{|x| /^-:[0-9]+: warning/.match(x)}
-    if exception = /^-:[0-9]+:.*/m.match(output.join)
-      ret << exception[0].map{|line| "# ~> " + line }
+    if exception = /^-e?:[0-9]+:.*|^(?!!XMP)[^\n]+:[0-9]+:in .*/m.match(output.join)
+      err = exception[0]
+      err.gsub!(Regexp.union(@stdin_path), '-') if @stdin_path
+      ret << err.map{|line| "# ~> " + line }
     end
     ret
   end
 
   def oneline_ize(code)
-    "((" + code.gsub(/\r?\n|\r/, ';') + "))#{@postfix}\n"
+    "((" + code.gsub(/\r?\n|\r/, ';') + "));#{@postfix}\n"
   end
 
   def debugprint(*args)