license_finder 3.0.4 → 3.1.1

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

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe PipPackage do
-    subject do
-      make_package({
-        "summary" => "summary",
-        "description" => "description",
-        "home_page" => "homepage"
-      })
-    end
-
-    def make_package(pypi_def)
-      described_class.new('jasmine', '1.3.1', pypi_def, install_path: "jasmine/install/path", children: ["achild"])
-    end
-
-    its(:name) { should == "jasmine" }
-    its(:version) { should == "1.3.1" }
-    its(:authors) { should == "" }
-    its(:summary) { should == "summary" }
-    its(:description) { should == "description" }
-    its(:homepage) { should == "homepage" }
-    its(:groups) { should == [] } # TODO: any way to extract install_requires and tests_require from `pip list` or `pip show`?
-    its(:children) { should == ["achild"] }
-    its(:install_path) { should eq "jasmine/install/path" }
-    its(:package_manager) { should eq 'Pip' }
-
-
-    describe '#license_names_from_spec' do
-      describe "with no pypi info" do
-        it "is empty" do
-          subject = make_package({})
-
-          expect(subject.license_names_from_spec).to be_empty
-        end
-      end
-
-      describe "with valid pypi license" do
-        it "returns the license from 'license' preferentially" do
-          data = { "license" => "MIT", "classifiers" => [ 'License :: OSI Approved :: Apache 2.0 License' ] }
-
-          subject = make_package(data)
-
-          expect(subject.license_names_from_spec).to eq ['MIT']
-        end
-
-        context "when there's no explicit license" do
-          it "returns the license from the 'classifiers' if there is only one" do
-            data = { "classifiers" => [ 'License :: OSI Approved :: Apache 2.0 License' ] }
-
-            subject = make_package(data)
-
-            expect(subject.license_names_from_spec).to eq ['Apache 2.0 License']
-          end
-
-          it "returns multiple licenses if there are many in 'classifiers'" do
-            data = { "classifiers" => [ 'License :: OSI Approved :: Apache 2.0 License', 'License :: OSI Approved :: GPL' ] }
-
-            subject = make_package(data)
-
-            expect(subject.license_names_from_spec).to eq ['Apache 2.0 License', 'GPL']
-          end
-        end
-
-        context "with blank license" do
-          it "returns the license from the classifier if it exists" do
-            data = { "license" => "", "classifiers" => [ 'License :: OSI Approved :: Apache 2.0 License' ] }
-
-            subject = make_package(data)
-
-            expect(subject.license_names_from_spec).to eq ['Apache 2.0 License']
-          end
-        end
-
-        context "with UNKNOWN license" do
-          it "returns the license from the classifier if it exists" do
-            data = { "license" => "UNKNOWN", "classifiers" => [ 'License :: OSI Approved :: Apache 2.0 License' ] }
-
-            subject = make_package(data)
-
-            expect(subject.license_names_from_spec).to eq ['Apache 2.0 License']
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe Pip do
-    let(:pip) { Pip.new }
-    it_behaves_like "a PackageManager"
-
-    describe '.current_packages' do
-      def stub_pip(stdout)
-        allow(pip).to receive("`").with(/license_finder_pip.py/).and_return(stdout)
-      end
-
-      def stub_pypi(name, version, response)
-        stub_request(:get, "https://pypi.python.org/pypi/#{name}/#{version}/json")
-          .to_return(response)
-      end
-
-      it 'fetches data from pip' do
-        stub_pip [
-          {"name" => "jasmine", "version" => "1.3.1", "location" => "jasmine/path", "dependencies" => ["jasmine-core"]},
-          {"name" => "jasmine-core", "version" => "1.3.1", "location" => "jasmine-core/path"}
-        ].to_json
-        stub_pypi("jasmine", "1.3.1", status: 200, body: '{}')
-        stub_pypi("jasmine-core", "1.3.1", status: 200, body: '{}')
-
-        expect(pip.current_packages.map { |p| [p.name, p.version, p.install_path.to_s, p.children] }).to eq [
-          ["jasmine", "1.3.1", "jasmine/path/jasmine", ["jasmine-core"]],
-          ["jasmine-core", "1.3.1", "jasmine-core/path/jasmine-core", []]
-        ]
-      end
-
-      it "fetches data from pypi" do
-        stub_pip [{"name" => "jasmine", "version" => "1.3.1", "location" => "jasmine/path"}].to_json
-        stub_pypi("jasmine", "1.3.1", status: 200, body: JSON.generate(info: {summary: "A summary"}))
-
-        expect(pip.current_packages.first.summary).to eq "A summary"
-      end
-
-      it "ignores pypi if it can't find useful info" do
-        stub_pip [{"name" => "jasmine", "version" => "1.3.1", "location" => "jasmine/path"}].to_json
-        stub_pypi("jasmine", "1.3.1", status: 404, body: '')
-
-        expect(pip.current_packages.first.summary).to eq ""
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe RebarPackage do
-    subject do
-      described_class.new(
-        "uuid",
-        "TAG: v1.3.2",
-        install_path: "deps/uuid",
-        homepage: "git://github.com/okeuday/uuid.git"
-      )
-    end
-
-    its(:name) { should == "uuid" }
-    its(:version) { should == "TAG: v1.3.2" }
-    its(:summary) { should eq "" }
-    its(:description) { should == "" }
-    its(:homepage) { should == "git://github.com/okeuday/uuid.git" }
-    its(:groups) { should == [] }
-    its(:children) { should == [] }
-    its(:install_path) { should eq "deps/uuid" }
-    its(:package_manager) { should eq 'Rebar' }
-  end
-end

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

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe Rebar do
-    subject { Rebar.new(project_path: Pathname('/fake/path')) }
-
-    it_behaves_like "a PackageManager"
-
-    output = <<-CMDOUTPUT
-== Sample comment
-uuid TAG v1.3.2 git://github.com/okeuday/uuid.git
-jiffy TAG 0.9.0 https://github.com/davisp/jiffy.git
-    CMDOUTPUT
-
-    describe '.current_packages' do
-      before do
-        allow(Dir).to receive(:chdir).with(Pathname('/fake/path')) { |&block| block.call }
-      end
-
-      it 'lists all the current packages' do
-        allow(subject).to receive(:capture).with('rebar list-deps').and_return([output, true])
-
-        current_packages = subject.current_packages
-        expect(current_packages.map(&:name)).to eq(["uuid", "jiffy"])
-        expect(current_packages.map(&:install_path)).to eq([Pathname("deps/uuid"), Pathname("deps/jiffy")])
-      end
-
-      it "fails when command fails" do
-        allow(subject).to receive(:capture).with(/rebar/).and_return(['Some error', false]).once
-        expect { subject.current_packages }.to raise_error(RuntimeError)
-      end
-
-      it "uses custom rebar command, if provided" do
-        rebar = Rebar.new(rebar_command: "rebarfoo", project_path: Pathname('/fake/path'))
-        allow(rebar).to receive(:capture).with(/rebarfoo/).and_return([output, true])
-
-        current_packages = rebar.current_packages
-        expect(current_packages.map(&:name)).to eq(["uuid", "jiffy"])
-      end
-
-      it "uses custom rebar_deps_dir, if provided" do
-        rebar = Rebar.new(rebar_deps_dir: "foo", project_path: Pathname('/fake/path'))
-        allow(rebar).to receive(:capture).with(/rebar/).and_return([output, true])
-
-        current_packages = rebar.current_packages
-        expect(current_packages.map(&:install_path)).to eq([Pathname("foo/uuid"), Pathname("foo/jiffy")])
-      end
-    end
-  end
-end

