licensee 9.12.0 → 9.13.0

data/spec/licensee/hash_helper_spec.rb

@@ -55,7 +55,7 @@ RSpec.describe Licensee::HashHelper do
   end
 
   it 'does not expose other methods' do
-    expect(hash).to_not have_key(:baz)
+    expect(hash).not_to have_key(:baz)
   end
 
   it 'calls to_h recursively' do

data/spec/licensee/license_field_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe Licensee::LicenseField do
   context 'class' do
     it 'returns all license fields' do
       expect(described_class.all.count).to eql(expected_count)
-      expect(described_class.all.first).to be_a(Licensee::LicenseField)
+      expect(described_class.all.first).to be_a(described_class)
     end
 
     it 'returns all license field keys' do
@@ -35,7 +35,7 @@ RSpec.describe Licensee::LicenseField do
       let(:fields) { described_class.from_array(array) }
 
       it 'returns an array of LicenseFields' do
-        expect(fields.count).to eql(2)
+        expect(fields.count).to be(2)
         expect(fields.first).to be_a(described_class)
         expect(fields.first.name).to eql('year')
         expect(fields.last.name).to eql('fullname')
@@ -47,7 +47,7 @@ RSpec.describe Licensee::LicenseField do
       let(:fields) { described_class.from_content(content) }
 
       it 'pulls fields from content' do
-        expect(fields.count).to eql(2)
+        expect(fields.count).to be(2)
         expect(fields.first.key).to eql('year')
         expect(fields[1].key).to eql('fullname')
       end

data/spec/licensee/license_meta_spec.rb

@@ -16,7 +16,7 @@ RSpec.describe Licensee::LicenseMeta do
 
       it 'responds to the field as a hash key' do
         if field['required']
-          expect(subject[name]).to_not be_nil
+          expect(subject[name]).not_to be_nil
         else
           expect { subject[name] }.not_to raise_error
         end
@@ -38,11 +38,12 @@ RSpec.describe Licensee::LicenseMeta do
     end
   end
 
-  context '#from_hash' do
+  describe '#from_hash' do
+    subject { described_class.from_hash(hash) }
+
     let(:hash) do
       { 'title' => 'Test license', 'description' => 'A test license' }
     end
-    subject { described_class.from_hash(hash) }
 
     it 'sets values' do
       expect(subject.title).to eql('Test license')
@@ -72,25 +73,26 @@ RSpec.describe Licensee::LicenseMeta do
     end
   end
 
-  context '#from_yaml' do
-    let(:yaml) { "title: Test license\ndescription: A test license" }
+  describe '#from_yaml' do
     subject { described_class.from_yaml(yaml) }
 
+    let(:yaml) { "title: Test license\ndescription: A test license" }
+
     it 'parses yaml' do
       expect(subject.title).to eql('Test license')
       expect(subject.description).to eql('A test license')
     end
 
     it 'sets defaults' do
-      expect(subject.hidden).to eql(true)
-      expect(subject.featured).to eql(false)
+      expect(subject.hidden).to be(true)
+      expect(subject.featured).to be(false)
     end
 
     context 'nil yaml' do
       let(:yaml) { nil }
 
       it 'returns defaults' do
-        expect(subject.hidden).to eql(true)
+        expect(subject.hidden).to be(true)
       end
     end
 
@@ -98,15 +100,15 @@ RSpec.describe Licensee::LicenseMeta do
       let(:yaml) { '' }
 
       it 'returns defaults' do
-        expect(subject.featured).to eql(false)
+        expect(subject.featured).to be(false)
       end
     end
   end
 
   it 'returns the list of helper methods' do
-    expect(described_class.helper_methods.length).to eql(13)
+    expect(described_class.helper_methods.length).to be(13)
     expect(described_class.helper_methods).to include(:hidden?)
-    expect(described_class.helper_methods).to_not include(:hidden)
+    expect(described_class.helper_methods).not_to include(:hidden)
     expect(described_class.helper_methods).to include(:title)
   end
 

data/spec/licensee/license_rules_spec.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 RSpec.describe Licensee::LicenseRules do
-  let(:mit) { Licensee::License.find('mit') }
   subject { mit.rules }
 
