starscope 1.5.4 → 1.6.0

data/test/unit/db_test.rb

@@ -7,14 +7,14 @@ describe Starscope::DB do
   end
 
   it 'must raise on invalid tables' do
-    proc { @db.records(:foo) }.must_raise Starscope::DB::NoTableError
+    _(proc { @db.records(:foo) }).must_raise Starscope::DB::NoTableError
   end
 
   it 'must add paths' do
     paths = [GOLANG_SAMPLE, "#{FIXTURES}/**/*"]
     @db.add_paths(paths)
 
-    @db.metadata(:paths).must_equal paths
+    _(@db.metadata(:paths)).must_equal paths
     validate(@db)
   end
 
@@ -24,10 +24,10 @@ describe Starscope::DB do
     @db.add_excludes(["#{FIXTURES}/**"])
 
     files = @db.metadata(:files).keys
-    files.wont_include RUBY_SAMPLE
-    files.wont_include GOLANG_SAMPLE
-    @db.records(:defs).must_be_empty
-    @db.records(:end).must_be_empty
+    _(files).wont_include RUBY_SAMPLE
+    _(files).wont_include GOLANG_SAMPLE
+    _(@db.records(:defs)).must_be_empty
+    _(@db.records(:end)).must_be_empty
   end
 
   it 'must pick up new files in old paths' do
@@ -40,23 +40,23 @@ describe Starscope::DB do
   it 'must remove old files in existing paths' do
     @db.load("#{FIXTURES}/db_removed_files.json")
     @db.update
-    @db.metadata(:files).keys.wont_include "#{FIXTURES}/foo"
+    _(@db.metadata(:files).keys).wont_include "#{FIXTURES}/foo"
   end
 
   it "must update stale existing files when extractor hasn't changed" do
     @db.load("#{FIXTURES}/db_out_of_date.json")
-    @db.metadata(:langs)[:Golang].must_be :>=, Starscope::DB::LANGS[:Golang]
+    _(@db.metadata(:langs)[:Golang]).must_be :>=, Starscope::DB::LANGS[:Golang]
 
     cur_mtime = @db.metadata(:files)[GOLANG_SAMPLE][:last_updated]
     File.expects(:mtime).twice.returns(cur_mtime + 1)
     @db.update
 
     file = @db.metadata(:files)[GOLANG_SAMPLE]
-    file[:last_updated].must_equal cur_mtime + 1
-    file[:lang].must_equal :Golang
-    file[:lines].wont_be_empty
-    @db.records(:defs).wont_be_empty
-    @db.records(:calls).wont_be_empty
+    _(file[:last_updated]).must_equal cur_mtime + 1
+    _(file[:lang]).must_equal :Golang
+    _(file[:lines]).wont_be_empty
+    _(@db.records(:defs)).wont_be_empty
+    _(@db.records(:calls)).wont_be_empty
   end
 
   it 'must update unchanged existing files with old extractor versions' do
@@ -67,11 +67,11 @@ describe Starscope::DB do
     @db.update
 
     file = @db.metadata(:files)[GOLANG_SAMPLE]
-    file[:last_updated].must_equal cur_mtime
-    file[:lang].must_equal :Golang
-    file[:lines].wont_be_empty
-    @db.records(:defs).wont_be_empty
-    @db.records(:calls).wont_be_empty
+    _(file[:last_updated]).must_equal cur_mtime
+    _(file[:lang]).must_equal :Golang
+    _(file[:lines]).wont_be_empty
+    _(@db.records(:defs)).wont_be_empty
+    _(@db.records(:calls)).wont_be_empty
   end
 
   it 'must update unchanged existing files with old sublang extractor versions' do
@@ -82,12 +82,12 @@ describe Starscope::DB do
     @db.update
 
     file = @db.metadata(:files)[GOLANG_SAMPLE]
-    file[:last_updated].must_equal cur_mtime
-    file[:lang].must_equal :Golang
-    file[:sublangs].must_be_empty
-    file[:lines].wont_be_empty
-    @db.records(:defs).wont_be_empty
-    @db.records(:calls).wont_be_empty
+    _(file[:last_updated]).must_equal cur_mtime
+    _(file[:lang]).must_equal :Golang
+    _(file[:sublangs]).must_be_empty
+    _(file[:lines]).wont_be_empty
+    _(@db.records(:defs)).wont_be_empty
+    _(@db.records(:calls)).wont_be_empty
   end
 
   it 'must update unchanged existing files when the extractor has been removed' do
