license_finder 3.0.4 → 3.1.1

data/spec/lib/license_finder/package_delta_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe PackageDelta do
-    describe '#<=>' do
-      let(:foo) { Package.new('foo') }
-      let(:bar) { Package.new('bar') }
-
-      it 'sorts by status (added, removed, unchanged)' do
-        p1 = PackageDelta.added(foo)
-        p2 = PackageDelta.removed(bar)
-        p3 = PackageDelta.unchanged(foo, bar)
-
-        expect([p3, p2, p1].sort).to eq([p1, p2, p3])
-      end
-    end
-  end
-end

data/spec/lib/license_finder/package_manager_spec.rb

@@ -1,62 +0,0 @@
-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
-
-    describe "#package_management_command" do
-      it "defaults to nil" do
-        expect(LicenseFinder::PackageManager.package_management_command).to be_nil
-      end
-    end
-
-    describe ".installed?" do
-      context "package_management_command is nil" do
-        before do
-          allow(LicenseFinder::PackageManager).to receive(:package_management_command).and_return(nil)
-        end
-
-        it "returns true" do
-          expect(LicenseFinder::PackageManager.installed?).to be_truthy
-        end
-      end
-
-      context "package_management_command exists" do
-        before do
-          allow(LicenseFinder::PackageManager).to receive(:package_management_command).and_return("foobar")
-          allow(LicenseFinder::PackageManager).to receive(:command_exists?).with("foobar").and_return(true)
-        end
-
-        it "returns true" do
-          expect(LicenseFinder::PackageManager.installed?).to be_truthy
-        end
-      end
-
-      context "package_management_command does not exist" do
-        before do
-          allow(LicenseFinder::PackageManager).to receive(:package_management_command).and_return("foobar")
-          allow(LicenseFinder::PackageManager).to receive(:command_exists?).with("foobar").and_return(false)
-        end
-
-        it "returns false" do
-          expect(LicenseFinder::PackageManager.installed?).to be_falsey
-        end
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe BowerPackage do
-    subject do
-      described_class.new(
-        "canonicalDir" => "/path/to/thing",
-        "pkgMeta" => {
-          "name" => "dependency-library",
-          "description" => "description",
-          "version" => "1.3.3.7",
-          "readme" => "some readme stuff",
-          "homepage" => "homepage"
-        }
-      )
-    end
-
-    its(:name) { should == "dependency-library" }
-    its(:version) { should == "1.3.3.7" }
-    its(:summary) { should == "description" }
-    its(:description) { should == "some readme stuff" }
-    its(:homepage) { should == "homepage" }
-    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" }
-    its(:package_manager) { should eq 'Bower' }
-
-    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
-
-      it 'reports itself as missing' do
-        expect(subject).to be_missing
-      end
-    end
-
-    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 all license structures' do
-        package = BowerPackage.new(package1)
-        expect(package.license_names_from_spec).to eq ["MIT"]
-
-        package = BowerPackage.new(package2)
-        expect(package.license_names_from_spec).to eq ["BSD"]
-
-        package = BowerPackage.new(package3)
-        expect(package.license_names_from_spec).to eq ["PSF"]
-
-        package = BowerPackage.new(package4)
-        expect(package.license_names_from_spec).to eq ["MIT"]
-      end
-    end
-  end
-end
-

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

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe Bower do
-    subject { Bower.new(project_path: Pathname('/fake/path')) }
-
-    it_behaves_like 'a PackageManager'
-
-    describe '.current_packages' do
-      it 'lists all the current packages' do
-        json = <<-JSON
-          {
-            "dependencies": {
-              "dependency-library": {
-                "canonicalDir": "/path/to/thing",
-                "pkgMeta": {
-                  "name": "dependency-library"
-                }
-              },
-              "another-dependency": {
-                "canonicalDir": "/path/to/thing2",
-                "pkgMeta": {
-                  "name": "another-dependency"
-                }
-              }
-            }
-          }
-        JSON
-
-        allow(Dir).to receive(:chdir).with(Pathname('/fake/path')) { |&block| block.call }
-        allow(subject).to receive(:capture).with('bower list --json -l action --allow-root').and_return([json, true])
-
-        expect(subject.current_packages.map { |p| [p.name, p.install_path] }).to eq [
-          %w(dependency-library /path/to/thing), %w(another-dependency /path/to/thing2)
-        ]
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe BundlerPackage do
-    subject { described_class.new(gemspec, bundler_dependency) }
-
-    let(:gemspec) do
-      Gem::Specification.new do |s|
-        s.name = 'spec_name'
-        s.version = '2.1.3'
-        s.authors = ['first', 'second']
-        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: [:staging, :assets]) }
-
-    its(:name) { should == 'spec_name' }
-    its(:version) { should == '2.1.3' }
-    its(:authors) { should == 'first, second' }
-    its(:summary) { should == "summary" }
-    its(:description) { should == "description" }
-    its(:homepage) { should == "homepage" }
-    its(:groups) { should == %w[staging assets] }
-    its(:children) { should == ['foo'] }
-    its(:license_names_from_spec) { should eq ['MIT', 'GPL'] }
-    its(:install_path) { should =~ /spec_name-2\.1\.3\z/ }
-    its(:package_manager) { should == "Bundler" }
-  end
-end

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

