bloopletech-rtags 0.99.1

data/LICENSE.txt

@@ -0,0 +1,55 @@
+rtags is copyrighted free software.
+
+You can redistribute it and/or modify it under either the terms of the GPL
+(see COPYING.txt file), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.
+

data/README

@@ -0,0 +1,8 @@
+rtags: like ctags, but for ruby.
+
+For more information, see ./bin/rtags
+
+Originally by Keiju ISHITSUKA
+Was maintained by Pjotr Prins
+Currently maintained by no-one
+

data/RELEASENOTES

@@ -0,0 +1,43 @@
+rtags.rb - 
+
+Release Version: 0.96 (April 2006) by Pjotr Prins
+	Improved filtering on repository files (skip _darcs, CVS, .SVN)
+	Test for hash bang Ruby - if no .rb extension
+
+Release Version: 0.95 (December 2006) by Pjotr Prins
+	Added -R/--recurse switch by Chetan Patil
+	Added regression tests for recursion
+
+Release Version: 0.94 (December 2006) by Pjotr Prins
+	Added support for ClassName.new tags - which point to the
+	  Class def initialize methods
+
+Release Version: 0.93 (August 2006) by Pjotr Prins
+  Fixed bug where multiple lines were written to tags file - which
+  	broke them for vi
+	Fixed infinite loop for specific cases
+	Added -a switch (append mode)
+	Turned warnings off by default (-w switch)
+	Included RELEASENOTES in gem
+	More regression testing (-a, tags, TAGS)
+	Run regression test before making a release
+
+Release Version: 0.92 (August 2006) by Pjotr Prins
+	Added catching of parse errors
+	Fixed exit on 'alias' token error (`parse_alias': undefined method `name')
+	Added support for command line arguments with optparse
+	Added debug switches (--debug, --debug_tokens)
+	Print to stderr on debug
+	Added support for alternate tags filename (-f switch)
+	Added --quiet switch
+	Added regression files to ./test
+
+Release Version: 0.91 (July 2006) by Pjotr Prins
+  First independent public release on RubyForge
+  Depends on irb 0.9
+	Wrote install.sh and gem packaging
+           
+Release Version: 0.9 (2002/07/09) by Keiju ISHITSUKA
+  Released as part of irb source tree
+
+

data/TODO

@@ -0,0 +1,40 @@
+TODO
+
+For version 1.0:
+
+- Recognise 'alias :name' tokens
+- include the argument list and an end of line $ pattern (at least the          
+  first opening parenthesis should be included in the pattern)                    
+- indicate whether the entry is a c(lass), a m(odule), or a f (method)          
+  like ctags
+
+Later:
+
+- Add switch for not following symlinks
+- Fix class Foo::Bar to show as such in the TAGS file
+- Find modules with double colon notation like "BIO::MODULE::IO"
+- Cache class names so classes can be found that lack an initialize
+	method
+- Provide - command line switch, allowing for
+	  find . -name '*.rb' -print | rtags -
+
+MUSINGS
+
+Apart from adding the - switch at some point in the future it would
+be neat to have smarter tags. For one, if a class has not initialize
+method we would like to jump to the class definition on
+Classname.new. If we were to store the tags we find in memory
+(instead of just writing them out, as is the current behaviour) it
+would be trivial to implement.
+
+Also some tokens (alias) and multilines are not handled correctly.
+
+Try:
+
+cd ./test                                                                      ruby ../bin/rtags -R
+
+and you get
+
+Warn: parse error in <./data/report.rb> in line 170, pos 4
+
+which is an unrecognised alias.

data/bin/rtags

@@ -0,0 +1,861 @@
+#!/usr/bin/env ruby
+#
+#   rtags is a Ruby replacement for ctags - allowing for name navigation in
+#   source code using vim, emacs and others.
+#   
+#   by Keiju ISHITSUKA and Pjotr Prins
+#   
+#   LICENSE: RUBY LICENSE - see file LICENSE.TXT
+#   INSTALL: see file README
+#   RELEASE NOTES: see file RELEASENOTES
+
+RTAGS_VERSION='0.99.1 (January 2013)'
+
+require 'optparse'
+require 'ostruct'
+
+usage = <<USAGE
+
+        rtags #{RTAGS_VERSION} (Ruby tags) by Keiju ISHITSUKA
+				  improvements by Pjotr Prins, Chetan Patil, Gaizka Villane, Brenton Fletcher
+        
+        A Ruby tool for using Ruby tags rendering more tags than
+        other tools for use with vim or emacs
+       
+        For info see http://rtags.rubyforge.org/
+
+        usage:
+
+                rtags [--vi] [-R] filenames
+                rtags --help
+
+        by default creates an emacs tags file. With the --vi switch
+        a vim tags file is created instead.
+
+USAGE
+
+
+$options = OpenStruct.new()
+$options.warning_level = 0
+$options.recurse = false
+
+OptionParser.new do |opts|
+  opts.on_tail("-h", "--help", "Print this message") do
+ 		print(usage)
+    print(opts)
+    print <<EXAMPLE
+    
+Examples:
+
+    rtags *.rb
+    rtags -x *.rb
+    rtags -R <path>
+    rtags --vi -f vim_tags *.rb
+    rtags `find ~/src/ -name *.rb|grep -v _darcs`
+    
+EXAMPLE
+    exit()
+  end
+   
+  opts.on("-f tagfile", String, "Output to tagfile") do |s|
+    $options.tagfile = s
+  end
+  opts.on("-a", "append mode") do 
+    $options.tagfile_mode = 'a'
+  end
+  opts.on("-w level", Integer, "Warning level (default 0)") do |w|
+    $options.warning_level = w
+  end
+  opts.on("--vi", "Use vi type tags (default is emacs)") do 
+    $options.vi = true
+  end
+  opts.on("-x", "Print cross reference file to stdout") do
+    $options.xref = true
+  end
+  opts.on("-b", "When using -x, only print base name. E.g., print only 'method' and not '::Module::Class#method'") do
+    $options.xref_only_base = true
+  end
+  opts.on("-B", "When using -x, only print absolute name. E.g., print only '::Module::Class#method' and not 'method'. Inverse of -b") do
+    $options.xref_only_abs = true
+  end
+  opts.on("--quiet", "Quiet mode") do 
+    $options.quiet = true
+  end
+  opts.on("--debug", "Debug output to stderr") do 
+    $options.debug = true
+  end
+  opts.on("--debug_tokens", "Debug token information to stdout") do 
+    $options.debug_tokens = true
+  end
+  opts.on("-R", "--recurse", "Recurse path for .rb files (default '.')") do 
+    $options.recurse = true
+  end
+  opts.on("-L file", String, "Read from file a list of file names for which tags should be generated.") do |f|
+    $options.files_in_list = f
+  end
+end.parse!(ARGV)
+
+if $options.tagfile == nil
+  if $options.vi
+    $options.tagfile = 'tags' 
+  else
+    $options.tagfile = 'TAGS' 
+  end
+end
+$options.tagfile_mode = 'w' if $options.tagfile_mode == nil
+$options.warning_level = -1 if $options.quiet
+if $options.recurse and ARGV.size == 0
+	ARGV.push '.'
+end
+
+print "\nrtags.rb #{RTAGS_VERSION} writing to file '#{$options.tagfile}'\n" if (!$options.quiet && !$options.xref)
+
+require "e2mmap"
+require "tracer"
+
+require "irb/ruby-lex"
+require "irb/ruby-token"
+
+class RubyLex
+  def identify_string_dvar
+  end
+end
+
+require "stringio"
+
+module RTAGS
+  @RCS_ID='-rtags.rb 0.95 -'
+
+  class RTToken
+    def initialize(readed, context, name, token)
+      @readed = readed
+      @context = context
+      @name = name
+      @token = token
+    end
+    attr :readed
+    attr :context
+    attr :name
+    attr :token
+
+    def line_no
+      @token.line_no
+    end
+
+    def seek
+      @token.seek
+    end
+
+    def to_s
+      "#{def_name} #{abs_name} in #{token.inspect}"
+    end
+  end
+
+  class RTModule < RTToken
+    def abs_name
+      (context || "") + "::" + name
+    end
+    
+    def def_name
+      "module"
+    end
+  end
+
+  class RTClass < RTModule
+    def abs_name
+      (context || "") + "::" + name
+    end
+
+    def def_name
+      "class"
+    end
+  end
+
+  class RTSingleClass < RTClass
+    def abs_name
+      (context || "") + "<<" + name
+    end
+
+    def def_name
+      "class"
+    end
+  end
+
+  class RTMethod < RTToken
+    def abs_name
+      (context || "") + "#" + name
+    end
+
+    def def_name
+      "method"
+    end
+  end
+	
+  class RTAlias < RTMethod
+    def def_name
+      "alias"
+    end
+  end
+	
+  class RTAttr < RTMethod
+    def def_name
+      "attr"
+    end
+  end
+
+  class RTClassCall < RTMethod
+    def abs_name
+      (context || "") + "!" + (token.name == name ? name : "#{token.name}(#{name})")
+    end
+
+    def def_name
+      "class call"
+    end
+  end
+
+  class RTSingleMethod < RTToken
+    def abs_name
+      (context || "") + "." + name
+    end
+
+    def def_name
+      "class method"
+    end
+  end
+	
+  class RTSingleAlias < RTSingleMethod
+    def def_name
+      "alias"
+    end
+  end
+	
+  class RTSingleAttr < RTSingleMethod
+    def def_name
+      "attr"
+    end
+  end
+
+  class RTSingleClassCall < RTSingleMethod
+    def abs_name
+      (context || "") + ":" + (token.name == name ? name : "#{token.name}(#{name})")
+    end
+
+    def def_name
+      "class call"
+    end
+  end
+  
+  class Parser
+    include RubyToken
+
+    def initialize(file_name)
+      @size = 0
+      @input_file_name = file_name
+      @scanner = RubyLex.new
+      @scanner.exception_on_syntax_error = false
+      # @scanner.skip_space = true
+      # @scanner.readed_auto_clean_up = true
+      #parse_statements
+    end
+
+		# display warnings on stderr, depending on the set warning_level
+
+		def warn s,level=0,token=nil,extra=nil
+			if level <= $options.warning_level
+	      $stderr.print "\nWarn: #{s} in <#{@input_file_name}> "
+				if token
+	  	    $stderr.print "in line #{token.line_no}, pos #{token.char_no}"
+					# $stderr.print "by name <#{token.name}>" if token and token.name
+					$stderr.print "\n"
+				end
+				if $options.debug
+      		$stderr.print "Token=",token.inspect,"\n" if token
+      		$stderr.print extra if extra
+				end
+			end
+		end
+
+		# Scan +@input_file_name+ for tags and yields each tag
+
+    def scan(&block)
+      print "\nParsing #{@input_file_name}..." if (!$options.quiet && !$options.xref)
+
+      input = StringIO.new(File.read(@input_file_name) + "\n")
+      @tokens = []
+      @unget_readed = []
+      @readed = []
+      @scanner.set_input(input)
+      parse_statements(&block)
+    end
+
+		# get the next token - fetching it from the temporary +@tokens+
+		# stack if it is not empty
+		
+    def get_tk
+      if @tokens.empty?
+        tk = @scanner.token
+        @readed.push @scanner.get_readed
+        $stderr.print tk.inspect if $options.debug_tokens
+        tk
+      else
+        @readed.push @unget_readed.shift
+        tk = @tokens.shift
+        $stderr.print tk.inspect if $options.debug_tokens
+        tk
+      end
+    end
+
+    # lookahead returning the next token without popping it
+    def peek_tk
+      unget_tk(tk = get_tk)
+      tk
+    end
+
+    # push the token +tk+ back onto the stack
+    def unget_tk(tk)
+      @tokens.unshift tk
+      @unget_readed.unshift @readed.pop
+    end
+
+    def skip_tkspace(skip_nl = true)
+      tokens = []
+      while ((tk = get_tk).kind_of?(TkSPACE) ||
+             (skip_nl && tk.kind_of?(TkNL)))
+        tokens.push tk
+      end
+      unget_tk(tk)
+      tokens
+    end
+
+    # returns the actual token string as it was read and 
+    # sets the read buffer to zero length
+    def get_tkreaded
+      readed = @readed.join("")
+      @readed = []
+      readed
+    end
+
+    NORMAL = "::"
+    SINGLE = "<<"
+
+		# The 'grunt' method splits a line into tokens and invokes the
+		# basic parsers for class, module, method etc.
+		
+    def parse_statements(context = nil, single = NORMAL, &block)
+      begin
+        last_seekpos = -1
+        nest = 1
+        symbeg = false
+
+        while (tk = get_tk)
+          case tk
+          when TkCLASS
+            parse_class(context, single, tk, &block)
+          when TkMODULE
+            parse_module(context, single, tk, &block)
+          when TkDEF
+            nest += 1
+            parse_method(context, single, tk, &block)
+          when TkALIAS
+            parse_alias(context, single, tk, &block)
+          when TkCASE,
+               TkDO,
+               TkFOR,
+               TkIF,
+               TkUNLESS,
+               TkUNTIL,
+               TkWHILE, 
+               TkBEGIN
+            nest += 1
+          when TkSYMBEG
+            symbeg = true
+          when TkIDENTIFIER
+            parse_identifier(context, single, nest, symbeg, tk, &block)
+            symbeg = false
+          when TkEND
+            return if (nest -= 1) == 0
+          end
+          begin
+            get_tkreaded
+            skip_tkspace(false) # don't skip newlines
+						# prevent endless loop (tokenizer does not always behave
+						# at eof)
+						tmp_tk = tk
+						seekpos = tmp_tk.seek if tmp_tk and tmp_tk.seek
+					  if last_seekpos == seekpos
+							warn('bailing out early',0,tk)
+            	return
+						end
+						last_seekpos = seekpos
+          end while peek_tk == TkNL
+					# p [@input_file_name, peek_tk]
+        end
+      rescue
+				warn('parse error',0,tk,"#{$!.message}:\n#{$!.backtrace.join("\n")}")
+      end
+    end
+
+    # Get the full name of the constant including namespaces
+    def parse_full_constant_name(name_token)
+      name = name_token.name
+      if peek_tk.kind_of? TkCOLON2
+        get_tk # skip the ::
+        namespaced_name_token = get_tk
+        rest = parse_full_constant_name(namespaced_name_token)
+        name += '::' + rest unless rest.nil?
+      end
+
+      name
+    end
+
+    def parse_class(context, single, tk, &block)
+      skip_tkspace
+      case name_t = get_tk
+      when TkCONSTANT
+        name = parse_full_constant_name(name_t)
+        if single == SINGLE
+          yield RTSingleClass.new(get_tkreaded, context, name, tk)
+        else
+          yield RTClass.new(get_tkreaded, context, name, tk)
+        end
+        parse_statements((context || "") + single + name, &block)
+
+      when TkLSHFT
+        skip_tkspace
+        case (name_t2 = get_tk)
+        when TkSELF
+          parse_statements(context, SINGLE, &block)
+        when TkCONSTANT, TkIVAR
+#          yield RTSingleClass.new(get_tkreaded, context, name_t2.name, tk)
+          parse_statements((context || "") + "::" + name_t2.name, 
+                           SINGLE,
+                           &block)
+        else
+          warn('unrecognised token',1,name_t2)
+        end
+      else
+        warn('unrecognised token',1,name_t2)
+      end
+    end
+
+    def parse_module(context, single, tk, &block)
+      skip_tkspace
+      name = get_tk.name
+      yield RTModule.new(get_tkreaded, context, name, tk)
+      parse_statements((context||"") + single + name, &block)
+    end
+
+    def parse_method(context, single, tk, &block)
+      skip_tkspace
+      name_t = get_tk
+      back_tk = skip_tkspace
+
+      if (dot = get_tk).kind_of?(TkDOT)
+        # tricky tech. Not sure when this gets reached - probably 
+				# 'static' definitions as part of modules
+        @scanner.instance_eval{@lex_state = EXPR_FNAME}
+        skip_tkspace
+        name_t2 = get_tk
+        case name_t
+        when TkSELF
+          name = name_t2.name
+        when TkId
+          if context and 
+              context =~ /^#{name_t.name}$/ || context =~ /::#{name_t.name}$/
+            name = name_t2.name
+          else
+            context = (context || "") + "::" + name_t.name
+            name = name_t2.name
+          end
+        else
+					warn('unrecognised token',1,name_t2)
+          #break
+        end
+        yield RTSingleMethod.new(get_tkreaded, context, name, tk)
+
+      else
+        unget_tk dot
+        back_tk.reverse_each do |tk|
+          unget_tk tk
+        end
+        name = name_t.name
+				# ---- if the method is an initialize make sure the class
+				# initiation (with Class.new) points to the tag
+				if name=='initialize'
+					name = 'new' 
+        	if context and context =~ /::(\S+)$/
+						name = $1+'.new'
+					end
+				end
+        if single == SINGLE
+          yield RTSingleMethod.new(get_tkreaded, context, name, tk)
+        else
+          yield RTMethod.new(get_tkreaded, context, name, tk)
+        end
+      end
+    end
+
+    def parse_alias(context, single, tk, &block)
+      skip_tkspace
+      if (token = get_tk).is_a? TkSYMBEG
+        # Name is in next token
+        token = get_tk
+      end
+
+      name = token.name
+      if context
+        if single == SINGLE
+          yield RTSingleAlias.new(get_tkreaded, context, name, tk)
+        else
+          yield RTAlias.new(get_tkreaded, context, name, tk)
+        end
+      else
+        if single == SINGLE
+          yield RTSingleAlias.new(get_tkreaded, "main", name, tk)
+        else
+          yield RTAlias.new(get_tkreaded, nil, name, tk)
+        end
+      end
+    end
+
+    def parse_attr(context, single, tk, &block)
+      args = parse_symbol_arg(1)
+      if args.size > 0
+        name = args[0]
+        if context
+          if single == SINGLE
+            yield RTSingleAttr.new(get_tkreaded, context, name, tk)
+          else
+            yield RTAttr.new(get_tkreaded, context, name, tk)
+          end
+        else
+          if single == SINGLE
+            yield RTSingleAttr.new(get_tkreaded, "main", name, tk)
+          else
+            yield RTAttr.new(get_tkreaded, nil, name, tk)
+          end
+        end
+      else
+				warn('token not recognized - next attr arg size == zero',1)
+      end    
+    end
+
+    def parse_attr_accessor(context, single, tk, &block)
+      args = parse_symbol_arg
+      readed = get_tkreaded
+      for name in args
+        if context
+          if single == SINGLE
+            yield RTSingleAttr.new(readed, context, name, tk)
+          else
+            yield RTAttr.new(readed, context, name, tk)
+          end
+        else
+          if single == SINGLE
+            yield RTSingleAttr.new(readed, "main", name, tk)
+          else
+            yield RTAttr.new(readed, nil, name, tk)
+          end
+        end
+      end    
+    end
+
+    KNOWN_CLASS_METHOD_CALLS = %w(belongs_to has_one has_many has_and_belongs_to_many after_create after_destroy after_find after_initialize after_save after_update after_validation around_create around_destroy around_save around_update before_create before_destroy before_save before_update before_validation)
+
+    def parse_known_class_method_calls(context, single, tk, &block)
+      args = parse_symbol_arg
+      readed = get_tkreaded
+      (args.empty? ? [tk.name] : args).each do |name|
+        if context
+          if single == SINGLE
+            yield RTSingleClassCall.new(readed, context, name, tk)
+          else
+            yield RTClassCall.new(readed, context, name, tk)
+          end
+        else
+          if single == SINGLE
+            yield RTSingleClassCall.new(readed, "main", name, tk)
+          else
+            yield RTClassCall.new(readed, nil, name, tk)
+          end
+        end
+      end
+    end
+
+    def parse_identifier(context, single, nest, symbeg, tk, &block)
+      case tk.name
+      when "attr"
+        parse_attr(context, single, tk, &block)
+      when /^attr_(reader|writer|accessor)$/
+        parse_attr_accessor(context, single, tk, &block)
+      else
+        if !context.nil? && nest == 1 && !symbeg
+          parse_known_class_method_calls(context, single, tk, &block)
+        end
+      end
+    end
+
+
+
+    def parse_symbol_arg(no = nil)
+      args = []
+      skip_tkspace
+      case (tk = get_tk)
+      when TkLPAREN
+        loop do
+          skip_tkspace
+          if tk1 = parse_symbol_in_arg
+            args.push tk1
+            break if no and args.size >= no
+          end
+
+          skip_tkspace
+          case tk2 = get_tk
+          when TkRPAREN
+            break
+          when TkCOMMA
+          else
+            warn('token not recognized in funargs',1,tk)
+            break
+          end
+        end
+      else
+        unget_tk tk
+
+        loop do
+          skip_tkspace(false)
+          case (tk1 = get_tk)
+          when TkCOMMA
+          when TkDO, TkNL
+            unget_tk tk1
+            break
+          else
+            skip_tkspace
+            unget_tk tk1
+            if tk = parse_symbol_in_arg
+              args.push tk
+              break if no and args.size >= no
+            else
+	      warn('token not recognized in funargs',1,tk1)
+
+              unless args.empty?
+                while (tk2 = get_tk) && !tk2.is_a?(TkNL) && !tk2.is_a?(TkDO)
+                end
+                unget_tk tk2
+                return args
+              end
+              return args
+            end
+          end
+        end
+      end
+      args
+    end
+
+    def parse_symbol_in_arg
+      case (tk = get_tk)
+      when TkSYMBEG
+        case (tk1 = get_tk)
+        when TkIDENTIFIER
+          tokens = skip_tkspace(false)
+          if (tk2 = get_tk).is_a?(TkASSIGN)
+            unget_tk tk2
+            tokens.each { |tk3| unget_tk tk3 }
+            unget_tk tk1
+            unget_tk tk
+	    warn('token not recognized; next ',1,tk)
+            nil
+          else
+            tokens.each { |tk3| unget_tk tk3 }
+            tk1.name
+          end
+        when TkCONSTANT, TkFID
+          tk1.name
+        else
+          unget_tk tk1
+          warn('token not recognized; next SYMBEG ',1,tk1)
+          nil
+        end
+      when TkSTRING
+        eval @readed[-1]
+      else
+        unget_tk tk
+        warn('token not recognized; next SYMBEG and STRING ',1,tk) if $options.debug 
+        nil
+      end
+    end
+  end
+
+	module Filter
+
+		# Test for boring repository directories that should be skipped
+		def Filter::skipdir name
+			if name =~ /\/(\.svn|\.hg|_darcs|CVS|\.git)/
+				print "\nSkipping boring directory #{name}"
+				return true
+			end
+			false
+		end
+
+		# Test whether this is a Ruby file
+		def Filter::skipfile name
+	  	if name =~ /.rb$/i
+				return false
+			end
+			# OK - test for magic hash bang
+			firstline = File.new(name, :encoding => "BINARY").gets
+			return false if firstline =~ /^#\!/ and firstline =~ /ruby/i
+			true
+		end
+		
+	end
+	
+  class TAGS
+    def initialize(files)
+      if $options.recurse
+        @files = []
+        recurse = lambda do |fname|
+          if File.directory? fname and not Filter::skipdir(fname)
+            Dir.entries(fname).select {|f| f !~ /^\.(?:\.|\w+)?$/ }.map {|f| fname+'/'+f }.each(&recurse)
+          else
+            # is a file
+						if File.file?(fname) and not Filter::skipfile(fname)
+	            # @files.push(fname) if fname =~ /.rb$/i
+	            @files.push(fname)
+						end
+          end
+        end
+        files.each(&recurse)
+      else
+        @files = files
+      end
+    end
+  end
+
+  class EMACS_TAGS < TAGS
+		# Create the tags file in emacs mode
+    def shipout
+      open($options.tagfile, $options.tagfile_mode) do |out|
+        @output = out
+        @files.each do |fn|
+          if File.directory? fn
+            puts "\nWarning: #{fn} is a directory - SKIPPING. Specify --recurse option to recurse into directories.\n"
+            next
+          end
+          output = []
+          size = 0
+
+          $stderr.printf "--\n-- parse file: %s\n", fn if $options.debug
+          parser = Parser.new(fn)
+          parser.scan do |tk|
+            $stderr.print tk, "\n" if $options.debug
+						line = tk.readed.split(/\n/)[0]
+            item = sprintf("%s\C-?%s\C-A%d,%s\n",
+                           line,
+                           tk.abs_name,
+                           tk.line_no,
+                           tk.seek)
+            output.push item
+            size += item.size
+          end
+          @output.print "\C-L\n#{fn},#{size}\n"
+          @output.print output.join
+        end
+      end
+    end
+  end
+
+  class VI_TAGS < TAGS
+		# Create the tags file in vi(m) mode
+    def shipout
+      output = []
+      @files.each do |fn|
+        if File.directory? fn
+          puts "\nWarning: #{fn} is a directory - SKIPPING. Specify --recurse option to recurse into directories.\n"
+          next
+        end
+        
+        $stderr.printf "--\n-- parse file: %s\n", fn if $options.debug
+        parser = Parser.new(fn) 
+        parser.scan do |tk|
+          $stderr.print tk, "\n" if $options.debug
+					line = tk.readed.split(/\n/)[0]
+          output.push sprintf("%s\t%s\t/^%s/\n",
+                                tk.name,
+                                fn,
+                                line)
+          output.push sprintf("%s\t%s\t/^%s/\n",
+                                tk.abs_name,
+                                fn,
+                                line)
+        end
+      end
+			# sort entries
+      open($options.tagfile, $options.tagfile_mode) do |out|
+        out << output.sort!.join
+      end
+    end
+  end
+
+  class XREF_TAGS < TAGS
+    # Print cross ref file (like ctags -x)
+    def shipout
+      output = []
+      @files.each do |fn|
+        if File.directory? fn
+          puts "\nWarning: #{fn} is a directory - SKIPPING. Specify --recurse option to recurse into directories.\n"
+          next
+        end
+
+        size = 0
+        
+        $stderr.printf "--\n-- parse file: %s\n", fn if $options.debug
+        parser = Parser.new(fn)
+        parser.scan do |tk|
+          $stderr.print tk, "\n" if $options.debug
+          line = tk.readed.split(/\n/)[0]
+          unless $options.xref_only_abs
+            output.push sprintf("%-16s %-10s %4d %-16s %s\n",
+                                tk.name.gsub(/^::/, "").gsub(" ", "_"),
+                                tk.def_name,
+                                tk.line_no,
+                                fn,
+                                line)
+          end
+
+          unless $options.xref_only_base
+            output.push sprintf("%-16s %-10s %4d %-16s %s\n",
+                                tk.abs_name.gsub(/^::/, "").gsub(" ", "_"),
+                                tk.def_name,
+                                tk.line_no,
+                                fn,
+                                line)
+          end
+        end
+      end
+      puts output.join
+    end
+  end
+
+  
+end
+
+if (!$options.files_in_list && ARGV.size == 0) or ARGV[0] == '--help'
+        ARGV.shift
+        print usage
+        exit 1
+end
+
+files = ARGV
+files += File.readlines($options.files_in_list).map { |f| f.chomp } if $options.files_in_list
+
+if $options.vi
+  tags = RTAGS::VI_TAGS.new(files)
+elsif $options.xref
+  tags = RTAGS::XREF_TAGS.new(files)
+else
+  tags = RTAGS::EMACS_TAGS.new(files)
+end
+tags.shipout
+print "\n" if !$options.xref
+$stderr.print "\nEnd - tagfile generated\n" if (!$options.quiet && !$options.xref)

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: bloopletech-rtags
+version: !ruby/object:Gem::Version
+  version: 0.99.1
+  prerelease: 
+platform: ruby
+authors:
+- Pjotr Prins, Keiju Ishitsuka
+autorequire: irb
+bindir: bin
+cert_chain: []
+date: 2013-01-23 00:00:00.000000000 Z
+dependencies: []
+description: This is the original commit of the rtags source code as written by Keiju
+  ISHITSUKA as part of the irb project. Now irb has moved into the main Ruby source
+  tree rtags has become an independent project
+email: pjotr.public02@thebird.nl
+executables:
+- rtags
+extensions: []
+extra_rdoc_files: []
+files:
+- RELEASENOTES
+- TODO
+- README
+- LICENSE.txt
+- bin/rtags
+homepage: http://rtags.rubyforge.org
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: rtags
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: rtags is a Ruby replacement for ctags - allowing for name navigation in source
+  code using vim, emacs and others
+test_files: []
+has_rdoc: false