licensee 6.1.1 → 7.0.0

data/test/helper.rb

@@ -5,3 +5,8 @@ require 'shoulda'
 require 'open3'
 require_relative 'functions'
 require_relative '../lib/licensee'
+
+def assert_license_content(expected, readme)
+  content = Licensee::Project::Readme.license_content(readme)
+  assert_equal expected, content
+end

data/test/test_licensee.rb

@@ -1,27 +1,28 @@
 require 'helper'
 
 class TestLicensee < Minitest::Test
-  should "know the licenses" do
+  should 'know the licenses' do
     assert_equal Array, Licensee.licenses.class
     assert_equal 15, Licensee.licenses.size
-    assert_equal 24, Licensee.licenses(:hidden => true).size
+    assert_equal 26, Licensee.licenses(hidden: true).size
     assert_equal Licensee::License, Licensee.licenses.first.class
   end
 
   should "detect a project's license" do
-    assert_equal "mit", Licensee.license(fixture_path("licenses.git")).key
+    assert_equal 'mit', Licensee.license(fixture_path('licenses.git')).key
   end
 
-  should "init a project" do
-    assert_equal Licensee::GitProject, Licensee.project(fixture_path("licenses.git")).class
+  should 'init a project' do
+    project = Licensee.project(fixture_path('licenses.git'))
+    assert_equal Licensee::GitProject, project.class
   end
 
-  context "confidence threshold" do
-    should "return the confidence threshold" do
+  context 'confidence threshold' do
+    should 'return the confidence threshold' do
       assert_equal 90, Licensee.confidence_threshold
     end
 
-    should "let the user override the confidence threshold" do
+    should 'let the user override the confidence threshold' do
       Licensee.confidence_threshold = 50
       assert_equal 50, Licensee.confidence_threshold
       Licensee.confidence_threshold = 90

data/test/test_licensee_bin.rb

@@ -1,12 +1,18 @@
 require 'helper'
 
 class TestLicenseeBin < Minitest::Test
-  should "work via commandline" do
-    root = File.expand_path "..", File.dirname(__FILE__)
+  should 'work via commandline' do
+    root = File.expand_path '..', File.dirname(__FILE__)
     Dir.chdir root
-    stdout,stderr,status = Open3.capture3("#{root}/bin/licensee")
-    assert stdout.include?("License: MIT"), "expected #{stdout} to include `License: MIT`"
-    assert stdout.include?("License file: LICENSE.md"), "expected #{stdout} to include `Matched file: LICENSE.md`"
+    stdout, stderr, status = Open3.capture3("#{root}/bin/licensee")
+
+    msg = "expected #{stdout} to include `License: MIT`"
+    assert stdout.include?('License: MIT'), msg
+
+    msg = "expected #{stdout} to include `Matched file: LICENSE.md`"
+    assert stdout.include?('License file: LICENSE.md'), msg
+
     assert_equal 0, status
+    assert stderr.empty?
   end
 end

data/test/test_licensee_copyright_matcher.rb

@@ -2,51 +2,51 @@
 require 'helper'
 
 class TestLicenseeCopyrightMatchers < Minitest::Test
-  should "match the license" do
-    text = "Copyright 2015 Ben Balter"
+  should 'match the license' do
+    text = 'Copyright 2015 Ben Balter'
     file = Licensee::Project::LicenseFile.new(text)
-    assert_equal "no-license", Licensee::Matchers::Copyright.new(file).match.key
+    assert_equal 'no-license', Licensee::Matchers::Copyright.new(file).match.key
   end
 
-  should "know the match confidence" do
-    text = "Copyright 2015 Ben Balter"
+  should 'know the match confidence' do
+    text = 'Copyright 2015 Ben Balter'
     file = Licensee::Project::LicenseFile.new(text)
     assert_equal 100, Licensee::Matchers::Copyright.new(file).confidence
   end
 
-  should "match Copyright (C) copyright notices" do
-    text = "Copyright (C) 2015 Ben Balter"
+  should 'match Copyright (C) copyright notices' do
+    text = 'Copyright (C) 2015 Ben Balter'
     file = Licensee::Project::LicenseFile.new(text)
-    assert_equal "no-license", Licensee::Matchers::Copyright.new(file).match.key
+    assert_equal 'no-license', Licensee::Matchers::Copyright.new(file).match.key
   end
 
