ripper-tags 0.1.3 → 0.2.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    Yzc2MzlhZjllZTM4NTk1OWMzNmU3ZjkyNDIxNjVmYTk1NmJiOGJhZA==
-  data.tar.gz: !binary |-
-    ZDlmM2U4YmUyNzZkMGY3OTkxNTRmNWRjMGQxZTk1YjQzN2NiZGZlZA==
+SHA1:
+  metadata.gz: 5a6a3d465781a89ac1728aae902fad12c456bbeb
+  data.tar.gz: cd72ea7c347ac44cf838eb4f68a2e6a4de44f269
 SHA512:
-  metadata.gz: !binary |-
-    Zjg2MDJmOTg4Y2UwYTA4MzI0ZDUwNWEzYWY3ZGZkYmE5ZTQ5YTRkN2FkMWZm
-    MmQ1ODdmNmZhNWYwYzA1MzM4ZWY1OWNlMTU2M2VmNjI3MWNiYWVlZGJhY2M3
-    MTEzNGQ3NDQ1ZmUyOGVlNjRlM2I0Njc4YzdjN2M3ZjNiOWQ3YjU=
-  data.tar.gz: !binary |-
-    NGY3N2YxMzU0NDM2MmIyNjRiZGU4MmUwNThmYzE2YjVjMWFlMjdmMzMwMTkx
-    NzkxZWViZWZjMzRhNmRjZDYxYjQ2ZWNhNGI2MWI1ZjNhZTlmODBjN2VmYjcy
-    ZjNkYjU0MjE4MTlhZmI5Nzc1ZDBkZTcwNDYxYTA4NmFhZDI5NTc=
+  metadata.gz: 5f0dc42cefd0807694183b743b1525926c6865b8474f7f17d20c95c1031a2c8d6b27930f4cd0c301d2845a5a773ccdea9a6e369997eb326f4ffa7698081e0683
+  data.tar.gz: e058985d5b4f662329e190a08e74f18df15138b68d07581028a3f0f42c2728064233725d1e0a9796e691a0c25d10efabfcaa449701b6aef2088952796c3903ab

data/lib/ripper-tags.rb

@@ -1,5 +1,6 @@
 require 'optparse'
 require 'ostruct'
+require 'set'
 require 'ripper-tags/parser'
 require 'ripper-tags/data_reader'
 require 'ripper-tags/default_formatter'
@@ -8,11 +9,14 @@ require 'ripper-tags/vim_formatter'
 require 'ripper-tags/json_formatter'
 
 module RipperTags
-  def self.version() "0.1.2" end
+  def self.version() "0.2.0" end
+
+  FatalError = Class.new(RuntimeError)
 
   def self.default_options
     OpenStruct.new \
       :format => nil,
+      :extra_flags => Set.new,
       :tag_file_name => "./tags",
       :tag_relative => nil,
       :debug => false,
@@ -36,8 +40,8 @@ module RipperTags
              '"-" outputs to standard output') do |fname|
         options.tag_file_name = fname
       end
-      opts.on("--tag-relative", "Make file paths relative to the directory of the tag file") do
-        options.tag_relative = true
+      opts.on("--tag-relative[=OPTIONAL]", "Make file paths relative to the directory of the tag file") do |value|
+        options.tag_relative = value != "no"
       end
       opts.on("-R", "--recursive", "Descend recursively into subdirectories") do
         options.recursive = true
@@ -61,6 +65,16 @@ module RipperTags
       opts.on("-e", "--emacs", "Output Emacs format (default if `--tag-file' is `TAGS')") do
         options.format = "emacs"
       end
+      opts.on("--extra=FLAGS", "Specify extra flags for the formatter") do |flags|
+        flags = flags.split("")
+        operation = :add
+        if flags[0] == "+" || flags[0] == "-"
+          operation = :delete if flags.shift == "-"
+        else
+          options.extra_flags.clear
+        end
+        flags.each { |f| options.extra_flags.send(operation, f) }
+      end
 
       opts.separator ""
 
@@ -76,6 +90,22 @@ module RipperTags
       opts.on_tail("--force", "Skip files with parsing errors") do
         options.force = true
       end
+      opts.on_tail("--list-kinds=LANG", "Print tag kinds that this parser supports and exit") do |lang|
+        if lang.downcase == "ruby"
+          puts((<<-OUT).gsub(/^ +/, ''))
+            c  classes
+            f  methods
+            m  modules
+            F  singleton methods
+            C  constants
+            a  aliases
+          OUT
+          exit
+        else
+          $stderr.puts "Error: language %p is not supported" % lang
+          exit 1
+        end
+      end
       opts.on_tail("-v", "--version", "Print version information") do
         puts opts.ver
         exit
