licensee 4.9.0 → 5.0.0b1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e32073ffb1db6eed03c14cee02c4d72096fc70c8
-  data.tar.gz: f658b84856962074cebd0a310510510b7aa34dac
+  metadata.gz: 49baf7865bddf84e8237149cba6f21768e661c39
+  data.tar.gz: 95dbc39d96bed4d0952df9e85eb56ae37f387c1f
 SHA512:
-  metadata.gz: 36b583c9dfc992f30e54425046d79f23b4522b31e470b54d61e1d08e20b146be096fdf8a684e0b45780ff487108a9bf5850452ba002883a1e8d357d316ef87c3
-  data.tar.gz: 682553fa645a933c8bf3c2db07a29a59ff5269564aef2c58604bf17351212508e8f74f9e51388d71894f4e844c6bf52bc21dca1c6385f598695e67d4fb9cdb39
+  metadata.gz: 60a4c027e6d388d732ad3588606c380d90595be0955f55e9415a727370c78c8faff40c781843bc04989fb3a591821f91579079f54c2197f02778e9cac6cb73a3
+  data.tar.gz: 510467b863f02cdb658986dd5626460d0383c5602d22c3f170094d7d38bf80e56727691a4c8fc30dc7b4c79003a610383a90dfa4864fc87b1f3a4f83eb404012

data/bin/licensee

@@ -3,11 +3,12 @@ require_relative "../lib/licensee"
 
 path = ARGV[0] || Dir.pwd
 
+Licensee.package_manager_files = true
 project = Licensee::Project.new(path)
-license = project.license_file
+license = project.matched_file
 
 if license
-  puts "License file: #{license.path}"
+  puts "Matched file: #{license.path}"
   puts "License: #{license.match ? license.match.meta['title'] : 'no license'}"
   puts "Confidence: #{license.confidence}%"
   puts "Method: #{license.matcher.class}"

data/lib/licensee.rb

@@ -5,15 +5,17 @@ require 'levenshtein'
 
 require_relative "licensee/version"
 require_relative "licensee/license"
-require_relative "licensee/licenses"
-require_relative "licensee/license_file"
 require_relative "licensee/project"
+require_relative "licensee/project_file"
 require_relative "licensee/filesystem_repository"
 require_relative "licensee/matcher"
 require_relative "licensee/matchers/exact_matcher"
 require_relative "licensee/matchers/copyright_matcher"
 require_relative "licensee/matchers/git_matcher"
 require_relative "licensee/matchers/levenshtein_matcher"
+require_relative "licensee/matchers/package_matcher"
+require_relative "licensee/matchers/gemspec_matcher"
+require_relative "licensee/matchers/npm_bower_matcher"
 
 class Licensee
 
@@ -25,11 +27,11 @@ class Licensee
 
   class << self
 
-    attr_writer :confidence_threshold
+    attr_writer :confidence_threshold, :package_manager_files
 
     # Returns an array of Licensee::License instances
     def licenses
-      @licenses ||= Licensee::Licenses.list
+      @licenses ||= Licensee::License.all
     end
 
     # Returns the license for a given git repo
@@ -45,11 +47,24 @@ class Licensee
     # Array of matchers to use, in order of preference
     # The order should be decending order of anticipated speed to match
     def matchers
-      [Licensee::CopyrightMatcher, Licensee::ExactMatcher, Licensee::GitMatcher, Licensee::LevenshteinMatcher]
+      matchers = [
+        Licensee::CopyrightMatcher,
+        Licensee::ExactMatcher,
+        Licensee::GitMatcher,
+        Licensee::LevenshteinMatcher,
+        Licensee::GemspecMatcher,
+        Licensee::NpmBowerMatcher
+      ]
+      matchers.reject! { |m| m.package_manager? } unless package_manager_files?
+      matchers
     end
 
     def confidence_threshold
       @confidence_threshold ||= CONFIDENCE_THRESHOLD
     end
+
+    def package_manager_files?
+      @package_manager_files ||= false
+    end
   end
 end

data/lib/licensee/license.rb

@@ -2,16 +2,36 @@ class Licensee
   class InvalidLicense < ArgumentError; end
   class License
 