data/spec/lib/license_finder/package_spec.rb

@@ -1,179 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe Package do
-    subject do
-      described_class.new(
-        "a package",
-        "1.3.1",
-        authors: "the authors",
-        summary: "a summary",
-        description: "a description",
-        homepage: "a homepage",
-        groups: %w[dev test],
-        children: %w[child-1 child2],
-        install_path: "some/package/path",
-        spec_licenses: %w[MIT GPL]
-      )
-    end
-
-    its(:name) { should == "a package" }
-    its(:version) { should == "1.3.1" }
-    its(:authors) { should == 'the authors' }
-    its(:summary) { should == "a summary" }
-    its(:description) { should == "a description" }
-    its(:homepage) { should == "a homepage" }
-    its(:groups) { should == %w[dev test] }
-    its(:children) { should == %w[child-1 child2] }
-    its(:install_path) { should eq "some/package/path" }
-
-    it 'has defaults' do
-      subject = described_class.new(nil, nil)
-      expect(subject.name).to be_nil
-      expect(subject.version).to be_nil
-      expect(subject.authors).to eq ""
-      expect(subject.summary).to eq ""
-      expect(subject.description).to eq ""
-      expect(subject.homepage).to eq ""
-      expect(subject.groups).to eq []
-      expect(subject.children).to eq []
-      expect(subject.install_path).to be_nil
-      expect(subject.license_names_from_spec).to eq []
-      expect(subject.licenses.map(&:name)).to eq ['unknown']
-    end
-
-    describe '#licenses' do
-      def stub_license_files(*license_names)
-        license_files = license_names.map do |license_name|
-          double(:file, license: License.find_by_name(license_name), path: "some/path")
-        end
-        allow(LicenseFiles).to receive(:find).with("some/package/path")
-          .and_return(license_files)
-      end
-
-      it "are not required" do
-        subject = described_class.new(nil, nil)
-        expect(subject.licenses.map(&:name)).to eq ['unknown']
-      end
-
-      describe "decided by user" do
-        it "returns all decided licenses" do
-          subject = described_class.new(nil, nil)
-          subject.decide_on_license(License.find_by_name("MIT"))
-          subject.decide_on_license(License.find_by_name("GPL"))
-          expect(subject.licenses.map(&:name)).to match_array ["MIT", "GPL"]
-        end
-
-        it "de-duplicates across license aliases" do
-          subject = described_class.new(nil, nil)
-          subject.decide_on_license(License.find_by_name("MIT"))
-          subject.decide_on_license(License.find_by_name("Expat"))
-          expect(subject.licenses.map(&:name)).to eq ["MIT"]
-        end
-
-        it "trumps licenses from the spec" do
-          subject = described_class.new(nil, nil, spec_licenses: ["GPL"])
-          subject.decide_on_license(License.find_by_name("MIT"))
-          expect(subject.licenses.map(&:name)).to eq ["MIT"]
-        end
-
-        it "trumps licenses from the install path" do
-          stub_license_files 'Detected License'
-          subject = described_class.new(nil, nil, install_path: "some/package/path")
-          subject.decide_on_license(License.find_by_name("MIT"))
-          expect(subject.licenses.map(&:name)).to eq ["MIT"]
-        end
-      end
-
-      describe "from the spec" do
-        it "converts the names to licenses" do
-          subject = described_class.new(nil, nil, spec_licenses: ["MIT", "GPL"])
-          expect(subject.licenses.map(&:name)).to match_array ["MIT", "GPL"]
-        end
-
-        it "de-duplicates across license aliases" do
-          subject = described_class.new(nil, nil, spec_licenses: ["MIT", "Expat"])
-          expect(subject.licenses.map(&:name)).to eq ["MIT"]
-        end
-
-        it "trumps licenses from the install path" do
-          stub_license_files 'Detected License'
-          subject = described_class.new(nil, nil, spec_licenses: ["MIT"], install_path: "some/package/path")
-          expect(subject.licenses.map(&:name)).to eq ["MIT"]
-        end
-      end
-
-      describe "from the install path" do
-        it "uses the licenses reported by files in the install path" do
-          stub_license_files 'MIT', 'GPL'
-          subject = described_class.new(nil, nil, install_path: "some/package/path")
-          expect(subject.licenses.map(&:name)).to eq ["MIT", "GPL"]
-        end
-
-        it "de-duplicates across license aliases" do
-          stub_license_files 'MIT', 'Expat'
-          subject = described_class.new(nil, nil, install_path: "some/package/path")
-          expect(subject.licenses.map(&:name)).to eq ["MIT"]
-        end
-      end
-    end
-
-    describe '#blacklisted?' do
-      it 'defaults to false' do
-        expect(subject.blacklisted?).to eq(false)
-      end
-
-      it 'can be set by blacklisted!' do
-        subject.blacklisted!
-        expect(subject.blacklisted?).to eq(true)
-      end
-    end
-
-    describe '#approved?' do
-      it 'returns false by default' do
-        expect(subject.approved?).to eq(false)
-      end
-
-      it 'returns true when approved manually' do
-        subject.approved_manually!('I approve of this dependency')
-        expect(subject.approved?).to eq(true)
-      end
-
-      it 'returns true when whitelisted' do
-        subject.whitelisted!
-        expect(subject.approved?).to eq(true)
-      end
-
-      it 'returns false when blacklisted' do
-        subject.blacklisted!
-        expect(subject.approved?).to eq(false)
-      end
-    end
-
-    describe '#eql?' do
-      it 'returns true if package name matches' do
-        p1 = Package.new('package', '0.0.1')
-        p2 = Package.new('package', '0.0.1')
-        p3 = Package.new('foo', 'foo')
-        p4 = Package.new('foo', 'foo2')
-
-        expect(p1.eql?(p2)).to be true
-        expect(p1.eql?(p3)).to be false
-        expect(p3.eql?(p4)).to be false
-
-        expect(p1.hash).to eq p2.hash
-        expect(p3.hash).not_to eq p4.hash
-      end
-    end
-
-    describe '#<=>' do
-      it 'sorts by name' do
-        p1 = Package.new('bob')
-        p2 = Package.new('jim')
-        p3 = Package.new('dan')
-
-        expect([p2, p1, p3].sort).to eq([p1, p3, p2])
-      end
-    end
-  end
-end

