licensee 9.10.1 → 9.13.2

data/spec/licensee/hash_helper_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe Licensee::HashHelper do
   class HashHelperSpecFixture
     include Licensee::HashHelper
@@ -53,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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 RSpec.describe Licensee::LicenseField do
   let(:expected_count) { 7 }
 
   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
@@ -33,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')
@@ -45,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe Licensee::LicenseMeta do
   subject { Licensee::License.find('mit').meta }
 
@@ -14,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
@@ -36,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')
@@ -70,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
 
@@ -96,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
 
@@ -116,7 +120,7 @@ RSpec.describe Licensee::LicenseMeta do
           'Babel' => 'https://github.com/babel/babel/blob/master/LICENSE'
         },
         {
-          '.NET Core' => 'https://github.com/dotnet/corefx/blob/master/LICENSE.TXT'
+          '.NET Core' => 'https://github.com/dotnet/runtime/blob/master/LICENSE.TXT'
         },
         {
           'Rails' => 'https://github.com/rails/rails/blob/master/MIT-LICENSE'

data/spec/licensee/license_rules_spec.rb

@@ -1,7 +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
@@ -35,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,6 +1,8 @@
+# frozen_string_literal: true
+
 RSpec.describe Licensee::License do
-  let(:license_count) { 36 }
-  let(:hidden_license_count) { 24 }
+  let(:license_count) { 41 }
+  let(:hidden_license_count) { 28 }
   let(:featured_license_count) { 3 }
   let(:pseudo_license_count) { 2 }
   let(:non_featured_license_count) do
@@ -14,7 +16,7 @@ RSpec.describe Licensee::License do
   let(:no_license) { described_class.find('no-license') }
   let(:gpl) { described_class.find('gpl-3.0') }
   let(:lgpl) { described_class.find('lgpl-3.0') }
-  let(:content_hash) { '46cdc03462b9af57968df67b450cc4372ac41f53' }
+  let(:content_hash) { license_hashes['mit'] }
 
   let(:license_dir) do
     File.expand_path 'vendor/choosealicense.com/_licenses', project_root
@@ -33,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
 
@@ -43,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
 
@@ -63,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
@@ -74,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
 
@@ -85,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
 
@@ -122,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
 
@@ -139,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
@@ -195,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
@@ -214,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
@@ -236,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
@@ -299,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
 
@@ -317,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
@@ -351,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?
@@ -438,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)
@@ -473,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,16 +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
 
   {
@@ -27,6 +30,98 @@ RSpec.describe Licensee::Matchers::Cabal do
     end
   end
 
+  context 'non-standard license format' do
+    let(:content) { "license: #{cabal_license}" }
+
+    context 'GPL-3' do
+      let(:cabal_license) { 'GPL-3' }
+
+      it 'returns GPL-3.0' do
+        expect(subject.match).to eql(Licensee::License.find('GPL-3.0'))
+      end
+    end
+
+    context 'GPL-2' do
+      let(:cabal_license) { 'GPL-2' }
+
+      it 'returns GPL-2.0' do
+        expect(subject.match).to eql(Licensee::License.find('GPL-2.0'))
+      end
+    end
+
+    context 'LGPL-2.1' do
+      let(:cabal_license) { 'LGPL-2.1' }
+
+      it 'returns LGPL-2.1' do
+        expect(subject.match).to eql(Licensee::License.find('LGPL-2.1'))
+      end
+    end
+
+    context 'LGPL-3' do
+      let(:cabal_license) { 'LGPL-3' }
+
+      it 'returns LGPL-3.0' do
+        expect(subject.match).to eql(Licensee::License.find('LGPL-3.0'))
+      end
+    end
+
+    context 'AGPL-3' do
+      let(:cabal_license) { 'AGPL-3' }
+
+      it 'returns AGPL-3.0' do
+        expect(subject.match).to eql(Licensee::License.find('AGPL-3.0'))
+      end
+    end
+
+    context 'BSD2' do
+      let(:cabal_license) { 'BSD2' }
+
+      it 'returns BSD-2-Clause' do
+        expect(subject.match).to eql(Licensee::License.find('BSD-2-Clause'))
+      end
+    end
+
+    context 'BSD3' do
+      let(:cabal_license) { 'BSD3' }
+
+      it 'returns BSD-3-Clause' do
+        expect(subject.match).to eql(Licensee::License.find('BSD-3-Clause'))
+      end
+    end
+
+    context 'MIT' do
+      let(:cabal_license) { 'MIT' }
+
+      it 'returns MIT' do
+        expect(subject.match).to eql(Licensee::License.find('MIT'))
+      end
+    end
+
+    context 'ISC' do
+      let(:cabal_license) { 'ISC' }
+
+      it 'returns ISC' do
+        expect(subject.match).to eql(Licensee::License.find('ISC'))
+      end
+    end
+
+    context 'MPL-2.0' do
+      let(:cabal_license) { 'MPL-2.0' }
+
+      it 'returns MPL-2.0' do
+        expect(subject.match).to eql(Licensee::License.find('MPL-2.0'))
+      end
+    end
+
+    context 'Apache-2.0' do
+      let(:cabal_license) { 'Apache-2.0' }
+
+      it 'returns Apache-2.0' do
+        expect(subject.match).to eql(Licensee::License.find('Apache-2.0'))
+      end
+    end
+  end
+
   context 'no license field' do
     let(:content) { 'foo: bar' }