@@ -1,56 +0,0 @@
-require "spec_helper"
-
-module LicenseFinder
-  describe Bundler do
-    it_behaves_like "a PackageManager"
-
-    let(:definition) do
-      double('definition', {
-        :dependencies => [],
-        :groups => [:dev, :production],
-        :specs_for => [
-          build_gemspec('gem1', '1.2.3'),
-          build_gemspec('gem2', '0.4.2')
-        ]
-      })
-    end
-
-    def build_gemspec(name, version, dependency=nil)
-      Gem::Specification.new do |s|
-        s.name = name
-        s.version = version
-        s.summary = 'summary'
-        s.description = 'description'
-
-        if dependency
-          s.add_dependency dependency
-        end
-      end
-    end
-
-    describe '.current_packages' do
-      subject do
-        Bundler.new(ignored_groups: ['dev', 'test'], definition: definition).current_packages
-      end
-
-      it "should have 2 dependencies" do
-        expect(subject.size).to eq(2)
-      end
-
-      context "when initialized with a parent and child gem" do
-        before do
-          allow(definition).to receive(:specs_for).with([:production]).and_return([
-            build_gemspec('gem1', '1.2.3', 'gem2'),
-            build_gemspec('gem2', '0.4.2', 'gem3')
-          ])
-        end
-
-        it "should update the child dependency with its parent data" do
-          gem1 = subject.first
-
-          expect(gem1.children).to eq(["gem2"])
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe CocoaPodsPackage do
-    subject do
-      described_class.new("Name", "1.0.0", license_text)
-    end
-    let(:license_text) { nil }
-
-    its(:name) { should == "Name" }
-    its(:version) { should == "1.0.0" }
-    its(:summary) { should eq "" }
-    its(:description) { should eq "" }
-    its(:homepage) { should eq "" }
-    its(:groups) { should == [] }
-    its(:children) { should == [] }
-    its(:package_manager) { should eq 'CocoaPods' }
-
-    describe '#licenses' do
-      context "when there's a license" do
-        let(:license_text) { "LicenseText" }
-
-        it "returns the name of the license if the license is found be text" do
-          license = double(:license, name: "LicenseName")
-          allow(License).to receive(:find_by_text).with(license_text).and_return(license)
-
-          expect(subject.licenses.map(&:name)).to eq ["LicenseName"]
-        end
-
-        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.map(&:name)).to eq ["unknown"]
-        end
-      end
-
-      it "returns unknown when there's no license" do
-        expect(subject.licenses.map(&:name)).to eq ["unknown"]
-      end
-
-      it "respects license decisions" do
-        subject.decide_on_license(License.find_by_name("A"))
-        expect(subject.licenses.map(&:name)).to eq ["A"]
-      end
-    end
-  end
-end
-

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

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe CocoaPods do
-    let(:project_path) { fixture_path("all_pms") }
-    let(:cocoa_pods) { CocoaPods.new(project_path: project_path) }
-    it_behaves_like "a PackageManager"
-
-    def stub_acknowledgments(hash = {})
-      plist = {
-        "PreferenceSpecifiers" => [
-          {
-            "FooterText" => hash[:license],
-            "Title" => hash[:name]
-          }
-        ]
-      }
-
-      expect(cocoa_pods).to receive(:read_plist).and_return(plist)
-    end
-
-    def stub_lockfile(pods)
-      allow(YAML).to receive(:load_file)
-        .with(project_path.join("Podfile.lock"))
-        .and_return("PODS" => pods)
-    end
-
-    describe '.current_packages' do
-      it 'lists all the current packages' do
-        stub_lockfile([
-          { "ABTest (0.0.5)" => ["OpenUDID"] },
-          "JSONKit (1.5pre)",
-          "OpenUDID (1.0.0)"
-        ])
-        stub_acknowledgments
-
-        expect(cocoa_pods.current_packages.map { |p| [p.name, p.version ] }).to eq [
-          ["ABTest", "0.0.5"],
-          ["JSONKit", "1.5pre"],
-          ["OpenUDID", "1.0.0"]
-        ]
-      end
-
-      it "passes the license text to the package" do
-        stub_lockfile(["Dependency Name (1.0)"])
-        stub_acknowledgments({name: "Dependency Name", license: "The MIT License"})
-
-        expect(cocoa_pods.current_packages.first.licenses.map(&:name)).to eq ['MIT']
-      end
-
-      it "handles no licenses" do
-        stub_lockfile(["Dependency Name (1.0)"])
-        stub_acknowledgments
-
-        expect(cocoa_pods.current_packages.first.licenses.map(&:name)).to eq ['unknown']
-      end
-    end
-  end
-end

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

