ripper-tags 0.1.0

data/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+gemspec
+
+gem 'rake'
+gem 'ripper', :platforms => :mri_18

data/README.md

@@ -0,0 +1,57 @@
+## ripper-tags
+
+fast, accurate ctags generator for ruby source code using Ripper
+
+### usage (bin)
+
+```
+$ ripper-tags /usr/lib/ruby/1.8/timeout.rb
+   30  module   Timeout
+   35   class   Timeout::Error < Interrupt
+   37   class   Timeout::ExitException < Exception
+   40   const   Timeout::THIS_FILE
+   41   const   Timeout::CALLER_OFFSET
+   52     def   Timeout#timeout
+  100     def   Object#timeout
+  108   const   TimeoutError
+
+$ ripper-tags --debug /usr/lib/ruby/1.8/timeout.rb
+[[:module,
+  ["Timeout", 30],
+  [[:class, ["Error", 35], ["Interrupt", 35], []],
+   [:class, ["ExitException", 37], ["Exception", 37], []],
+   [:assign, "THIS_FILE", 40],
+   [:assign, "CALLER_OFFSET", 41],
+   [:def, "timeout", 52]]],
+ [:def, "timeout", 100],
+ [:assign, "TimeoutError", 108]]
+
+$ ripper-tags --vim /usr/lib/ruby/1.8/timeout.rb
+!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
+!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
+CALLER_OFFSET	/usr/lib/ruby/1.8/timeout.rb	/^  CALLER_OFFSET = ((c = caller[0]) && THIS_FILE =~ c) ? 1 : 0$/;"	C	class:Timeout
+Error	/usr/lib/ruby/1.8/timeout.rb	/^  class Error < Interrupt$/;"	c	class:Timeout	inherits:Interrupt
+ExitException	/usr/lib/ruby/1.8/timeout.rb	/^  class ExitException < ::Exception # :nodoc:$/;"	c	class:Timeout	inherits:Exception
+THIS_FILE	/usr/lib/ruby/1.8/timeout.rb	/^  THIS_FILE = \/\\A#{Regexp.quote(__FILE__)}:\/o$/;"	C	class:Timeout
+Timeout	/usr/lib/ruby/1.8/timeout.rb	/^module Timeout$/;"	m
+TimeoutError	/usr/lib/ruby/1.8/timeout.rb	/^TimeoutError = Timeout::Error # :nodoc:$/;"	C	class:
+timeout	/usr/lib/ruby/1.8/timeout.rb	/^def timeout(n, e = nil, &block) # :nodoc:$/;"	f	class:Object
+timeout	/usr/lib/ruby/1.8/timeout.rb	/^  def timeout(sec, klass = nil)$/;"	f	class:Timeout
+
+$ ripper-tags --json /usr/lib/ruby/1.8/timeout.rb
+{"full_name":"Timeout","name":"Timeout","kind":"module","line":30,"language":"Ruby","path":"/usr/lib/ruby/1.8/timeout.rb","pattern":"module Timeout"}
+{"full_name":"Timeout::Error","name":"Error","class":"Timeout","inherits":"Interrupt","kind":"class","line":35,"language":"Ruby","path":"/usr/lib/ruby/1.8/timeout.rb","pattern":"  class Error < Interrupt"}
+{"full_name":"Timeout::ExitException","name":"ExitException","class":"Timeout","inherits":"Exception","kind":"class","line":37,"language":"Ruby","path":"/usr/lib/ruby/1.8/timeout.rb","pattern":"  class ExitException < ::Exception # :nodoc:"}
+{"name":"THIS_FILE","full_name":"Timeout::THIS_FILE","class":"Timeout","kind":"constant","line":40,"language":"Ruby","path":"/usr/lib/ruby/1.8/timeout.rb","pattern":"  THIS_FILE = /\\A#{Regexp.quote(__FILE__)}:/o"}
+{"name":"CALLER_OFFSET","full_name":"Timeout::CALLER_OFFSET","class":"Timeout","kind":"constant","line":41,"language":"Ruby","path":"/usr/lib/ruby/1.8/timeout.rb","pattern":"  CALLER_OFFSET = ((c = caller[0]) && THIS_FILE =~ c) ? 1 : 0"}
+{"name":"timeout","full_name":"Timeout#timeout","class":"Timeout","kind":"method","line":52,"language":"Ruby","path":"/usr/lib/ruby/1.8/timeout.rb","pattern":"  def timeout(sec, klass = nil)"}
+{"name":"timeout","full_name":"Object#timeout","class":"Object","kind":"method","line":100,"language":"Ruby","path":"/usr/lib/ruby/1.8/timeout.rb","pattern":"def timeout(n, e = nil, &block) # :nodoc:"}
+{"name":"TimeoutError","full_name":"TimeoutError","class":"","kind":"constant","line":108,"language":"Ruby","path":"/usr/lib/ruby/1.8/timeout.rb","pattern":"TimeoutError = Timeout::Error # :nodoc:"}
+```
+
+### usage (api)
+
+``` ruby
+require 'tag_ripper'
+tags = TagRipper.extract("def abc() end", "mycode.rb")
+```

