ripper-tags 0.1.1 → 0.1.2

data/lib/{tag_ripper.rb → ripper-tags/parser.rb}

@@ -1,6 +1,8 @@
 require 'ripper'
 
-class TagRipper < Ripper
+module RipperTags
+
+class Parser < Ripper
   def self.extract(data, file='(eval)')
     sexp = new(data, file).parse
     Visitor.new(sexp, file, data).tags
@@ -33,13 +35,14 @@ class TagRipper < Ripper
     [:defs, receiver && receiver[0], *method]
   end
   def on_alias(lhs, rhs)
-    [:alias, lhs[0], rhs[0], rhs[1]]
+    [:alias, lhs[0], rhs[0], rhs[1]] if lhs && rhs
   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)]
+    lhs, line = lhs
+    [:assign, lhs, rhs, line]
   end
   def on_sclass(name, body)
     [:sclass, name && name.flatten(1), *body.compact]
@@ -52,6 +55,7 @@ class TagRipper < Ripper
   end
 
   def on_const_path_ref(a, b)
+    return if a.nil? || b.nil?
     a.flatten!(1)
     [[a && a[0], b[0]].join('::'), b[1]]
   end
@@ -61,9 +65,14 @@ class TagRipper < Ripper
   end
 
   def on_command(name, *args)
-    # if name =~ /^(attr_|alias)/
-    #   [name.to_sym, *args]
-    # end
+    case name[0]
+    when "define_method", "alias_method",
+         "has_one", "has_many",
+         "belongs_to", "has_and_belongs_to_many",
+         "scope", "named_scope",
+         /^attr_(accessor|reader|writer)$/
+      on_method_add_arg([:fcall, name], args[0])
+    end
   end
   def on_bodystmt(*args)
     args
@@ -78,6 +87,20 @@ class TagRipper < Ripper
   end
   alias on_if_mod on_unless_mod
 
+  def on_dyna_symbol(*args)
+    if args.length == 1 && args[0]
+      [args[0], lineno]
+    end
+  end
+
+  def on_tstring_content(str)
+    str
+  end
+
+  def on_xstring_add(first, arg)
+    arg if first.nil?
+  end
+
   def on_var_ref(*args)
     on_vcall(*args) || args
   end
@@ -87,7 +110,84 @@ class TagRipper < Ripper
   end
 
   def on_call(lhs, op, rhs)
