ripper-tags 0.1.1 → 0.1.2

data/test/test_formatters.rb

@@ -0,0 +1,120 @@
+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,9 +1,23 @@
-require File.expand_path('../../lib/tag_ripper', __FILE__)
 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 = TagRipper.extract(<<-EOC)
+    tags = extract(<<-EOC)
       Const1 = 123
       def gmethod
       end
@@ -63,7 +77,7 @@ class TagRipperTest < Test::Unit::TestCase
   end
 
   def test_extract_access
-    tags = TagRipper.extract(<<-EOC)
+    tags = extract(<<-EOC)
       class Test
         def abc() end
       private
@@ -80,4 +94,205 @@ class TagRipperTest < Test::Unit::TestCase
     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
 end

metadata

@@ -1,85 +1,83 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: ripper-tags
-version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: 
-  segments: 
-  - 0
-  - 1
-  - 1
-  version: 0.1.1
+version: !ruby/object:Gem::Version
+  version: 0.1.2
 platform: ruby
-authors: 
+authors:
 - Aman Gupta
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-01-03 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-11-28 00:00:00.000000000 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"
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: fast, accurate ctags generator for ruby source code using Ripper
-email: 
+email:
 - aman@tmm1.net
-executables: 
+executables:
 - ripper-tags
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
+- .gitignore
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
 - bin/ripper-tags
-- lib/tag_ripper.rb
+- lib/ripper-tags.rb
+- lib/ripper-tags/data_reader.rb
+- lib/ripper-tags/default_formatter.rb
+- lib/ripper-tags/emacs_formatter.rb
+- 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: []
-
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+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"
+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: 1.8.24
+rubygems_version: 2.1.11
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: ctags generator for ruby code
 test_files: []
-
+has_rdoc: false