licensee 8.5.0 → 8.6.0

data/test/licensee/matchers/test_copyright_matcher.rb

@@ -1,59 +0,0 @@
-# encoding=utf-8
-require 'helper'
-
-class TestLicenseeCopyrightMatchers < Minitest::Test
-  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
-  end
-
-  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'
-    file = Licensee::Project::LicenseFile.new(text)
-    assert_equal 'no-license', Licensee::Matchers::Copyright.new(file).match.key
-  end
-
-  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
-  end
-
-  should 'match (c) copyright notices' do
-    text = '(C) 2015 Ben Balter'
-    file = Licensee::Project::LicenseFile.new(text)
-    assert_equal 'no-license', Licensee::Matchers::Copyright.new(file).match.key
-  end
-
-  should 'not false positive' do
-    path = Licensee::License.find('mit').path
-    text = File.read(path, encoding: 'utf-8').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'
-    file = Licensee::Project::LicenseFile.new(text)
-    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')
-    file = Licensee::Project::LicenseFile.new(text)
-    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'
-    file = Licensee::Project::LicenseFile.new(text)
-    assert_equal 'no-license', Licensee::Matchers::Copyright.new(file).match.key
-  end
-end

data/test/licensee/matchers/test_dice_matcher.rb

@@ -1,60 +0,0 @@
-require 'helper'
-
-class TestLicenseeDiceMatchers < Minitest::Test
-  def setup
-    text = license_from_path(Licensee::License.find('mit').path)
-    @mit = Licensee::Project::LicenseFile.new(text)
-
-    text = license_from_path(Licensee::License.find('gpl-2.0').path)
-    @gpl = Licensee::Project::LicenseFile.new(text)
-  end
-
-  def concat_licenses(*args)
-    args.map do |license|
-      license_from_path(Licensee::License.find(license).path)
-    end.join("\n")
-  end
-
-  should 'match the license' do
-    assert_equal 'mit', Licensee::Matchers::Dice.new(@mit).match.key
-  end
-
-  should 'know the match confidence' do
-    matcher = Licensee::Matchers::Dice.new(@mit)
-    assert matcher.confidence > 95, "#{matcher.confidence} < 95"
-  end
-
-  should 'know when two licenses have be concatenated' do
-    text = concat_licenses('mit', 'gpl-2.0')
-    license = Licensee::Project::LicenseFile.new(text)
-    matcher = Licensee::Matchers::Dice.new(license)
-    if matcher.match
-      msg = "Expected no-license, got #{matcher.match.key}"
-      msg << " (#{matcher.match.similarity(license).round(2)}% similar)"
-    end
-    refute matcher.match, msg
-  end
-
-  should 'build the list of licenses by similarity' do
-    matcher = Licensee::Matchers::Dice.new(@gpl)
-
-    match = matcher.licenses_by_similiarity.first
-    assert_equal Licensee::License, match[0].class
-    assert_equal 'gpl-2.0', match[0].key
-    assert_equal 100.0, match[1]
-
-    match = matcher.licenses_by_similiarity[1]
-    assert_equal 'lppl-1.3c', match[0].key
-    assert_equal 49.52, match[1].round(2)
-  end
-
-  should 'build the list of matches' do
-    matcher = Licensee::Matchers::Dice.new(@gpl)
-
-    assert_equal 1, matcher.matches.count
-    match = matcher.matches.first
-    assert_equal Licensee::License, match[0].class
-    assert_equal 'gpl-2.0', match[0].key
-    assert_equal 100.0, match[1]
-  end
-end

data/test/licensee/matchers/test_exact_matcher.rb