@@ -104,7 +134,7 @@ module RipperTags
     when "emacs"  then RipperTags::EmacsFormatter
     when "json"   then RipperTags::JSONFormatter
     when "custom" then RipperTags::DefaultFormatter
-    else raise ArgumentError, "unknown format: #{options.format.inspect}"
+    else raise FatalError, "unknown format: #{options.format.inspect}"
     end.new(options)
   end
 
@@ -116,5 +146,11 @@ module RipperTags
         formatter.write(tag, out)
       end
     end
+  rescue FatalError => err
+    $stderr.puts "%s: %s" % [
+      File.basename($0),
+      err.message
+    ]
+    exit 1
   end
 end

data/lib/ripper-tags/data_reader.rb

@@ -61,9 +61,11 @@ module RipperTags
 
   class DataReader
     attr_reader :options
+    attr_accessor :read_mode
 
     def initialize(options)
       @options = options
+      @read_mode = defined?(::Encoding) ? 'r:utf-8' : 'r'
     end
 
     def file_finder
@@ -71,7 +73,7 @@ module RipperTags
     end
 
     def read_file(filename)
-      str = File.open(filename, 'r:utf-8') {|f| f.read }
+      str = File.open(filename, read_mode) {|f| f.read }
       normalize_encoding(str)
     end
 

data/lib/ripper-tags/default_formatter.rb

@@ -1,4 +1,5 @@
 require 'pathname'
+require 'set'
 
 module RipperTags
   class DefaultFormatter
@@ -6,6 +7,22 @@ module RipperTags
 
     def initialize(options)
       @options = options
+
+      if @options.extra_flags
+        unsupported = @options.extra_flags - supported_flags.to_set
+        if unsupported.any?
+          raise FatalError, "these flags are not supported in the '%s' format: %s" % [
+            options.format,
+            unsupported.to_a.join(", ")
+          ]
+        end
+      end
+    end
+
+    def supported_flags() [] end
+
+    def extra_flag?(flag)
+      options.extra_flags && options.extra_flags.include?(flag)
     end
 
     def stdout?
@@ -35,6 +52,10 @@ module RipperTags
       end
     end
 
+    def constant?(tag)
+      tag[:kind] == 'class' || tag[:kind] == 'module' || tag[:kind] == 'constant'
+    end
+
     def display_kind(tag)
       case tag.fetch(:kind)
       when /method$/ then 'def'

data/lib/ripper-tags/emacs_formatter.rb

@@ -17,6 +17,13 @@ module RipperTags
       @section_io = nil
     end
 
+    def supported_flags() ['q'] end
+
+    def include_qualified_names?
+      return @include_qualified_names if defined? @include_qualified_names
+      @include_qualified_names = extra_flag?('q')
+    end
+
     def with_output
       super do |io|
         begin
@@ -30,7 +37,10 @@ module RipperTags
     def write(tag, io)
       filename = relative_path(tag)
       section_io = start_file_section(filename, io)
-      super(tag, section_io)
+      section_io.puts format(tag)
+      if include_qualified_names? && tag[:full_name] != tag[:name] && constant?(tag)
+        section_io.puts format(tag, :full_name)
+      end
     end
 
     def start_file_section(filename, io)
@@ -56,11 +66,10 @@ module RipperTags
       "\x0C\n%s,%d\n" % [ filename, data_size ]
     end
 
-    def format(tag)
-      pattern = tag.fetch(:pattern)
+    def format(tag, name_field = :name)
       "%s\x7F%s\x01%d,%d" % [
         tag.fetch(:pattern),
-        tag.fetch(:name),
+        tag.fetch(name_field),
         tag.fetch(:line),
         0,
       ]

data/lib/ripper-tags/json_formatter.rb

@@ -1,10 +1,34 @@
-require 'yajl'
+begin
+  require 'yajl/json_gem' unless defined?(::JSON)
+rescue LoadError
+  require 'json'
+end
 require 'ripper-tags/default_formatter'
 
 module RipperTags
   class JSONFormatter < DefaultFormatter
