rcodetools 0.4.0.0

data/lib/rcodetools/doc.rb

@@ -0,0 +1,176 @@
+require 'rcodetools/completion'
+# Call Ri for any editors!!
+#  by rubikitch <rubikitch@ruby-lang.org>
+class XMPDocFilter < XMPFilter
+  include ProcessParticularLine
+
+  def initialize(opts = {})
+    super
+    @filename = opts[:filename]
+    extend UseMethodAnalyzer if opts[:use_method_analyzer]
+  end
+
+  def self.run(code, opts)
+    new(opts).doc(code, opts[:lineno], opts[:column])
+  end
+
+  def prepare_line(expr, column)
+    set_expr_and_postfix!(expr, column){|c| 
+      withop_re = /^.{#{c-1}}[#{OPERATOR_CHARS}]+/
+      if expr =~ withop_re
+        withop_re
+      else
+        /^.{#{c}}[\w#{OPERATOR_CHARS}]*/
+      end
+    }
+    recv = expr
+
+    # When expr already knows receiver and method,
+    return(__prepare_line :recv => expr.eval_string, :meth => expr.meth) if expr.eval_string
+
+    case expr
+    when /^(?:::)?([A-Z].*)(?:::|\.)(.*)$/    # nested constants / class methods
+      __prepare_line :klass => $1, :meth_or_constant => $2
+    when /^(?:::)?[A-Z]/               # normal constants
+      __prepare_line :klass => expr
+    when /\.([^.]*)$/             # method call
+      __prepare_line :recv => Regexp.last_match.pre_match, :meth => $1
+    when /^(.+)(\[\]=?)$/                   # [], []=
+      __prepare_line :recv => $1, :meth => $2
+    when /[#{OPERATOR_CHARS}]+$/                   # operator
+      __prepare_line :recv => Regexp.last_match.pre_match, :meth => $&
+    else                        # bare words
+      __prepare_line :recv => "self", :meth => expr
+    end
+  end
+
+  def __prepare_line(x)
+    v = "#{VAR}"
+    klass = "#{VAR}_klass"
+    flag = "#{VAR}_flag"
+    which_methods = "#{VAR}_methods"
+    ancestor_class = "#{VAR}_ancestor_class"
+    idx = 1
+    recv = x[:recv] || x[:klass] || raise(ArgumentError, "need :recv or :klass")
+    meth = x[:meth_or_constant] || x[:meth]
+    debugprint "recv=#{recv}", "meth=#{meth}"
+    if meth
+      code = <<-EOC
+#{v} = (#{recv})
+if Class === #{v}
+  #{flag} = #{v}.respond_to?('#{meth}') ? "." : "::"
+  #{klass} = #{v}
+  #{which_methods} = :methods
+else
+  #{flag} = "#"
+  #{klass} = #{v}.class
+  #{which_methods} = :instance_methods
+end
+#{ancestor_class} = #{klass}.ancestors.delete_if{|c| c==Kernel }.find{|c| c.__send__(#{which_methods}, false).include? '#{meth}' }
+$stderr.print("#{MARKER}[#{idx}] => " + #{v}.class.to_s  + " ")
+
+if #{ancestor_class}
+  $stderr.puts(#{ancestor_class}.to_s + #{flag} + '#{meth}')
+else
+  [Kernel, Module, Class].each do |k|
+    if (k.instance_methods(false) + k.private_instance_methods(false)).include? '#{meth}'
+      $stderr.printf("%s#%s\\n", k, '#{meth}'); exit
+    end
+  end
+  $stderr.puts(#{v}.to_s + '::' + '#{meth}')
+end
+exit
+      EOC
+    else
+      code = <<-EOC
+#{v} = (#{recv})
+$stderr.print("#{MARKER}[#{idx}] => " + #{v}.class.to_s  + " ")
+$stderr.puts(#{v}.to_s)
+exit
+      EOC
+    end
+    oneline_ize(code)
+  end
+
+  # overridable by module
+  def _doc(code, lineno, column)
+  end
+
+  def doc(code, lineno, column=nil)
+    _doc(code, lineno, column) or runtime_data(code, lineno, column).to_s
+  end
+
+  module UseMethodAnalyzer
+    METHOD_ANALYSIS = "method_analysis"
+    def have_method_analysis
+      File.file? METHOD_ANALYSIS
+    end
+
+    def find_method_analysis
+      here = Dir.pwd
+      oldpwd = here
+      begin
+        while ! have_method_analysis
+          Dir.chdir("..")
+          if Dir.pwd == here
+            return nil          # not found
+          end
+          here = Dir.pwd
+        end
+      ensure
+        Dir.chdir oldpwd
+      end
+      yield(File.join(here, METHOD_ANALYSIS))
+    end
+
+    def _doc(code, lineno, column=nil)
+      find_method_analysis do |ma_file|
+        methods = open(ma_file, "rb"){ |f| Marshal.load(f)}
+        line = File.readlines(@filename)[lineno-1]
+        current_method = line[ /^.{#{column}}\w*/][ /\w+[\?!]?$/ ].sub(/:+/,'')
+        filename = @filename  # FIXME
+        begin 
+          methods[filename][lineno].grep(Regexp.new(Regexp.quote(current_method)))[0]
+        rescue NoMethodError
+          raise "doc/method_analyzer:cannot find #{current_method}"
+        end
+
+      end
+    end
+  end
+
+end
+
+# ReFe is so-called `Japanese Ri'.
+class XMPReFeFilter < XMPDocFilter
+  def doc(code, lineno, column=nil)
+    "refe '#{super}'"
+  end
+end
+
+class XMPRiFilter < XMPDocFilter
+  def doc(code, lineno, column=nil)
+    "ri '#{super}'"
+  end
+end
+
+class XMPRiEmacsFilter < XMPDocFilter
+  def doc(code, lineno, column=nil)
+    begin 
+      %!(rct-find-tag-or-ri "#{super}")!
+    rescue Exception => err
+      return %Q[(error "#{err.message}")]
+    end
+  end
+end
+
+class XMPRiVimFilter < XMPDocFilter
+  def doc(code, lineno, column=nil)
+    begin
+      %{call RCT_find_tag_or_ri("#{super}")}
+    rescue Exception => err
+      return %Q[echo #{err.message.inspect}]
+    end
+  end
+end
+

data/lib/rcodetools/options.rb

@@ -0,0 +1,83 @@
+require 'optparse'
+
+# Domain specific OptionParser extensions
+module OptionHandler
+  def set_banner
+    self.banner = "Usage: #{$0} [options] [inputfile] [-- cmdline args]"
+  end
+
+  def handle_position(options)
+    separator ""
+    separator "Position options:"
+    on("--line=LINE", "Current line number.") do |n|
+      options[:lineno] = n.to_i
+    end
+    on("--column=COLUMN", "Current column number.") do |n|
+      options[:column] = n.to_i
+    end
+  end
+
+  def handle_interpreter(options)
+    separator ""
+    separator "Interpreter options:"
+    on("-S FILE", "--interpreter FILE", "Use interpreter FILE.") do |interpreter|
+      options[:interpreter] = interpreter
+    end
+    on("-I PATH", "Add PATH to $LOAD_PATH") do |path|
+      options[:include_paths] << path
+    end
+    on("-r LIB", "Require LIB before execution.") do |lib|
+      options[:libs] << lib
+    end
+    on("-e EXPR", "--eval=EXPR", "--stub=EXPR", "Evaluate EXPR after execution.") do |expr|
+      options[:evals] << expr
+    end
+
+  end
+
+  def handle_misc(options)
+    separator ""
+    separator "Misc options:"
+    on("--cd DIR", "Change working directory to DIR.") do |dir|
+      options[:wd] = dir
+    end
+    on("--debug", "Write transformed source code to xmp-tmp.PID.rb.") do
+      options[:dump] = "xmp-tmp.#{Process.pid}.rb"
+    end
+    separator ""
+    on("-h", "--help", "Show this message") do
+      puts self
+      exit
+    end
+    on("-v", "--version", "Show version information") do
+      puts "#{File.basename($0)} #{XMPFilter::VERSION}"
+      exit
+    end
+  end
+
+
+end
+
+def set_extra_opts(options)
+  if idx = ARGV.index("--")
+    options[:options] = ARGV[idx+1..-1]
+    ARGV.replace ARGV[0...idx]
+  else
+    options[:options] = []
+  end
+end
+
+DEFAULT_OPTIONS = {
+  :interpreter       => "ruby",
+  :options => ["hoge"],
+  :min_codeline_size => 50,
+  :libs              => [],
+  :evals             => [],
+  :include_paths     => [],
+  :dump              => nil,
+  :wd                => nil,
+  :warnings          => true,
+  :use_parentheses   => true,
+  :column            => nil,
+  :output_stdout     => true,
+  }

data/lib/rcodetools/xmpfilter.rb

@@ -0,0 +1,208 @@
+#!/usr/bin/env ruby
+# Copyright (c) 2005-2006 Mauricio Fernandez <mfp@acm.org> http://eigenclass.org
+#                         rubikitch <rubikitch@ruby-lang.org>
+# Use and distribution subject to the terms of the Ruby license.
+
+class XMPFilter
+  VERSION = "0.4.0"
+
+  MARKER = "!XMP#{Time.new.to_i}_#{Process.pid}_#{rand(1000000)}!"
+  XMP_RE = Regexp.new("^" + Regexp.escape(MARKER) + '\[([0-9]+)\] (=>|~>|==>) (.*)')
+  VAR = "_xmp_#{Time.new.to_i}_#{Process.pid}_#{rand(1000000)}"
+  WARNING_RE = /.*:([0-9]+): warning: (.*)/
+
+  RuntimeData = Struct.new(:results, :exceptions, :bindings)
+
+  INITIALIZE_OPTS = {:interpreter => "ruby", :options => [], :libs => [],
+                     :include_paths => [], :warnings => true, 
+                     :use_parentheses => true}
+
+  # The processor (overridable)
+  def self.run(code, opts)
+    new(opts).annotate(code)
+  end
+
+  def initialize(opts = {})
+    options = INITIALIZE_OPTS.merge opts
+    @interpreter = options[:interpreter]
+    @options = options[:options]
+    @libs = options[:libs]
+    @evals = options[:evals] || []
+    @include_paths = options[:include_paths]
+    @output_stdout = options[:output_stdout]
+    @dump = options[:dump]
+    @warnings = options[:warnings]
+    @parentheses = options[:use_parentheses]
+    @ignore_NoMethodError = options[:ignore_NoMethodError]
+
+    @postfix = ""
+  end
+
+  def add_markers(code, min_codeline_size = 50)
+    maxlen = code.map{|x| x.size}.max
+    maxlen = [min_codeline_size, maxlen + 2].max
+    ret = ""
+    code.each do |l|
+      l = l.chomp.gsub(/ # (=>|!>).*/, "").gsub(/\s*$/, "")
+      ret << (l + " " * (maxlen - l.size) + " # =>\n")
+    end
+    ret
+  end
+
+  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
+    stdout, stderr = execute(newcode)
+    output = stderr.readlines
+    runtime_data = extract_data(output)
+    idx = 0
+    annotated = code.gsub(/^(.*) # =>.*/) do |l|
+      expr = $1
+      if /^\s*#/ =~ l
+        l 
+      else
+        annotated_line(l, expr, runtime_data, idx += 1)
+      end
+    end.gsub(/ # !>.*/, '').gsub(/# (>>|~>)[^\n]*\n/m, "");
+    ret = final_decoration(annotated, output)
+    if @output_stdout and (s = stdout.read) != ""
+      ret << s.inject(""){|s,line| s + "# >> #{line}".chomp + "\n" }
+    end
+    ret
+  end
+
+  def annotated_line(line, expression, runtime_data, idx)
+    "#{expression} # => " + (runtime_data.results[idx].map{|x| x[1]} || []).join(", ")
+  end
+  
+  def prepare_line_annotation(expr, idx)
+    v = "#{VAR}"
+    blocal = "__#{VAR}"
+    blocal2 = "___#{VAR}"
+    # rubikitch: oneline-ized
+# <<EOF.chomp
+# ((#{v} = (#{expr}); $stderr.puts("#{MARKER}[#{idx}] => " + #{v}.class.to_s + " " + #{v}.inspect) || begin; $stderr.puts local_variables; local_variables.each{|#{blocal}| #{blocal2} = eval(#{blocal}); if #{v} == #{blocal2} && #{blocal} != %#{expr}.strip; $stderr.puts("#{MARKER}[#{idx}] ==> " + #{blocal}); elsif [#{blocal2}] == #{v}; $stderr.puts("#{MARKER}[#{idx}] ==> [" + #{blocal} + "]") end }; nil rescue Exception; nil end || #{v}))
+# EOF
+    oneline_ize(<<-EOF).chomp
+#{v} = (#{expr})
+$stderr.puts("#{MARKER}[#{idx}] => " + #{v}.class.to_s + " " + #{v}.inspect) || begin
+  $stderr.puts local_variables
+  local_variables.each{|#{blocal}|
+    #{blocal2} = eval(#{blocal})
+    if #{v} == #{blocal2} && #{blocal} != %#{expr}.strip
+      $stderr.puts("#{MARKER}[#{idx}] ==> " + #{blocal})
+    elsif [#{blocal2}] == #{v}
+      $stderr.puts("#{MARKER}[#{idx}] ==> [" + #{blocal} + "]")
+    end
+  }
+  nil
+rescue Exception
+  nil
+end || #{v}
+    EOF
+
+  end
+  alias_method :prepare_line, :prepare_line_annotation
+
+  def execute_tmpfile(code)
+    stdin, stdout, stderr = (1..3).map do |i|
+      fname = "xmpfilter.tmpfile_#{Process.pid}-#{i}.rb"
+      at_exit { File.unlink fname }
+      File.open(fname, "w+")
+    end
+    stdin.puts code
+    stdin.close
+    exe_line = <<-EOF.map{|l| l.strip}.join(";")
+      $stdout.reopen('#{stdout.path}', 'w')
+      $stderr.reopen('#{stderr.path}', 'w')
+      $0.replace '#{stdin.path}'
+      ARGV.replace(#{@options.inspect})
+      load #{stdin.path.inspect}
+      #{@evals.join(";")}
+    EOF
+    system(*(interpreter_command << "-e" << exe_line))
+    [stdout, stderr]
+  end
+
+  def execute_popen(code)
+    require 'open3'
+    stdin, stdout, stderr = Open3::popen3(*interpreter_command)
+    stdin.puts code
+    @evals.each{|x| stdin.puts x } unless @evals.empty?
+    stdin.close
+    [stdout, stderr]
+  end
+
+  if /win|mingw/ =~ RUBY_PLATFORM && /darwin/ !~ RUBY_PLATFORM
+    alias_method :execute, :execute_tmpfile
+  else
+    alias_method :execute, :execute_popen
+  end
+
+  def interpreter_command
+    r = [@interpreter, "-w"]
+    r << "-d" if $DEBUG
+    r << "-I#{@include_paths.join(":")}" unless @include_paths.empty?
+    @libs.each{|x| r << "-r#{x}" } unless @libs.empty?
+    (r << "-").concat @options unless @options.empty?
+    r
+  end
+
+  def extract_data(output)
+    results = Hash.new{|h,k| h[k] = []}
+    exceptions = Hash.new{|h,k| h[k] = []}
+    bindings = Hash.new{|h,k| h[k] = []}
+    output.grep(XMP_RE).each do |line|
+      result_id, op, result = XMP_RE.match(line).captures
+      case op
+      when "=>"
+        klass, value = /(\S+)\s+(.*)/.match(result).captures
+        results[result_id.to_i] << [klass, value]
+      when "~>"
+        exceptions[result_id.to_i] << result
+      when "==>"
+        bindings[result_id.to_i] << result unless result.index(VAR) 
+      end
+    end
+    RuntimeData.new(results, exceptions, bindings)
+  end
+
+  def final_decoration(code, output)
+    warnings = {}
+    output.join.grep(WARNING_RE).map do |x|
+      md = WARNING_RE.match(x)
+      warnings[md[1].to_i] = md[2]
+    end
+    idx = 0
+    ret = code.map do |line|
+      w = warnings[idx+=1]
+      if @warnings
+        w ? (line.chomp + " # !> #{w}") : line
+      else
+        line
+      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 }
+    end
+    ret
+  end
+
+  def oneline_ize(code)
+    "((" + code.gsub(/\r?\n|\r/, ';') + "))#{@postfix}\n"
+  end
+
+  def debugprint(*args)
+    $stderr.puts(*args) if $DEBUG
+  end
+end # clas XMPFilter
+
+class XMPAddMarkers < XMPFilter
+  def self.run(code, opts)
+    new(opts).add_markers(code, opts[:min_codeline_size])
+  end
+end