+  let(:mit) { Licensee::License.find('mit') }
+
   Licensee::Rule.groups.each do |group|
     context "the #{group} rule group" do
       it 'responds as a hash key string' do
@@ -37,9 +38,10 @@ RSpec.describe Licensee::LicenseRules do
   end
 
   context 'created from a hash' do
-    let(:hash) { { 'permissions' => Licensee::Rule.all } }
     subject { described_class.from_hash(hash) }
 
+    let(:hash) { { 'permissions' => Licensee::Rule.all } }
+
     it 'exposes the rules' do
       expect(subject.permissions.first.label).to eql('Commercial use')
     end

data/spec/licensee/license_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 RSpec.describe Licensee::License do
-  let(:license_count) { 39 }
+  let(:license_count) { 40 }
   let(:hidden_license_count) { 27 }
   let(:featured_license_count) { 3 }
   let(:pseudo_license_count) { 2 }
@@ -35,7 +35,7 @@ RSpec.describe Licensee::License do
       let(:arguments) { {} }
 
       it 'returns the licenses' do
-        expect(licenses).to all be_a(Licensee::License)
+        expect(licenses).to all be_a(described_class)
         expect(licenses.count).to eql(license_count - hidden_license_count)
       end
 
@@ -45,8 +45,8 @@ RSpec.describe Licensee::License do
 
       it 'includes featured licenses' do
         expect(licenses).to include(mit)
-        expect(licenses).to_not include(cc_by)
-        expect(licenses).to_not include(other)
+        expect(licenses).not_to include(cc_by)
+        expect(licenses).not_to include(other)
       end
     end
 
@@ -65,8 +65,8 @@ RSpec.describe Licensee::License do
 
       it 'includes only featured licenses' do
         expect(licenses).to include(mit)
-        expect(licenses).to_not include(cc_by)
-        expect(licenses).to_not include(other)
+        expect(licenses).not_to include(cc_by)
+        expect(licenses).not_to include(other)
         expect(licenses.count).to eql(featured_license_count)
       end
     end
@@ -76,8 +76,8 @@ RSpec.describe Licensee::License do
 
       it 'includes only non-featured licenses' do
         expect(licenses).to include(unlicense)
-        expect(licenses).to_not include(mit)
-        expect(licenses).to_not include(other)
+        expect(licenses).not_to include(mit)
+        expect(licenses).not_to include(other)
         expect(licenses.count).to eql(non_featured_license_count)
       end
 
@@ -87,20 +87,20 @@ RSpec.describe Licensee::License do
         it 'includes only non-featured licenses' do
           expect(licenses).to include(unlicense)
           expect(licenses).to include(cc_by)
-          expect(licenses).to_not include(mit)
+          expect(licenses).not_to include(mit)
           expect(licenses.count).to eql(license_count - featured_license_count)
         end
       end
     end
 
     context 'pseudo licenses' do
-      let(:other) { Licensee::License.find('other') }
+      let(:other) { described_class.find('other') }
 
       context 'by default' do
         let(:arguments) { {} }
 
         it "doesn't include pseudo licenses" do
-          expect(licenses).to_not include(other)
+          expect(licenses).not_to include(other)
         end
       end
 
@@ -124,7 +124,7 @@ RSpec.describe Licensee::License do
         let(:arguments) { { hidden: true, pseudo: false } }
 
         it "doesn'tincludes psudo licenses" do
-          expect(licenses).to_not include(other)
+          expect(licenses).not_to include(other)
         end
       end
 
@@ -141,7 +141,7 @@ RSpec.describe Licensee::License do
           let(:arguments) { { hidden: true, psuedo: false } }
 
           it "doesn'tincludes psudo licenses" do
-            expect(licenses).to_not include(other)
+            expect(licenses).not_to include(other)
           end
         end
       end
@@ -197,9 +197,9 @@ RSpec.describe Licensee::License do
     expect(no_license.spdx_id).to eql('NONE')
   end
 
-  context '#other?' do
+  describe '#other?' do
     it 'knows MIT is not other' do
-      expect(gpl).to_not be_other
+      expect(gpl).not_to be_other
     end
 
     it 'knows the other license is other?' do
