starscope 1.1.2 → 1.2.0

data/test/unit/test_db.rb

@@ -1,136 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'tempfile'
-
-describe StarScope::DB do
-
-  def validate(db)
-    files = db.instance_eval('@meta[:files]')
-    files.keys.must_include GOLANG_SAMPLE
-    files.keys.must_include RUBY_SAMPLE
-    files[GOLANG_SAMPLE][:last_updated].must_equal File.mtime(GOLANG_SAMPLE).to_i
-    files[RUBY_SAMPLE][:last_updated].must_equal File.mtime(RUBY_SAMPLE).to_i
-
-    tbls = db.instance_eval('@tables')
-    defs = tbls[:defs].map {|x| x[:name][-1]}
-    assert defs.include? :DB
-    assert defs.include? :NoTableError
-    assert defs.include? :load
-    assert defs.include? :update
-    assert defs.include? :files_from_path
-    assert defs.include? :single_var
-    assert defs.include? :single_const
-  end
-
-  before do
-    @db = StarScope::DB.new(:quiet)
-  end
-
-  it "must raise on invalid tables" do
-    proc {@db.dump_table(:foo)}.must_raise StarScope::DB::NoTableError
-  end
-
-  it "must add paths" do
-    paths = [GOLANG_SAMPLE, "#{FIXTURES}/**/*"]
-    @db.add_paths(paths)
-    @db.instance_eval('@meta[:paths]').must_equal paths
-    validate(@db)
-  end
-
-  it "must add excludes" do
-    paths = [GOLANG_SAMPLE, "#{FIXTURES}/**/*"]
-    @db.add_paths(paths)
-    @db.add_excludes(["#{FIXTURES}/**"])
-    files = @db.instance_eval('@meta[:files]').keys
-    files.wont_include RUBY_SAMPLE
-    files.wont_include GOLANG_SAMPLE
-    tbls = @db.instance_eval('@tables')
-    tbls[:defs].must_be_empty
-    tbls[:end].must_be_empty
-  end
-
-  it "must pick up new files in old paths" do
-    @db.instance_eval("@meta[:paths] = [\"#{FIXTURES}/**/*\"]")
-    @db.update
-    validate(@db)
-  end
-
-  it "must remove old files in existing paths" do
-    @db.instance_eval("@meta[:paths] = [\"#{FIXTURES}/**/*\"]")
-    @db.instance_eval("@meta[:files] = {\"#{FIXTURES}/foo\" => {:last_updated=>1}}")
-    @db.update
-    @db.instance_eval("@meta[:files]").keys.wont_include "#{FIXTURES}/foo"
-  end
-
-  it "must update stale existing files" do
-    @db.instance_eval("@meta[:paths] = [\"#{FIXTURES}/**/*\"]")
-    @db.instance_eval("@meta[:files] = {\"#{GOLANG_SAMPLE}\" => {:last_updated=>1}}")
-    @db.instance_eval("@tables[:defs] = [{:file => \"#{GOLANG_SAMPLE}\"}]")
-    @db.update
-    validate(@db)
-  end
-
-  it "must load an old DB file" do
-    @db.load("#{FIXTURES}/db_old.json.gz")
-    @db.instance_eval('@meta[:paths]').must_equal ["#{FIXTURES}/**/*"]
-    validate(@db)
-  end
-
-  it "must round-trip a database" do
-    file = Tempfile.new('starscope_test')
-    begin
-      @db.add_paths(["#{FIXTURES}"])
-      @db.save(file.path)
-      tmp = StarScope::DB.new(:quiet)
-      tmp.load(file.path)
-      validate(tmp)
-    ensure
-      file.close
-      file.unlink
-    end
-  end
-
-  it "must export to ctags" do
-    file = Tempfile.new('starscope_test')
-    begin
-      @db.add_paths(["#{FIXTURES}"])
-      @db.export_ctags(file)
-      file.rewind
-      lines = file.lines.to_a
-      lines.must_include "NoTableError\t#{FIXTURES}/sample_ruby.rb\t/^  class NoTableError < StandardError; end$/;\"\tkind:c\tlanguage:Ruby\n"
-    ensure
-      file.close
-      file.unlink
-    end
-  end
-
-  it "must export to cscope" do
-    file = Tempfile.new('starscope_test')
-    begin
-      @db.add_paths(["#{FIXTURES}"])
-      @db.export_cscope(file)
-      file.rewind
-      lines = file.lines.to_a
-
-      lines.must_include "\t@#{FIXTURES}/sample_golang.go\n"
-      lines.must_include "\tgSunday\n"
-      lines.must_include "\t`add_file\n"
-      lines.must_include "\t}}\n"
-      lines.must_include "13 class \n"
-
-      lines.wont_include "= [\n"
-      lines.wont_include "4 LANGS = [\n"
-      lines.wont_include "116 tmpdb[entry[:file]][entry[:line_no]] ||= []\n"
-    ensure
-      file.close
-      file.unlink
-    end
-  end
-
-  it "must run queries" do
-    @db.add_paths(["#{FIXTURES}"])
-    @db.query(:calls, "abc").must_equal []
-    @db.query(:defs, "xyz").must_equal []
-    @db.query(:calls, "add_file").length.must_equal 3
-  end
-
-end

