license_finder 1.2 → 2.0.0.rc2

data/spec/lib/license_finder/license/definitions_spec.rb

@@ -2,17 +2,11 @@ require 'spec_helper'
 
 describe LicenseFinder::License::Definitions do
   it "should create unrecognized licenses" do
-    license = described_class.build_unrecognized("foo", [])
+    license = described_class.build_unrecognized("foo")
     expect(license.name).to eq("foo")
     expect(license.url).to be_nil
     expect(license).to be_matches_name("foo")
     expect(license).not_to be_matches_text("foo")
-    expect(license).not_to be_whitelisted
-  end
-
-  it "should whitelist unrecognized licenses" do
-    license = described_class.build_unrecognized("foo", ["foo"])
-    expect(license).to be_whitelisted
   end
 end
 

data/spec/lib/license_finder/license_spec.rb

@@ -15,23 +15,13 @@ module LicenseFinder
       end
 
       context "making the default license" do
-        it "set the name to 'other'" do
-          expect(License.find_by_name(nil).name).to eq("other")
+        it "set the name to 'unknown'" do
+          expect(License.find_by_name(nil).name).to eq("unknown")
         end
 
         it "does not equal other uses of the default license" do
           expect(License.find_by_name(nil)).not_to eq(License.find_by_name(nil))
         end
-
-        context "when there is a whitelist" do
-          before do
-            allow(LicenseFinder.config).to receive(:whitelist).and_return(["not empty"])
-          end
-
-          it "does not blow up" do
-            expect(License.find_by_name(nil).name).to eq("other")
-          end
-        end
       end
     end
 
@@ -51,30 +41,12 @@ module LicenseFinder
       defaults = {
         short_name: "Default Short Name",
         url: "http://example.com/license",
-        whitelisted: false,
         matcher: License::Matcher.from_text('Default Matcher')
       }
 
       License.new(defaults.merge(settings))
     end
 
-    describe "#whitelisted?" do
-      it "is true if the settings say it is" do
-        expect(make_license).not_to be_whitelisted
-        expect(make_license(whitelisted: true)).to be_whitelisted
-      end
-
-      it "can be made true (without mutating original)" do
-        original = make_license
-        license = original.whitelist
-        expect(license).not_to eq(original)
-        expect(license).to be_whitelisted
-        expect(license.url).to eq("http://example.com/license")
-        expect(license).to be_matches_name "Default Short Name"
-        expect(license).to be_matches_text "Default Matcher"
-      end
-    end
-
     describe "#matches_name?" do
       it "should match on short_name" do
         expect(make_license(short_name: "Foo")).to be_matches_name "Foo"

data/spec/lib/license_finder/package_manager_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe PackageManager do
+    describe "#current_packages_with_relations" do
+      it "sets packages' parents" do
+        grandparent = Package.new("grandparent", nil, children: ["parent"])
+        parent      = Package.new("parent",      nil, children: ["child"])
+        child       = Package.new("child")
+
+        pm = described_class.new
+        allow(pm).to receive(:current_packages) { [grandparent, parent, child] }
+
+        expect(pm.current_packages_with_relations.map(&:parents)).to eq([
+          [].to_set,
+          ["grandparent"].to_set,
+          ["parent"].to_set
+        ])
+      end
+    end
+  end
+end

data/spec/lib/license_finder/package_managers/bower_package_spec.rb

@@ -23,83 +23,50 @@ module LicenseFinder
     its(:summary) { should == "description" }
     its(:description) { should == "some readme stuff" }
     its(:homepage) { should == "homepage" }
-    its(:groups) { should == [] }
-    its(:children) { should == [] }
+    its(:groups) { should == [] } # TODO: does `bower list` output devDependencies? If so, put them in 'dev' group?
+    its(:children) { should == [] } # TODO: get dependencies from dependencies and devDependencies, like NPM
+    its(:install_path) { should eq "/path/to/thing" }
+
+
+    context "when package is NOT installed" do
+      subject do
+        described_class.new(
+          "missing" => true,
+          "endpoint" => {
+            "name" => "some_package_that_is_not_installed",
+            "target" => ">=3.0"
+          }
+        )
+      end
+
+      it "shows the name and version from the endpoint block" do
+        expect(subject.name).to eq("some_package_that_is_not_installed")
+        expect(subject.version).to eq(">=3.0")
+      end
 