-    def self.all
-      Licensee::licenses
+    class << self
+      def all
+        @all ||= keys.map { |key| self.new(key) }
+      end
+
+      def keys
+        @keys ||= license_files.map { |l| File.basename(l, ".txt").downcase }
+      end
+
+      def find(key)
+        key = key.downcase
+        all.find { |l| l.key == key }
+      end
+      alias_method :[], :find
+
+      def license_dir
+        File.expand_path "../../vendor/choosealicense.com/_licenses", File.dirname(__FILE__)
+      end
+
+      def license_files
+        @license_files ||= Dir.glob("#{license_dir}/*.txt")
+      end
     end
 
     attr_reader :key
 
     YAML_DEFAULTS = {
       "featured" => false,
-      "hidden" => false,
-      "variant" => false
+      "hidden"   => false,
+      "variant"  => false
     }
 
     HIDDEN_LICENSES = %w[other no-license]
@@ -22,7 +42,7 @@ class Licensee
 
     # Path to vendored license file on disk
     def path
-      @path ||= File.expand_path "#{@key}.txt", Licensee::Licenses.base
+      @path ||= File.expand_path "#{@key}.txt", Licensee::License.license_dir
     end
 
     # Raw content of license file, including YAML front matter

data/lib/licensee/matcher.rb

@@ -12,6 +12,10 @@ class Licensee
       self.new(file).match
     end
 
+    def self.package_manager?
+      false
+    end
+
     def initialize(file)
       @file = file
     end

data/lib/licensee/matchers/copyright_matcher.rb

@@ -17,7 +17,7 @@ class Licensee
     private
 
     def no_license
-      @no_license ||= Licensee::Licenses.find("no-license")
+      @no_license ||= Licensee::License.find("no-license")
     end
   end
 end

data/lib/licensee/matchers/gemspec_matcher.rb