data/test/unit/test_golang.rb

@@ -1,80 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-class TestGolang < Minitest::Test
-  def setup
-    @db = {}
-    StarScope::Lang::Go.extract(GOLANG_SAMPLE) do |tbl, name, args|
-      @db[tbl] ||= []
-      @db[tbl] << StarScope::Record.build(GOLANG_SAMPLE, name, args)
-    end
-  end
-
-  def test_recognition
-    assert StarScope::Lang::Go.match_file(GOLANG_SAMPLE)
-    refute StarScope::Lang::Go.match_file(RUBY_SAMPLE)
-    refute StarScope::Lang::Go.match_file(EMPTY_FILE)
-  end
-
-  def test_defs
-    assert @db.keys.include? :defs
-    defs = @db[:defs].map {|x| x[:name][-1]}
-    assert defs.include? :a
-    assert defs.include? :b
-    assert defs.include? :c
-    assert defs.include? :ttt
-    assert defs.include? :main
-    assert defs.include? :v1
-    assert defs.include? :v2
-    assert defs.include? :Sunday
-    assert defs.include? :Monday
-    assert defs.include? :single_var
-    assert defs.include? :single_const
-
-    refute defs.include? :"0x00"
-    refute defs.include? :"0x01"
-    refute defs.include? :"0x02"
-    refute defs.include? :"0x03"
-  end
-
-  def test_ends
-    assert @db.keys.include? :end
-    assert @db[:end].count == 7
-  end
-
-  def test_function_calls
-    assert @db.keys.include? :calls
-    calls = @db[:calls].group_by {|x| x[:name][-1]}
-    assert calls.keys.include? :a
-    assert calls.keys.include? :b
-    assert calls.keys.include? :c
-    assert calls.keys.include? :ttt
-    assert calls.keys.include? :Errorf
-    assert calls[:a].count == 3
-    assert calls[:b].count == 4
-    assert calls[:c].count == 4
-    assert calls[:ttt].count == 2
-    assert calls[:Errorf].count == 1
-  end
-
-  def test_variable_assigns
-    assert @db.keys.include? :assigns
-    assigns = @db[:assigns].group_by {|x| x[:name][-1]}
-    assert assigns.keys.include? :x
-    assert assigns.keys.include? :y
-    assert assigns.keys.include? :z
-    assert assigns.keys.include? :n
-    assert assigns.keys.include? :m
-    assert assigns.keys.include? :msg
-    assert assigns[:x].count == 2
-    assert assigns[:y].count == 1
-    assert assigns[:z].count == 1
-    assert assigns[:n].count == 1
-    assert assigns[:m].count == 2
-  end
-
-  def test_imports
-    assert @db.keys.include? :imports
-    imports = @db[:imports].group_by {|x| x[:name][-1]}
-    assert imports.keys.include? :fmt
-  end
-end