@@ -1,25 +0,0 @@
-require 'helper'
-
-class TestLicenseeExactMatchers < Minitest::Test
-  def setup
-    path = Licensee::License.find('mit').path
-    text = File.read(path, encoding: 'utf-8').split('---').last
-    @mit = Licensee::Project::LicenseFile.new(text)
-  end
-
-  should 'match the license' do
-    assert_equal 'mit', Licensee::Matchers::Exact.new(@mit).match.key
-  end
-
-  should 'know the match confidence' do
-    assert_equal 100, Licensee::Matchers::Exact.new(@mit).confidence
-  end
-
-  should 'require the file to be the same length' do
-    path = Licensee::License.find('mit').path
-    text = File.read(path, encoding: 'utf-8').split('---').last
-    text << ' MIT'
-    license = Licensee::Project::LicenseFile.new(text)
-    refute Licensee::Matchers::Exact.new(license).match
-  end
-end

data/test/licensee/matchers/test_gemspec_matcher.rb

@@ -1,11 +0,0 @@
-require 'helper'
-
-class TestLicenseeGemspecMatchers < Minitest::Test
-  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
-  end
-end

data/test/licensee/matchers/test_npm_bower_matcher.rb

@@ -1,27 +0,0 @@
-require 'helper'
-
-class TestLicenseeNpmBowerMatchers < Minitest::Test
-  should 'detect NPM files' do
-    pkg = File.read fixture_path('npm/package.json')
-    pkgfile = Licensee::Project::PackageInfo.new(pkg)
-    matcher = Licensee::Matchers::NpmBower.new(pkgfile)
-    assert_equal 'mit', matcher.send(:license_property)
-    assert_equal 'mit', matcher.match.key
-  end
-
-  should 'detect Bower files' do
-    pkg = File.read fixture_path('bower/bower.json')
-    pkgfile = Licensee::Project::PackageInfo.new(pkg)
-    matcher = Licensee::Matchers::NpmBower.new(pkgfile)
-    assert_equal 'mit', matcher.send(:license_property)
-    assert_equal 'mit', matcher.match.key
-  end
-
-  should 'not err on non-spdx licenses' do
-    pkg = File.read fixture_path('npm-non-spdx/package.json')
-    pkgfile = Licensee::Project::PackageInfo.new(pkg)
-    matcher = Licensee::Matchers::NpmBower.new(pkgfile)
-    assert_equal 'mit-1.0', matcher.send(:license_property)
-    assert_equal nil, matcher.match
-  end
-end

data/test/licensee/matchers/test_package_matcher.rb

@@ -1,27 +0,0 @@
-require 'helper'
-
-class PackageMatcherTestHelper < Licensee::Matchers::Package
-  attr_accessor :license_property, :file
-end
-
-class TestLicenseePackageMatcher < Minitest::Test
-  def setup
-    pkg = File.read fixture_path('npm/package.json')
-    @file = Licensee::Project::PackageInfo.new(pkg)
-    @matcher = PackageMatcherTestHelper.new(@file)
-    @matcher.license_property = 'mit'
-  end
-
-  should 'store the file' do
-    assert_equal @matcher.file, @file
-  end
-
-  should 'match' do
-    assert @matcher.match
-    assert_equal 'mit', @matcher.match.key
-  end
-
-  should 'return the confidence' do
-    assert_equal 90, @matcher.confidence
-  end
-end

data/test/licensee/project_files/test_license_file.rb

@@ -1,73 +0,0 @@
-require 'helper'
-
-class TestLicenseeLicenseFile < Minitest::Test
-  def setup
-    @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
-    end
-
-    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
-      assert_equal 93, @file.wordset.count
-      assert_equal 'the', @file.wordset.first
-    end
-
-    should 'create the hash' do
-      assert_equal 'fb278496ea4663dfcf41ed672eb7e56eb70de798', @file.hash
-    end
-  end
-
-  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
-    }.freeze
-
-    EXPECTATIONS.each do |filename, expected|
-      should "score a license named `#{filename}` as `#{expected}`" do
-        score = Licensee::Project::LicenseFile.name_score(filename)
-        assert_equal expected, score
-      end
-    end
-  end
-
-  context 'LGPL scoring' do
-    {
-      'COPYING.lesser' => 1,
-      'copying.lesser' => 1,
-      'license.lesser' => 0,
-      'LICENSE.md'     => 0,
-      'FOO.md'         => 0
-    }.each do |filename, expected|
-      should "score a license named `#{filename}` as `#{expected}`" do
-        score = Licensee::Project::LicenseFile.lesser_gpl_score(filename)
-        assert_equal expected, score
-      end
-    end
-  end
-end