-    describe '#licenses' do
-      def stub_license_files(license_files)
-        allow(PossibleLicenseFiles).to receive(:find).with("/path/to/thing").and_return(license_files)
+      it 'reports itself as missing' do
+        expect(subject).to be_missing
       end
+    end
 
-      let(:package1) { { "pkgMeta" => {"license" => "MIT"}, "canonicalDir" => "/some/path" } }
-      let(:package2) { { "pkgMeta" => {"licenses" => [{"type" => "BSD", "url" => "github.github/github"}]}, "canonicalDir" => "/some/path" } }
-      let(:package3) { { "pkgMeta" => {"license" => {"type" => "PSF", "url" => "github.github/github"}}, "canonicalDir" => "/some/path" } }
-      let(:package4) { { "pkgMeta" => {"licenses" => ["MIT"]}, "canonicalDir" => "/some/path" } }
+    describe '#license_names_from_spec' do
+      let(:package1) { { "pkgMeta" => {"license" => "MIT"} } }
+      let(:package2) { { "pkgMeta" => {"licenses" => [{"type" => "BSD"}]} } }
+      let(:package3) { { "pkgMeta" => {"license" => {"type" => "PSF"}} } }
+      let(:package4) { { "pkgMeta" => {"licenses" => ["MIT"]} } }
 
-      it 'finds the license for both license  structures' do
+      it 'finds the license for all license structures' do
         package = BowerPackage.new(package1)
-        expect(package.licenses.length).to eq 1
-        expect(package.licenses.first.name).to eq("MIT")
+        expect(package.license_names_from_spec).to eq ["MIT"]
 
         package = BowerPackage.new(package2)
-        expect(package.licenses.length).to eq 1
-        expect(package.licenses.first.name).to eq("BSD")
+        expect(package.license_names_from_spec).to eq ["BSD"]
 
         package = BowerPackage.new(package3)
-        expect(package.licenses.length).to eq 1
-        expect(package.licenses.first.name).to eq("Python Software Foundation License")
+        expect(package.license_names_from_spec).to eq ["PSF"]
 
         package = BowerPackage.new(package4)
-        expect(package.licenses.length).to eq 1
-        expect(package.licenses.first.name).to eq("MIT")
-      end
-
-
-      context "regardless of whether there are licenses in files" do
-        before do
-          stub_license_files [double(:file, license: License.find_by_name('Detected License'), path: "/")]
-        end
-
-        it "returns the license from the spec if there is only one unique license" do
-          package = BowerPackage.new({ "pkgMeta" => {"licenses" => ["MIT", "Expat"]}, "canonicalDir" => "/path/to/thing" })
-          expect(package.licenses.length).to eq 1
-          expect(package.licenses.first.name).to eq("MIT")
-        end
-
-        it "returns 'multiple licenses' if there's more than one license" do
-          package = BowerPackage.new({ "pkgMeta" => {"licenses" => ["MIT", "BSD"]}, "canonicalDir" => "/some/path" })
-          expect(package.licenses.length).to eq 2
-          expect(package.licenses.map(&:name)).to eq %w(MIT BSD)
-        end
-      end
-
-      context "when there is nothing in the spec" do
-        it "returns a license in a file if only one unique license detected" do
-          stub_license_files([
-            double(:first_file, license: License.find_by_name('MIT'), path: "/"),
-            double(:second_file, license: License.find_by_name('Expat'), path: "/")
-          ])
-
-          expect(subject.licenses.length).to eq 1
-          expect(subject.licenses.first.name).to eq "MIT"
-        end
-
-        it "returns 'other' if there are no licenses in files" do
-          stub_license_files []
-
-          expect(subject.licenses.length).to eq 1
-          expect(subject.licenses.first.name).to eq "other"
-        end
-
-        it "returns 'other' if there are many licenses in files" do
-          stub_license_files([
-            double(:first_file, license: License.find_by_name('First Detected License'), path: "/"),
-            double(:second_file, license: License.find_by_name('Second Detected License'), path: "/")
-          ])
-
-          expect(subject.licenses.length).to eq 2
-          expect(subject.licenses.map(&:name)).to eq ["First Detected License", "Second Detected License"]
-        end
+        expect(package.license_names_from_spec).to eq ["MIT"]
       end
     end
   end

