starscope 1.5.7 → 1.6.0

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,
@@ -27,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

data/test/unit/langs/ruby_test.rb

@@ -10,57 +10,57 @@ describe Starscope::Lang::Ruby do
   end
 
   it 'must match ruby files' do
-    Starscope::Lang::Ruby.match_file(RUBY_SAMPLE).must_equal true
-    Starscope::Lang::Ruby.match_file('bin/starscope').must_equal true
+    _(Starscope::Lang::Ruby.match_file(RUBY_SAMPLE)).must_equal true
+    _(Starscope::Lang::Ruby.match_file('bin/starscope')).must_equal true
   end
 
   it 'must not match non-ruby files' do
-    Starscope::Lang::Ruby.match_file(GOLANG_SAMPLE).must_equal false
-    Starscope::Lang::Ruby.match_file(EMPTY_FILE).must_equal false
+    _(Starscope::Lang::Ruby.match_file(GOLANG_SAMPLE)).must_equal false
+    _(Starscope::Lang::Ruby.match_file(EMPTY_FILE)).must_equal false
   end
 
   it 'must identify function definitions' do
-    @db.keys.must_include :defs
+    _(@db.keys).must_include :defs
     defs = @db[:defs].map { |x| x[:name][-1] }
 
-    defs.must_include :DB
-    defs.must_include :NoTableError
-    defs.must_include :load
-    defs.must_include :update
-    defs.must_include :files_from_path
+    _(defs).must_include :DB
+    _(defs).must_include :NoTableError
+    _(defs).must_include :load
+    _(defs).must_include :update
+    _(defs).must_include :files_from_path
   end
 
   it 'must identify constant definitions' do
-    @db[:defs].map { |x| x[:name][-1] }.must_include :PBAR_FORMAT
+    _(@db[:defs].map { |x| x[:name][-1] }).must_include :PBAR_FORMAT
   end
 
   it 'must identify endings' do
-    @db.keys.must_include :end
-    @db[:end].count.must_equal 13
+    _(@db.keys).must_include :end
+    _(@db[:end].count).must_equal 13
   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 :add_file
-    calls.keys.must_include :each
-    calls[:add_file].count.must_equal 3
-    calls[:each].count.must_equal 8
+    _(calls.keys).must_include :add_file
+    _(calls.keys).must_include :each
+    _(calls[:add_file].count).must_equal 3
+    _(calls[:each].count).must_equal 8
   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 :pbar
-    assigns.keys.must_include :PBAR_FORMAT
-    assigns.keys.must_include :foo
-    assigns[:pbar].count.must_equal 2
-    assigns[:PBAR_FORMAT].count.must_equal 1
-    assigns[:foo].count.must_equal 1
+    _(assigns.keys).must_include :pbar
+    _(assigns.keys).must_include :PBAR_FORMAT
+    _(assigns.keys).must_include :foo
+    _(assigns[:pbar].count).must_equal 2
+    _(assigns[:PBAR_FORMAT].count).must_equal 1
+    _(assigns[:foo].count).must_equal 1
 
-    assigns.keys.wont_include '='.to_sym
-    assigns.keys.wont_include '<'.to_sym
+    _(assigns.keys).wont_include :'='
+    _(assigns.keys).wont_include :<
   end
 end

data/test/unit/output_test.rb

@@ -6,7 +6,7 @@ describe Starscope::Output do
     out = Starscope::Output.new(:quiet, buf)
     out.normal('foo')
     out.extra('foo')
-    buf.size.must_equal 0
+    _(buf.size).must_equal 0
   end
 
   it 'must be normal' do
@@ -14,7 +14,7 @@ describe Starscope::Output do
     out = Starscope::Output.new(:normal, buf)
     out.normal('foo')
     out.extra('foo')
-    buf.size.must_equal 4
+    _(buf.size).must_equal 4
   end
 
   it 'must be verbose' do