@@ -98,11 +98,11 @@ describe Starscope::DB do
     @db.update
 
     file = @db.metadata(:files)[GOLANG_SAMPLE]
-    file[:last_updated].must_equal cur_mtime
-    file[:lang].must_equal :Golang
-    file[:lines].wont_be_empty
-    @db.records(:defs).wont_be_empty
-    @db.records(:calls).wont_be_empty
+    _(file[:last_updated]).must_equal cur_mtime
+    _(file[:lang]).must_equal :Golang
+    _(file[:lines]).wont_be_empty
+    _(@db.records(:defs)).wont_be_empty
+    _(@db.records(:calls)).wont_be_empty
   end
 
   it 'must not update file with up-to-date time and extractor' do
@@ -110,13 +110,13 @@ describe Starscope::DB do
     @db.update
 
     file = @db.metadata(:files)[GOLANG_SAMPLE]
-    file[:last_updated].must_equal 10_000_000_000
-    @db.tables.must_be_empty
+    _(file[:last_updated]).must_equal 10_000_000_000
+    _(@db.tables).must_be_empty
   end
 
   it 'must load an old DB file' do
     @db.load("#{FIXTURES}/db_old.json.gz")
-    @db.metadata(:paths).must_equal ["#{FIXTURES}/**/*"]
+    _(@db.metadata(:paths)).must_equal ["#{FIXTURES}/**/*"]
     validate(@db)
   end
 
@@ -136,26 +136,26 @@ describe Starscope::DB do
 
   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
+    _(@db.query(:calls, 'abc')).must_equal []
+    _(@db.query(:defs, 'xyz')).must_equal []
+    _(@db.query(:calls, 'add_file').length).must_equal 3
   end
 
   it 'must run queries on multiple tables' do
     @db.add_paths([FIXTURES])
-    ret = @db.query([:calls, :defs], 'foo')
-    ret.length.must_equal 4
-    ret.first[:name].last.must_equal :foo
+    ret = @db.query(%i[calls defs], 'foo')
+    _(ret.length).must_equal 4
+    _(ret.first[:name].last).must_equal :foo
   end
 
   it 'must symbolize compound name' do
     rec = Starscope::DB.normalize_record(:foo, ['a', :b], {})
-    rec[:name].must_equal [:a, :b]
+    _(rec[:name]).must_equal %i[a b]
   end
 
   it 'must symbolize and array-wrap simple name' do
     rec = Starscope::DB.normalize_record(:foo, 'a', {})
-    rec[:name].must_equal [:a]
+    _(rec[:name]).must_equal [:a]
   end
 
   it 'must store extractor metadata returned from the `extract` call' do
@@ -167,21 +167,21 @@ describe Starscope::DB do
 
     @db.add_paths([GOLANG_SAMPLE])
 