data/spec/lib/license_finder/package_managers/bundler_package_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module LicenseFinder
   describe BundlerPackage do
-    subject { described_class.new(gemspec, nil) }
+    subject { described_class.new(gemspec, bundler_dependency) }
 
     it_behaves_like "a Package"
 
@@ -13,86 +13,22 @@ module LicenseFinder
         s.summary = 'summary'
         s.description = 'description'
         s.homepage = 'homepage'
+        s.licenses = ['MIT', 'GPL']
 
         s.add_dependency 'foo'
       end
     end
 
+    let(:bundler_dependency) { double(:dependency, groups: [1, 2, 3]) }
+
     its(:name) { should == 'spec_name' }
     its(:version) { should == '2.1.3' }
     its(:summary) { should == "summary" }
     its(:description) { should == "description" }
     its(:homepage) { should == "homepage" }
-    its(:groups) { should == [] }
+    its(:groups) { should == [1, 2, 3] }
     its(:children) { should == ['foo'] }
-
-    describe "#licenses" do
-      def stub_license_files(license_files)
-        allow(PossibleLicenseFiles).to receive(:find).and_return(license_files)
-      end
-
-      context "regardless of whether there are licenses in files" do
-        before do
-          stub_license_files [double(:file, license: License.find_by_name('Detected License'), path: "/")]
-        end
-
-        context 'if the gemspec provides two synonymous licenses' do
-          before { gemspec.licenses = ['MIT', 'Expat'] }
-
-          it 'returns the license only once' do
-            expect(subject.licenses.length).to eq 1
-            expect(subject.licenses.first.name).to eq "MIT"
-          end
-        end
-
-        context 'if the gemspec provides many licenses' do
-          before { gemspec.licenses = ['First Gemspec License', 'Second Gemspec License'] }
-
-          it "returns 'multiple licenses' with the names of the licenses from the gemspec (but not those from detected files)" do
-            expect(subject.licenses.length).to eq 2
-            expect(subject.licenses.map(&:name)).to eq ["First Gemspec License", "Second Gemspec License"]
-          end
-        end
-      end
-
-      context "when there is nothing in the spec" do
-        it "returns a license in a file if there is only one unique license detected" do
-          stub_license_files([
-            double(:first_file, license: License.find_by_name('MIT'), path: "/"),
-            double(:second_file, license: License.find_by_name('Expat'), path: "/")
-          ])
-
-          expect(subject.licenses.length).to eq 1
-          expect(subject.licenses.first.name).to eq "MIT"
-        end
-
-        it "returns 'other' if there are no licenses in files" do
-          stub_license_files []
-
-          expect(subject.licenses.length).to eq 1
-          expect(subject.licenses.first.name).to eq "other"
-        end
-
-        it "returns 'multiple licenses' if there are many licenses in files" do
-          stub_license_files([
-            double(:first_file, license: License.find_by_name('First Detected License'), path: "/"),
-            double(:second_file, license: License.find_by_name('Second Detected License'), path: "/")
-          ])
-
-          expect(subject.licenses.length).to eq 2
-          expect(subject.licenses.map(&:name)).to eq ["First Detected License", "Second Detected License"]
-        end
-      end
-    end
-
-    describe "#groups" do
-      subject { described_class.new(gemspec, bundler_dependency) }
-
-      let(:bundler_dependency) { double(:dependency, groups: [1, 2, 3]) }
-
-      it "returns bundler dependency's groups" do
-        expect(subject.groups).to eq(bundler_dependency.groups)
-      end
-    end
+    its(:license_names_from_spec) { should eq ['MIT', 'GPL'] }
+    its(:install_path) { should =~ /spec_name-2\.1\.3\z/ }
   end
 end

data/spec/lib/license_finder/package_managers/cocoa_pods_package_spec.rb

@@ -11,9 +11,9 @@ module LicenseFinder
 
     its(:name) { should == "Name" }
     its(:version) { should == "1.0.0" }
-    its(:summary) { should be_nil }
-    its(:description) { should be_nil }
-    its(:homepage) { should be_nil }
+    its(:summary) { should eq "" }
+    its(:description) { should eq "" }
+    its(:homepage) { should eq "" }
     its(:groups) { should == [] }
     its(:children) { should == [] }
 