@@ -216,7 +216,7 @@ RSpec.describe Licensee::License do
     end
 
     it 'includes defaults' do
-      expect(other.meta['hidden']).to eql(true)
+      expect(other.meta['hidden']).to be(true)
     end
 
     it 'returns the name' do
@@ -238,27 +238,27 @@ RSpec.describe Licensee::License do
     end
 
     it 'knows if a license is hidden' do
-      expect(mit).to_not be_hidden
+      expect(mit).not_to be_hidden
       expect(cc_by).to be_hidden
     end
 
     it 'knows if a license is featured' do
       expect(mit).to be_featured
-      expect(unlicense).to_not be_featured
+      expect(unlicense).not_to be_featured
     end
 
     it 'knows if a license is GPL' do
-      expect(mit).to_not be_gpl
+      expect(mit).not_to be_gpl
       expect(gpl).to be_gpl
     end
 
     it 'knows a license is lgpl' do
-      expect(mit).to_not be_gpl
+      expect(mit).not_to be_gpl
       expect(lgpl).to be_lgpl
     end
 
     it 'knows if a license is CC' do
-      expect(gpl).to_not be_creative_commons
+      expect(gpl).not_to be_creative_commons
       expect(cc_by).to be_creative_commons
     end
   end
@@ -301,11 +301,11 @@ RSpec.describe Licensee::License do
 
   it 'knows equality' do
     expect(mit).to eql(mit)
-    expect(gpl).to_not eql(mit)
+    expect(gpl).not_to eql(mit)
   end
 
   it 'knows if a license is a pseudo license' do
-    expect(mit).to_not be_pseudo_license
+    expect(mit).not_to be_pseudo_license
     expect(other).to be_pseudo_license
   end
 
@@ -319,24 +319,24 @@ RSpec.describe Licensee::License do
     expect(mit.rules).to be_a(Licensee::LicenseRules)
     expect(mit.rules).to have_key('permissions')
     expect(mit.rules['permissions'].first).to be_a(Licensee::Rule)
-    expect(mit.rules.flatten.count).to eql(7)
+    expect(mit.rules.flatten.count).to be(7)
   end
 
   it 'returns rules by tag and group' do
     expect(cc_by.rules).to have_key('limitations')
     rule = cc_by.rules['limitations'].find { |r| r.tag == 'patent-use' }
-    expect(rule).to_not be_nil
+    expect(rule).not_to be_nil
     expect(rule.description).to include('does NOT grant')
 
     expect(gpl.rules).to have_key('permissions')
     rule = gpl.rules['permissions'].find { |r| r.tag == 'patent-use' }
-    expect(rule).to_not be_nil
+    expect(rule).not_to be_nil
     expect(rule.description).to include('an express grant of patent rights')
   end
 
   context 'fields' do
     it 'returns the license fields' do
-      expect(mit.fields.count).to eql(2)
+      expect(mit.fields.count).to be(2)
       expect(mit.fields.first.key).to eql('year')
       expect(mit.fields.last.key).to eql('fullname')
       expect(gpl.fields).to be_empty
@@ -353,19 +353,19 @@ RSpec.describe Licensee::License do
       it 'returns mustache content' do
         expect(license.content_for_mustache).to match(/{{{year}}}/)
         expect(license.content_for_mustache).to match(/{{{fullname}}}/)
-        expect(license.content_for_mustache).to_not match(/\[year\]/)
-        expect(license.content_for_mustache).to_not match(/\[fullname\]/)
+        expect(license.content_for_mustache).not_to match(/\[year\]/)
+        expect(license.content_for_mustache).not_to match(/\[fullname\]/)
       end
 
       it "doesn't mangle other fields" do
         expect(license.content_for_mustache).to match(/\[foo\]/)
-        expect(license.content_for_mustache).to_not match(/{{{foo}}}/)
+        expect(license.content_for_mustache).not_to match(/{{{foo}}}/)
       end
     end
   end
 
   context 'License.title_regex' do
-    Licensee::License.all(hidden: true, pseudo: false).each do |license|
+    described_class.all(hidden: true, pseudo: false).each do |license|
       context "the #{license.title} license" do
         %i[title nickname key].each do |variation|
           next if license.send(variation).nil?