-    def format(tag)
-      Yajl.dump(tag)
+    def supported_flags() ['s'] end
+
+    def stream_format?
+      return @stream_format if defined? @stream_format
+      @stream_format = extra_flag?('s')
+    end
+
+    def with_output
+      super do |true_out|
+        buffer = []
+        yield buffer
+
+        if stream_format?
+          buffer.each { |tag| true_out.puts ::JSON.dump(tag) }
+        else
+          true_out.write ::JSON.dump(buffer)
+        end
+      end
+    end
+
+    def write(tag, buffer)
+      buffer << tag
     end
   end
 end

data/lib/ripper-tags/parser.rb

@@ -81,6 +81,7 @@ class Parser < Ripper
     ret = [success, failure].flatten(1).compact
     ret.any?? ret : nil
   end
+  alias on_unless on_if
 
   def on_unless_mod(condition, success)
     nil
@@ -93,6 +94,7 @@ class Parser < Ripper
     end
   end
 
+  undef on_tstring_content
   def on_tstring_content(str)
     str
   end
@@ -144,13 +146,14 @@ class Parser < Ripper
           gen
         end
       when "has_many", "has_and_belongs_to_many"
-        a = args[1][0].to_s
+        a = args[1][0]
         kind = name.to_sym
         gen = []
-        unless a.is_a?(Enumerable)
+        unless a.is_a?(Enumerable) && !a.is_a?(String)
+          a = a.to_s
           gen << [:rails_def, kind, a, line]
           gen << [:rails_def, kind, "#{a}=", line]
-          if a.respond_to?(:chomp) && (sing = a.chomp('s')) != a
+          if (sing = a.chomp('s')) != a
             # poor man's singularize
             gen << [:rails_def, kind, "#{sing}_ids", line]
             gen << [:rails_def, kind, "#{sing}_ids=", line]
@@ -159,10 +162,10 @@ class Parser < Ripper
         gen
       when "belongs_to", "has_one"
         a = args[1][0]
-        unless a.is_a?(Enumerable)
+        unless a.is_a?(Enumerable) && !a.is_a?(String)
           kind = name.to_sym