data/test/licensee/project_files/test_package_info.rb

@@ -1,19 +0,0 @@
-require 'helper'
-
-class TestLicenseePackageInfo < Minitest::Test
-  context 'license filename scoring' do
-    EXPECTATIONS = {
-      'licensee.gemspec' => 1.0,
-      'package.json'     => 1.0,
-      'bower.json'       => 0.75,
-      'README.md'        => 0.0
-    }.freeze
-
-    EXPECTATIONS.each do |filename, expected|
-      should "score a license named `#{filename}` as `#{expected}`" do
-        score = Licensee::Project::PackageInfo.name_score(filename)
-        assert_equal expected, score
-      end
-    end
-  end
-end

data/test/licensee/project_files/test_readme.rb

@@ -1,47 +0,0 @@
-require 'helper'
-
-class TestLicenseeReadme < Minitest::Test
-  context 'readme filename scoring' do
-    EXPECTATIONS = {
-      'readme'     => 1.0,
-      'README'     => 1.0,
-      'readme.md'  => 0.9,
-      'README.md'  => 0.9,
-      'readme.txt' => 0.9,
-      'LICENSE'    => 0.0
-    }.freeze
-
-    EXPECTATIONS.each do |filename, expected|
-      should "score a readme named `#{filename}` as `#{expected}`" do
-        assert_equal expected, Licensee::Project::Readme.name_score(filename)
-      end
-    end
-  end
-
-  context 'readme content' do
-    should 'be blank if not license text' do
-      assert_license_content nil, 'There is no License in this README'
-    end
-
-    should 'get content after h1' do
-      assert_license_content 'hello world', "# License\n\nhello world"
-    end
-
-    should 'get content after h2' do
-      assert_license_content 'hello world', "## License\n\nhello world"
-    end
-
-    should 'be case-insensitive' do
-      assert_license_content 'hello world', "## LICENSE\n\nhello world"
-    end
-
-    should 'be british' do
-      assert_license_content 'hello world', "## Licence\n\nhello world"
-    end
-
-    should 'not include trailing content' do
-      readme = "## License\n\nhello world\n\n# Contributing"
-      assert_license_content 'hello world', readme
-    end
-  end
-end

data/test/licensee/test_content_helper.rb

@@ -1,81 +0,0 @@
-require 'helper'
-
-class ContentHelperTestHelper
-  include Licensee::ContentHelper
-  attr_accessor :content
-
-  DEFAULT_CONTENT = <<-EOS.freeze
-Copyright 2016 Ben Balter
-
-The made
-up  license.
------------
-  EOS
-
-  def initialize(content = nil)
-    @content = content || DEFAULT_CONTENT
-  end
-end
-
-class TestLicenseeContentHelper < Minitest::Test
-  def setup
-    @helper = ContentHelperTestHelper.new
-  end
-
-  context 'normalizing' do
-    should 'strips copyright' do
-      refute_match('Copyright', @helper.content_normalized)
-      refute_match('Ben Balter', @helper.content_normalized)
-    end
-
-    should 'downcases' do
-      refute_match('The', @helper.content_normalized)
-      assert_match('the', @helper.content_normalized)
-    end
-
-    should 'strips HRs' do
-      refute_match('---', @helper.content_normalized)
-    end
-
-    should 'squeeze whitespace' do
-      refute_match('  ', @helper.content_normalized)
-    end
-
-    should 'strips whitespace' do
-      refute_match(/\n/i, @helper.content_normalized)
-    end
-
-    should 'normalize the content' do
-      assert_equal 'the made up license.', @helper.content_normalized
-    end
-  end
-
-  should 'generate the hash' do
-    assert_equal '3c59634b9fae4396a76a978f3f6aa718ed790a9a', @helper.hash
-  end
-
-  should 'calculate the length' do
-    assert_equal 20, @helper.length
-  end
-
-  should 'know the max delta' do
-    assert_equal 1, @helper.max_delta
-  end
-
-  should 'build the wordset' do
-    assert_equal %w(the made up license).to_set, @helper.wordset
-  end
-
-  should 'calculate the length delta' do
-    other = ContentHelperTestHelper.new 'asdf'
-    assert_equal 16, @helper.length_delta(other)
-  end
-
-  should 'calculate the similarity' do
-    other = ContentHelperTestHelper.new 'asdf'
-    assert_equal 0, @helper.similarity(other)
-
-    other = ContentHelperTestHelper.new 'Not really the made up license'
-    assert_equal 80.0, @helper.similarity(other)
-  end
-end

