rcodetools 0.4.0.0

data/bin/xmpfilter

@@ -0,0 +1,75 @@
+#! /home/batsman/usr//bin/ruby
+require 'rcodetools/xmpfilter'
+require 'rcodetools/options'
+
+options = DEFAULT_OPTIONS
+rails_settings = false
+klass = XMPFilter
+
+opts = OptionParser.new do |opts|
+  opts.extend OptionHandler
+  opts.set_banner
+
+  opts.separator ""
+  opts.separator "Modes:"
+  opts.on("-a", "--annotations", "Annotate code (default)") do
+    klass = XMPFilter
+  end
+  opts.on("-u", "--unittest", "Complete Test::Unit assertions.") do 
+    require 'rcodetools/xmptestunitfilter'
+    klass = XMPTestUnitFilter
+  end
+  opts.on("-s", "--spec", "Complete RSpec expectations.") do
+    require 'rcodetools/xmptestunitfilter'
+    klass = XMPRSpecFilter
+    options[:interpreter] = "spec"
+  end
+  opts.on("-m", "--markers", "Add # => markers.") do
+    klass = XMPAddMarkers
+  end
+
+  opts.handle_interpreter options
+
+  opts.separator ""
+  opts.separator "Specific options:"
+  opts.on("-l N", "--min-line-length N", Integer, "Align markers to N spaces.") do |min_codeline_size|
+    options[:min_codeline_size] = min_codeline_size
+  end
+  opts.on("--rails", "Setting appropriate for Rails.",
+          "(no warnings, find working directory,",
+          " Test::Unit assertions)") do 
+    require 'rcodetools/xmptestunitfilter'
+    options[:warnings] = false
+    klass = XMPTestUnitFilter
+    rails_settings = true
+  end
+  opts.on("--[no-]poetry", "Whether to use extra parentheses.",
+          "(default: use them)") do |poetry_p|
+    options[:use_parentheses] = !poetry_p
+  end
+  opts.on("--[no-]warnings", "Whether to add warnings (# !>).", 
+          "(default: enabled)") {|warnings_p| options[:warnings] = warnings_p }
+  opts.on("-q", "--quiet", "Supress standard output.") do
+    options[:output_stdout] = false
+  end
+
+  opts.handle_misc options
+end
+
+set_extra_opts options
+opts.parse!(ARGV)
+
+if rails_settings && !options[:wd]
+  if File.exist? ARGF.path
+    options[:wd] = File.dirname(ARGF.path)
+  elsif File.exist? "test/unit"
+    options[:wd] = "test/unit"
+  elsif File.exist? "unit"
+    options[:wd] = "unit"
+  end
+end
+targetcode = ARGF.read
+Dir.chdir options[:wd] if options[:wd]
+
+# Do the job. dispatched by klass.
+puts klass.run(targetcode, options)

data/icicles-rcodetools.el