data/Rakefile

@@ -0,0 +1,6 @@
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new 'test' do |t|
+  t.test_files = FileList['test/test_*.rb']
+end

data/bin/ripper-tags

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+require 'tag_ripper'
+require 'pp'
+
+if ARGV.delete('--json')
+  require 'yajl'
+  json = true
+end
+if ARGV.delete('--debug')
+  debug = true
+end
+if ARGV.delete('--vim')
+  vim = true
+  all_tags = []
+end
+
+ARGV.each do |file|
+  begin
+    data = File.read(file)
+    sexp = TagRipper.new(data, file).parse
+    v = TagRipper::Visitor.new(sexp, file, data)
+
+    if debug
+      pp sexp
+    elsif json
+      v.tags.each do |tag|
+        puts Yajl.dump(tag)
+      end
+    elsif vim
+      all_tags += v.tags
+    else
+      v.tags.each do |tag|
+        kind = case tag[:kind]
+        when /method$/ then 'def'
+        when /^const/  then 'const'
+        else tag[:kind]
+        end
+        if kind == 'class' && tag[:inherits]
+          suffix = " < #{tag[:inherits]}"
+        else
+          suffix = ''
+        end
+
+        puts "#{tag[:line].to_s.rjust(5)}  #{kind.to_s.rjust(6)}   #{tag[:full_name]}#{suffix}"
+      end
+    end
+  rescue Exception => e
+    STDERR.puts [e, file].inspect
+    raise e
+  end
+end
+
+if vim
+  puts <<-EOC
+!_TAG_FILE_FORMAT\t2\t/extended format; --format=1 will not append ;" to lines/
+!_TAG_FILE_SORTED\t1\t/0=unsorted, 1=sorted, 2=foldcase/
+EOC
+
+  all_tags.sort_by!{ |t| t[:name] }
+  all_tags.each do |tag|
+    kwargs = ''
+    kwargs << "\tclass:#{tag[:class].gsub('::','.')}" if tag[:class]
+    kwargs << "\tinherits:#{tag[:inherits].gsub('::','.')}" if tag[:inherits]
+
+    kind = case tag[:kind]
+           when 'method' then 'f'
+           when 'singleton method' then 'F'
+           when 'constant' then 'C'
+           else tag[:kind].slice(0,1)
+           end
+
+    code = tag[:pattern].gsub('\\','\\\\\\\\').gsub('/','\\/')
+    puts "%s\t%s\t/^%s$/;\"\t%c%s" % [tag[:name], tag[:path], code, kind, kwargs]
+  end
+end

data/lib/tag_ripper.rb

