license_finder 0.9.5.1-java → 1.0.0.0-java

data/spec/lib/license_finder/license/{new_bsd_spec.rb → definitions_spec.rb}

@@ -1,12 +1,68 @@
 require 'spec_helper'
 
-describe LicenseFinder::License::NewBSD do
-  subject { LicenseFinder::License::NewBSD.new("") }
+describe LicenseFinder::License, "Apache2" do
+  it "should be findable" do |e|
+    described_class.find_by_name("Apache2").should be
+  end
+end
+
+describe LicenseFinder::License, "BSD" do
+  it "should be findable" do |e|
+    described_class.find_by_name("BSD").should be
+  end
+end
+
+describe LicenseFinder::License, "GPLv2" do
+  it "should be findable" do
+    described_class.find_by_name("GPLv2").should be
+  end
+end
+
+describe LicenseFinder::License, "ISC" do
+  it "should be findable" do
+    described_class.find_by_name("ISC").should be
+  end
+end
+
+describe LicenseFinder::License, "LGPL" do
+  it "should be findable" do
+    described_class.find_by_name("LGPL").should be
+  end
+end
+
+describe LicenseFinder::License, "MIT" do
+  subject { described_class.find_by_name "MIT" }
+
+  describe "#matches_text?" do
+    it "should return true if the text contains the MIT url" do
+      subject.should be_matches_text "MIT License is awesome http://opensource.org/licenses/mit-license"
+
+      subject.should be_matches_text "MIT Licence is awesome http://www.opensource.org/licenses/mit-license"
+
+      subject.should_not be_matches_text "MIT Licence is awesome http://www!opensource!org/licenses/mit-license"
+    end
+
+    it "should return true if the text begins with 'The MIT License'" do
+      subject.should be_matches_text "The MIT License"
 
-  it_behaves_like "a license matcher"
+      subject.should be_matches_text "The MIT Licence"
+
+      subject.should_not be_matches_text "Something else\nThe MIT License"
+    end
+
+    it "should return true if the text contains 'is released under the MIT license'" do
+      subject.should be_matches_text "is released under the MIT license"
+
+      subject.should be_matches_text "is released under the MIT licence"
+    end
+  end
+end
+
+describe LicenseFinder::License, "NewBSD" do
+  subject { described_class.find_by_name "NewBSD" }
 
   it "should match regardless of organization or copyright holder names" do
-    license = LicenseFinder::License::NewBSD.new <<-LICENSE
+    license = <<-LICENSE
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
     * Redistributions of source code must retain the above copyright
@@ -30,11 +86,11 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     LICENSE
 
-    license.should be_matches
+    subject.should be_matches_text license
   end
 
   it "should match with the alternate wording of third clause" do
-    license = LicenseFinder::License::NewBSD.new <<-LICENSE
+    license = <<-LICENSE
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
     * Redistributions of source code must retain the above copyright
@@ -58,6 +114,36 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     LICENSE
 
-    license.should be_matches
+    subject.should be_matches_text license
+  end
+end
+
+describe LicenseFinder::License, "Python" do
+  it "should be findable" do
+    described_class.find_by_name("Python").should be
+  end
+end
+
+describe LicenseFinder::License, "Ruby" do
+  subject { described_class.find_by_name "Ruby" }
+
+  describe "#matches?" do
+    it "should return true when the Ruby license URL is present" do
+      subject.should be_matches_text "This gem is available under the following license:\nhttp://www.ruby-lang.org/en/LICENSE.txt\nOkay?"
+    end
+
+    it "should return false when the Ruby License URL is not present" do
+      subject.should_not be_matches_text "This gem is available under the following license:\nhttp://www.example.com\nOkay?"
+    end
+
+    it "should return false for pathological licenses" do
+      subject.should_not be_matches_text "This gem is available under the following license:\nhttp://wwwzruby-langzorg/en/LICENSEztxt\nOkay?"
+    end
+  end
+end
+
+describe LicenseFinder::License, "SimplifiedBSD" do
+  it "should be findable" do
+    described_class.find_by_name("SimplifiedBSD").should be
   end
 end

data/spec/lib/license_finder/license_spec.rb

@@ -1,45 +1,91 @@
 require 'spec_helper'
 
-class FooLicense < LicenseFinder::License::Base
-  self.alternative_names = ["the foo license"]
-  self.license_url = "http://foo.license.com"
-
-  def self.pretty_name
-    "Ye Ole Foo License"
-  end
-end
-
 module LicenseFinder
   describe License do
     describe ".find_by_name" do
-      it "should match on demodulized names" do
-        License.find_by_name("FooLicense").should == FooLicense
+      it "should find a registered license" do
+        License.find_by_name("Apache2").should be_a License
+      end
+
+      context "when license not found" do
+        it "should return UnknownLicense with the name" do
+          license = License.find_by_name("New License")
+
+          expect(license).to be_a UnknownLicense
+          expect(license.pretty_name).to eq "New License"
+        end
       end