-  should "match Copyright © copyright notices" do
-    text = "copyright © 2015 Ben Balter"
+  should 'match Copyright © copyright notices' do
+    text = 'copyright © 2015 Ben Balter'
     file = Licensee::Project::LicenseFile.new(text)
-    assert_equal "no-license", Licensee::Matchers::Copyright.new(file).match.key
+    assert_equal 'no-license', Licensee::Matchers::Copyright.new(file).match.key
   end
 
-  should "not false positive" do
-    text = File.open(Licensee::License.find("mit").path).read.split("---").last
+  should 'not false positive' do
+    text = File.open(Licensee::License.find('mit').path).read.split('---').last
     file = Licensee::Project::LicenseFile.new(text)
     assert_equal nil, Licensee::Matchers::Copyright.new(file).match
   end
 
-  should "handle UTF-8 encoded copyright notices" do
-    text = "Copyright (c) 2010-2014 Simon Hürlimann"
+  should 'handle UTF-8 encoded copyright notices' do
+    text = 'Copyright (c) 2010-2014 Simon Hürlimann'
     file = Licensee::Project::LicenseFile.new(text)
-    assert_equal "no-license", Licensee::Matchers::Copyright.new(file).match.key
+    assert_equal 'no-license', Licensee::Matchers::Copyright.new(file).match.key
   end
 
-  should "handle ASCII-8BIT encoded copyright notices" do
-    text = "Copyright \xC2\xA92015 Ben Balter`".force_encoding("ASCII-8BIT")
+  should 'handle ASCII-8BIT encoded copyright notices' do
+    text = "Copyright \xC2\xA92015 Ben Balter`".force_encoding('ASCII-8BIT')
     file = Licensee::Project::LicenseFile.new(text)
-    assert_equal "no-license", Licensee::Matchers::Copyright.new(file).match.key
+    assert_equal 'no-license', Licensee::Matchers::Copyright.new(file).match.key
   end
 
-  should "match comma, separated dates" do
-    text = "Copyright (c) 2003, 2004 Ben Balter"
+  should 'match comma, separated dates' do
+    text = 'Copyright (c) 2003, 2004 Ben Balter'
     file = Licensee::Project::LicenseFile.new(text)
-    assert_equal "no-license", Licensee::Matchers::Copyright.new(file).match.key
+    assert_equal 'no-license', Licensee::Matchers::Copyright.new(file).match.key
   end
- end
+end

data/test/test_licensee_dice_matcher.rb

@@ -2,20 +2,20 @@ require 'helper'
 
 class TestLicenseeDiceMatchers < Minitest::Test
   def setup
-    text = license_from_path(Licensee::License.find("mit").path)
+    text = license_from_path(Licensee::License.find('mit').path)
     @mit = Licensee::Project::LicenseFile.new(text)
   end
 
-  should "match the license" do
-    assert_equal "mit", Licensee::Matchers::Dice.new(@mit).match.key
+  should 'match the license' do
+    assert_equal 'mit', Licensee::Matchers::Dice.new(@mit).match.key
   end
 
-  should "know the match confidence" do
+  should 'know the match confidence' do
     matcher = Licensee::Matchers::Dice.new(@mit)
     assert matcher.confidence > 95, "#{matcher.confidence} < 95"
   end
 
-  should "calculate max delta" do
+  should 'calculate max delta' do
     assert_equal 83.7, Licensee::Matchers::Dice.new(@mit).max_delta
   end
 end

data/test/test_licensee_exact_matcher.rb

@@ -2,15 +2,15 @@ require 'helper'
 
 class TestLicenseeExactMatchers < Minitest::Test
   def setup
-    text = File.open(Licensee::License.find("mit").path).read.split("---").last
+    text = File.open(Licensee::License.find('mit').path).read.split('---').last
     @mit = Licensee::Project::LicenseFile.new(text)
   end
 
-  should "match the license" do
-    assert_equal "mit", Licensee::Matchers::Exact.new(@mit).match.key
+  should 'match the license' do
+    assert_equal 'mit', Licensee::Matchers::Exact.new(@mit).match.key
   end
 
-  should "know the match confidence" do
+  should 'know the match confidence' do
     assert_equal 100, Licensee::Matchers::Exact.new(@mit).confidence
   end
 end

data/test/test_licensee_gemspec_matcher.rb