-          %W[ #{a} #{a}= build_#{a} create_#{a} create_#{a}! ].inject([]) do |gen, ident|
-            gen << [:rails_def, kind, ident, line]
+          %W[ #{a} #{a}= build_#{a} create_#{a} create_#{a}! ].inject([]) do |all, ident|
+            all << [:rails_def, kind, ident, line]
           end
         end
       end
@@ -224,6 +227,8 @@ end
       @lines = data.split("\n")
       @namespace = []
       @tags = []
+      @is_singleton = false
+      @current_access = nil
 
       process(sexp)
     end
@@ -248,14 +253,13 @@ end
         sexp.each{ |child| process(child) }
       when Symbol
         name, *args = sexp
-        handler = "on_#{name}"
-        __send__(handler, *args) if respond_to?(handler)
+        __send__("on_#{name}", *args) unless name.to_s.index("@") == 0
       when String, nil
         # nothing
       end
     end
 
-    def on_module_or_class(kind, name, superclass, body)
+    def on_module_or_class(kind, name, superclass, *body)
       name, line = *name
       @namespace << name
 
@@ -284,12 +288,12 @@ end
       @namespace.pop
     end
 
-    def on_module(name, body = nil)
-      on_module_or_class(:module, name, nil, body)
+    def on_module(name, *body)
+      on_module_or_class(:module, name, nil, *body)
     end
 
-    def on_class(name, superclass, body = nil)
-      on_module_or_class(:class, name, superclass, body)
+    def on_class(name, superclass, *body)
+      on_module_or_class(:class, name, superclass, *body)
     end
 
     def on_private()   @current_access = 'private'   end
@@ -306,10 +310,17 @@ end
         return on_module_or_class(kind, [name, line], superclass, rhs[4])
       end
 
+      namespace = @namespace
+      if name.include?('::')
+        parts = name.split('::')
+        name = parts.pop
+        namespace = namespace + parts
+      end
+
       emit_tag :constant, line,
         :name => name,
-        :full_name => (@namespace + [name]).join('::'),
-        :class => @namespace.join('::')
+        :full_name => (namespace + [name]).join('::'),
+        :class => namespace.join('::')
     end
 
     def on_alias(name, other, line)
@@ -351,7 +362,7 @@ end
     end
 
     def on_sclass(name, body)
-      name, line = *name
+      name, _ = *name
       @namespace << name unless name == 'self'
       prev_is_singleton, @is_singleton = @is_singleton, true
       process(body)
@@ -361,7 +372,7 @@ end
     end
 
     def on_class_eval(name, body)
-      name, line = *name
+      name, _ = *name
       @namespace << name
       process(body)
     ensure

data/lib/ripper-tags/vim_formatter.rb

@@ -2,6 +2,13 @@ require 'ripper-tags/default_formatter'
 
 module RipperTags
   class VimFormatter < DefaultFormatter
+    def supported_flags() ['q'] end
+
+    def include_qualified_names?
+      return @include_qualified_names if defined? @include_qualified_names
+      @include_qualified_names = extra_flag?('q')
+    end
+
     def header
       <<-EOC
 !_TAG_FILE_FORMAT\t2\t/extended format; --format=1 will not append ;" to lines/
@@ -23,6 +30,9 @@ module RipperTags
 
     def write(tag, out)
       @queued_write << format(tag)
+      if include_qualified_names? && tag[:full_name] != tag[:name] && constant?(tag)
+        @queued_write << format(tag, :full_name)
+      end
     end
 
     def display_constant(const)
@@ -60,13 +70,13 @@ module RipperTags
       end
     end
 
-    def format(tag)
+    def format(tag, name_field = :name)
       "%s\t%s\t/^%s$/;\"\t%s%s%s" % [
-        tag.fetch(:name),
+        tag.fetch(name_field),
         relative_path(tag),
         display_pattern(tag),
         display_kind(tag),
-        display_class(tag),
+        name_field == :full_name ? nil : display_class(tag),
         display_inheritance(tag),
       ]
     end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: ripper-tags
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Aman Gupta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-11 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: yajl-ruby
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2015-07-29 00:00:00.000000000 Z
+dependencies: []
 description: fast, accurate ctags generator for ruby source code using Ripper
 email:
 - aman@tmm1.net
@@ -32,11 +18,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- Gemfile
 - LICENSE
 - README.md
-- Rakefile
 - bin/ripper-tags
 - lib/ripper-tags.rb
 - lib/ripper-tags/data_reader.rb
@@ -45,16 +28,6 @@ files:
 - lib/ripper-tags/json_formatter.rb
 - lib/ripper-tags/parser.rb
 - lib/ripper-tags/vim_formatter.rb
-- ripper-tags.gemspec
-- test/fixtures/_git/hooks/hook.rb
-- test/fixtures/encoding.rb
-- test/fixtures/non-script.txt
-- test/fixtures/very/deep/script.rb
-- test/fixtures/very/inter.rb
-- test/test_cli.rb
-- test/test_data_reader.rb
-- test/test_formatters.rb
-- test/test_ripper_tags.rb
 homepage: http://github.com/tmm1/ripper-tags
 licenses:
 - MIT
@@ -65,19 +38,18 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.2.3
 signing_key: 
 specification_version: 4
 summary: ctags generator for ruby code
 test_files: []
-has_rdoc: false

data/.gitignore

@@ -1,5 +0,0 @@
-tags
-TAGS
-ripper-tags-*gem
-*.swp
-Gemfile.lock

data/Gemfile

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

data/Rakefile

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

data/ripper-tags.gemspec

@@ -1,23 +0,0 @@
-Gem::Specification.new do |s|
-  s.name = 'ripper-tags'
-  s.version = '0.1.3'
-
-  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.license = 'MIT'
-
-  s.files = `git ls-files`.split("\n")
-end

data/test/fixtures/encoding.rb

@@ -1,4 +0,0 @@
-# vi:fenc=latin1
-def encoding
-  "This is a test. I�t�rn�ti�n�liz�ti�n\n"
-end

data/test/test_cli.rb

@@ -1,84 +0,0 @@
-require 'test/unit'
-require 'stringio'
-require 'ripper-tags'
-
-class CliTest < Test::Unit::TestCase
-  def process_args(argv)
-    RipperTags.process_args(argv, lambda {|o| o})
-  end
-
-  def test_empty_args
-    err = assert_raise(SystemExit) do
-      with_program_name('ripper-tags') do
-        capture_stderr do
-          RipperTags.process_args([])
-        end
-      end
-    end
-    assert_equal "Usage: ripper-tags [options] FILES...", err.message
-  end
-
-  def test_invalid_option
-    err = assert_raise(OptionParser::InvalidOption) do
-      RipperTags.process_args(%[--moo])
-    end
-    assert_equal "invalid option: --moo", err.message
-  end
-
-  def test_recurse_defaults_to_current_dir
-    options = process_args(%w[-R])
-    assert_equal true, options.recursive
-    assert_equal %w[.], options.files
-  end
-
-  def test_exclude_add_patterns
-    options = process_args(%w[-R --exclude vendor --exclude=bundle/*])
-    assert_equal %w[.git vendor bundle/*], options.exclude
-  end
-
-  def test_exclude_clear
-    options = process_args(%w[-R --exclude=])
-    assert_equal [], options.exclude
-  end
-
-  def test_TAGS_triggers_to_emacs_format
-    options = process_args(%w[-f ./TAGS script.rb])
-    assert_equal './TAGS', options.tag_file_name
-    assert_equal 'emacs', options.format
-  end
-
-  def test_tag_relative_off_by_default
-    options = process_args(%w[ -R ])
-    assert_equal false, options.tag_relative
-  end
-
-  def test_tag_relative_on
-    options = process_args(%w[ -R --tag-relative ])
-    assert_equal true, options.tag_relative
-  end
-
-  def test_tag_relative_on_for_emacs
-    options = process_args(%w[ -R -e ])
-    assert_equal true, options.tag_relative
-  end
-
-  def with_program_name(name)
-    old_name = $0
-    $0 = name
-    begin
-      yield
-    ensure
-      $0 = old_name
-    end
-  end
-
-  def capture_stderr
-    old_stderr = $stderr
-    $stderr = StringIO.new
-    begin
-      yield
-    ensure
-      $stderr = old_stderr
-    end
-  end
-end

data/test/test_data_reader.rb

@@ -1,80 +0,0 @@
-require 'test/unit'
-require 'ostruct'
-require 'ripper-tags/data_reader'
-
-class DataReaderTest < Test::Unit::TestCase
-  FIXTURES = File.expand_path('../fixtures', __FILE__)
-
-  def fixture(path)
-    File.join(FIXTURES, path)
-  end
-
-  def find_files(*files)
-    opts = files.last.is_a?(Hash) ? files.pop : {}
-    options = OpenStruct.new({:files => files, :recursive => true}.merge(opts))
-    finder = RipperTags::FileFinder.new(options)
-    finder.each_file.map {|f| f.sub("#{FIXTURES}/", '') }
-  end
-
-  def test_encoding
-    with_default_encoding('utf-8') do
-      options = OpenStruct.new(:files => [fixture('encoding.rb')])
-      reader = RipperTags::DataReader.new(options)
-      tags = reader.each_tag.to_a
-      assert_equal 'Object#encoding', tags[0][:full_name]
-    end
-  end
-
-  def test_encoding_non_utf8_default
-    with_default_encoding('us-ascii') do
-      options = OpenStruct.new(:files => [fixture('encoding.rb')])
-      reader = RipperTags::DataReader.new(options)
-      tags = reader.each_tag.to_a
-      assert_equal 'Object#encoding', tags[0][:full_name]
-    end
-  end
-
-  def test_file_finder
-    files = find_files(fixture(''), :exclude => %w[_git])
-    expected = %w[
-      encoding.rb
-      very/deep/script.rb
-      very/inter.rb
-    ]
-    assert_equal Set.new(expected), Set.new(files)
-  end
-
-  def test_file_finder_no_exclude
-    files = find_files(fixture(''), :exclude => [])
-    assert files.include?('_git/hooks/hook.rb'), files.inspect
-  end
-
-  def test_file_finder_exclude
-    files = find_files(fixture(''), :exclude => %w[_git very])
-    expected = %w[ encoding.rb ]
-    assert_equal expected, files
-  end
-
-  def test_file_finder_exclude_glob
-    files = find_files(fixture(''), :exclude => %w[_git very/deep/*])
-    expected = %w[
-      encoding.rb
-      very/inter.rb
-    ]
-    assert_equal Set.new(expected), Set.new(files)
-  end
-
-  def with_default_encoding(name)
-    if defined?(Encoding)
-      old_default = Encoding.default_external
-      Encoding.default_external = name
-      begin
-        yield
-      ensure
-        Encoding.default_external = old_default
-      end
-    else
-      yield
-    end
-  end
-end

data/test/test_formatters.rb

@@ -1,120 +0,0 @@
-require 'test/unit'
-require 'stringio'
-require 'ostruct'
-require 'ripper-tags'
-
-class FormattersTest < Test::Unit::TestCase
-  def build_tag(attrs = {})
-    { :kind => 'class',
-      :line => 1,
-      :path => './script.rb',
-      :access => 'public',
-    }.merge(attrs)
-  end
-
-  def formatter_for(opts)
-    options = OpenStruct.new(opts)
-    RipperTags.formatter_for(options)
-  end
-
-  def test_custom
-    default = formatter_for(:format => 'custom', :tag_file_name => '-')
-
-    tags = []
-    tags << build_tag(:line => 1, :kind => 'class', :full_name => 'A::B', :inherits => 'C')
-    tags << build_tag(:line => 2, :kind => 'method', :full_name => 'A::B#imethod')
-    tags << build_tag(:line => 3, :kind => 'singleton method', :full_name => 'A::B.smethod')
-
-    output = capture_stdout do
-      default.with_output do |out|
-        tags.each { |tag| default.write(tag, out) }
-      end
-    end
-
-    assert_equal <<-OUT, output
-    1     class   A::B < C
-    2       def   A::B#imethod
-    3       def   A::B.smethod
-    OUT
-  end
-
-  def test_vim
-    vim = formatter_for(:format => 'vim')
-    assert_equal %{C\t./script.rb\t/^class C < D$/;"\tc\tclass:A.B\tinherits:D}, vim.format(build_tag(
-      :kind => 'class', :name => 'C',
-      :pattern => "class C < D",
-      :class => 'A::B', :inherits => 'D'
-    ))
-    assert_equal %{M\t./script.rb\t/^module M$/;"\tm\tclass:A.B}, vim.format(build_tag(
-      :kind => 'module', :name => 'M',
-      :pattern => "module M",
-      :class => 'A::B'
-    ))
-    assert_equal %{imethod\t./script.rb\t/^  def imethod(*args)$/;"\tf\tclass:A.B}, vim.format(build_tag(
-      :kind => 'method', :name => 'imethod',
-      :pattern => "  def imethod(*args)",
-      :class => 'A::B'
-    ))
-    assert_equal %{smethod\t./script.rb\t/^  def self.smethod(*args)$/;"\tF\tclass:A.B}, vim.format(build_tag(
-      :kind => 'singleton method', :name => 'smethod',
-      :pattern => "  def self.smethod(*args)",
-      :class => 'A::B'
-    ))
-  end
-
-  def test_emacs
-    emacs = formatter_for(:format => 'emacs')
-    assert_equal %{  class C < D\x7FC\x015,0}, emacs.format(build_tag(
-      :kind => 'class', :name => 'C',
-      :pattern => "  class C < D", :line => 5,
-      :class => 'A::B', :inherits => 'D'
-    ))
-  end
-
-  def test_emacs_file_section_headers
-    emacs = formatter_for(:format => 'emacs', :tag_file_name => '-')
-
-    tags = []
-    tags << build_tag(:line => 1, :path => 'path/to/source.rb', :name => 'imethod', :pattern => 'def imethod')
-    tags << build_tag(:line => 2, :path => 'path/to/source.rb', :name => 'smethod', :pattern => 'def self.smethod')
-    tags << build_tag(:line => 3, :path => 'path/to/another.rb', :name => 'imethod', :pattern => 'def imethod')
-
-    output = capture_stdout do
-      emacs.with_output do |out|
-        tags.each { |tag| emacs.write(tag, out) }
-      end
-    end
-
-    assert_equal <<-OUT, output
-\x0C
-path/to/source.rb,53
-def imethod\x7Fimethod\x011,0
-def self.smethod\x7Fsmethod\x012,0
-\x0C
-path/to/another.rb,24
-def imethod\x7Fimethod\x013,0
-    OUT
-  end
-
-  def test_relative
-    formatter = formatter_for(:format => 'custom', :tag_file_name => '.git/tags', :tag_relative => true)
-    tag = build_tag(:path => 'path/to/script.rb')
-    assert_equal '../path/to/script.rb', formatter.relative_path(tag)
-  end
-
-  def test_no_relative
-    formatter = formatter_for(:format => 'custom', :tag_file_name => '.git/tags')
-    tag = build_tag(:path => 'path/to/script.rb')
-    assert_equal 'path/to/script.rb', formatter.relative_path(tag)
-  end
-
-  def capture_stdout
-    old_stdout, $stdout = $stdout, StringIO.new
-    begin
-      yield
-      $stdout.string
-    ensure
-      $stdout = old_stdout
-    end
-  end
-end

data/test/test_ripper_tags.rb

@@ -1,342 +0,0 @@
-require 'test/unit'
-require 'ripper-tags/parser'
-
-class TagRipperTest < Test::Unit::TestCase
-  def extract(code)
-    RipperTags::Parser.extract(code)
-  end
-
-  def inspect(tag)
-    raise ArgumentError, "expected tag, got %p" % tag unless tag
-    "%d: %s %s%s" % [
-      tag[:line],
-      tag[:kind],
-      tag[:full_name],
-      tag[:inherits] ? " < #{tag[:inherits]}" : "",
-    ]
-  end
-
-  def test_extract_basics
-    tags = 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
-      M::C::Const3 = true
-      M.class_eval do
-        def imethod5
-        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
-      M::C::Const3
-      M#imethod5
-    ], tags.map{ |t| t[:full_name] }
-  end
-
-  def test_extract_access
-    tags = 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
-
-  def test_extract_module_eval
-    tags = extract(<<-EOC)
-      M.module_eval do
-        class C; end
-        def imethod; end
-      end
-    EOC
-    assert_equal '2: class M::C', inspect(tags[0])
-    assert_equal '3: method M#imethod', inspect(tags[1])
-  end
-
-  def test_extract_manual_subclass
-    tags = extract(<<-EOC)
-      module M
-        C = Class.new(Sup::Klass)
-        C = Class.new Sup::Klass
-        C = Class.new
-        C = Class.new(klass)
-      end
-    EOC
-    assert_equal '2: class M::C < Sup::Klass', inspect(tags[1])
-    assert_equal '3: class M::C < Sup::Klass', inspect(tags[2])
-    assert_equal '4: class M::C', inspect(tags[3])
-    assert_equal '5: class M::C', inspect(tags[4])
-  end
-
-  def test_extract_assign_from_struct
-    tags = extract(<<-EOC)
-      module M
-        C = Struct.new(:name)
-        C = Struct.new :name
-      end
-    EOC
-    assert_equal '2: class M::C', inspect(tags[1])
-    assert_equal '3: class M::C', inspect(tags[2])
-  end
-
-  def test_extract_class_struct_scope
-    tags = extract(<<-EOC)
-      module M
-        S = Struct.new(:name) do
-          def imethod; end
-        end
-        C = Class.new(SuperClass) do
-          def imethod; end
-        end
-      end
-    EOC
-    assert_equal '3: method M::S#imethod', inspect(tags[2])
-    assert_equal '5: class M::C < SuperClass', inspect(tags[3])
-    assert_equal '6: method M::C#imethod', inspect(tags[4])
-  end
-
-  def test_extract_manual_module
-    tags = extract(<<-EOC)
-      class C
-        M = Module.new
-        M = Module.new do
-          def imethod; end
-        end
-      end
-    EOC
-    assert_equal '2: module C::M', inspect(tags[1])
-    assert_equal '3: module C::M', inspect(tags[2])
-    assert_equal '4: method C::M#imethod', inspect(tags[3])
-  end
-
-  def test_extract_define_method
-    tags = extract(<<-EOC)
-      module M
-        define_method(:imethod) do |arg|
-        end
-        define_method :imethod do |arg|
-        end
-        define_method(:imethod) { |arg| }
-      end
-    EOC
-    assert_equal '2: method M#imethod', inspect(tags[1])
-    assert_equal '4: method M#imethod', inspect(tags[2])
-    assert_equal '6: method M#imethod', inspect(tags[3])
-  end
-
-  def test_ignore_dynamic_define_method
-    tags = extract(<<-EOC)
-      module M
-        define_method(:"imethod_\#{i}") { |arg| }
-        define_method("imethod_\#{i}") { |arg| }
-      end
-    EOC
-    assert_equal 1, tags.length
-  end
-
-  def test_extract_alias
-    tags = extract(<<-EOC)
-      module M
-        alias :"[]" :get
-        alias :"[]=" :set
-        alias :set :"[]="
-      end
-    EOC
-    assert_equal '2: alias M#[] < get', inspect(tags[1])
-    assert_equal '3: alias M#[]= < set', inspect(tags[2])
-    assert_equal '4: alias M#set < []=', inspect(tags[3])
-  end
-
-  def test_ignore_dynamic_alias
-    tags = extract(<<-EOC)
-      module M
-        alias :"imethod_\#{i}" :foo
-        alias "imethod_\#{i}" :foo
-      end
-    EOC
-    assert_equal 1, tags.length
-  end
-
-  def test_extract_alias_method
-    tags = extract(<<-EOC)
-      module M
-        alias_method(:imethod, :foo)
-        alias_method :imethod, :foo
-      end
-    EOC
-    assert_equal '2: alias M#imethod < foo', inspect(tags[1])
-    assert_equal '3: alias M#imethod < foo', inspect(tags[2])
-  end
-
-  def test_ignore_dynamic_alias_method
-    tags = extract(<<-EOC)
-      module M
-        alias_method :"imethod_\#{i}", :foo
-        alias_method "imethod_\#{i}", :foo
-      end
-    EOC
-    assert_equal 1, tags.length
-  end
-
-  def test_extract_attr_accessor
-    tags = extract(<<-EOC)
-      module M
-        attr_accessor :a, :b
-        attr_reader(:a, :b)
-        attr_writer(:a, :b)
-      end
-    EOC
-    assert_equal '2: method M#a',  inspect(tags[1])
-    assert_equal '2: method M#a=', inspect(tags[2])
-    assert_equal '2: method M#b',  inspect(tags[3])
-    assert_equal '2: method M#b=', inspect(tags[4])
-    assert_equal '3: method M#a',  inspect(tags[5])
-    assert_equal '3: method M#b',  inspect(tags[6])
-    assert_equal '4: method M#a=', inspect(tags[7])
-    assert_equal '4: method M#b=', inspect(tags[8])
-  end
-
-  def test_extract_rails_associations
-    tags = extract(<<-EOC)
-      class C
-        belongs_to :org, :touch => true
-        has_one :author, :dependent => :destroy
-        has_many :posts
-        has_and_belongs_to_many :tags, :join_table => 'c_tags'
-      end
-    EOC
-    assert_equal 'Rails', tags[1][:language]
-
-    assert_equal '2: belongs_to C.org', inspect(tags[1])
-    assert_equal '2: belongs_to C.org=', inspect(tags[2])
-    assert_equal '2: belongs_to C.build_org', inspect(tags[3])
-    assert_equal '2: belongs_to C.create_org', inspect(tags[4])
-    assert_equal '2: belongs_to C.create_org!', inspect(tags[5])
-
-    assert_equal '3: has_one C.author', inspect(tags[6])
-    assert_equal '3: has_one C.author=', inspect(tags[7])
-    assert_equal '3: has_one C.build_author', inspect(tags[8])
-    assert_equal '3: has_one C.create_author', inspect(tags[9])
-    assert_equal '3: has_one C.create_author!', inspect(tags[10])
-
-    assert_equal '4: has_many C.posts', inspect(tags[11])
-    assert_equal '4: has_many C.posts=', inspect(tags[12])
-    assert_equal '4: has_many C.post_ids', inspect(tags[13])
-    assert_equal '4: has_many C.post_ids=', inspect(tags[14])
-
-    assert_equal '5: has_and_belongs_to_many C.tags', inspect(tags[15])
-    assert_equal '5: has_and_belongs_to_many C.tags=', inspect(tags[16])
-    assert_equal '5: has_and_belongs_to_many C.tag_ids', inspect(tags[17])
-    assert_equal '5: has_and_belongs_to_many C.tag_ids=', inspect(tags[18])
-  end
-
-  def test_extract_rails_scopes
-    tags = extract(<<-EOC)
-      class C
-        named_scope(:red) { {:conditions=>{:color => 'red'}} }
-        scope :red, where(:color => 'red')
-      end
-    EOC
-    assert_equal 'Rails', tags[1][:language]
-
-    assert_equal '2: scope C.red',  inspect(tags[1])
-    assert_equal '3: scope C.red',  inspect(tags[2])
-  end
-
-  def test_extract_from_erb
-    tags = extract(<<-EOC)
-      class NavigationTest < ActionDispatch::IntegrationTest
-      <% unless options[:skip_active_record] -%>
-        fixtures :all
-      <% end -%>
-
-        # test "the truth" do
-        #   assert true
-        # end
-      end
-    EOC
-
-    assert_equal 1, tags.size
-    assert_equal 'NavigationTest', tags[0][:name]
-  end
-
-  def test_extract_with_keyword_variables
-    tags = extract(<<-EOC)
-      class Foo
-        @public
-        @protected
-        @private
-      end
-    EOC
-
-    assert_equal 1, tags.size
-    assert_equal 'Foo', tags[0][:name]
-  end
-
-  def test_extract_associations_with_class_name
-    tags = extract(<<-EOC)
-      class Foo
-        belongs_to Bar
-        has_one Bar
-        has_and_belongs_to_many Bar
-        has_many Bar
-      end
-    EOC
-
-    assert_equal 1, tags.size
-    assert_equal 'Foo', tags[0][:name]
-  end
-end