+    end
+
+    describe ".find_by_text" do
+      it "should find a registered license" do
+        License.find_by_text('This gem is released under the MIT license').should be_a License
+      end
+
+      it "returns UnknownLicense with nil name if not found" do
+        license = License.find_by_text("foo")
 
-      it "should match on pretty names" do
-        License.find_by_name("Ye Ole Foo License").should == FooLicense
+        expect(license).to be_a UnknownLicense
+        expect(license.pretty_name).to be_nil
+      end
+    end
+
+    def make_license(settings = {})
+      described_class.new({
+        short_name: "Default Short Name",
+        url: "http://example.com/license",
+        matcher: License::Matcher.from_text('Default Matcher')
+      }.merge(settings))
+    end
+
+    describe "#matches_name?" do
+      it "should match on short_name" do
+        make_license(short_name: "Foo").should be_matches_name "Foo"
+      end
+
+      it "should match on pretty name" do
+        make_license(pretty_name: "Foo").should be_matches_name "Foo"
       end
 
       it "should match on alternative names" do
-        License.find_by_name("the foo license").should == FooLicense
+        license = make_license(other_names: ["Foo", "Bar"])
+        license.should be_matches_name "Foo"
+        license.should be_matches_name "Bar"
       end
 
-      it "should return nil if no match" do
-        License.find_by_name(:unknown).should be_nil
+      it "should ignore case" do
+        make_license(pretty_name: "Foo").should be_matches_name "foo"
+        make_license(pretty_name: "foo").should be_matches_name "Foo"
+      end
+
+      it "should not fail if pretty_name or other_names are omitted" do
+        make_license.should be_matches_name "Default Short Name"
       end
     end
-  end
-end
 
-describe LicenseFinder::License::Base do
-  describe ".names" do
-    subject do
-      Class.new(LicenseFinder::License::Base) do
-        def self.demodulized_name; "FooLicense"; end
-        self.alternative_names = ["foo license"]
-      end.names
+    describe ".matches_text?" do
+      it "should match on text" do
+        license = make_license(matcher: License::Matcher.new(/The license text/))
+        license.should be_matches_text "The license text"
+        license.should_not be_matches_text "Some other text"
+      end
+
+      it "should match regardless of placeholder names, whitespace, or quotes" do
+        license_text = <<-LICENSE
+          The "company" of <company name> shall not be
+          held `responsible` for 'anything'.
+        LICENSE
+        license = make_license(matcher: License::Matcher.from_text(License::Text.normalize_punctuation(license_text)))
+
+        license.should be_matches_text <<-FILE
+          The ''company'' of foo bar *%*%*%*%
+          shall not be held "responsible" for `anything`.
+        FILE
+      end
     end
 
-    it { should =~ ["FooLicense", "foo license"] }
+    it "should default pretty_name to short_name" do
+      make_license.pretty_name.should == "Default Short Name"
+    end
   end
 end

data/spec/lib/license_finder/license_url_spec.rb

@@ -1,20 +1,16 @@
 require "spec_helper"
 
-class FooLicense < LicenseFinder::License::Base
-  self.alternative_names = ["the foo license"]
-  self.license_url = "http://foo.license.com"
-end
-
-describe LicenseFinder::LicenseUrl do
-  describe ".find_by_name" do
-    subject { LicenseFinder::LicenseUrl }
+module LicenseFinder
+  describe LicenseUrl do
+    describe ".find_by_name" do
+      subject { LicenseUrl }
 
-    specify { subject.find_by_name("FooLicense").should      == "http://foo.license.com" }
-    specify { subject.find_by_name("fOolICENse").should      == "http://foo.license.com" }
-    specify { subject.find_by_name("the foo license").should == "http://foo.license.com" }
+      before do
+        License.stub(:find_by_name).with("Foo").
+          and_return(double(:foo_license, url: "http://foo.license.com"))
+      end
 
-    specify { subject.find_by_name(nil).should be_nil }
-    specify { subject.find_by_name("").should be_nil }
-    specify { subject.find_by_name("unknown license").should be_nil }
+      specify { subject.find_by_name("Foo").should == "http://foo.license.com" }
+    end
   end
 end

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

@@ -31,12 +31,12 @@ module LicenseFinder
         PossibleLicenseFiles.stub(:find).with("/path/to/thing").and_return(license_files)
       end
 
-      let(:package1) { { "pkgMeta" => {"license" => "MIT"} } }
-      let(:package2) { { "pkgMeta" => {"licenses" => [{"type" => "BSD", "url" => "github.github/github"}]} } }
-      let(:package3) { { "pkgMeta" => {"license" => {"type" => "PSF", "url" => "github.github/github"}} } }
-      let(:package4) { { "pkgMeta" => {"licenses" => ["MIT"]} } }
+      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" } }
 
-      it 'finds the license for both license structures' do
+      it 'finds the license for both license  structures' do
         BowerPackage.new(package1).license.should eq("MIT")
         BowerPackage.new(package2).license.should eq("BSD")
         BowerPackage.new(package3).license.should eq("PSF")