@@ -22,6 +22,6 @@ describe Starscope::Output do
     out = Starscope::Output.new(:verbose, buf)
     out.normal('foo')
     out.extra('foo')
-    buf.size.must_equal 8
+    _(buf.size).must_equal 8
   end
 end

data/test/unit/queryable_test.rb

@@ -1,61 +1,61 @@
 require_relative '../test_helper'
 
-describe Starscope::Queryable do
-  SAMPLE_RECORDS = [
-    { name: [:"[abc"], foo: 'baz' },
-    { name: [:"not a match"], foo: 'bar', x: 'y' },
-    { name: [:a, :b, :c, :d], file: :somefile }
-  ].freeze
-
-  class MockQuerable
-    include Starscope::Queryable
-    def initialize
-      @tables = {
-        mytable: SAMPLE_RECORDS,
-        empty_table: []
-      }
-      @meta = {
-        files: {
-          somefile: {
-            lang: :ruby
-          }
+SAMPLE_RECORDS = [
+  { name: [:'[abc'], foo: 'baz' },
+  { name: [:'not a match'], foo: 'bar', x: 'y' },
+  { name: %i[a b c d], file: :somefile }
+].freeze
+
+class MockQuerable
+  include Starscope::Queryable
+  def initialize
+    @tables = {
+      mytable: SAMPLE_RECORDS,
+      empty_table: []
+    }
+    @meta = {
+      files: {
+        somefile: {
+          lang: :ruby
         }
       }
-    end
+    }
   end
+end
 
+describe Starscope::Queryable do
   before do
     @mock = MockQuerable.new
   end
 
   it 'must handle empty input' do
-    @mock.query(:empty_table, 'foo').must_be_empty
+    _(@mock.query(:empty_table, 'foo')).must_be_empty
   end
 
   it 'must handle scoped queries' do
-    @mock.query(:mytable, 'a::b::').must_equal [SAMPLE_RECORDS[2]]
+    _(@mock.query(:mytable, 'a::b::')).must_equal [SAMPLE_RECORDS[2]]
   end
 
   it 'must handle regex queries' do
-    @mock.query(:mytable, 'a[bc]{2}').must_equal [SAMPLE_RECORDS[0]]
+    _(@mock.query(:mytable, 'a[bc]{2}')).must_equal [SAMPLE_RECORDS[0]]
 
-    @mock.query(:mytable, 'a.*d').must_equal [SAMPLE_RECORDS[2]]
+    _(@mock.query(:mytable, 'a.*d')).must_equal [SAMPLE_RECORDS[2]]
   end
 
   it 'must handle malformed regexes' do
-    @mock.query(:mytable, '[abc').must_equal [SAMPLE_RECORDS[0]]
+    _(@mock.query(:mytable, '[abc')).must_equal [SAMPLE_RECORDS[0]]
   end
 
   it 'must handle simple filters' do
-    @mock.query(:mytable, '.*', foo: 'bar').must_equal [SAMPLE_RECORDS[1]]
+    _(@mock.query(:mytable, '.*', foo: 'bar')).must_equal [SAMPLE_RECORDS[1]]
   end
 
   it 'must handle multiple filters' do
-    @mock.query(:mytable, '.*', foo: 'bar', x: 'y').must_equal [SAMPLE_RECORDS[1]]
-    @mock.query(:mytable, '.*', foo: 'bar', x: 'nope').must_be_empty
+    _(@mock.query(:mytable, '.*', foo: 'bar', x: 'y')).must_equal [SAMPLE_RECORDS[1]]
+    _(@mock.query(:mytable, '.*', foo: 'bar', x: 'nope')).must_be_empty
   end
 
   it 'must handle filters on file properties' do
-    @mock.query(:mytable, '.*', lang: 'ruby').must_equal [SAMPLE_RECORDS[2]]
+    _(@mock.query(:mytable, '.*', lang: 'ruby')).must_equal [SAMPLE_RECORDS[2]]
   end
 end