rcodetools 0.4.0.0

data/Rakefile.method_analysis

@@ -0,0 +1,30 @@
+
+# Rake tasks to generate TAGS and gather method analysis information.
+# See README.method_analysis for more information.
+
+## my standard Rakefile
+task :tags => "TAGS"
+
+desc "Generate method_analysis by ruby -rmethod_analyzer."
+task :analyze => [:_prepare_method_analyze, :tags] do
+  at_exit { sh "ls -l method_analysis" }
+end
+
+task :_prepare_method_analyze do
+  ENV['METHOD_ANALYZER_FORMAT']="marshal"
+  sh "rm -f method_analysis"
+  puts "generating method_analysis"
+end
+
+## application-specific Rakefile (RTtool)
+task :analyze do
+  sh "ruby -Ilib -rmethod_analyzer test/test.rb"
+  sh "ruby -Ilib -rmethod_analyzer test/test-rt2html-lib.rb"
+  sh "ruby -Ilib -rmethod_analyzer test/test-rtparser.rb"
+end
+
+file "TAGS" => FileList["lib/rt/*.rb"] do
+  sh "method_args.rb -t lib/rt/*.rb > TAGS"
+end
+
+

data/THANKS

@@ -0,0 +1,6 @@
+Some names forgotten, tell me if you care :) -- mfp
+
+rubikitch
+* expanded xmp3.rb (a previous version of xmpfilter.rb) to support RSpec expectations
+* wrote the elisp magic to use xmpfilter.rb with emacs
+* made the 100% accurate, editor-independent completion system

data/bin/rct-complete

@@ -0,0 +1,37 @@
+#! /home/batsman/usr//bin/ruby
+require 'rcodetools/xmpfilter'
+require 'rcodetools/completion'
+require 'rcodetools/options'
+
+options = DEFAULT_OPTIONS
+klass = XMPCompletionFilter
+
+opts = OptionParser.new do |opts|
+  opts.extend OptionHandler
+  opts.set_banner
+
+  opts.separator ""
+  opts.separator "Modes:"
+  opts.on("-C", "--completion", "List completion candidates.(default)") do
+    klass = XMPCompletionFilter
+  end
+  opts.on("--completion-emacs", "Generate completion code for Emacs.") do
+    klass = XMPCompletionEmacsFilter
+  end
+  opts.on("--completion-emacs-icicles", "Generate completion code for Emacs/Icicles.") do
+    klass = XMPCompletionEmacsIciclesFilter
+  end
+
+  opts.handle_position options
+  opts.handle_interpreter options
+  opts.handle_misc options
+end
+
+set_extra_opts options
+opts.parse!(ARGV)
+
+targetcode = ARGF.read
+Dir.chdir options[:wd] if options[:wd]
+
+# Do the job. dispatched by klass.
+puts klass.run(targetcode, options)

data/bin/rct-doc

@@ -0,0 +1,50 @@
+#! /home/batsman/usr//bin/ruby
+require 'rcodetools/xmpfilter'
+require 'rcodetools/doc'
+require 'rcodetools/options'
+
+options = DEFAULT_OPTIONS
+klass = XMPDocFilter
+
+opts = OptionParser.new do |opts|
+  opts.extend OptionHandler
+  opts.set_banner
+
+  opts.separator ""
+  opts.separator "Modes:"
+  opts.on("-D", "--doc", "Print callee method with class.(default)") do
+    klass = XMPDocFilter
+  end
+  opts.on("--refe", "Refe callee method.") do
+    klass = XMPReFeFilter
+  end
+  opts.on("--ri", "Ri callee method.") do
+    klass = XMPRiFilter
+  end
+  opts.on("--ri-emacs", "Generate ri code for emacs.") do
+    klass = XMPRiEmacsFilter
+  end
+  opts.on("--ri-vim", "Generate ri code for vim.") do
+    klass = XMPRiVimFilter
+  end
+  opts.separator ""
+  opts.on("--use-method-analyzer", "") do |n|
+    options[:use_method_analyzer] = true
+  end
+  opts.on("--filename=FILENAME") do |n|
+    options[:filename] = File.expand_path n
+  end
+
+  opts.handle_position options
+  opts.handle_interpreter options
+  opts.handle_misc options
+end
+
+set_extra_opts options
+opts.parse!(ARGV)
+
+targetcode = ARGF.read
+Dir.chdir options[:wd] if options[:wd]
+
+# Do the job. dispatched by klass.
+puts klass.run(targetcode, options)

