license_finder 2.0.4 → 2.1.0.rc1

data/lib/license_finder/diff.rb

@@ -0,0 +1,47 @@
+module LicenseFinder
+  class Diff
+    def self.compare(f1, f2)
+      p1 = Set.new(build_packages(f1))
+      p2 = Set.new(build_packages(f2))
+
+      added = p2.difference(p1).to_a
+      removed = p1.difference(p2).to_a
+      unchanged = p1.intersection(p2).to_a
+
+      [].tap do |packages|
+        unchanged.each do |package|
+          package_previous = package_with_name(p1, package)
+          package_current = package_with_name(p2, package)
+
+          if package_current.licenses == package_previous.licenses
+            packages << PackageDelta.unchanged(package_current, package_previous)
+          else
+            packages << PackageDelta.removed(package_previous)
+            packages << PackageDelta.added(package_current)
+          end
+        end
+
+        added.each    { |package| packages << PackageDelta.added(package) }
+        removed.each  { |package| packages << PackageDelta.removed(package) }
+      end
+    end
+
+    private
+
+    def self.build_packages(content)
+      CSV.parse(content).map do |row|
+        row.map!(&:strip)
+        package = Package.new(row[0], row[1], spec_licenses: [row[2]])
+        if row.count == 4
+          MergedPackage.new(package, row[3].split(','))
+        else
+          package
+        end
+      end
+    end
+
+    def self.package_with_name(set, package)
+      set.find { |p| p.name == package.name }
+    end
+  end
+end

data/lib/license_finder/license_aggregator.rb

@@ -0,0 +1,25 @@
+module LicenseFinder
+  class LicenseAggregator
+    def initialize(license_finder_config, subprojects)
+      @license_finder_config = license_finder_config
+      @subprojects = subprojects
+    end
+
+    def dependencies
+      aggregate_packages
+        .group_by { |package| [package.name, package.version] }
+        .map do |_, packages|
+          MergedPackage.new(packages[0].dependency, packages.flat_map(&:subproject_paths))
+        end
+    end
+
+    private
+
+    def aggregate_packages
+      @subprojects.flat_map do |project_path|
+        finder = LicenseFinder::Core.new(@license_finder_config.merge(project_path: project_path))
+        finder.acknowledged.map { |dep| MergedPackage.new(dep, [project_path]) }
+      end
+    end
+  end
+end

data/lib/license_finder/package.rb

@@ -32,8 +32,10 @@ module LicenseFinder
     def initialize(name, version = nil, options={})
       @logger = options[:logger] || Core.default_logger
 
+      ## DESCRIPTION
       @name = name
       @version = version
+      @authors = options[:authors] || ""
       @summary = options[:summary] || ""
       @description = options[:description] || ""
       @homepage = options[:homepage] || ""
@@ -43,6 +45,7 @@ module LicenseFinder
 
       ## APPROVAL
       @whitelisted = false
+      @blacklisted = false
       @manual_approval = nil
 
       ## LICENSING
@@ -52,7 +55,9 @@ module LicenseFinder
       @decided_licenses = Set.new
     end
 
-    attr_reader :name, :version,
+    ## DESCRIPTION
+
+    attr_reader :name, :version, :authors,
                 :summary, :description, :homepage,
                 :children, :parents, :groups
 
@@ -62,24 +67,49 @@ module LicenseFinder
       @manual_approval = approval
     end
 
-    def whitelisted!
-      @whitelisted = true
+    def approved_manually?
+      !@manual_approval.nil?
     end
 
     def approved?
-      approved_manually? || whitelisted?
+      # Question: is `!blacklisted?` redundant?
+      # DecisionApplier does not call `whitelisted!` or `approved_manually!`
+      # if a Package has been blacklisted.
+      (approved_manually? || whitelisted?) && !blacklisted?
     end
 
-    def approved_manually?
-      !@manual_approval.nil?
+    def whitelisted!
+      @whitelisted = true
     end
 
     def whitelisted?
       @whitelisted
     end
 
+    def blacklisted!
+      @blacklisted = true
+    end
+
+    def blacklisted?
+      @blacklisted
+    end
+
     attr_reader :manual_approval
 
+    ## EQUALITY
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    def eql?(other)
+      name == other.name
+    end
+
+    def hash
+      [name].hash
+    end
+
     ## LICENSING
 
     attr_reader :license_names_from_spec # stubbed in tests, otherwise private
@@ -121,6 +151,7 @@ end
 
 require 'license_finder/packages/manual_package'
 require 'license_finder/package_managers/bower_package'