-    @db.metadata(:files)[GOLANG_SAMPLE][:a].must_equal 1
+    _(@db.metadata(:files)[GOLANG_SAMPLE][:a]).must_equal 1
   end
 
   private
 
   def validate(db)
     files = db.metadata(: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
-
-    db.records(:defs).wont_be_empty
-    db.records(:calls).wont_be_empty
-    db.records(:imports).wont_be_empty
-    db.records(:requires).wont_be_empty
+    _(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
+
+    _(db.records(:defs)).wont_be_empty
+    _(db.records(:calls)).wont_be_empty
+    _(db.records(:imports)).wont_be_empty
+    _(db.records(:requires)).wont_be_empty
   end
 end

data/test/unit/exportable_test.rb

@@ -11,7 +11,7 @@ describe Starscope::Exportable do
     @db.export_to(:ctags, @buf, '.')
     @buf.rewind
     lines = @buf.each_line.to_a
-    lines.must_include(
+    _(lines).must_include(
       "NoTableError\t" \
       "./#{FIXTURES}/sample_ruby.rb\t" \
       "/^  class NoTableError < StandardError; end$/;\"\t" \
@@ -24,7 +24,7 @@ describe Starscope::Exportable do
     @db.export_to(:ctags, @buf, '../foo')
     @buf.rewind
     lines = @buf.each_line.to_a
-    lines.must_include(
+    _(lines).must_include(
       "NoTableError\t" \
       "../foo/#{FIXTURES}/sample_ruby.rb\t" \
       "/^  class NoTableError < StandardError; end$/;\"\t" \
@@ -38,14 +38,16 @@ describe Starscope::Exportable do
     @buf.rewind
     lines = @buf.each_line.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).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).must_include "\tgsingle_var_unicode\n"
 
-    lines.wont_include "= [\n"
-    lines.wont_include "4 LANGS = [\n"
-    lines.wont_include "116 tmpdb[entry[:file]][entry[:line_no]] ||= []\n"
+    _(lines).wont_include "\tgsingle_var_Äunicode\n"
+    _(lines).wont_include "= [\n"
+    _(lines).wont_include "4 LANGS = [\n"
+    _(lines).wont_include "116 tmpdb[entry[:file]][entry[:line_no]] ||= []\n"
   end
 end

data/test/unit/fragment_extractor_test.rb

@@ -1,13 +1,13 @@
 require_relative '../test_helper'
 
-describe Starscope::FragmentExtractor do
-  module Starscope
-    module Lang
-      module Dummy
-      end
+module Starscope
+  module Lang
+    module Dummy
     end
   end
+end
 
+describe Starscope::FragmentExtractor do
   before do
     @extractor = Starscope::FragmentExtractor.new(
       :Dummy,
@@ -15,7 +15,8 @@ describe Starscope::FragmentExtractor do
         { frag: "def foo; end\n", line_no: 12 },
         { frag: "def bar\n", line_no: 15 },
         { frag: "end\n", line_no: 29 }
-      ])
+      ]
+    )
     @reconstructed = "def foo; end\ndef bar\nend"
   end
 
@@ -26,20 +27,20 @@ describe Starscope::FragmentExtractor do
 
   it 'must pass along extractor metadata from the child' do
     ::Starscope::Lang::Dummy.expects(:extract).returns a: 1, b: 3
-    @extractor.extract(:foo, '---').must_equal a: 1, b: 3
+    _(@extractor.extract(:foo, '---')).must_equal a: 1, b: 3
   end
 
   it 'must pass along the name from the child' do
-    @extractor.name.must_equal ::Starscope::Lang::Dummy.name
+    _(@extractor.name).must_equal ::Starscope::Lang::Dummy.name
   end
 
   it 'must override-merge yielded args based on line number' do
     ::Starscope::Lang::Dummy.expects(:extract).yields(:foo, :bar, line_no: 2, foo: :bar)
 
     @extractor.extract(:foo, '---') do |tbl, name, args|
-      tbl.must_equal :foo
-      name.must_equal :bar
-      args.must_equal line_no: 15, foo: :bar
+      _(tbl).must_equal :foo
+      _(name).must_equal :bar
+      _(args).must_equal line_no: 15, foo: :bar
     end
   end
 end

data/test/unit/langs/erb_test.rb

@@ -4,33 +4,33 @@ describe Starscope::Lang::ERB do
   before do
     @frags = []
     Starscope::Lang::ERB.extract(ERB_SAMPLE, File.read(ERB_SAMPLE)) do |tbl, name, args|
-      tbl.must_equal Starscope::DB::FRAGMENT
-      name.must_equal :Ruby
+      _(tbl).must_equal Starscope::DB::FRAGMENT
+      _(name).must_equal :Ruby
       @frags << args
     end
   end
 
   it 'must match erb files' do
-    Starscope::Lang::ERB.match_file(ERB_SAMPLE).must_equal true
+    _(Starscope::Lang::ERB.match_file(ERB_SAMPLE)).must_equal true
   end
 
   it 'must not match non-erb files' do
-    Starscope::Lang::ERB.match_file(GOLANG_SAMPLE).must_equal false
-    Starscope::Lang::ERB.match_file(EMPTY_FILE).must_equal false
+    _(Starscope::Lang::ERB.match_file(GOLANG_SAMPLE)).must_equal false
+    _(Starscope::Lang::ERB.match_file(EMPTY_FILE)).must_equal false
   end
 
   it 'must identify all fragments' do
-    @frags.must_equal [{ frag: ' if foo ', line_no: 1 },
-                       { frag: ' elsif bar ', line_no: 3 },
-                       { frag: ' end ', line_no: 5 },
-                       { frag: ' case x', line_no: 8 },
-                       { frag: 'when :bar ', line_no: 9 },
-                       { frag: ' magic ', line_no: 9 },
-                       { frag: ' when :baz', line_no: 9 },
-                       { frag: 'when :foo ', line_no: 10 },
-                       { frag: ' end ', line_no: 12 },
-                       { frag: ' foo ', line_no: 14 },
-                       { frag: ' bar ', line_no: 14 },
-                       { frag: ' baz ', line_no: 14 }]
+    _(@frags).must_equal [{ frag: ' if foo ', line_no: 1 },
+                          { frag: ' elsif bar ', line_no: 3 },
+                          { frag: ' end ', line_no: 5 },
+                          { frag: ' case x', line_no: 8 },
+                          { frag: 'when :bar ', line_no: 9 },
+                          { frag: ' magic ', line_no: 9 },
+                          { frag: ' when :baz', line_no: 9 },
+                          { frag: 'when :foo ', line_no: 10 },
+                          { frag: ' end ', line_no: 12 },
+                          { frag: ' foo ', line_no: 14 },
+                          { frag: ' bar ', line_no: 14 },
+                          { frag: ' baz ', line_no: 14 }]
   end
 end

data/test/unit/langs/golang_test.rb

@@ -10,89 +10,89 @@ describe Starscope::Lang::Golang do
   end
 
   it 'must match golang files' do
-    Starscope::Lang::Golang.match_file(GOLANG_SAMPLE).must_equal true
+    _(Starscope::Lang::Golang.match_file(GOLANG_SAMPLE)).must_equal true
   end
 
   it 'must not match non-golang files' do
-    Starscope::Lang::Golang.match_file(RUBY_SAMPLE).must_equal false
-    Starscope::Lang::Golang.match_file(EMPTY_FILE).must_equal false
+    _(Starscope::Lang::Golang.match_file(RUBY_SAMPLE)).must_equal false
+    _(Starscope::Lang::Golang.match_file(EMPTY_FILE)).must_equal false
   end
 
   it 'must identify definitions' do
-    @db.keys.must_include :defs
+    _(@db.keys).must_include :defs
     defs = @db[:defs].map { |x| x[:name][-1] }
 
-    defs.must_include :a
-    defs.must_include :b
-    defs.must_include :c
-    defs.must_include :ttt
-    defs.must_include :main
-    defs.must_include :v1
-    defs.must_include :v2
-    defs.must_include :Sunday
-    defs.must_include :Monday
-    defs.must_include :single_var
-    defs.must_include :single_const
-
-    defs.wont_include :"0x00"
-    defs.wont_include :"0x01"
-    defs.wont_include :"0x02"
-    defs.wont_include :"0x03"
+    _(defs).must_include :a
+    _(defs).must_include :b
+    _(defs).must_include :c
+    _(defs).must_include :ttt
+    _(defs).must_include :main
+    _(defs).must_include :v1
+    _(defs).must_include :v2
+    _(defs).must_include :Sunday
+    _(defs).must_include :Monday
+    _(defs).must_include :single_var_Äunicode
+    _(defs).must_include :single_const
+
+    _(defs).wont_include :'0x00'
+    _(defs).wont_include :'0x01'
+    _(defs).wont_include :'0x02'
+    _(defs).wont_include :'0x03'
   end
 
   it 'must identify endings' do
-    @db.keys.must_include :end
-    @db[:end].count.must_equal 7
+    _(@db.keys).must_include :end
+    _(@db[:end].count).must_equal 7
   end
 
   it 'must identify function calls' do
-    @db.keys.must_include :calls
+    _(@db.keys).must_include :calls
     calls = @db[:calls].group_by { |x| x[:name][-1] }
 
-    calls.keys.must_include :a
-    calls.keys.must_include :b
-    calls.keys.must_include :c
-    calls.keys.must_include :ttt
-    calls.keys.must_include :Errorf
-
-    calls[:a].count.must_equal 3
-    calls[:b].count.must_equal 4
-    calls[:c].count.must_equal 4
-    calls[:ttt].count.must_equal 2
-    calls[:Errorf].count.must_equal 1
+    _(calls.keys).must_include :a
+    _(calls.keys).must_include :b
+    _(calls.keys).must_include :c
+    _(calls.keys).must_include :ttt
+    _(calls.keys).must_include :Errorf
+
+    _(calls[:a].count).must_equal 3
+    _(calls[:b].count).must_equal 4
+    _(calls[:c].count).must_equal 4
+    _(calls[:ttt].count).must_equal 2
+    _(calls[:Errorf].count).must_equal 1
   end
 
   it 'must identify variable assignments' do
-    @db.keys.must_include :assigns
+    _(@db.keys).must_include :assigns
     assigns = @db[:assigns].group_by { |x| x[:name][-1] }
 
-    assigns.keys.must_include :x
-    assigns.keys.must_include :y
-    assigns.keys.must_include :z
-    assigns.keys.must_include :n
-    assigns.keys.must_include :m
-    assigns.keys.must_include :msg
-
-    assigns[:x].count.must_equal 2
-    assigns[:y].count.must_equal 1
-    assigns[:z].count.must_equal 1
-    assigns[:n].count.must_equal 1
-    assigns[:m].count.must_equal 2
+    _(assigns.keys).must_include :x
+    _(assigns.keys).must_include :y
+    _(assigns.keys).must_include :z
+    _(assigns.keys).must_include :n
+    _(assigns.keys).must_include :m
+    _(assigns.keys).must_include :msg
+
+    _(assigns[:x].count).must_equal 2
+    _(assigns[:y].count).must_equal 1
+    _(assigns[:z].count).must_equal 1
+    _(assigns[:n].count).must_equal 1
+    _(assigns[:m].count).must_equal 2
   end
 
   it 'must identify imports' do
-    @db.keys.must_include :imports
+    _(@db.keys).must_include :imports
     imports = @db[:imports].group_by { |x| x[:name][-1] }
 
-    imports.keys.must_include :fmt
+    _(imports.keys).must_include :fmt
   end
 
   it 'must correctly find the end of string constants' do
-    Starscope::Lang::Golang.find_end_of_string('"123"foo', 0).must_equal 4
-    Starscope::Lang::Golang.find_end_of_string('a"123"foo', 0).must_equal 1
-    Starscope::Lang::Golang.find_end_of_string('a"123"foo', 1).must_equal 5
-    Starscope::Lang::Golang.find_end_of_string('"1\""foo', 0).must_equal 4
-    Starscope::Lang::Golang.find_end_of_string('"1\\""foo', 0).must_equal 4
-    Starscope::Lang::Golang.find_end_of_string('"1\\\\\"foo', 0).must_equal 9
+    _(Starscope::Lang::Golang.find_end_of_string('"123"foo', 0)).must_equal 4
+    _(Starscope::Lang::Golang.find_end_of_string('a"123"foo', 0)).must_equal 1
+    _(Starscope::Lang::Golang.find_end_of_string('a"123"foo', 1)).must_equal 5
+    _(Starscope::Lang::Golang.find_end_of_string('"1\""foo', 0)).must_equal 4
+    _(Starscope::Lang::Golang.find_end_of_string('"1\\""foo', 0)).must_equal 4
+    _(Starscope::Lang::Golang.find_end_of_string('"1\\\\\"foo', 0)).must_equal 9
   end
 end

data/test/unit/langs/javascript_test.rb

@@ -10,78 +10,78 @@ describe Starscope::Lang::Javascript do
   end
 
   it 'must match js files' do
-    Starscope::Lang::Javascript.match_file(JAVASCRIPT_EXAMPLE).must_equal true
+    _(Starscope::Lang::Javascript.match_file(JAVASCRIPT_EXAMPLE)).must_equal true
   end
 
   it 'must not match non-js files' do
-    Starscope::Lang::Javascript.match_file(RUBY_SAMPLE).must_equal false
-    Starscope::Lang::Javascript.match_file(EMPTY_FILE).must_equal false
+    _(Starscope::Lang::Javascript.match_file(RUBY_SAMPLE)).must_equal false
+    _(Starscope::Lang::Javascript.match_file(EMPTY_FILE)).must_equal false
   end
 
   it 'must identify definitions' do
-    @db.keys.must_include :defs
+    _(@db.keys).must_include :defs
     defs = @db[:defs].map { |x| x[:name][-1] }
 
-    defs.must_include :Component
-    defs.must_include :StyleSheet
-    defs.must_include :styles
-    defs.must_include :NavigatorRouteMapper
-    defs.must_include :LeftButton
-    defs.must_include :RightButton
-    defs.must_include :_tabItem
-    defs.must_include :render
-    defs.must_include :setRef
-    defs.must_include :route
-    defs.must_include :foo
-    defs.must_include :MyStat
-    defs.must_include :myStatFunc
-    defs.must_include :bracelessMethod
+    _(defs).must_include :Component
+    _(defs).must_include :StyleSheet
+    _(defs).must_include :styles
+    _(defs).must_include :NavigatorRouteMapper
+    _(defs).must_include :LeftButton
+    _(defs).must_include :RightButton
+    _(defs).must_include :_tabItem
+    _(defs).must_include :render
+    _(defs).must_include :setRef
+    _(defs).must_include :route
+    _(defs).must_include :foo
+    _(defs).must_include :MyStat
+    _(defs).must_include :myStatFunc
+    _(defs).must_include :bracelessMethod
 
-    defs.wont_include :setStyle
-    defs.wont_include :setState
-    defs.wont_include :fontFamily
-    defs.wont_include :navigator
-    defs.wont_include :madness
-    defs.wont_include :React
+    _(defs).wont_include :setStyle
+    _(defs).wont_include :setState
+    _(defs).wont_include :fontFamily
+    _(defs).wont_include :navigator
+    _(defs).wont_include :madness
+    _(defs).wont_include :React
   end
 
   it 'must only tag static classes once' do
-    @db[:defs].count { |x| x[:name][-1] == :MyStat }.must_equal 1
+    _(@db[:defs].count { |x| x[:name][-1] == :MyStat }).must_equal 1
   end
 
   it 'must identify endings' do
-    @db.keys.must_include :end
-    @db[:end].count.must_equal 12
+    _(@db.keys).must_include :end
+    _(@db[:end].count).must_equal 12
 
     # bracelessMethod doesn't have a taggable end token so
     # we have to do a little dancing with an empty name and a precise column
-    @db[:end][0][:name].must_equal [:'']
-    @db[:end][0][:col].must_equal 27
+    _(@db[:end][0][:name]).must_equal [:'']
+    _(@db[:end][0][:col]).must_equal 27
   end
 
   it 'must identify function calls' do
-    @db.keys.must_include :calls
+    _(@db.keys).must_include :calls
     calls = @db[:calls].group_by { |x| x[:name][-1] }
 
-    calls.keys.must_include :create
-    calls.keys.must_include :setStyle
-    calls.keys.must_include :pop
-    calls.keys.must_include :fetchData
-    calls.keys.must_include :setState
-    calls.keys.must_include :func1
+    _(calls.keys).must_include :create
+    _(calls.keys).must_include :setStyle
+    _(calls.keys).must_include :pop
+    _(calls.keys).must_include :fetchData
+    _(calls.keys).must_include :setState
+    _(calls.keys).must_include :func1
 
-    calls[:pop].count.must_equal 1
-    calls[:_tabItem].count.must_equal 3
+    _(calls[:pop].count).must_equal 1
+    _(calls[:_tabItem].count).must_equal 3
   end
 
   it 'must identify module requires' do
-    @db.keys.must_include :requires
+    _(@db.keys).must_include :requires
     requires = @db[:requires].group_by { |x| x[:name][-1] }
 
-    requires.keys.must_include :'foo-bar'
-    requires.keys.must_include :'react-native'
-    requires.keys.wont_include :NOPE
-    requires.keys.wont_include :true
-    requires.keys.wont_include :false
+    _(requires.keys).must_include :'foo-bar'
+    _(requires.keys).must_include :'react-native'
+    _(requires.keys).wont_include :NOPE
+    _(requires.keys).wont_include true
+    _(requires.keys).wont_include false
   end
 end