@@ -25,21 +25,18 @@ module LicenseFinder
           license = double(:license, name: "LicenseName")
           allow(License).to receive(:find_by_text).with(license_text).and_return(license)
 
-          expect(subject.licenses.length).to eq 1
-          expect(subject.licenses.first.name).to eq "LicenseName"
+          expect(subject.licenses.map(&:name)).to eq ["LicenseName"]
         end
 
-        it "returns other if the license can't be found by text" do
+        it "returns unknown if the license can't be found by text" do
           allow(License).to receive(:find_by_text).with(license_text).and_return(nil)
 
-          expect(subject.licenses.length).to eq 1
-          expect(subject.licenses.first.name).to eq "other"
+          expect(subject.licenses.map(&:name)).to eq ["unknown"]
         end
       end
 
-      it "returns other when there's no license" do
-        expect(subject.licenses.length).to eq 1
-        expect(subject.licenses.first.name).to eq "other"
+      it "returns unknown when there's no license" do
+        expect(subject.licenses.map(&:name)).to eq ["unknown"]
       end
     end
   end

data/spec/lib/license_finder/package_managers/gradle_package_spec.rb

@@ -4,13 +4,8 @@ module LicenseFinder
   describe GradlePackage do
     subject do
       described_class.new(
-        {
-          "name" => "ch.qos.logback:logback-classic:1.1.1",
-          "file" => ["logback-classic-1.1.1.jar"],
-          "license" => [
-            { "name" => "Eclipse Public License - v 1.0", "url"=>"http://www.eclipse.org/legal/epl-v10.html"}
-          ]
-        }
+        "name" => "ch.qos.logback:logback-classic:1.1.1",
+        "license" => [ { "name" => "MIT" } ]
       )
     end
 
@@ -18,48 +13,49 @@ module LicenseFinder
 
     its(:name) { should == "logback-classic" }
     its(:version) { should == "1.1.1" }
+    its(:summary) { should == "" }
     its(:description) { should == "" }
+    its(:homepage) { should == "" }
+    its(:groups) { should == [] } # no way to get groups from gradle?
+    its(:children) { should == [] } # no way to get children from gradle?
+    its(:install_path) { should be_nil }
 
-    describe "#licenses" do
-      it "returns the license if found" do
-        expect(subject.licenses.length).to eq 1
-        expect(subject.licenses.first.name).to eq "Eclipse Public License - v 1.0"
+    describe "#license_names_from_spec" do
+      it "returns the license" do
+        expect(subject.license_names_from_spec).to eq ["MIT"]
       end
 
-      context "when there are multiple licenses" do
+      context "when there are no licenses" do
+        subject { described_class.new("name" => "a:b:c") }
+
+        it "is empty" do
+          expect(subject.license_names_from_spec).to be_empty
+        end
+      end
+
+      context "when there are no real licenses" do
         subject do
           described_class.new(
-            {
-              "name" => "ch.qos.logback:logback-classic:1.1.1",
-              "file" => ["logback-classic-1.1.1.jar"],
-              "license" => [
-                { "name" => "Eclipse Public License - v 1.0", "url"=>"http://www.eclipse.org/legal/epl-v10.html"},
-                { "name"=>"GNU Lesser General Public License", "url"=>"http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html"}
-              ]
-            }
+            "name" => "a:b:c",
+            "license" => [ { "name" => "No license found"} ]
           )
         end
 
-        it "returns 'multiple licenses'" do
-          expect(subject.licenses.length).to eq 2
-          expect(subject.licenses.map(&:name)).to eq ['Eclipse Public License - v 1.0', 'GNU Lesser General Public License']
+        it "is empty" do
+          expect(subject.license_names_from_spec).to be_empty
         end
       end
 
-      context "when the license is not found" do
+      context "when there are multiple licenses" do
         subject do
           described_class.new(
-            {
-              "name" => "ch.qos.logback:logback-classic:1.1.1",
-              "file" => ["logback-classic-1.1.1.jar"],
-              "license" => []
-             }
+            "name" => "a:b:c",
+            "license" => [ { "name" => "1" }, { "name" => "2" } ]
           )
         end
 
-        it "returns 'other' otherwise" do
-          expect(subject.licenses.length).to eq 1
-          expect(subject.licenses.first.name).to eq "other"
+        it "returns multiple licenses" do
+          expect(subject.license_names_from_spec).to eq ['1', '2']
         end
       end
     end