+require 'license_finder/package_managers/go_package'
 require 'license_finder/package_managers/bundler_package'
 require 'license_finder/package_managers/pip_package'
 require 'license_finder/package_managers/npm_package'
@@ -128,3 +159,5 @@ require 'license_finder/package_managers/maven_package'
 require 'license_finder/package_managers/gradle_package'
 require 'license_finder/package_managers/cocoa_pods_package'
 require 'license_finder/package_managers/rebar_package'
+require 'license_finder/package_managers/merged_package'
+require 'license_finder/package_managers/nuget_package'

data/lib/license_finder/package_delta.rb

@@ -0,0 +1,65 @@
+module LicenseFinder
+  class PackageDelta
+    STATUSES = [:added, :removed, :unchanged]
+
+    def initialize(status, current_package, previous_package)
+      @status = status
+      @current_package = current_package
+      @previous_package = previous_package
+    end
+
+    def name
+      pick_package.name
+    end
+
+    def current_version
+      @current_package ? @current_package.version : nil
+    end
+
+    def previous_version
+      @previous_package ? @previous_package.version : nil
+    end
+
+    def subproject_paths
+      pick_package.subproject_paths
+    end
+
+    def status
+      @status
+    end
+
+    def licenses
+      pick_package.licenses
+    end
+
+    def merged_package?
+      pick_package.class == MergedPackage
+    end
+
+    def method_missing(method_name)
+      nil
+    end
+
+    def self.added(package)
+      new(:added, package, nil)
+    end
+
+    def self.removed(package)
+      new(:removed, nil, package)
+    end
+
+    def self.unchanged(current_package, previous_package)
+      new(:unchanged, current_package, previous_package)
+    end
+
+    def <=>(other)
+      STATUSES.index(status) <=> STATUSES.index(other.status)
+    end
+
+    private
+
+    def pick_package
+      @current_package ? @current_package : @previous_package
+    end
+  end
+end

data/lib/license_finder/package_manager.rb

@@ -13,14 +13,14 @@ module LicenseFinder
   #
   class PackageManager
     def self.package_managers
-      [Bundler, NPM, Pip, Bower, Maven, Gradle, CocoaPods, Rebar]
+      [GoDep, GoWorkspace, Bundler, NPM, Pip, Bower, Maven, Gradle, CocoaPods, Rebar, Nuget]
     end
 
     def self.current_packages(options)
-      package_managers
+      active_package_managers = package_managers
         .map { |pm| pm.new(options) }
         .select(&:active?)
-        .flat_map(&:current_packages_with_relations)
+      active_package_managers.flat_map(&:current_packages_with_relations)
     end
 
     def initialize options={}
@@ -33,6 +33,10 @@ module LicenseFinder
         .tap { |is_active| logger.active self.class, is_active }
     end
 
+    def capture(command)
+      [`#{command}`, $?.success?]
+    end
+
     def current_packages_with_relations
       packages = current_packages
       packages.each do |parent|
@@ -51,6 +55,8 @@ module LicenseFinder
 end
 
 require 'license_finder/package_managers/bower'
+require 'license_finder/package_managers/go_workspace'
+require 'license_finder/package_managers/go_dep'
 require 'license_finder/package_managers/bundler'
 require 'license_finder/package_managers/npm'
 require 'license_finder/package_managers/pip'
@@ -58,5 +64,6 @@ require 'license_finder/package_managers/maven'
 require 'license_finder/package_managers/cocoa_pods'
 require 'license_finder/package_managers/gradle'
 require 'license_finder/package_managers/rebar'
+require 'license_finder/package_managers/nuget'
 
 require 'license_finder/package'

data/lib/license_finder/package_managers/bower.rb

@@ -11,7 +11,9 @@ module LicenseFinder
     private
 
     def bower_output
-      output = `bower list --json -l action`
+      command = 'bower list --json -l action'
+      output, success = Dir.chdir(project_path) { capture(command) }
+      raise "Command '#{command}' failed to execute: #{output}" unless success
 
       JSON(output)
         .fetch("dependencies", {})

data/lib/license_finder/package_managers/bundler.rb

@@ -10,9 +10,8 @@ module LicenseFinder
 
     def current_packages
       logger.log self.class, "including groups #{included_groups.inspect}"