-    [:call, lhs && lhs[0], rhs && rhs[0], rhs[1]]
+    return unless lhs && rhs
+    arg = block = nil
+    [:call, lhs[0], rhs[0], arg, block]
+  end
+
+  def on_method_add_arg(call, args)
+    call_name = call && call[0]
+    first_arg = args && :args == args[0] && args[1]
+
+    if :call == call_name && first_arg
+      if args.length == 2
+        # augment call if a single argument was used
+        call = call.dup
+        call[3] = args[1]
+      end
+      call
+    elsif :fcall == call_name && first_arg
+      name, line = call[1]
+      case name
+      when "alias_method"
+        [:alias, args[1][0], args[2][0], line] if args[1] && args[2]
+      when "define_method"
+        [:def, args[1][0], line]
+      when "scope", "named_scope"
+        [:rails_def, :scope, args[1][0], line]
+      when /^attr_(accessor|reader|writer)$/
+        gen_reader = $1 != 'writer'
+        gen_writer = $1 != 'reader'
+        args[1..-1].inject([]) do |gen, arg|
+          gen << [:def, arg[0], line] if gen_reader
+          gen << [:def, "#{arg[0]}=", line] if gen_writer
+          gen
+        end
+      when "has_many", "has_and_belongs_to_many"
+        a = args[1][0]
+        kind = name.to_sym
+        gen = []
+        gen << [:rails_def, kind, a, line]
+        gen << [:rails_def, kind, "#{a}=", line]
+        if (sing = a.chomp('s')) != a
+          # poor man's singularize
+          gen << [:rails_def, kind, "#{sing}_ids", line]
+          gen << [:rails_def, kind, "#{sing}_ids=", line]
+        end
+        gen
+      when "belongs_to", "has_one"
+        a = args[1][0]
+        kind = name.to_sym
+        %W[ #{a} #{a}= build_#{a} create_#{a} create_#{a}! ].inject([]) do |gen, ident|
+          gen << [:rails_def, kind, ident, line]
+        end
+      end
+    else
+      super
+    end
+  end
+
+  # handle `Class.new arg` call without parens
+  def on_command_call(*args)
+    if args.last && :args == args.last[0]
+      args_add = args.pop
+      call = on_call(*args)
+      on_method_add_arg(call, args_add)
+    else
+      super
+    end
+  end
+
+  def on_fcall(*args)
+    [:fcall, *args]
+  end
+
+  def on_args_add(sub, arg)
+    if sub
+      sub + [arg]
+    else
+      [:args, arg].compact
+    end
   end
 
   def on_do_block(*args)
@@ -95,14 +195,22 @@ class TagRipper < Ripper
   end
 
   def on_method_add_block(method, body)
-    return unless method and body
-    if method[2] == 'class_eval'
+    return unless method
+    if %w[class_eval module_eval].include?(method[2]) && body
       [:class_eval, [
         method[1].is_a?(Array) ? method[1][0] : method[1],
         method[3]
       ], body.last]
+    elsif :call == method[0] && body
+      # augment the `Class.new/Struct.new` call with associated block
+      call = method.dup
+      call[4] = body.last
+      call
+    else
+      super
     end
   end
+end
 
   class Visitor
     attr_reader :tags
@@ -117,14 +225,14 @@ class TagRipper < Ripper
     end
 
     def emit_tag(kind, line, opts={})
-      @tags << opts.merge(
+      @tags << {
         :kind => kind.to_s,
         :line => line,
         :language => 'Ruby',
         :path => @path,
         :pattern => @lines[line-1].chomp,
         :access => @current_access
-      ).delete_if{ |k,v| v.nil? }
+      }.update(opts).delete_if{ |k,v| v.nil? }
     end
 
     def process(sexp)
@@ -153,6 +261,7 @@ class TagRipper < Ripper
         superclass_name = superclass[0] == :call ?
           superclass[1] :
           superclass[0]
+        superclass_name = nil unless superclass_name =~ /^[A-Z]/
       end
       full_name = @namespace.join('::')
       parts = full_name.split('::')
@@ -170,7 +279,7 @@ class TagRipper < Ripper
       @namespace.pop
     end
 
-    def on_module(name, body)
+    def on_module(name, body = nil)
       on_module_or_class(:module, name, nil, body)
     end
 
@@ -182,9 +291,16 @@ class TagRipper < Ripper
     def on_protected() @current_access = 'protected' end
     def on_public()    @current_access = 'public'    end
 
-    def on_assign(name, line)
+    def on_assign(name, rhs, line)
       return unless name =~ /^[A-Z]/
 
+      if rhs && :call == rhs[0] && rhs[1] && "#{rhs[1][0]}.#{rhs[2]}" =~ /^(Class|Module|Struct)\.new$/
+        kind = $1 == 'Module' ? :module : :class
+        superclass = $1 == 'Class' ? rhs[3] : nil
+        superclass.flatten! if superclass
+        return on_module_or_class(kind, [name, line], superclass, rhs[4])
+      end
+
       emit_tag :constant, line,
         :name => name,
         :full_name => (@namespace + [name]).join('::'),
@@ -219,6 +335,16 @@ class TagRipper < Ripper
         :class => ns.join('::')
     end
 
+    def on_rails_def(kind, name, line)
+      ns = (@namespace.empty?? 'Object' : @namespace.join('::'))
+
+      emit_tag kind, line,
+        :language => 'Rails',
+        :name => name,
+        :full_name => "#{ns}.#{name}",
+        :class => ns
+    end
+
     def on_sclass(name, body)
       name, line = *name
       @namespace << name unless name == 'self'
@@ -241,5 +367,7 @@ class TagRipper < Ripper
     end
     alias on_aref_field on_call
     alias on_field on_call
+    alias on_fcall on_call
+    alias on_args on_call
   end
 end

data/lib/ripper-tags/vim_formatter.rb

@@ -0,0 +1,74 @@
+require 'ripper-tags/default_formatter'
+
+module RipperTags
+  class VimFormatter < DefaultFormatter
+    def header
+      <<-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
+    end
+
+    # prepend header and sort lines before closing output
+    def with_output
+      super do |out|
+        out.puts header
+        @queued_write = []
+        yield out
+        @queued_write.sort.each do |line|
+          out.puts(line)
+        end
+      end
+    end
+
+    def write(tag, out)
+      @queued_write << format(tag)
+    end
+
+    def display_constant(const)
+      const.to_s.gsub('::', '.')
+    end
+
+    def display_pattern(tag)
+      tag.fetch(:pattern).to_s.gsub('\\','\\\\\\\\').gsub('/','\\/')
+    end
+
+    def display_class(tag)
+      if tag[:class]
+        "\tclass:%s" % display_constant(tag[:class])
+      else
+        ""
+      end
+    end
+
+    def display_inheritance(tag)
+      if tag[:inherits] && 'class' == tag[:kind]
+        "\tinherits:%s" % display_constant(tag[:inherits])
+      else
+        ""
+      end
+    end
+
+    def display_kind(tag)
+      case tag.fetch(:kind)
+      when 'method' then 'f'
+      when 'singleton method' then 'F'
+      when 'constant' then 'C'
+      when 'scope', 'belongs_to', 'has_one', 'has_many', 'has_and_belongs_to_many'
+        'F'
+      else tag[:kind].slice(0,1)
+      end
+    end
+
+    def format(tag)
+      "%s\t%s\t/^%s$/;\"\t%s%s%s" % [
+        tag.fetch(:name),
+        relative_path(tag),
+        display_pattern(tag),
+        display_kind(tag),
+        display_class(tag),
+        display_inheritance(tag),
+      ]
+    end
+  end
+end

data/lib/ripper-tags.rb

@@ -0,0 +1,120 @@
+require 'optparse'
+require 'ostruct'
+require 'ripper-tags/parser'
+require 'ripper-tags/data_reader'
+require 'ripper-tags/default_formatter'
+require 'ripper-tags/emacs_formatter'
+require 'ripper-tags/vim_formatter'
+require 'ripper-tags/json_formatter'
+
+module RipperTags
+  def self.version() "0.1.2" end
+
+  def self.default_options
+    OpenStruct.new \
+      :format => nil,
+      :tag_file_name => "./tags",
+      :tag_relative => nil,
+      :debug => false,
+      :verbose_debug => false,
+      :verbose => false,
+      :force => false,
+      :files => %w[.],
+      :recursive => false,
+      :exclude => %w[.git],
+      :all_files => false
+  end
+
+  def self.option_parser(options)
+    OptionParser.new do |opts|
+      opts.banner = "Usage: #{opts.program_name} [options] FILES..."
+      opts.version = version
+
+      opts.separator ""
+
+      opts.on("-f", "--tag-file (FILE|-)", "File to write tags to (default: `#{options.tag_file_name}')",
+             '"-" 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
+      end
+      opts.on("-R", "--recursive", "Descend recursively into subdirectories") do
+        options.recursive = true
+      end
+      opts.on("--exclude PATTERN", "Exclude a file, directory or pattern") do |pattern|
+        if pattern.empty?
+          options.exclude.clear
+        else
+          options.exclude << pattern
+        end
+      end
+      opts.on("--all-files", "Parse all files as ruby files, not just `*.rb' ones") do
+        options.all_files = true
+      end
+
+      opts.separator " "
+
+      opts.on("--format (emacs|json|custom)", "Set output format (default: vim)") do |fmt|
+        options.format = fmt
+      end
+      opts.on("-e", "--emacs", "Output Emacs format (default if `--tag-file' is `TAGS')") do
+        options.format = "emacs"
+      end
+
+      opts.separator ""
+
+      opts.on_tail("-d", "--debug", "Output parse tree") do
+        options.debug = true
+      end
+      opts.on_tail("--debug-verbose", "Output parse tree verbosely") do
+        options.verbose_debug = true
+      end
+      opts.on_tail("-V", "--verbose", "Print additional information on stderr") do
+        options.verbose = true
+      end
+      opts.on_tail("--force", "Skip files with parsing errors") do
+        options.force = true
+      end
+      opts.on_tail("-v", "--version", "Print version information") do
+        puts opts.ver
+        exit
+      end
+
+      yield(opts, options) if block_given?
+    end
+  end
+
+  def self.process_args(argv, run = method(:run))
+    option_parser(default_options) do |optparse, options|
+      file_list = optparse.parse(argv)
+      if !file_list.empty? then options.files = file_list
+      elsif !options.recursive then abort(optparse.banner)
+      end
+      options.format ||= File.basename(options.tag_file_name) == "TAGS" ? "emacs" : "vim"
+      options.tag_relative = options.format == "emacs" if options.tag_relative.nil?
+      return run.call(options)
+    end
+  end
+
+  def self.formatter_for(options)
+    options.formatter ||
+    case options.format
+    when "vim"    then RipperTags::VimFormatter
+    when "emacs"  then RipperTags::EmacsFormatter
+    when "json"   then RipperTags::JSONFormatter
+    when "custom" then RipperTags::DefaultFormatter
+    else raise ArgumentError, "unknown format: #{options.format.inspect}"
+    end.new(options)
+  end
+
+  def self.run(options)
+    reader = RipperTags::DataReader.new(options)
+    formatter = formatter_for(options)
+    formatter.with_output do |out|
+      reader.each_tag do |tag|
+        formatter.write(tag, out)
+      end
+    end
+  end
+end

data/ripper-tags.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'ripper-tags'
-  s.version = '0.1.1'
+  s.version = '0.1.2'
 
   s.summary = 'ctags generator for ruby code'
   s.description = 'fast, accurate ctags generator for ruby source code using Ripper'
@@ -17,5 +17,7 @@ Gem::Specification.new do |s|
   s.bindir = 'bin'
   s.executables << 'ripper-tags'
 
+  s.license = 'MIT'
+
   s.files = `git ls-files`.split("\n")
 end

data/test/fixtures/encoding.rb

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

data/test/test_cli.rb

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,80 @@
+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 expected, 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 expected, 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