@@ -0,0 +1,16 @@
+class Licensee
+  class GemspecMatcher < PackageMatcher
+
+    # We definitely don't want to be evaling arbitrary Gemspec files
+    # While not 100% accurate, use some lenient regex to try to grep the
+    # license declaration from the Gemspec as a string, if any
+    LICENSE_REGEX = /^\s*[a-z0-9_]+\.license\s*\=\s*[\'\"]([a-z\-0-9\.]+)[\'\"]\s*$/i
+
+    private
+
+    def license_property
+      match = file.content.match LICENSE_REGEX
+      match[1].downcase if match && match[1]
+    end
+  end
+end

data/lib/licensee/matchers/npm_bower_matcher.rb

@@ -0,0 +1,15 @@
+class Licensee
+  class NpmBowerMatcher < PackageMatcher
+
+    # While we could parse the package.json or bower.json file, prefer
+    # a lenient regex for speed and security. Moar parsing moar problems.
+    LICENSE_REGEX = /\s*[\"\']license[\"\']\s*\:\s*[\'\"]([a-z\-0-9\.]+)[\'\"],?\s*/i
+
+    private
+
+    def license_property
+      match = file.content.match LICENSE_REGEX
+      match[1].downcase if match && match[1]
+    end
+  end
+end

data/lib/licensee/matchers/package_matcher.rb

@@ -0,0 +1,16 @@
+class Licensee
+  class PackageMatcher < Matcher
+
+    def match
+      Licensee.licenses.find { |l| l.key == license_property } if file.package?
+    end
+
+    def confidence
+      90
+    end
+
+    def self.package_manager?
+      true
+    end
+  end
+end

data/lib/licensee/project.rb

@@ -1,6 +1,6 @@
 class Licensee
   class Project
-    attr_reader :repository
+    attr_reader :repository, :revision
 
     # Initializes a new project
     #
@@ -13,66 +13,44 @@ class Licensee
         begin
           @repository = Rugged::Repository.new(path_or_repo)
         rescue Rugged::RepositoryError
-          if revision
-            raise
-          else
-            @repository = FilesystemRepository.new(path_or_repo)
-          end
+          raise if revision
+          @repository = FilesystemRepository.new(path_or_repo)
         end
       end
 
       @revision = revision
     end
 
-    # Returns an instance of Licensee::LicenseFile if there's a license file detected
+    # Returns the matching Licensee::License instance if a license can be detected
+    def license
+      @license ||= matched_file.match if matched_file
+    end
+
     def license_file
-      @license_file ||= LicenseFile.new(license_blob, :path => license_path) if license_blob
+      @license_file ||= files.select { |f| f.license? }.sort_by { |f| f.license_score }.last
     end
 
-    # Returns the matching Licensee::License instance if a license can be detected
-    def license
-      @license ||= license_file.match if license_file
+    def package_file
+      return unless Licensee.package_manager_files?
+      @package_file ||= files.select { |f| f.package? }.sort_by { |f| f.package_score }.last
     end
 
-    # Scores a given file as a potential license
-    #
-    # filename - (string) the name of the file to score
-    #
-    # Returns 1.0  if the file is definitely a license file
-    # Returns 0.75 if the file is probably a license file
-    # Returns 0.5  if the file is likely a license file
-    # Returns 0.0  if the file is definitely not a license file
-    def self.match_license_file(filename)
-      return 1.0  if filename =~ /\A(un)?licen[sc]e(\.[^.]+)?\z/i
-      return 0.75 if filename =~ /\Acopy(ing|right)(\.[^.]+)?\z/i
-      return 0.5  if filename =~ /licen[sc]e/i
-      return 0.0
+    def matched_file
+      license_file || package_file
     end
 
     private
 
     def commit
-      @revision ? @repository.lookup(@revision) : @repository.last_commit
+      @commit ||= revision ? repository.lookup(revision) : repository.last_commit
     end
 
     def tree
-      commit.tree.select { |blob| blob[:type] == :blob }
-    end
-
-    # Detects the license file, if any
-    # Returns the blob hash as detected in the tree
-    def license_hash
-      hashes = tree.map { |blob| [self.class.match_license_file(blob[:name]), blob] }
-      hash = hashes.select { |hash| hash[0] > 0 }.sort_by { |hash| hash[0] }.last
-      hash[1] if hash
-    end
-
-    def license_blob
-      @repository.lookup(license_hash[:oid]) if license_hash
+      @tree ||= commit.tree.select { |blob| blob[:type] == :blob }
     end
 
-    def license_path
-      license_hash[:name] if license_hash
+    def files
+      @files ||= tree.map { |blob| ProjectFile.new(repository.lookup(blob[:oid]), blob[:name]) }
     end
   end
 end

data/lib/licensee/project_file.rb

@@ -0,0 +1,91 @@
+class Licensee
+  class ProjectFile
+
+    # Note: File can be a license file (e.g., `LICENSE.txt`)
+    # or a package manager file (e.g, `package.json`)
+
+    attr_reader :blob, :path
+    alias_method :filename, :path
+
+    def initialize(blob, path)
+      @blob = blob
+      @path = path
+    end
+
+    # Raw file contents
+    def content
+      @contents ||= blob.content.force_encoding("UTF-8")
+    end
+    alias_method :to_s, :content
+    alias_method :contents, :content
+
+    # File content with all whitespace replaced with a single space
+    def content_normalized
+      @content_normalized ||= content.downcase.gsub(/\s+/, " ").strip
+    end
+
+    # Determines which matching strategy to use, returns an instane of that matcher
+    def matcher
+      @matcher ||= Licensee.matchers.map { |m| m.new(self) }.find { |m| m.match }
+    end
+
+    # Returns an Licensee::License instance of the matches license
+    def match
+      @match ||= matcher.match if matcher
+    end
+
+    # Returns the percent confident with the match
+    def confidence
+      @condience ||= matcher.confidence if matcher
+    end
+
+    def similarity(other)
+      blob.hashsig(Rugged::Blob::HashSignature::WHITESPACE_SMART)
+      other.hashsig ? blob.similarity(other.hashsig) : 0
+    rescue Rugged::InvalidError
+      0
+    end
+
+    # Comptutes a diff between known license and project license
+    def diff(options={})
+      options = options.merge(:reverse => true)
+      blob.diff(match.body, options).to_s if match
+    end
+
+    def license_score
+      self.class.license_score(filename)
+    end
+
+    def license?
+      license_score != 0.0
+    end
+
+    def package_score
+      return 1.0  if filename =~ /[a-zA-Z0-9\-_]+\.gemspec/
+      return 1.0  if filename =~ /package\.json/
+      return 0.75 if filename =~ /bower.json/
+      return 0.0
+    end
+
+    def package?
+      Licensee.package_manager_files? && package_score != 0.0
+    end
+
+    class << self
+      # Scores a given file as a potential license
+      #
+      # filename - (string) the name of the file to score
+      #
+      # Returns 1.0  if the file is definitely a license file
+      # Returns 0.75 if the file is probably a license file
+      # Returns 0.5  if the file is likely a license file
+      # Returns 0.0  if the file is definitely not a license file
+      def license_score(filename)
+        return 1.0  if filename =~ /\A(un)?licen[sc]e(\.[^.]+)?\z/i
+        return 0.75 if filename =~ /\Acopy(ing|right)(\.[^.]+)?\z/i
+        return 0.5  if filename =~ /licen[sc]e/i
+        return 0.0
+      end
+    end
+  end
+end

data/lib/licensee/version.rb

@@ -1,3 +1,3 @@
 class Licensee
-  VERSION = "4.9.0"
+  VERSION = "5.0.0b1"
 end

data/test/fixtures/bower/bower.json

@@ -0,0 +1,3 @@
+{
+  "license": "mit"
+}

data/test/fixtures/npm-non-spdx/package.json

@@ -0,0 +1,3 @@
+{
+  "license": "mit-1.0"
+}

data/test/fixtures/npm/package.json

@@ -0,0 +1,3 @@
+{
+  "license": "mit"
+}

data/test/functions.rb

@@ -1,7 +1,7 @@
 # Pulled from helper.rb because something in the test suite monkey patches benchmarking
 
 require 'securerandom'
-require 'licensee/filesystem_repository'
+require_relative '../lib/licensee'
 
 def fixtures_base
   File.expand_path "fixtures", File.dirname( __FILE__ )
@@ -36,7 +36,7 @@ def verify_license_file(license, chaos = false, wrap=false)
   text = wrap(text, wrap) if wrap
 
   blob = FakeBlob.new(text)
-  license_file = Licensee::LicenseFile.new(blob)
+  license_file = Licensee::ProjectFile.new(blob, "LICENSE")
 
   actual = license_file.match
   assert actual, "No match for #{expected}. Here's the test text:\n#{text}"

data/test/helper.rb

@@ -4,7 +4,4 @@ require 'minitest/autorun'
 require 'shoulda'
 require 'open3'
 require_relative 'functions'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'licensee'
+require_relative '../lib/licensee'

data/test/test_licensee.rb

@@ -15,13 +15,27 @@ class TestLicensee < Minitest::Test
     Licensee.diff(fixture_path("licenses.git"))
   end
 
-  should "return the confidence threshold" do
-    assert_equal 90, Licensee.confidence_threshold
+  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
+      Licensee.confidence_threshold = 50
+      assert_equal 50, Licensee.confidence_threshold
+      Licensee.confidence_threshold = 90
+    end
   end
 
-  should "let the user override the confidence threshold" do
-    Licensee.confidence_threshold = 50
-    assert_equal 50, Licensee.confidence_threshold
-    Licensee.confidence_threshold = 90
+  context "npm-bower matcher" do
+    should "be disabled by default" do
+      refute Licensee.matchers.include? Licensee::NpmBowerMatcher
+    end
+
+    should "be enable-able" do
+      Licensee.package_manager_files = true
+      assert Licensee.matchers.include? Licensee::NpmBowerMatcher
+      Licensee.package_manager_files = false
+    end
   end
 end

data/test/test_licensee_bin.rb

@@ -6,7 +6,7 @@ class TestLicenseeBin < Minitest::Test
     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 `License file: LICENSE.md`"
+    assert stdout.include?("Matched file: LICENSE.md"), "expected #{stdout} to include `Matched file: LICENSE.md`"
     assert_equal 0, status
   end
 end

data/test/test_licensee_copyright_matcher.rb

@@ -6,7 +6,7 @@ class TestLicenseeCopyrightMatcher < Minitest::Test
   def setup
     text = "Copyright 2015 Ben Balter"
     blob = FakeBlob.new(text)
-    @file = Licensee::LicenseFile.new(blob)
+    @file = Licensee::ProjectFile.new(blob, "LICENSE")
   end
 
   should "match the license" do
@@ -20,35 +20,35 @@ class TestLicenseeCopyrightMatcher < Minitest::Test
   should "match Copyright (C) copyright notices" do
     text = "Copyright (C) 2015 Ben Balter"
     blob = FakeBlob.new(text)
-    file = Licensee::LicenseFile.new(blob)
+    file = Licensee::ProjectFile.new(blob, "LICENSE")
     assert_equal "no-license", Licensee::CopyrightMatcher.match(file).key
   end
 
   should "match Copyright © copyright notices" do
     text = "copyright © 2015 Ben Balter"
     blob = FakeBlob.new(text)
-    file = Licensee::LicenseFile.new(blob)
+    file = Licensee::ProjectFile.new(blob, "LICENSE")
     assert_equal "no-license", Licensee::CopyrightMatcher.match(file).key
   end
 
   should "not false positive" do
-    text = File.open(Licensee::Licenses.find("mit").path).read.split("---").last
+    text = File.open(Licensee::License.find("mit").path).read.split("---").last
     blob = FakeBlob.new(text)
-    file = Licensee::LicenseFile.new(blob)
+    file = Licensee::ProjectFile.new(blob, "LICENSE")
     assert_equal nil, Licensee::CopyrightMatcher.match(file)
   end
 
   should "handle UTF-8 encoded copyright notices" do
     text = "Copyright (c) 2010-2014 Simon Hürlimann"
     blob = FakeBlob.new(text)
-    file = Licensee::LicenseFile.new(blob)
+    file = Licensee::ProjectFile.new(blob, "LICENSE")
     assert_equal "no-license", Licensee::CopyrightMatcher.match(file).key
   end
 
   should "handle ASCII-8BIT encoded copyright notices" do
     text = "Copyright \xC2\xA92015 Ben Balter`".force_encoding("ASCII-8BIT")
     blob = FakeBlob.new(text)
-    file = Licensee::LicenseFile.new(blob)
+    file = Licensee::ProjectFile.new(blob, "LICENSE")
     assert_equal "no-license", Licensee::CopyrightMatcher.match(file).key
   end
  end

data/test/test_licensee_exact_matcher.rb

@@ -3,9 +3,9 @@ require 'helper'
 class TestLicenseeExactMatcher < Minitest::Test
 
   def setup
-    text = File.open(Licensee::Licenses.find("mit").path).read.split("---").last
+    text = File.open(Licensee::License.find("mit").path).read.split("---").last
     blob = FakeBlob.new(text)
-    @mit = Licensee::LicenseFile.new(blob)
+    @mit = Licensee::ProjectFile.new(blob, "LICENSE")
   end
 
   should "match the license" do

data/test/test_licensee_gemspec_matcher.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+class TestLicenseeGemspecMatcher < Minitest::Test
+  def setup
+    Licensee.package_manager_files = true
+  end
+
+  def teardown
+    Licensee.package_manager_files = false
+  end
+
+  should "detect its own license" do
+    root = File.expand_path "../", File.dirname(__FILE__)
+    project = Licensee::Project.new(root)
+    matcher = Licensee::GemspecMatcher.new(project.package_file)
+    assert_equal "mit", matcher.send(:license_property)
+    assert_equal "mit", matcher.match.key
+  end
+end

data/test/test_licensee_git_matcher.rb

@@ -3,9 +3,9 @@ require 'helper'
 class TestLicenseeGitMatcher < Minitest::Test
 
   def setup
-    text = license_from_path( Licensee::Licenses.find("mit").path )
+    text = license_from_path( Licensee::License.find("mit").path )
     blob = FakeBlob.new(text)
-    @mit = Licensee::LicenseFile.new(blob)
+    @mit = Licensee::ProjectFile.new(blob, "LICENSE")
   end
 
   should "match the license" do

data/test/test_licensee_levenshtein_matcher.rb

@@ -3,9 +3,9 @@ require 'helper'
 class TestLicenseeLevenshteinMatcher < Minitest::Test
 
   def setup
-    text = license_from_path( Licensee::Licenses.find("mit").path )
+    text = license_from_path( Licensee::License.find("mit").path )
     blob = FakeBlob.new(text)
-    @mit = Licensee::LicenseFile.new(blob)
+    @mit = Licensee::ProjectFile.new(blob, "LICENSE")
   end
 
   should "match the license" do
@@ -22,8 +22,8 @@ class TestLicenseeLevenshteinMatcher < Minitest::Test
   end
 
   should "calculate length delta" do
-    isc = Licensee::Licenses.find("isc")
-    assert_equal 2, Licensee::LevenshteinMatcher.new(@mit).length_delta(Licensee::Licenses.find("mit"))
+    isc = Licensee::License.find("isc")
+    assert_equal 2, Licensee::LevenshteinMatcher.new(@mit).length_delta(Licensee::License.find("mit"))
     assert_equal 334, Licensee::LevenshteinMatcher.new(@mit).length_delta(isc)
   end
 

data/test/test_licensee_license.rb

@@ -88,4 +88,23 @@ class TestLicenseeLicense < Minitest::Test
     assert_equal "Other", license.name
     refute license.featured?
   end
+
+  describe "class methods" do
+    should "know license names" do
+      assert_equal Array, Licensee::License.keys.class
+      assert_equal 19, Licensee::License.keys.size
+    end
+
+    should "load the licenses" do
+      assert_equal Array, Licensee::License.all.class
+      assert_equal 19, 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
+  end
 end

data/test/test_licensee_npm_bower_matcher.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+class TestLicenseeNpmBowerMatcher < Minitest::Test
+
+  def setup
+    Licensee.package_manager_files = true
+  end
+
+  def teardown
+    Licensee.package_manager_files = false
+  end
+
+  should "detect NPM files" do
+    project = Licensee::Project.new fixture_path "npm"
+    matcher = Licensee::NpmBowerMatcher.new(project.package_file)
+    assert_equal "mit", matcher.send(:license_property)
+    assert_equal "mit", matcher.match.key
+  end
+
+  should "detect Bower files" do
+    project = Licensee::Project.new fixture_path "bower"
+    matcher = Licensee::NpmBowerMatcher.new(project.package_file)
+    assert_equal "mit", matcher.send(:license_property)
+    assert_equal "mit", matcher.match.key
+  end
+
+  should "not err on non-spdx licenses" do
+    project = Licensee::Project.new fixture_path "npm-non-spdx"
+    matcher = Licensee::NpmBowerMatcher.new(project.package_file)
+    assert_equal "mit-1.0", matcher.send(:license_property)
+    assert_equal nil, matcher.match
+  end
+end

data/test/test_licensee_project.rb

@@ -28,7 +28,7 @@ class TestLicenseeProject < Minitest::Test
 
       should "detect the license file" do
         project = make_project "licenses.git", as_git
-        assert_instance_of Licensee::LicenseFile, project.license_file
+        assert_instance_of Licensee::ProjectFile, project.license_file
       end
 
       should "detect the license" do
@@ -36,24 +36,9 @@ class TestLicenseeProject < Minitest::Test
         assert_equal "mit", project.license.key
       end
 
-      should "return the license hash" do
-        project = make_project "licenses.git", as_git
-        assert_equal "LICENSE", project.send(:license_hash)[:name]
-      end
-
-      should "return the license blob" do
-        project = make_project "licenses.git", as_git
-        assert_equal 1077, project.send(:license_blob).size
-      end
-
-      should "return the license path" do
-        project = make_project "licenses.git", as_git
-        assert_equal "LICENSE", project.send(:license_path)
-      end
-
       should "detect an atypically cased license file" do
         project = make_project "case-sensitive.git", as_git
-        assert_instance_of Licensee::LicenseFile, project.license_file
+        assert_instance_of Licensee::ProjectFile, project.license_file
       end
 
       should "detect MIT-LICENSE licensed projects" do
@@ -83,29 +68,20 @@ class TestLicenseeProject < Minitest::Test
     end
   end
 
-  context "license filename scoring" do
-
-    EXPECTATIONS = {
-      "license"            => 1.0,
-      "LICENCE"            => 1.0,
-      "license.md"         => 1.0,
-      "LICENSE.md"         => 1.0,
-      "license.txt"        => 1.0,
-      "unLICENSE"          => 1.0,
-      "unlicence"          => 1.0,
-      "COPYING"            => 0.75,
-      "copyRIGHT"          => 0.75,
-      "COPYRIGHT.txt"      => 0.75,
-      "LICENSE-MIT"        => 0.5,
-      "MIT-LICENSE.txt"    => 0.5,
-      "mit-license-foo.md" => 0.5,
-      "README.txt"         => 0.0
-    }
-
-    EXPECTATIONS.each do |filename, expected|
-      should "score a license named `#{filename}` as `#{expected}`" do
-        assert_equal expected, Licensee::Project.match_license_file(filename)
-      end
+  describe "packages" do
+
+    def setup
+      Licensee.package_manager_files = true
+    end
+
+    def teardown
+      Licensee.package_manager_files = false
+    end
+
+    should "detect a package file" do
+      project = Licensee::Project.new fixture_path "npm"
+      assert_equal "package.json", project.package_file.filename
+      assert_equal "mit", project.license.key
     end
   end
 end

data/test/test_licensee_project_file.rb

@@ -0,0 +1,59 @@
+require 'helper'
+
+class TestLicenseeProjectFile < Minitest::Test
+
+  def setup
+    @repo = Rugged::Repository.new(fixture_path("licenses.git"))
+    blob = 'bcb552d06d9cf1cd4c048a6d3bf716849c2216cc'
+    @file = Licensee::ProjectFile.new(@repo.lookup(blob), "LICENSE")
+    @gpl = Licensee::License.find "GPL-3.0"
+    @mit = Licensee::License.find "MIT"
+  end
+
+  should "read the file" do
+    assert @file.contents =~ /MIT/
+  end
+
+  should "match the license" do
+    assert_equal "mit", @file.match.key
+  end
+
+  should "know the path" do
+    assert_equal "LICENSE", @file.path
+  end
+
+  should "diff the file" do
+    expected = "-Copyright (c) [year] [fullname]\n+Copyright (c) 2014 Ben Balter"
+    assert @file.diff.include?(expected)
+  end
+
+  should "calculate confidence" do
+    assert_equal 94, @file.confidence
+  end
+
+  context "license filename scoring" do
+
+    EXPECTATIONS = {
+      "license"            => 1.0,
+      "LICENCE"            => 1.0,
+      "license.md"         => 1.0,
+      "LICENSE.md"         => 1.0,
+      "license.txt"        => 1.0,
+      "unLICENSE"          => 1.0,
+      "unlicence"          => 1.0,
+      "COPYING"            => 0.75,
+      "copyRIGHT"          => 0.75,
+      "COPYRIGHT.txt"      => 0.75,
+      "LICENSE-MIT"        => 0.5,
+      "MIT-LICENSE.txt"    => 0.5,
+      "mit-license-foo.md" => 0.5,
+      "README.txt"         => 0.0
+    }
+
+    EXPECTATIONS.each do |filename, expected|
+      should "score a license named `#{filename}` as `#{expected}`" do
+        assert_equal expected, Licensee::ProjectFile.license_score(filename)
+      end
+    end
+  end
+end

data/test/test_licensee_vendor.rb

@@ -1,7 +1,7 @@
 require 'helper'
 
 class TestLicenseeVendor < Minitest::Test
-  Dir["#{Licensee::Licenses.base}/*"].shuffle.each do |license|
+  Licensee::License.send(:license_files).shuffle.each do |license|
 
     should "detect the #{license} license" do
       verify_license_file(license)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: licensee
 version: !ruby/object:Gem::Version
-  version: 4.9.0
+  version: 5.0.0b1
 platform: ruby
 authors:
 - Ben Balter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-22 00:00:00.000000000 Z
+date: 2015-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rugged
@@ -109,15 +109,18 @@ files:
 - lib/licensee.rb
 - lib/licensee/filesystem_repository.rb
 - lib/licensee/license.rb
-- lib/licensee/license_file.rb
-- lib/licensee/licenses.rb
 - lib/licensee/matcher.rb
 - lib/licensee/matchers/copyright_matcher.rb
 - lib/licensee/matchers/exact_matcher.rb
+- lib/licensee/matchers/gemspec_matcher.rb
 - lib/licensee/matchers/git_matcher.rb
 - lib/licensee/matchers/levenshtein_matcher.rb
+- lib/licensee/matchers/npm_bower_matcher.rb
+- lib/licensee/matchers/package_matcher.rb
 - lib/licensee/project.rb
+- lib/licensee/project_file.rb
 - lib/licensee/version.rb
+- test/fixtures/bower/bower.json
 - test/fixtures/case-sensitive.git/HEAD
 - test/fixtures/case-sensitive.git/config
 - test/fixtures/case-sensitive.git/objects/01/7b4f1eebd1dcb735e950b1d01093e3e2bf85e9
@@ -168,19 +171,22 @@ files:
 - test/fixtures/no-license.git/objects/e1/d9b2a3d41c2ea74a520e66da2b5c63b2f6202f
 - test/fixtures/no-license.git/objects/ff/1592f44259635df9feda5e02853964b26f9e4d
 - test/fixtures/no-license.git/refs/heads/master
+- test/fixtures/npm-non-spdx/package.json
+- test/fixtures/npm/package.json
 - test/functions.rb
 - test/helper.rb
 - test/test_licensee.rb
 - test/test_licensee_bin.rb
 - test/test_licensee_copyright_matcher.rb
 - test/test_licensee_exact_matcher.rb
+- test/test_licensee_gemspec_matcher.rb
 - test/test_licensee_git_matcher.rb
 - test/test_licensee_levenshtein_matcher.rb
 - test/test_licensee_license.rb
-- test/test_licensee_license_file.rb
-- test/test_licensee_licenses.rb
 - test/test_licensee_matcher.rb
+- test/test_licensee_npm_bower_matcher.rb
 - test/test_licensee_project.rb
+- test/test_licensee_project_file.rb
 - test/test_licensee_vendor.rb
 - vendor/choosealicense.com/_licenses/agpl-3.0.txt
 - vendor/choosealicense.com/_licenses/apache-2.0.txt
@@ -216,9 +222,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.8

data/lib/licensee/license_file.rb

@@ -1,52 +0,0 @@
-class Licensee
-  class LicenseFile
-    attr_reader :blob, :path
-
-    def initialize(blob, options={})
-      @blob = blob
-      @path = options[:path]
-    end
-
-    def similarity(other)
-      blob.hashsig(Rugged::Blob::HashSignature::WHITESPACE_SMART)
-      other.hashsig ? blob.similarity(other.hashsig) : 0
-    rescue Rugged::InvalidError
-      0
-    end
-
-    # Raw file contents
-    def content
-      @contents ||= begin
-        blob.content.force_encoding("UTF-8")
-      end
-    end
-    alias_method :to_s, :content
-    alias_method :contents, :content
-
-    # File content with all whitespace replaced with a single space
-    def content_normalized
-      @content_normalized ||= content.downcase.gsub(/\s+/, " ").strip
-    end
-
-    # Comptutes a diff between known license and project license
-    def diff(options={})
-      options = options.merge(:reverse => true)
-      blob.diff(match.body, options).to_s if match
-    end
-
-    # Determines which matching strategy to use, returns an instane of that matcher
-    def matcher
-      @matcher ||= Licensee.matchers.map { |m| m.new(self) }.find { |m| m.match }
-    end
-
-    # Returns an Licensee::License instance of the matches license
-    def match
-      @match ||= matcher.match if matcher
-    end
-
-    # Returns the percent confident with the match
-    def confidence
-      @condience ||= matcher.confidence if matcher
-    end
-  end
-end

data/lib/licensee/licenses.rb

@@ -1,36 +0,0 @@
-class Licensee
-  class Licenses
-    class << self
-
-      # Returns an array of Licensee::License instances
-      def list
-        @licenses ||= begin
-          licenses = []
-          keys.each { |key| licenses.push License.new(key) }
-          licenses
-        end
-      end
-
-      # Given a license key, attempt to return a matching Licensee::License instance
-      def find(key)
-        list.find { |l| l.key.downcase == key.downcase }
-      end
-      alias_method :[], :find
-
-      # Path to vendored licenses
-      def base
-        @base ||= File.expand_path "../../vendor/choosealicense.com/_licenses", File.dirname(__FILE__)
-      end
-
-      # Returns a list of potential license keys, as vendored
-      def keys
-        @keys ||= begin
-          keyes = Dir.entries(base)
-          keyes.map! { |l| File.basename(l, ".txt").downcase }
-          keyes.reject! { |l| l =~ /^\./ || l.nil? }
-          keyes
-        end
-      end
-    end
-  end
-end

data/test/test_licensee_license_file.rb

@@ -1,33 +0,0 @@
-require 'helper'
-
-class TestLicenseeLicenseFile < Minitest::Test
-
-  def setup
-    @repo = Rugged::Repository.new(fixture_path("licenses.git"))
-    blob = 'bcb552d06d9cf1cd4c048a6d3bf716849c2216cc'
-    @file = Licensee::LicenseFile.new(@repo.lookup(blob), :path => "LICENSE")
-    @gpl = Licensee::Licenses.find "GPL-3.0"
-    @mit = Licensee::Licenses.find "MIT"
-  end
-
-  should "read the file" do
-    assert @file.contents =~ /MIT/
-  end
-
-  should "match the license" do
-    assert_equal "mit", @file.match.key
-  end
-
-  should "know the path" do
-    assert_equal "LICENSE", @file.path
-  end
-
-  should "diff the file" do
-    expected = "-Copyright (c) [year] [fullname]\n+Copyright (c) 2014 Ben Balter"
-    assert @file.diff.include?(expected)
-  end
-
-  should "calculate confidence" do
-    assert_equal 94, @file.confidence
-  end
-end

data/test/test_licensee_licenses.rb

@@ -1,21 +0,0 @@
-require 'helper'
-
-class TestLicenseeLicenses < Minitest::Test
-
-  should "know license names" do
-    assert_equal Array, Licensee::Licenses.keys.class
-    assert_equal 19, Licensee::Licenses.keys.size
-  end
-
-  should "load the licenses" do
-    assert_equal Array, Licensee::Licenses.list.class
-    assert_equal 19, Licensee::Licenses.list.size
-    assert_equal Licensee::License, Licensee::Licenses.list.first.class
-  end
-
-  should "find a license" do
-    assert_equal "mit", Licensee::Licenses.find("mit").key
-    assert_equal "mit", Licensee::Licenses.find("MIT").key
-    assert_equal "mit", Licensee::Licenses["mit"].key
-  end
-end