@@ -1,11 +1,11 @@
 require 'helper'
 
 class TestLicenseeGemspecMatchers < Minitest::Test
-  should "detect its own license" do
-    root = File.expand_path "../", File.dirname(__FILE__)
+  should 'detect its own license' do
+    root = File.expand_path '../', File.dirname(__FILE__)
     project = Licensee::GitProject.new(root, detect_packages: true)
     matcher = Licensee::Matchers::Gemspec.new(project.package_file)
-    assert_equal "mit", matcher.send(:license_property)
-    assert_equal "mit", matcher.match.key
+    assert_equal 'mit', matcher.send(:license_property)
+    assert_equal 'mit', matcher.match.key
   end
 end

data/test/test_licensee_license.rb

@@ -1,119 +1,127 @@
 require 'helper'
 
 class TestLicenseeLicense < Minitest::Test
-
   def setup
-    @license = Licensee::License.new "MIT"
+    @license = Licensee::License.new 'MIT'
   end
 
-  should "read the license body" do
+  should 'read the license body' do
     assert @license.body
-    assert @license.text =~ /MIT/, "Expected the following license body to contain MIT:\n#{@license.body}"
+    msg = "Expected the following to contain MIT:\n#{@license.body}"
+    assert @license.text =~ /MIT/, msg
   end
 
-  should "read the license body if it contains `---`" do
-    license = Licensee::License.new "MIT"
+  should 'read the license body if it contains `---`' do
+    license = Licensee::License.new 'MIT'
     content = "---\nfoo: bar\n---\nSome license\n---------\nsome text\n"
     license.instance_variable_set(:@raw_content, content)
     assert_equal "Some license\n---------\nsome text\n", license.body
   end
 
-  should "read the license meta" do
-    assert_equal "MIT License", @license.meta["title"]
+  should 'read the license meta' do
+    assert_equal 'MIT License', @license.meta['title']
   end
 
-  should "know the license path" do
-    assert_equal File.expand_path("./vendor/choosealicense.com/_licenses/mit.txt"), @license.path
+  should 'know the license path' do
+    path = File.expand_path('./vendor/choosealicense.com/_licenses/mit.txt')
+    assert_equal path, @license.path
   end
 
-  should "know the license name" do
-    assert_equal "MIT License", @license.name
+  should 'know the license name' do
+    assert_equal 'MIT License', @license.name
   end
 
-  should "know the license nickname" do
-    expected = "GNU Affero GPL v3.0"
-    assert_equal expected, Licensee::License.find("agpl-3.0").nickname
+  should 'know the license nickname' do
+    expected = 'GNU AGPLv3'
+    assert_equal expected, Licensee::License.find('agpl-3.0').nickname
   end
 
-  should "know the license ID" do
-    assert_equal "mit", @license.key
+  should 'know the license ID' do
+    assert_equal 'mit', @license.key
   end
 
-  should "know the other license" do
-    assert_equal "other", Licensee::License.find_by_key("other").key
+  should 'know the other license' do
+    assert_equal 'other', Licensee::License.find_by_key('other').key
   end
 
-  should "know license equality" do
-    assert @license == Licensee::License.new("MIT")
-    refute @license == Licensee::License.new("ISC")
-    refute @license == nil
+  should 'know license equality' do
+    assert @license == Licensee::License.new('MIT')
+    refute @license == Licensee::License.new('ISC')
+    refute @license.nil?
   end
 
-  should "know if the license is featured" do
+  should 'know if the license is featured' do
     assert @license.featured?
     assert_equal TrueClass, @license.featured?.class
-    refute Licensee::License.new("cc0-1.0").featured?
-    assert_equal FalseClass, Licensee::License.new("cc0-1.0").featured?.class
+    refute Licensee::License.new('cc0-1.0').featured?
+    assert_equal FalseClass, Licensee::License.new('cc0-1.0').featured?.class
   end
 
-  should "inject default meta without overriding" do
-    license = Licensee::License.new("cc0-1.0")
+  should 'inject default meta without overriding' do
+    license = Licensee::License.new('cc0-1.0')
 
-    assert license.meta.has_key? "featured"
-    assert_equal false, license.meta["featured"]
+    assert license.meta.key? 'featured'
+    assert_equal false, license.meta['featured']
 
-    assert license.meta.has_key? "hidden"
-    assert_equal false, license.meta["hidden"]
+    assert license.meta.key? 'hidden'
+    assert_equal false, license.meta['hidden']
 