data/bin/rct-meth-args

@@ -0,0 +1,392 @@
+#!/usr/bin/env ruby
+# Copyright (c) 
+#  2006 Mauricio Fernandez <mfp@acm.org>    http://eigenclass.org
+#  2006 rubikitch <rubikitch@ruby-lang.org> http://www.rubyist.net/~rubikitch/
+#                    
+# Use and distribution subject to the same conditions as Ruby.
+
+
+$VERBOSE = nil
+$__method_args_off = true
+
+if ARGV.empty?
+  puts <<EOF
+rct-meth-args [-i] [-m] [-c] [-n] <file> [<file> ...]
+
+-i    omit instance methods defined in classes
+-m    omit instance methods defined in modules
+-c    omit class methods
+
+-n    print the filename and line number with output lines
+-t    generate TAGS output
+
+The given files will be #require()d in order.
+Examples:
+  ruby method_args.rb complex
+  ruby method_args.rb thread
+  ruby method_args.rb -c rubygems
+EOF
+  exit
+end
+
+def debugprint(*args)
+  $stderr.puts(*args) if $DEBUG
+end
+
+module MethodArgs
+  MAX_ARGS = 20
+
+  private
+  def needed_args(arity)
+    arity >= 0 ? arity : arity.abs - 1
+  end
+
+  def with_tracer
+    begin
+      set_trace_func @__trace_func
+      yield
+    ensure
+      set_trace_func nil
+    end
+  end
+
+  module LineContents
+    # usage: Contents[filename][lineno]
+    Contents = Hash.new{ |h,k|
+      sum = 0
+      # Unshift is needed because lineno starts with 1.
+      h[k] = File.readlines(k).map{ |line| [line.chomp, sum+=line.length] }.unshift nil
+    }
+    def content
+      Contents[filename][lineno.to_i][0] rescue ""
+    end
+
+    def byte
+      Contents[filename][lineno.to_i-1][1] rescue 0
+    end
+
+    def arg_desc
+      # TODO
+      desc = content[ /\((.+)\)/]
+      desc.gsub!(/(\S),(\S)/, '\1, \2')
+      desc.gsub!(/(\S)=(\S)/, '\1 = \2')
+      desc
+    end
+
+    FileNameCache = Hash.new{ |h,k| h[k] = File.expand_path(k) }
+    def full_filename
+      FileNameCache[filename]
+    end
+  end
+
+  class Location < Struct.new(:filename, :lineno)
+    include LineContents
+  end
+  
+  class Printer
+    def method_info(io, x)
+      prefix = x[:location] ? "#{x[:location].filename}:#{x[:location].lineno}:" : ""
+      io.puts "#{prefix}#{x[:fullname]}#{x[:arg_desc]}" unless x[:klass].to_s == "<Struct>"
+    end
+
+    def included_location(io, x)
+      x[:callsite] and io.print "#{x[:callsite].filename}:#{x[:callsite].lineno}:"
+      io.puts([ x[:comment], x[:mod], x[:flag], x[:self] ].join(" "))
+    end
+  end
+
+  class TagsPrinter
+    def initialize
+      @previous_filename = ""
+    end
+
+    def output_filename(filename)
+      if @previous_filename != filename
+        @previous_filename = filename
+        puts "\cl"
+        puts "#{filename},0"
+      end
+    end
+
+    def method_info(io, x)
+      return unless x[:location]
+      output_filename x[:location].full_filename
+      io.puts "#{x[:location].content}::#{x[:fullname]}
#{x[:location].lineno},#{x[:location].byte}"
+    end
+
+    def included_location(io, x)
+      return unless x[:callsite]
+      output_filename x[:callsite].full_filename
+      io.puts "#{x[:callsite].content}::#{x[:mod]}
#{x[:callsite].lineno},#{x[:callsite].byte}"
+    end
+  end
+
+  def _print_method_info(klass, is_singleton, meth, arg_desc=nil, location=nil, with_location=$__with_location, printer=$__printer)
+    arg_desc ||= "(...)"
+    arg_desc = " " + arg_desc unless arg_desc.empty?
+    flag = is_singleton ? "." : "#"
+    x = { :arg_desc => arg_desc, :klass => klass,
+      :fullname => [klass, flag, meth].join,
+      :location => with_location && location,
+    }
+    printer.method_info $>, x 
+  end
+
+  def output_attr_info(klass, object, meth, is_singleton, location)
+    arg_desc = meth.to_s =~ /=$/ ? "(value)" : ""
+    _print_method_info klass, is_singleton, meth, arg_desc, location
+  end
+
+  def output_method_info(klass, object, meth, is_singleton = false, by_attr = nil, by_define_method = nil)
+    return if $__method_args_off
+    file = line = params = values = nil
+    location = nil
+    begin
+      unless %w[initialize].include?(meth.to_s)
+        if is_singleton
+          return if class << klass; private_instance_methods(true) end.include?(meth.to_s)
+        else
+          return if class << object; private_instance_methods(true) end.include?(meth.to_s)
+        end
+      end
+    rescue TypeError          # no virtual class
+    end
+    
+    arity = is_singleton ? object.method(meth).arity : klass.instance_method(meth).arity
+    @__trace_func = lambda{|event, file, line, id, binding, classname|
+      begin
+        debugprint "!EVENT: #{event} #{classname}##{id}, #{file} #{line}"
+        debugprint "(#{self} #{meth})"
+        if event[/call/] && classname == self && id == meth
+          location = Location.new(file, line) if event == 'call'
+          debugprint "EVENT: #{event} #{classname}##{id}"
+          throw :done
+        end
+      rescue Exception
+        nil                     # rcov workaround
+      end
+    }
+    if by_define_method
+      _print_method_info klass, is_singleton, meth, nil, by_define_method
+      return
+    end
+    
+    if by_attr
+      output_attr_info klass, object, meth, is_singleton, by_attr
+      return
+    end
+    
+    catch(:done) do 
+      begin
+        with_tracer { object.send(meth, *(0...needed_args(arity))) }
+      rescue Exception
+        nil                 # rcov workaround
+      end
+    end
+    
+    arg_desc = location.arg_desc
+    
+    _print_method_info klass, is_singleton, meth, arg_desc, location
+  rescue Exception
+    debugprint "GOT EXCEPTION while processing #{klass} #{meth}"
+    debugprint $!.class
+    debugprint $!.message
+    debugprint $!.backtrace
+    _print_method_info klass, is_singleton, meth, nil, location
+  ensure
+    set_trace_func(nil)
+  end
+end
+
+class Object
+  include MethodArgs
+end
+
+class Module
+  class CallSite                # compatible with Location
+    include MethodArgs::LineContents
+    def initialize(caller_string)
+      @filename, @lineno, @in = caller_string.split(/:/)
+    end
+    attr_reader :filename, :lineno
+  end
+
+  def _method_defined_with(ivar, caller, &block)
+    begin
+      instance_variable_set(ivar, caller)
+      yield
+    ensure
+      instance_variable_set(ivar, false)
+    end
+  end
+
+  def with_attr(caller, &block)
+    _method_defined_with :@by_attr, caller, &block
+  end
+
+  def with_define_method(caller, &block)
+    _method_defined_with :@by_define_method, caller, &block
+  end
+
+  [ :attr, :attr_reader, :attr_writer, :attr_accessor ].each do |meth|
+    attr = instance_method(meth)
+    define_method(meth) do |*args|
+      with_attr(CallSite.new(caller(1)[0])){ attr.bind(self).call(*args) }
+    end
+  end
+
+  alias :__define_method_orig :define_method
+  def define_method(*args, &body)
+    with_define_method(CallSite.new(caller(1)[0])){ __define_method_orig(*args, &body) }
+  end
+
+end
+
+new_args = []
+omissions = {}
+$__with_location = false
+$__printer = Printer.new
+
+ARGV.each do |arg|
+  case arg
+  when "-n"; $__with_location = true
+  when "-t"; $__printer = TagsPrinter.new; $__with_location = true
+  when /-./; omissions[$&] = true
+  else new_args << arg
+  end
+end
+
+ARGV.replace new_args
+
+class Object
+  ALLOCATOR = Hash.new{|h,k| h[k] = k.allocate }.merge(Fixnum=>1,
+                                                       Bignum=>10000000000000000,
+                                                       Float=>1.1,
+                                                       Symbol=>:method_args_tmp,
+                                                       Binding=>binding,
+                                                       UnboundMethod=>instance_method(:object_id),
+                                                       Method=>method(:object_id),
+                                                       Proc=>lambda{},
+                                                       Continuation=>callcc{|c|c},
+                                                       Thread=>Thread.new{},
+                                                       FalseClass=>false,
+                                                       TrueClass=>true,
+                                                       NilClass=>nil,
+                                                       Struct=>Struct.new(:a).new(1))
+
+#  ABSTRACT_CLASSES = %w[Digest::Base ]
+  def self.method_added(meth)
+#     if ABSTRACT_CLASSES.include? self.to_s
+#       _print_method_info self, false, meth
+#       return
+#     end
+    begin
+      o = ALLOCATOR[self]
+    rescue Exception            # for abstract classes
+      nil
+    end
+    output_method_info(self, o, meth, false, @by_attr, @by_define_method)
+  end
+end unless omissions["-i"]
+
+class Module
+  method_added = instance_method(:method_added)
+  define_method(:method_added) do |meth|
+    begin
+      if instance_of? Module
+        o = Object.new
+        o.extend(self)
+        output_method_info(self, o, meth, false, @by_attr, @by_define_method)
+      end
+      method_added.bind(self).call(meth)
+    rescue Exception
+      _print_method_info self, false, meth
+    end
+  end
+end unless omissions["-m"]
+
+
+class Class
+  def singleton_method_added(meth)
+    by_attr = class << self; @by_attr; end
+    by_define_method = class << self; @by_define_method; end
+    output_method_info(self, self, meth, true, by_attr, by_define_method)
+  rescue Exception
+    _print_method_info self, true, meth
+  end
+end unless omissions["-c"]
+
+#### include / extend
+class Module
+  def _print_included_location(mod, caller_string, comment, flag, with_location=$__with_location, printer=$__printer)
+    if caller_string            # nil when the class is defined by C
+      x = { :comment => comment, :mod => mod, :flag => flag, :self => self,
+        :callsite => with_location && CallSite.new(caller_string)
+      }
+      printer.included_location $>, x
+    end
+  end
+
+  undef_method :included
+  def included(mod)
+    _print_included_location mod, caller(0)[1], "include", "<="
+  end
+
+  undef_method :extended
+  def extended(mod)
+    _print_included_location mod, caller(0)[1], "extend", "<-" if Module === mod
+  end
+end
+
+#### inheritance
+class Class
+  undef :inherited
+  def inherited(klass, caller_level=0)
+    _print_included_location klass, caller(caller_level)[1], "class", "<" unless self == Object
+  end
+end
+
+#### Struct inspection
+class << Struct
+  def to_s
+    orig = super
+    if orig =~ /<Class/
+      mems = instance_methods(false).select{ |m| m.to_s !~ /=$/}.sort.join(",")
+      mems.empty? ? "<Struct>" : "<Struct: #{mems}>"
+    else
+      orig
+    end
+  end
+
+  def inherited(klass)
+    if self == Struct
+      @inherited_delay = lambda{ super(klass, 3) }
+    else
+      super(klass, 1)
+    end
+  end
+
+  @@struct_initializing = false
+  def method_added(meth)
+    super unless @@struct_initializing
+  end
+
+  orig_new = instance_method(:new)
+  define_method(:new) do |*args|
+    begin
+      @@struct_initializing = true
+      orig_new.bind(self).call(*args)
+    ensure
+      @@struct_initializing = false
+      @inherited_delay[]
+    end
+  end
+
+end
+
+$__method_args_off = false
+
+ARGV.each{|x| require x}
+
+$__method_args_off = true
+# END { puts "zzzz OK" }