@@ -1,126 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe GoDep do
-    let(:options) { {} }
-    subject { GoDep.new(options.merge(project_path: Pathname('/fake/path'))) }
-
-
-    it_behaves_like 'a PackageManager'
-
-    describe '#current_packages' do
-      let(:content) do
-        '{
-          "ImportPath": "github.com/pivotal/foo",
-          "GoVersion": "go1.4.2",
-          "Deps": [
-            {
-              "ImportPath": "github.com/pivotal/foo",
-              "Rev": "61164e49940b423ba1f12ddbdf01632ac793e5e9"
-            },
-            {
-              "ImportPath": "github.com/pivotal/bar",
-              "Rev": "3245708abcdef234589450649872346783298736"
-            },
-            {
-              "ImportPath": "code.google.com/foo/bar",
-              "Rev": "3245708abcdef234589450649872346783298735"
-            }
-          ]
-        }'
-      end
-
-      before do
-        allow(IO).to receive(:read).with('/fake/path/Godeps/Godeps.json').and_return(content.to_s)
-      end
-
-      it 'sets the homepage for packages' do
-        packages = subject.current_packages
-
-        expect(packages[0].homepage).to eq("github.com/pivotal/foo")
-        expect(packages[1].homepage).to eq("github.com/pivotal/bar")
-        expect(packages[2].homepage).to eq("code.google.com/foo/bar")
-      end
-
-      context 'when dependencies are vendored' do
-        before do
-          allow(FileTest).to receive(:exist?).with('/fake/path/Godeps/_workspace').and_return(true)
-        end
-
-        it 'should return an array of packages' do
-          packages = subject.current_packages
-          expect(packages.map(&:name)).to include('github.com/pivotal/foo', 'github.com/pivotal/bar')
-          expect(packages.map(&:version)).to include('61164e4', '3245708')
-        end
-
-        it 'should set the install_path to the vendored directory' do
-          packages = subject.current_packages
-          expect(packages[0].install_path).to eq('/fake/path/Godeps/_workspace/src/github.com/pivotal/foo')
-          expect(packages[1].install_path).to eq('/fake/path/Godeps/_workspace/src/github.com/pivotal/bar')
-        end
-
-        context 'when requesting the full version' do
-          let(:options) { { go_full_version:true } }
-          it 'list the dependencies with full version' do
-            expect(subject.current_packages.map(&:version)).to eq [
-              "61164e49940b423ba1f12ddbdf01632ac793e5e9",
-              "3245708abcdef234589450649872346783298736",
-              "3245708abcdef234589450649872346783298735"]
-          end
-        end
-      end
-
-      context 'when there are duplicate dependencies' do
-        let(:content) do
-          '{
-               "ImportPath": "github.com/foo/bar",
-               "GoVersion": "go1.3",
-               "Deps": [
-                {
-                    "ImportPath": "github.com/foo/baz/sub1",
-                    "Rev": "28838aae6e8158e3695cf90e2f0ed2498b68ee1d"
-                },
-                {
-                    "ImportPath": "github.com/foo/baz/sub2",
-                    "Rev": "28838aae6e8158e3695cf90e2f0ed2498b68ee1d"
-                },
-                {
-                    "ImportPath": "github.com/foo/baz/sub3",
-                    "Rev": "28838aae6e8158e3695cf90e2f0ed2498b68ee1d"
-                }
-            ]
-          }'
-        end
-
-        it 'should return one dependency only' do
-          packages = subject.current_packages
-          expect(packages.map(&:name)).to eq(['github.com/foo/baz'])
-          expect(packages.map(&:version)).to eq(['28838aa'])
-        end
-      end
-
-      context 'when dependencies are not vendored' do
-        before do
-          @orig_gopath = ENV['GOPATH']
-          ENV['GOPATH'] = '/fake/go/path'
-        end
-
-        after do
-          ENV['GOPATH'] = @orig_gopath
-        end
-
-        it 'should return an array of packages' do
-          packages = subject.current_packages
-          expect(packages.map(&:name)).to include('github.com/pivotal/foo', 'github.com/pivotal/bar')
-          expect(packages.map(&:version)).to include('61164e4', '3245708')
-        end
-
-        it 'should set the install_path to the GOPATH' do
-          packages = subject.current_packages
-          expect(packages[0].install_path).to eq('/fake/go/path/src/github.com/pivotal/foo')
-          expect(packages[1].install_path).to eq('/fake/go/path/src/github.com/pivotal/bar')
-        end
-      end
-    end
-  end
-end