-    assert license.meta.has_key? "variant"
-    assert_equal true, license.meta["variant"]
+    assert license.meta.key? 'variant'
+    assert_equal true, license.meta['variant']
   end
 
-  should "know when the license is hidden" do
+  should 'know when the license is hidden' do
     refute @license.hidden?
-    assert Licensee::License.new("ofl-1.1").hidden?
-    assert Licensee::License.new("no-license").hidden?
+    assert Licensee::License.new('ofl-1.1').hidden?
+    assert Licensee::License.new('no-license').hidden?
   end
 
-  should "parse the license parts" do
+  should 'parse the license parts' do
     assert_equal 3, @license.send(:parts).size
   end
 
-  should "build the license URL" do
-    assert_equal "http://choosealicense.com/licenses/mit/", @license.url
+  should 'build the license URL' do
+    assert_equal 'http://choosealicense.com/licenses/mit/', @license.url
   end
 
-  should "return all licenses" do
+  should 'return all licenses' do
     assert_equal Array, Licensee::License.all.class
     assert Licensee::License.all.size > 3
   end
 
-  should "strip leading newlines from the license" do
-    assert_equal "T", @license.body[0]
+  should 'strip leading newlines from the license' do
+    assert_equal 'T', @license.body[0]
   end
 
-  should "fail loudly for invalid licenses" do
-    assert_raises(Licensee::InvalidLicense) { Licensee::License.new("foo").name }
+  should 'fail loudly for invalid licenses' do
+    assert_raises(Licensee::InvalidLicense) do
+      Licensee::License.new('foo').name
+    end
   end
 
   should "support 'other' licenses" do
-    license = Licensee::License.new("other")
+    license = Licensee::License.new('other')
     assert_equal nil, license.content
-    assert_equal "Other", license.name
+    assert_equal 'Other', license.name
     refute license.featured?
   end
 
-  should "know the license hash" do
-    assert_equal "fb278496ea4663dfcf41ed672eb7e56eb70de798", @license.hash
+  should 'know the license hash' do
+    assert_equal 'fb278496ea4663dfcf41ed672eb7e56eb70de798', @license.hash
   end
 
-  describe "name without version" do
-    should "strip the version from the license name" do
-      expected = "GNU Affero General Public License"
-      assert_equal expected, Licensee::License.find("agpl-3.0").name_without_version
-      expected = "GNU General Public License"
-      assert_equal expected,  Licensee::License.find("gpl-2.0").name_without_version
-      assert_equal expected,  Licensee::License.find("gpl-3.0").name_without_version
+  describe 'name without version' do
+    should 'strip the version from the license name' do
+      expected = 'GNU Affero General Public License'
+      name = Licensee::License.find('agpl-3.0').name_without_version
+      assert_equal expected, name
+
+      expected = 'GNU General Public License'
+      name = Licensee::License.find('gpl-2.0').name_without_version
+      assert_equal expected, name
+
+      name = Licensee::License.find('gpl-3.0').name_without_version
+      assert_equal expected, name
     end
 
     Licensee.licenses.each do |license|
@@ -123,30 +131,34 @@ class TestLicenseeLicense < Minitest::Test
     end
   end
 
-  describe "class methods" do
-    should "know license names" do
+  describe 'class methods' do
+    should 'know license names' do
       assert_equal Array, Licensee::License.keys.class
-      assert_equal 24, Licensee::License.keys.size
+      assert_equal 26, Licensee::License.keys.size
     end
 
-    should "load the licenses" do
+    should 'load the licenses' do
       assert_equal Array, Licensee::License.all.class
       assert_equal 15, Licensee::License.all.size
       assert_equal Licensee::License, Licensee::License.all.first.class
     end
 
-    should "find a license" do
-      assert_equal "mit", Licensee::License.find("mit").key
-      assert_equal "mit", Licensee::License.find("MIT").key
-      assert_equal "mit", Licensee::License["mit"].key
+    should 'find a license' do
+      assert_equal 'mit', Licensee::License.find('mit').key
+      assert_equal 'mit', Licensee::License.find('MIT').key
+      assert_equal 'mit', Licensee::License['mit'].key
     end
 