@@ -0,0 +1,241 @@
+require 'ripper'
+
+class TagRipper < Ripper
+  def self.extract(data, file='(eval)')
+    sexp = new(data, file).parse
+    Visitor.new(sexp, file, data).tags
+  end
+
+  SCANNER_EVENTS.each do |event|
+    module_eval(<<-End, __FILE__, __LINE__ + 1)
+      def on_#{event}(tok)
+        [tok, lineno]
+      end
+    End
+  end
+
+  def on_stmts_add(first, *rest)
+    (first || []) + rest.compact
+  end
+
+  def on_module(name, body)
+    [:module, name, *body.compact]
+  end
+  def on_class(name, superclass, body)
+    superclass.flatten!(1) if superclass
+    [:class, name, superclass, *body.compact]
+  end
+  def on_def(method, args, body)
+    [:def, *method]
+  end
+  def on_defs(receiver, op, method, args, body)
+    receiver.flatten!(1) if receiver
+    [:defs, receiver && receiver[0], *method]
+  end
+  def on_alias(lhs, rhs)
+    [:alias, lhs[0], rhs[0], rhs[1]]
+  end
+  def on_assign(lhs, rhs)
+    return if lhs.nil?
+    return if lhs[0] == :field
+    return if lhs[0] == :aref_field
+    [:assign, *lhs.flatten(1)]
+  end
+  def on_sclass(name, body)
+    [:sclass, name && name.flatten(1), *body.compact]
+  end
+  def on_field(lhs, op, rhs)
+    [:field, lhs && lhs[0], rhs[0], rhs[1]]
+  end
+  def on_aref_field(*args)
+    [:aref_field, *args]
+  end
+
+  def on_const_path_ref(a, b)
+    a.flatten!(1)
+    [[a && a[0], b[0]].join('::'), b[1]]
+  end
+
+  def on_binary(*args)
+  end
+
+  def on_command(name, *args)
+    # if name =~ /^(attr_|alias)/
+    #   [name.to_sym, *args]
+    # end
+  end
+  def on_bodystmt(*args)
+    args
+  end
+  def on_if(condition, success, failure)
+    ret = [success, failure].flatten(1).compact
+    ret.any?? ret : nil
+  end
+
+  def on_unless_mod(condition, success)
+    nil
+  end
+  alias on_if_mod on_unless_mod
+
+  def on_var_ref(*args)
+    on_vcall(*args) || args
+  end
+
+  def on_vcall(name)
+    [name[0].to_sym] if name[0].to_s =~ /private|protected|public$/
+  end
+
+  def on_call(lhs, op, rhs)
+    [:call, lhs && lhs[0], rhs && rhs[0], rhs[1]]
+  end
+
+  def on_do_block(*args)
+    args
+  end
+
+  def on_method_add_block(method, body)
+    return unless method and body
+    if method[2] == 'class_eval'
+      [:class_eval, [method[1], method[3]], body.last]
+    end
+  end
+
+  class Visitor
+    attr_reader :tags
+
+    def initialize(sexp, path, data)
+      @path = path
+      @lines = data.split("\n")
+      @namespace = []
+      @tags = []
+
+      process(sexp)
+    end
+
+    def emit_tag(kind, line, opts={})
+      @tags << opts.merge(
+        :kind => kind.to_s,
+        :line => line,
+        :language => 'Ruby',
+        :path => @path,
+        :pattern => @lines[line-1].chomp,
+        :access => @current_access
+      ).delete_if{ |k,v| v.nil? }
+    end
+
+    def process(sexp)
+      return unless sexp
+      return if Symbol === sexp
+
+      case sexp[0]
+      when Array
+        sexp.each{ |child| process(child) }
+      when Symbol
+        name, *args = sexp
+        __send__("on_#{name}", *args)
+      when String, nil
+        # nothing
+      end
+    end
+
+    def on_module_or_class(kind, name, superclass, body)
+      name, line = *name
+      @namespace << name
+
+      prev_access = @current_access
+      @current_access = nil
+
+      if superclass
+        superclass_name = superclass[0] == :call ?
+          superclass[1] :
+          superclass[0]
+      end
+      full_name = @namespace.join('::')
+      parts = full_name.split('::')
+      class_name = parts.pop
+
+      emit_tag kind, line,
+        :full_name => full_name,
+        :name => class_name,
+        :class => parts.any? && parts.join('::') || nil,
+        :inherits => superclass_name
+
+      process(body)
+    ensure
+      @current_access = prev_access
+      @namespace.pop
+    end
+
+    def on_module(name, body)
+      on_module_or_class(:module, name, nil, body)
+    end
+
+    def on_class(name, superclass, body)
+      on_module_or_class(:class, name, superclass, body)
+    end
+
+    def on_private()   @current_access = 'private'   end
+    def on_protected() @current_access = 'protected' end
+    def on_public()    @current_access = 'public'    end
+
+    def on_assign(name, line)
+      return unless name =~ /^[A-Z]/
+
+      emit_tag :constant, line,
+        :name => name,
+        :full_name => (@namespace + [name]).join('::'),
+        :class => @namespace.join('::')
+    end
+
+    def on_alias(name, other, line)
+      ns = (@namespace.empty?? 'Object' : @namespace.join('::'))
+
+      emit_tag :alias, line,
+        :name => name,
+        :inherits => other,
+        :full_name => "#{ns}#{@is_singleton ? '.' : '#'}#{name}",
+        :class => ns
+    end
+
+    def on_def(name, line)
+      kind = @is_singleton ? 'singleton method' : 'method'
+      ns = (@namespace.empty?? 'Object' : @namespace.join('::'))
+
+      emit_tag kind, line,
+        :name => name,
+        :full_name => "#{ns}#{@is_singleton ? '.' : '#'}#{name}",
+        :class => ns
+    end
+
+    def on_defs(klass, name, line)
+      ns = (@namespace + [klass != 'self' ? klass : nil]).compact
+      emit_tag 'singleton method', line,
+        :name => name,
+        :full_name => ns.join('::') + ".#{name}",
+        :class => ns.join('::')
+    end
+
+    def on_sclass(name, body)
+      name, line = *name
+      @namespace << name unless name == 'self'
+      prev_is_singleton, @is_singleton = @is_singleton, true
+      process(body)
+    ensure
+      @namespace.pop     unless name == 'self'
+      @is_singleton = prev_is_singleton
+    end
+
+    def on_class_eval(name, body)
+      name, line = *name
+      @namespace << name
+      process(body)
+    ensure
+      @namespace.pop
+    end
+
+    def on_call(*args)
+    end
+    alias on_aref_field on_call
+    alias on_field on_call
+  end
+end