data/test/licensee/test_license.rb

@@ -1,182 +0,0 @@
-require 'helper'
-
-class TestLicenseeLicense < Minitest::Test
-  def setup
-    @license = Licensee::License.new 'MIT'
-  end
-
-  should 'read the license body' do
-    assert @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'
-    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']
-  end
-
-  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
-  end
-
-  should 'know the license properties' do
-    assert_equal 4, @license.meta['permissions'].length
-    assert_equal 1, @license.meta['conditions'].length
-    assert_equal 1, @license.meta['limitations'].length
-  end
-
-  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
-  end
-
-  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?
-  end
-
-  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
-  end
-
-  should 'inject default meta without overriding' do
-    license = Licensee::License.new('agpl-3.0')
-
-    assert license.meta.key? 'featured'
-    assert_equal false, license.meta['featured']
-
-    assert license.meta.key? 'hidden'
-    assert_equal false, license.meta['hidden']
-  end
-
-  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?
-  end
-
-  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
-  end
-
-  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 'M', @license.body[0]
-  end
-
-  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')
-    assert_equal nil, license.content
-    assert_equal 'Other', license.name
-    assert license.hidden?
-    refute license.featured?
-    Licensee::License::YAML_DEFAULTS.each do |key, value|
-      assert_equal value, license.meta[key]
-    end
-  end
-
-  should 'know the license hash' do
-    assert_equal '750260c322080bab4c19fd55eb78bc73e1ae8f11', @license.hash
-  end
-
-  should "recognize GPL'd licenses" do
-    license = Licensee::License.new 'gpl-2.0'
-    assert license.gpl?
-
-    license = Licensee::License.new 'gpl-3.0'
-    assert license.gpl?
-
-    license = Licensee::License.new 'mit'
-    refute license.gpl?
-  end
-
-  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|
-      should "strip the version number from the #{license.name} license" do
-        assert license.name_without_version
-      end
-    end
-  end
-
-  describe 'class methods' do
-    should 'know license names' do
-      assert_equal Array, Licensee::License.keys.class
-      assert_equal 29, Licensee::License.keys.size
-    end
-
-    should 'load the licenses' do
-      assert_equal Array, Licensee::License.all.class
-      assert_equal 7, 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
-    end
-
-    should 'filter the licenses' do
-      assert_equal 29, Licensee::License.all(hidden: true).size
-      assert_equal 3,  Licensee::License.all(featured: true).size
-      assert_equal 4,  Licensee::License.all(featured: false).size
-
-      licenses = Licensee::License.all(featured: false, hidden: true)
-      assert_equal 26, licenses.size
-
-      licenses = Licensee::License.all(featured: false, hidden: false)
-      assert_equal 4, licenses.size
-    end
-  end
-end