-    should "filter the licenses" do
-      assert_equal 24, Licensee::License.all(:hidden => true).size
-      assert_equal 3,  Licensee::License.all(:featured => true).size
-      assert_equal 12, Licensee::License.all(:featured => false).size
-      assert_equal 21, Licensee::License.all(:featured => false, :hidden => true).size
-      assert_equal 12, Licensee::License.all(:featured => false, :hidden => false).size
+    should 'filter the licenses' do
+      assert_equal 26, Licensee::License.all(hidden: true).size
+      assert_equal 3,  Licensee::License.all(featured: true).size
+      assert_equal 12, Licensee::License.all(featured: false).size
+
+      licenses = Licensee::License.all(featured: false, hidden: true)
+      assert_equal 23, licenses.size
+
+      licenses = Licensee::License.all(featured: false, hidden: false)
+      assert_equal 12, licenses.size
     end
   end
 end

data/test/test_licensee_license_file.rb

@@ -2,54 +2,56 @@ require 'helper'
 
 class TestLicenseeLicenseFile < Minitest::Test
   def setup
-    @repo = Rugged::Repository.new(fixture_path("licenses.git"))
-    blob, _ = Rugged::Blob.to_buffer(@repo, 'bcb552d06d9cf1cd4c048a6d3bf716849c2216cc')
+    @repo = Rugged::Repository.new(fixture_path('licenses.git'))
+    ref   = 'bcb552d06d9cf1cd4c048a6d3bf716849c2216cc'
+    blob, = Rugged::Blob.to_buffer(@repo, ref)
     @file = Licensee::Project::LicenseFile.new(blob)
   end
 
-  context "content" do
-    should "parse the attribution" do
-      assert_equal "Copyright (c) 2014 Ben Balter", @file.attribution
+  context 'content' do
+    should 'parse the attribution' do
+      assert_equal 'Copyright (c) 2014 Ben Balter', @file.attribution
     end
 
-    should "not choke on non-UTF-8 licenses" do
+    should 'not choke on non-UTF-8 licenses' do
       text = "\x91License\x93".force_encoding('windows-1251')
       file = Licensee::Project::LicenseFile.new(text)
       assert_equal nil, file.attribution
     end
 
-    should "create the wordset" do
+    should 'create the wordset' do
       assert_equal 93, @file.wordset.count
-      assert_equal "the", @file.wordset.first
+      assert_equal 'the', @file.wordset.first
     end
 
-    should "create the hash" do
-      assert_equal "fb278496ea4663dfcf41ed672eb7e56eb70de798", @file.hash
+    should 'create the hash' do
+      assert_equal 'fb278496ea4663dfcf41ed672eb7e56eb70de798', @file.hash
     end
   end
 
-  context "license filename scoring" do
+  context 'license filename scoring' do
     EXPECTATIONS = {
-      "license"            => 1.0,
-      "LICENCE"            => 1.0,
-      "unLICENSE"          => 1.0,
-      "unlicence"          => 1.0,
-      "license.md"         => 0.9,
-      "LICENSE.md"         => 0.9,
-      "license.txt"        => 0.9,
-      "COPYING"            => 0.8,
-      "copyRIGHT"          => 0.8,
-      "COPYRIGHT.txt"      => 0.8,
-      "LICENSE.php"        => 0.7,
-      "LICENSE-MIT"        => 0.5,
-      "MIT-LICENSE.txt"    => 0.5,
-      "mit-license-foo.md" => 0.5,
-      "README.txt"         => 0.0
-    }
+      'license'            => 1.0,
+      'LICENCE'            => 1.0,
+      'unLICENSE'          => 1.0,
+      'unlicence'          => 1.0,
+      'license.md'         => 0.9,
+      'LICENSE.md'         => 0.9,
+      'license.txt'        => 0.9,
+      'COPYING'            => 0.8,
+      'copyRIGHT'          => 0.8,
+      'COPYRIGHT.txt'      => 0.8,
+      'LICENSE.php'        => 0.7,
+      'LICENSE-MIT'        => 0.5,
+      'MIT-LICENSE.txt'    => 0.5,
+      'mit-license-foo.md' => 0.5,
+      'README.txt'         => 0.0
+    }.freeze
 
     EXPECTATIONS.each do |filename, expected|
       should "score a license named `#{filename}` as `#{expected}`" do
-        assert_equal expected, Licensee::Project::LicenseFile.name_score(filename)
+        score = Licensee::Project::LicenseFile.name_score(filename)
+        assert_equal expected, score
       end
     end
   end