data/test/unit/test_record.rb

@@ -1,35 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-describe StarScope::Record do
-
-  it "must symbolize compound name" do
-    rec = StarScope::Record.build(:foo, ["a", :b], {})
-    rec[:name].must_equal [:a, :b]
-  end
-
-  it "must symbolize and array-wrap simple name" do
-    rec = StarScope::Record.build(:foo, "a", {})
-    rec[:name].must_equal [:a]
-  end
-
-  it "must read correct line from file" do
-
-    # we interleave the files here to test the cache
-
-    rec = StarScope::Record.build(GOLANG_SAMPLE, :a, {:line_no => 1})
-    rec[:line].must_equal "package main"
-
-    rec = StarScope::Record.build(GOLANG_SAMPLE, :a, {:line_no => 71})
-    rec[:line].must_equal "\tfmt.Println(t)"
-
-    rec = StarScope::Record.build(RUBY_SAMPLE, :a, {:line_no => 1})
-    rec[:line].must_equal "require 'date'"
-
-    rec = StarScope::Record.build(RUBY_SAMPLE, :a, {:line_no => 164})
-    rec[:line].must_equal "end"
-
-    rec = StarScope::Record.build(GOLANG_SAMPLE, :a, {:line_no => 44})
-    rec[:line].must_equal "}"
-  end
-
-end

data/test/unit/test_ruby.rb

@@ -1,60 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-class TestRuby < Minitest::Test
-  def setup
-    @db = {}
-    StarScope::Lang::Ruby.extract(RUBY_SAMPLE) do |tbl, name, args|
-      @db[tbl] ||= []
-      @db[tbl] << StarScope::Record.build(RUBY_SAMPLE, name, args)
-    end
-  end
-
-  def test_recognition
-    assert StarScope::Lang::Ruby.match_file(RUBY_SAMPLE)
-    assert StarScope::Lang::Ruby.match_file('bin/starscope')
-    refute StarScope::Lang::Ruby.match_file(GOLANG_SAMPLE)
-    refute StarScope::Lang::Ruby.match_file(EMPTY_FILE)
-  end
-
-  def test_function_defs
-    assert @db.keys.include? :defs
-    defs = @db[:defs].map {|x| x[:name][-1]}
-    assert defs.include? :DB
-    assert defs.include? :NoTableError
-    assert defs.include? :load
-    assert defs.include? :update
-    assert defs.include? :files_from_path
-  end
-
-  def test_constant_defs
-    assert @db[:defs].map {|x| x[:name][-1]}.include? :PBAR_FORMAT
-  end
-
-  def test_ends
-    assert @db.keys.include? :end
-    assert @db[:end].count == 13
-  end
-
-  def test_function_calls
-    assert @db.keys.include? :calls
-    calls = @db[:calls].group_by {|x| x[:name][-1]}
-    assert calls.keys.include? :add_file
-    assert calls.keys.include? :each
-    assert calls[:add_file].count == 3
-    assert calls[:each].count == 8
-  end
-
-  def test_variable_assigns
-    assert @db.keys.include? :assigns
-    assigns = @db[:assigns].group_by {|x| x[:name][-1]}
-    assert assigns.keys.include? :pbar
-    assert assigns.keys.include? :PBAR_FORMAT
-    assert assigns.keys.include? :foo
-    assert assigns[:pbar].count == 2
-    assert assigns[:PBAR_FORMAT].count == 1
-    assert assigns[:foo].count == 1
-
-    refute assigns.keys.include? "=".to_sym
-    refute assigns.keys.include? "<".to_sym
-  end
-end