data/ripper-tags.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |s|
+  s.name = 'ripper-tags'
+  s.version = '0.1.0'
+
+  s.summary = 'ctags generator for ruby code'
+  s.description = 'fast, accurate ctags generator for ruby source code using Ripper'
+
+  s.homepage = 'http://github.com/tmm1/ripper-tags'
+  s.has_rdoc = false
+
+  s.authors = ['Aman Gupta']
+  s.email = ['aman@tmm1.net']
+
+  s.add_dependency 'yajl-ruby'
+
+  s.require_paths = ['lib']
+  s.bindir = 'bin'
+  s.executables << 'ripper-tags'
+
+  s.files = `git ls-files`.split("\n")
+end

data/test/test_ripper_tags.rb

@@ -0,0 +1,76 @@
+require File.expand_path('../../lib/tag_ripper', __FILE__)
+require 'test/unit'
+
+class TagRipperTest < Test::Unit::TestCase
+  def test_extract_basics
+    tags = TagRipper.extract(<<-EOC)
+      Const1 = 123
+      def gmethod
+      end
+      module M
+        class C
+          Const2 = 456
+          def imethod
+          end
+          alias imethod_alias imethod
+          def self.cmethod
+          end
+        end
+      end
+      class M::C
+        def imethod2
+        end
+        def self.cmethod2
+        end
+        class << self
+          def cmethod3
+          end
+          alias cmethod_alias cmethod3
+        end
+      end
+      M::C.class_eval do
+        def imethod3
+        end
+        def self.cmethod4
+        end
+      end
+    EOC
+
+    assert_equal %w[
+      Const1
+      Object#gmethod
+      M
+      M::C
+      M::C::Const2
+      M::C#imethod
+      M::C#imethod_alias
+      M::C.cmethod
+      M::C
+      M::C#imethod2
+      M::C.cmethod2
+      M::C.cmethod3
+      M::C.cmethod_alias
+      M::C#imethod3
+      M::C.cmethod4
+    ], tags.map{ |t| t[:full_name] }
+  end
+
+  def test_extract_access
+    tags = TagRipper.extract(<<-EOC)
+      class Test
+        def abc() end
+      private
+        def def() end
+      protected
+        def ghi() end
+      public
+        def jkl() end
+      end
+    EOC
+
+    assert_equal nil,         tags.find{ |t| t[:name] == 'abc' }[:access]
+    assert_equal 'private',   tags.find{ |t| t[:name] == 'def' }[:access]
+    assert_equal 'protected', tags.find{ |t| t[:name] == 'ghi' }[:access]
+    assert_equal 'public',    tags.find{ |t| t[:name] == 'jkl' }[:access]
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: ripper-tags
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Aman Gupta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-01-01 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: fast, accurate ctags generator for ruby source code using Ripper
+email: 
+- aman@tmm1.net
+executables: 
+- ripper-tags
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- README.md
+- Rakefile
+- bin/ripper-tags
+- lib/tag_ripper.rb
+- ripper-tags.gemspec
+- test/test_ripper_tags.rb
+homepage: http://github.com/tmm1/ripper-tags
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: ctags generator for ruby code
+test_files: []
+