-      definition.specs_for(included_groups).map do |gem_def|
-        bundler_def = bundler_defs.detect { |bundler_def| bundler_def.name == gem_def.name }
-        BundlerPackage.new(gem_def, bundler_def, logger: logger).tap do |package|
+      details.map do |gem_detail, bundle_detail|
+        BundlerPackage.new(gem_detail, bundle_detail, logger: logger).tap do |package|
           logger.package self.class, package
         end
       end
@@ -27,21 +26,31 @@ module LicenseFinder
       @definition ||= ::Bundler::Definition.build(package_path, lockfile_path, nil)
     end
 
-    def package_path
-      project_path.join("Gemfile")
+    def details
+      gem_details.map do |gem_detail|
+        bundle_detail = bundler_details.detect { |bundle_detail| bundle_detail.name == gem_detail.name }
+        [gem_detail, bundle_detail]
+      end
+    end
+
+    def gem_details
+      @gem_details ||= definition.specs_for(included_groups)
     end
 
-    def bundler_defs
-      # memoized
-      @bundler_defs ||= definition.dependencies
+    def bundler_details
+      @bundler_details ||= definition.dependencies
     end
 
     def included_groups
       definition.groups - ignore_groups.map(&:to_sym)
     end
 
+    def package_path
+      project_path.join("Gemfile")
+    end
+
     def lockfile_path
-      package_path.dirname.join('Gemfile.lock')
+      project_path.join('Gemfile.lock')
     end
   end
 end

data/lib/license_finder/package_managers/bundler_package.rb

@@ -1,15 +1,19 @@
 module LicenseFinder
   class BundlerPackage < Package
     def initialize(spec, bundler_def, options={})
+      children = spec.dependencies.map(&:name)
+      groups = Array(bundler_def && bundler_def.groups).map(&:to_s)
+
       super(
         spec.name,
         spec.version.to_s,
         options.merge(
+          authors: Array(spec.authors).join(', '),
           summary: spec.summary,
           description: spec.description,
           homepage: spec.homepage,
-          children: spec.dependencies.map(&:name),
-          groups: Array(bundler_def && bundler_def.groups),
+          children: children,
+          groups: groups,
           spec_licenses: spec.licenses,
           install_path: spec.full_gem_path
         )

data/lib/license_finder/package_managers/go_dep.rb

@@ -0,0 +1,25 @@
+require 'json'
+
+module LicenseFinder
+  class GoDep < PackageManager
+    def current_packages
+      json = JSON.parse(package_path.read)
+      json['Deps'].map { |dep| GoPackage.from_dependency(dep, install_prefix) }
+    end
+
+    def package_path
+      project_path.join('Godeps/Godeps.json')
+    end
+
+    private
+
+    def install_prefix
+      go_path = workspace_dir.exist? ? workspace_dir : Pathname(ENV['GOPATH'])
+      go_path.join('src')
+    end
+
+    def workspace_dir
+      project_path.join('Godeps/_workspace')
+    end
+  end
+end

data/lib/license_finder/package_managers/go_package.rb

@@ -0,0 +1,19 @@
+module LicenseFinder
+  class GoPackage < Package
+    def self.from_workspace(name, path)
+      LicenseFinder::Package.new(name, 'unknown', {install_path: install_path(path)})
+    end
+
+    def self.from_dependency(hash, prefix)
+      name = hash['ImportPath']
+      version = hash['Rev'][0..6]
+      LicenseFinder::Package.new(name, version, {install_path: install_path(prefix.join(name))})
+    end
+
+    private
+
+    def self.install_path(path)
+      Pathname(path).cleanpath.to_s
+    end
+  end
+end

data/lib/license_finder/package_managers/go_workspace.rb

@@ -0,0 +1,35 @@
+require 'json'
+
+module LicenseFinder
+  class GoWorkspace < PackageManager
+    def current_packages
+      package_paths.map do |package_path|
+        package_name = Pathname(package_path).relative_path_from(project_src).to_s
+        GoPackage.from_workspace(package_name, package_path)
+      end
+    end
+
+    def package_path
+      project_path.join('.envrc')
+    end
+
+    def active?
+      active = package_path.exist? && IO.read(package_path).include?('GOPATH')
+      active.tap { |is_active| logger.active self.class, is_active }
+    end
+
+    private
+
+    def project_src
+      project_path.join('src')
+    end
+
+    def package_paths
+      command = 'go list -f "{{.ImportPath}} " ./...'
+      output, success = Dir.chdir(project_path) { capture(command) }
+      raise "Command '#{command}' failed to execute: #{output}" unless success
+
+      output.gsub(/\s{2,}/, ',').split(',').map { |path| path[1..-1] }
+    end
+  end
+end