@@ -440,7 +440,7 @@ RSpec.describe Licensee::License do
 
     context 'a license with an alt title' do
       let(:text) { 'The Clear BSD license' }
-      let(:license) { Licensee::License.find('bsd-3-clause-clear') }
+      let(:license) { described_class.find('bsd-3-clause-clear') }
 
       it 'matches' do
         expect(text).to match(license.title_regex)
@@ -475,7 +475,7 @@ RSpec.describe Licensee::License do
   end
 
   context 'source regex' do
-    Licensee::License.all(hidden: true, pseudo: false).each do |license|
+    described_class.all(hidden: true, pseudo: false).each do |license|
       context "the #{license.title} license" do
         let(:source) { URI.parse(license.source) }
 

data/spec/licensee/matchers/cabal_matcher_spec.rb

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
 
 RSpec.describe Licensee::Matchers::Cabal do
+  subject { described_class.new(file) }
+
   let(:content) { 'license: mit' }
   let(:file) { Licensee::ProjectFiles::LicenseFile.new(content, 'LICENSE.txt') }
   let(:mit) { Licensee::License.find('mit') }
   let(:no_license) { Licensee::License.find('no-license') }
-  subject { described_class.new(file) }
 
   it 'matches' do
     expect(subject.match).to eql(mit)
   end
 
   it 'has a confidence' do
-    expect(subject.confidence).to eql(90)
+    expect(subject.confidence).to be(90)
   end
 
   {
@@ -31,6 +32,7 @@ RSpec.describe Licensee::Matchers::Cabal do
 
   context 'non-standard license format' do
     let(:content) { "license: #{cabal_license}" }
+
     context 'GPL-3' do
       let(:cabal_license) { 'GPL-3' }
 

data/spec/licensee/matchers/cargo_matcher_spec.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 
 RSpec.describe Licensee::Matchers::Cargo do
+  subject { described_class.new(file) }
+
   let(:mit) { Licensee::License.find('mit') }
   let(:content) { 'license = "MIT"' }
   let(:file) { Licensee::ProjectFiles::LicenseFile.new(content, 'Cargo.toml') }
-  subject { described_class.new(file) }
 
   it 'stores the file' do
     expect(subject.file).to eql(file)
   end
 
   it 'has confidence' do
-    expect(subject.confidence).to eql(90)
+    expect(subject.confidence).to be(90)
   end
 
   it 'matches' do

data/spec/licensee/matchers/copyright_matcher_spec.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 RSpec.describe Licensee::Matchers::Copyright do
+  subject { described_class.new(file) }
+
   let(:content) { 'Copyright 2015 Ben Balter'.dup }
   let(:file) { Licensee::ProjectFiles::LicenseFile.new(content, 'LICENSE.txt') }
   let(:mit) { Licensee::License.find('mit') }
   let(:no_license) { Licensee::License.find('no-license') }
 
-  subject { described_class.new(file) }
-
   it 'stores the file' do
     expect(subject.file).to eql(file)
   end
@@ -17,7 +17,7 @@ RSpec.describe Licensee::Matchers::Copyright do
   end
 
   it 'has a confidence' do
-    expect(subject.confidence).to eql(100)
+    expect(subject.confidence).to be(100)
   end
 
   {

data/spec/licensee/matchers/cran_matcher_spec.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 RSpec.describe Licensee::Matchers::Cran do
+  subject { described_class.new(file) }
+
   let(:mit) { Licensee::License.find('mit') }
   let(:gpl2) { Licensee::License.find('gpl-2.0') }
   let(:gpl3) { Licensee::License.find('gpl-3.0') }
   let(:content) { "License: MIT + file LICENSE\nPackage: test" }
   let(:file) { Licensee::ProjectFiles::LicenseFile.new(content, 'DESCRIPTION') }
-  subject { described_class.new(file) }
 
   it 'stores the file' do
     expect(subject.file).to eql(file)
@@ -17,7 +18,7 @@ RSpec.describe Licensee::Matchers::Cran do
   end
 
   it 'is confident' do
-    expect(subject.confidence).to eql(90)
+    expect(subject.confidence).to be(90)
   end
 
   {