data/spec/lib/license_finder/packages/activation_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe Activation do
-    let(:package) { Package.new("p", nil) }
-    let(:license) { License.find_by_name("l") }
-    let(:activation) { described_class.new(package, license) }
-
-    it "reports that a license has been activated for a package" do
-      subject = Activation::Basic.new(package, license)
-      expect(subject.package).to eq package
-      expect(subject.license).to eq license
-    end
-
-    describe Activation::FromDecision do
-      it "reports that it came from a decision" do
-        expect(activation.sources).to eq ["from decision"]
-      end
-    end
-
-    describe Activation::FromSpec do
-      it "reports that it came from a spec" do
-        expect(activation.sources).to eq ["from spec"]
-      end
-    end
-
-    describe Activation::FromFiles do
-      it "reports that it came from some files" do
-        files = [double(:file, path: "x"), double(:file, path: "y")]
-        activation = described_class.new(package, license, files)
-        expect(activation.sources).to eq ["from file 'x'", "from file 'y'"]
-      end
-    end
-
-    describe Activation::None do
-      it "reports that has no source" do
-        expect(activation.sources).to eq []
-      end
-    end
-  end
-end

data/spec/lib/license_finder/packages/license_files_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe LicenseFiles do
-    describe "#find" do
-      def files_in(fixture)
-        root_path = fixture_path(fixture)
-        subject = described_class.find(root_path.to_s)
-
-        subject.map do |f|
-          Pathname(f.path).relative_path_from(root_path).to_s
-        end
-      end
-
-      it "is empty if passed a nil install path" do
-        subject = described_class.new nil
-        expect(subject.find).to eq([])
-      end
-
-      it "is empty if there aren't any license files" do
-        expect(files_in('not/a/dir')).to eq([])
-      end
-
-      it "includes files with names like LICENSE, README or COPYING" do
-        expect(files_in('license_names')).to match_array(
-        %w[COPYING.txt LICENSE Mit-License README.rdoc Licence.rdoc]
-        )
-      end
-
-      it "includes files deep in the hierarchy" do
-        expect(files_in('nested_gem')).to eq(['vendor/LICENSE'])
-      end
-
-      it "includes files nested inside LICENSE directory" do
-        expect(files_in('license_directory')).to match_array(%w[
-          COPYING
-          LICENSE/MIT.txt
-        ])
-      end
-
-      it "handles non UTF8 encodings" do
-        expect { files_in('utf8_gem') }.not_to raise_error
-      end
-    end
-  end
-end