@@ -49,6 +49,18 @@ module LicenseFinder
         subject.license.should == "Detected License"
       end
 
+      it "returns other if there's more than one license" do
+        package = BowerPackage.new({ "pkgMeta" => {"licenses" => ["MIT", "BSD"]}, "canonicalDir" => "/some/path" })
+        expect(package.license).to eq("other")
+      end
+
+      it "returns other if the license from spec and license from files are different" do
+        stub_license_files [double(:file, license: 'Detected License')]
+        package = BowerPackage.new({ "pkgMeta" => {"licenses" => ["MIT"]}, "canonicalDir" => "/path/to/thing" })
+
+        expect(package.license).to eq("other")
+      end
+
       it "returns 'other' otherwise" do
         stub_license_files []
 

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

@@ -37,10 +37,10 @@ module LicenseFinder
         subject.license.should == "Gemspec License"
       end
 
-      it "returns the first license if the gemspec provides many" do
+      it "returns 'other' if the gemspec provides many" do
         gemspec.licenses = ['First Gemspec License', 'Second Gemspec License']
 
-        subject.license.should == "First Gemspec License"
+        subject.license.should == "other"
       end
 
       it "returns a license in a file if detected" do

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

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+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"}
+          ]
+        }
+      )
+    end
+
+    it_behaves_like "it conforms to interface required by PackageSaver"
+
+    its(:name) { should == "logback-classic" }
+    its(:version) { should == "1.1.1" }
+    its(:description) { should == "" }
+    its(:licenses_from_spec) { should == ["Eclipse Public License - v 1.0"] }
+
+    describe "#license" do
+      it "returns the license if found" do
+        subject.license.should == "Eclipse Public License - v 1.0"
+      end
+
+      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" => "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"}
+              ]
+            }
+          )
+        end
+
+        it "returns 'other'" do
+          subject.license.should == 'other'
+        end
+      end
+
+      context "when the license is not found" do
+        subject do
+          described_class.new(
+            {
+              "name" => "ch.qos.logback:logback-classic:1.1.1",
+              "file" => ["logback-classic-1.1.1.jar"],
+              "license" => []
+             }
+          )
+        end
+
+        it "returns 'other' otherwise" do
+          subject.license.should == "other"
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe Gradle do
+    def license_xml(xml)
+      <<-resp
+        <dependencies>
+          #{xml}
+        </dependencies>
+      resp
+    end
+
+    describe '.current_packages' do
+      before do
+        expect(described_class).to receive(:`).with(/gradle downloadLicenses/)
+      end
+
+      it 'lists all the current packages' do
+        license_xml = license_xml("""
+          <dependency name='org.springframework:spring-aop:4.0.1.RELEASE'>
+            <file>spring-aop-4.0.1.RELEASE.jar</file>
+            <license name='The Apache Software License, Version 2.0' url='http://www.apache.org/licenses/LICENSE-2.0.txt' />
+          </dependency>
+          <dependency name='org.springframework:spring-core:4.0.1.RELEASE'>
+            <file>spring-core-4.0.1.RELEASE.jar</file>
+            <license name='The Apache Software License, Version 2.0' url='http://www.apache.org/licenses/LICENSE-2.0.txt' />
+          </dependency>
+        """)
+        allow(File).to receive(:read).with("build/reports/license/dependency-license.xml").and_return(license_xml)
+
+        current_packages = described_class.current_packages
+
+        expect(current_packages.size).to eq(2)
+        expect(current_packages.first).to be_a(Package)
+      end
+
+      it "handles multiple licenses" do
+        license_xml = license_xml("""
+          <dependency>
+            <license name='License 1'/>
+            <license name='License 2'/>
+          </dependency>
+        """)
+
+        allow(File).to receive(:read).with("build/reports/license/dependency-license.xml").and_return(license_xml)
+
+        GradlePackage.should_receive(:new).with("license" => [{"name" => "License 1"}, {"name" => "License 2"}])
+        Gradle.current_packages
+      end
+
+      it "handles no licenses" do
+        license_xml = license_xml("""
+          <dependency>
+            <license name='No license found' />
+          </dependency>
+        """)
+
+        allow(File).to receive(:read).with("build/reports/license/dependency-license.xml").and_return(license_xml)
+
+        GradlePackage.should_receive(:new).with("license" => [])
+        Gradle.current_packages
+      end
+    end
+
+    describe '.active?' do
+      let(:package) { Pathname.new('build.gradle').expand_path }
+
+      context 'with a build.gradle file' do
+        before :each do
+          allow(File).to receive(:exists?).with(package).and_return(true)
+        end
+
+        it 'returns true' do
+          expect(Gradle.active?).to eq(true)
+        end
+      end
+
+      context 'without a build.gradle file' do
+        before :each do
+          allow(File).to receive(:exists?).with(package).and_return(false)
+        end
+
+        it 'returns false' do
+          expect(Gradle.active?).to eq(false)
+        end
+      end
+    end
+  end
+end