@@ -0,0 +1,31 @@
+;;; icicles-rcodetools.el -- accurate completion with icicles
+
+;;; Copyright (c) 2006 rubikitch <rubikitch@ruby-lang.org>
+;;;
+;;; Use and distribution subject to the terms of the Ruby license.
+
+(require 'icicles)
+(require 'rcodetools)
+
+(setq rct-complete-symbol-function 'rct-complete-symbol--icicles)
+(icicle-define-command rct-complete-symbol--icicles
+                         "Perform ruby method and class completion on the text around point with icicles.
+C-M-RET shows RI documentation on each candidate.
+See also `rct-interactive'."
+
+                       (lambda (result)
+                         (save-excursion
+                           (search-backward pattern)
+                           (setq beg (point)))
+                         (delete-region beg end)
+                         (insert result)) ;/function
+                       "rct-complete: "       ;prompt
+                       rct-method-completion-table
+                       nil t pattern nil nil nil
+                       ((end (point)) beg
+                        pattern klass
+                        (icicle-candidate-help-fn
+                         (lambda (result) (ri result klass)))) ;bindings
+                       (rct-exec-and-eval rct-complete-command-name "--completion-emacs-icicles"))
+
+(provide 'icicles-rcodetools)

data/lib/method_analyzer.rb

@@ -0,0 +1,107 @@
+class Module
+  remove_method :attr_reader
+  def attr_reader(*names)
+    names.each do |name|
+      module_eval "def #{name}() @#{name} end"
+    end
+  end
+  remove_method :attr_writer
+  def attr_writer(*names)
+    names.each do |name|
+      module_eval "def #{name}=(x) @#{name}=x end"
+    end
+  end
+  remove_method :attr_accessor
+  def attr_accessor(*names)
+    attr_reader(*names)
+    attr_writer(*names)
+  end
+  remove_method :attr
+  def attr(name, writer=false)
+    attr_reader name
+    attr_writer name if writer
+  end
+end
+
+
+module MethodAnalyzer
+  @@methods = Hash.new{ |h,k| h[k] = Hash.new{ |h,k| h[k] = []} }
+  @@whereis = []
+  @@expand_path = Hash.new{ |h,k| h[k] = File.expand_path(k)}
+  
+  def self.trace_func(event, file, line, id, binding, klass, *rest)
+    return if file == __FILE__
+    return if (event != 'call' and event != 'c-call')
+    return if klass == Class and id == :inherited
+    return if klass == Module and id == :method_added
+    return if klass == Kernel and id == :singleton_method_added
+    saved_crit = Thread.critical
+    Thread.critical = true
+    
+    the_self = eval("self",binding)
+    flag = Class === the_self ? "." : "#"
+    #klass = klass == Kernel ? Object : klass
+    fullname = "#{klass}#{flag}#{id}"
+    file.replace @@expand_path[file]
+    if event == 'call'
+      @@whereis << [file, line, fullname] if file !~ /\(eval\)$/
+      file, line, rest = caller(4)[0].split(/:/)
+      file.replace @@expand_path[file] # DRY
+      p caller(0) if $DEBUG
+      line = line.to_i
+    end
+    @@methods[file][line] << fullname  if event =~ /call/
+
+    Thread.critical = saved_crit
+  end
+
+  def self.at_exit__output_marshal
+    at_exit do
+      set_trace_func nil
+      dbfile = "method_analysis"
+      old = Marshal.load(File.read(dbfile)) rescue {}
+      open(dbfile, "wb") do |io|
+        # Because Marshal.dump cannot handle hashes with default_proc
+        @@methods.default = nil
+        @@methods.each_value{ |v| v.default=nil; v.each_value{ |vv| vv.uniq! } }
+        Marshal.dump(@@methods.merge(old), io)
+      end
+    end
+  end
+
+
+  def self.at_exit__output_text
+    at_exit do
+      set_trace_func nil
+      puts "method fullnames"
+      @@methods.sort.each do |file, lines|
+        lines.sort.each do |line, methods|
+          printf "%s:%s:%s\n", file, line, methods.uniq.join(" ")
+        end
+      end
+
+      puts
+      puts "method definitions"
+      @@whereis.sort.uniq.each do |file, line, fullname |
+        printf "%s:%s:%s\n", file, line, fullname
+      end
+
+    end
+  end
+
+  def self.set_at_exit
+    case ENV['METHOD_ANALYZER_FORMAT']
+    when 'marshal'
+      at_exit__output_marshal
+    else
+      at_exit__output_text
+    end
+  end
+
+  set_at_exit
+  set_trace_func method(:trace_func).to_proc
+end
+
+if __FILE__ == $0
+  load "./test/data/method_analyzer-data.rb"
+end

data/lib/rcodetools/completion.rb

@@ -0,0 +1,282 @@
+require 'rcodetools/xmpfilter'
+require 'enumerator'
+# Common routines for XMPCompletionFilter/XMPDocFilter
+module ProcessParticularLine
+  def fill_literal!(expr)
+    [ "\"", "'", "`" ].each do |q|
+      expr.gsub!(/#{q}(.+)#{q}/){ '"' + "x"*$1.length + '"' }
+    end
+    expr.gsub!(/(%([wWqQxrs])?(\W))(.+?)\3/){
+      percent = $2 == 'x' ? '%'+$3 : $1 # avoid executing shell command
+      percent + "x"*$4.length + $3
+    }
+    [ %w[( )], %w[{ }], %w![ ]!, %w[< >] ].each do |b,e|
+      rb, re = [b,e].map{ |x| Regexp.quote(x)}
+      expr.gsub!(/(%([wWqQxrs])?(#{rb}))(.+)#{re}/){
+        percent = $2 == 'x' ? '%'+$3 : $1 # avoid executing shell command
+        percent + "x"*$4.length + e
+      }
+    end
+  end
+
+  module ExpressionExtension
+    attr_accessor :eval_string
+    attr_accessor :meth
+  end
+  OPERATOR_CHARS = '\|^&<>=~\+\-\*\/%\['
+  def set_expr_and_postfix!(expr, column, &regexp)
+    expr.extend ExpressionExtension
+
+    @postfix = ""
+    expr_orig = expr.clone
+    column ||= expr.length
+    last_char = expr[column-1]
+    expr.replace expr[ regexp[column] ]
+    debugprint "expr_orig=#{expr_orig}", "expr(sliced)=#{expr}"
+    right_stripped = Regexp.last_match.post_match
+    _handle_do_end right_stripped
+    aref_or_aset = aref_or_aset? right_stripped, last_char
+    debugprint "aref_or_aset=#{aref_or_aset.inspect}"
+    set_last_word! expr, aref_or_aset
+    fill_literal! expr_orig
+    _handle_brackets expr_orig, expr
+    expr << aref_or_aset if aref_or_aset
+    _handle_keywords expr_orig, column
+    debugprint "expr(processed)=#{expr}"
+    expr
+  end
+
+  def _handle_do_end(right_stripped)
+    right_stripped << "\n"
+    n_do = right_stripped.scan(/[\s\)]do\s/).length
+    n_end = right_stripped.scan(/\bend\b/).length
+    @postfix = ";begin" * (n_do - n_end)
+  end
+
+  def _handle_brackets(expr_orig, expr)
+    [ %w[{ }], %w[( )], %w![ ]! ].each do |left, right|
+      n_left  = expr_orig.count(left)  - expr.count(left)
+      n_right = expr_orig.count(right) - expr.count(right)
+      n = n_left - n_right
+      @postfix << ";#{left}" * n if n >= 0
+    end
+  end
+
+  def _handle_keywords(expr_orig, column)
+    %w[if unless while until for].each do |keyw|
+      pos = expr_orig.index(/\b#{keyw}\b/)
+      @postfix << ";begin" if pos and pos < column # if * xxx
+
+      pos = expr_orig.index(/;\s*#{keyw}\b/)
+      @postfix << ";begin" if pos and column < pos # * ; if xxx
+    end
+  end
+
+  def aref_or_aset?(right_stripped, last_char)
+    if last_char == ?[
+      case right_stripped
+      when /\]\s*=/: "[]="
+      when /\]/:     "[]"
+      end
+    end
+  end
+
+  def set_last_word!(expr, aref_or_aset=nil)
+    debugprint "expr(before set_last_word)=#{expr}"
+    if aref_or_aset
+      opchars = "" 
+    else
+      opchars = expr.slice!(/\s*[#{OPERATOR_CHARS}]+$/)
+      debugprint "expr(strip opchars)=#{expr}"
+    end
+    
+    expr.replace(if expr =~ /[\"\'\`]$/      # String operations
+                   "''"
+                 else
+                   fill_literal! expr
+                   phrase = current_phrase(expr)
+                   if aref_or_aset
+                     expr.eval_string = expr[0..-2]
+                     expr.meth = aref_or_aset
+                   elsif phrase.match( /^(.+)\.(.*)$/ )
+                     expr.eval_string, expr.meth = $1, $2
+                   elsif opchars != ''
+                     expr
+                   end
+                   debugprint "expr.eval_string=#{expr.eval_string}", "expr.meth=#{expr.meth}"
+                   phrase
+                 end << (opchars || '')) # ` font-lock hack
+    debugprint "expr(after set_last_word)=#{expr}"
+  end
+
+  def current_phrase(expr)
+    paren_level = 0
+    start = 0
+    (expr.length-1).downto(0) do |i|
+      c = expr[i,1]
+      if c =~ /[\)\}\]]/
+        paren_level += 1
+        next
+      end
+      if paren_level > 0
+        next if c =~ /[, ]/
+      else
+        break (start = i+1) if c =~ /[ ,\(\{\[]/
+      end
+      if c =~ /[\(\{\[]/
+        paren_level -= 1
+        break (start = i+1) if paren_level < 0
+      end
+    end
+    expr[start..-1]
+  end
+
+  def add_BEGIN
+    <<XXX
+BEGIN {
+class Object
+  def method_missing(meth, *args, &block)
+    # ignore NoMethodError
+  end
+end
+}
+XXX
+  end
+
+  class RuntimeDataError < RuntimeError; end
+  class NewCodeError < Exception; end
+  def runtime_data_with_class(code, lineno, column=nil)
+    newcode = code.to_a.enum_with_index.map{|line, i|
+      i+1==lineno ? prepare_line(line.chomp, column) : line
+    }.join
+    newcode << add_BEGIN if @ignore_NoMethodError
+    debugprint "newcode", newcode, "-"*80
+    stdout, stderr = execute(newcode)
+    output = stderr.readlines
+    debugprint "stdout", output, "-"*80
+    output = output.reject{|x| /^-:[0-9]+: warning/.match(x)}
+    runtime_data = extract_data(output)
+    if exception = /^-:[0-9]+:.*/m.match(output.join)
+      raise NewCodeError, exception[0].chomp
+    end
+    begin
+      dat = runtime_data.results[1][0]
+      [dat[0], dat[1..-1].to_s]
+    rescue
+      raise RuntimeDataError, runtime_data.inspect
+    end
+  end
+
+  def runtime_data(code, lineno, column=nil)
+    runtime_data_with_class(code, lineno, column)[1]
+  end
+
+end
+
+# Nearly 100% accurate completion for any editors!!
+#  by rubikitch <rubikitch@ruby-lang.org>
+class XMPCompletionFilter < XMPFilter
+  include ProcessParticularLine
+
+  # String completion begins with this.
+  attr :prefix
+
+  def self.run(code, opts)
+    new(opts).completion_code(code, opts[:lineno], opts[:column])
+  end
+
+  def prepare_line(expr, column)
+    set_expr_and_postfix!(expr, column){|c| /^.{#{c}}/ }
+    @prefix = expr
+    case expr
+    when /^\$\w+$/              # global variable
+      __prepare_line 'global_variables'
+    when /^@@\w+$/              # class variable
+      __prepare_line 'Module === self ? class_variables : self.class.class_variables'
+    when /^@\w+$/               # instance variable
+      __prepare_line 'instance_variables'
+    when /^([A-Z].*)::(.*)$/    # nested constants / class methods
+      @prefix = $2
+      __prepare_line "#$1.constants | #$1.methods(true)"
+    when /^[A-Z]\w*$/           # normal constants
+      __prepare_line 'Module.constants'
+    when /^::(.+)::(.*)$/       # toplevel nested constants
+      @prefix = $2
+      __prepare_line "::#$1.constants | ::#$1.methods"
+    when /^::(.*)/              # toplevel constant
+      @prefix = $1
+      __prepare_line 'Object.constants'
+    when /^(:[^:.]*)$/          # symbol
+      __prepare_line 'Symbol.all_symbols.map{|s| ":" + s.id2name}'
+    when /\.([^.]*)$/           # method call
+      @prefix = $1
+      __prepare_line "(#{Regexp.last_match.pre_match}).methods(true)"
+    else                        # bare words
+      __prepare_line "methods | private_methods | local_variables | self.class.constants"
+    end
+  end
+
+  def __prepare_line(all_completion_expr)
+    v = "#{VAR}"
+    idx = 1
+    oneline_ize(<<EOC)
+#{v} = (#{all_completion_expr}).grep(/^#{Regexp.quote(@prefix)}/)
+$stderr.puts("#{MARKER}[#{idx}] => " + #{v}.class.to_s  + " " + #{v}.join(" ")) || #{v}
+exit
+EOC
+  end
+
+  # Array of completion candidates.
+  def candidates(code, lineno, column=nil)
+    methods = runtime_data(code, lineno, column) rescue ""
+    methods.split.sort
+  end
+
+  # Completion code for editors.
+  def completion_code(code, lineno, column=nil)
+    candidates(code, lineno, column).join("\n")
+  end
+end
+
+class XMPCompletionEmacsFilter < XMPCompletionFilter
+  def completion_code(code, lineno, column=nil)
+    elisp = "(progn\n"
+    elisp <<  "(setq rct-method-completion-table '("
+    begin
+      candidates(code, lineno, column).each do |meth|
+        elisp << format('("%s") ', meth)
+      end
+    rescue Exception => err
+      return %Q[(error "#{err.message}")]
+    end
+    elisp << "))\n"
+    elisp << %Q[(setq pattern "#{prefix}")\n]
+    elisp << %Q[(try-completion pattern rct-method-completion-table nil)\n]
+    elisp << ")"                # /progn
+  end
+end
+
+class XMPCompletionEmacsIciclesFilter < XMPCompletionFilter
+  def candidates(code, lineno, column=nil)
+    klass, methods = runtime_data_with_class(code, lineno, column) rescue ["", ""]
+    @klass = klass
+    methods.split.sort
+  end
+
+  def completion_code(code, lineno, column=nil)
+    elisp = "(progn\n"
+    elisp <<  "(setq rct-method-completion-table '("
+    begin
+      candidates(code, lineno, column).each do |meth|
+        elisp << format('("%s") ', meth)
+      end
+    rescue Exception => err
+      return %Q[(error "#{err.message}")]
+    end
+    elisp << "))\n"
+    elisp << %Q[(setq pattern "#{prefix}")\n]
+    elisp << %Q[(setq klass "#{@klass}")\n]
+    elisp << ")"                # /progn
+  end
+end
+