license_finder 2.0.4 → 2.1.0.rc1

data/lib/license_finder/package_managers/gradle.rb

@@ -1,33 +1,32 @@
-require "xmlsimple"
+require 'xmlsimple'
+require_relative 'gradle_dependency_finder'
 
 module LicenseFinder
   class Gradle < PackageManager
     def initialize(options={})
       super
-      @command = options[:gradle_command] || "gradle"
+      @command = options[:gradle_command] || 'gradle'
     end
 
     def current_packages
-      `#{@command} downloadLicenses`
-
-      xml = license_report.read
-
-      options = {
-        'GroupTags' => { 'dependencies' => 'dependency' }
-      }
-      dependencies = XmlSimple.xml_in(xml, options).fetch('dependency', [])
-
-      dependencies.map do |dep|
-        GradlePackage.new(dep, logger: logger)
+      command = "#{@command} downloadLicenses"
+      output, success = Dir.chdir(project_path) { capture(command) }
+      raise "Command '#{command}' failed to execute: #{output}" unless success
+
+      dependencies = GradleDependencyFinder.new(project_path).dependencies
+      packages = dependencies.flat_map do |xml_file|
+        options = {'GroupTags' => {'dependencies' => 'dependency'}}
+        contents = XmlSimple.xml_in(xml_file, options).fetch('dependency', [])
+        contents.map do |dep|
+          GradlePackage.new(dep, logger: logger)
+        end
       end
+
+      packages.uniq
     end
 
     private
 
-    def license_report
-      project_path.join('build/reports/license/dependency-license.xml')
-    end
-
     def package_path
       project_path.join('build.gradle')
     end

data/lib/license_finder/package_managers/gradle_dependency_finder.rb

@@ -0,0 +1,13 @@
+module LicenseFinder
+  class GradleDependencyFinder
+    def initialize(project_path)
+      @project_path = project_path
+    end
+
+    def dependencies
+      Pathname
+        .glob(@project_path.join('**', 'dependency-license.xml'))
+        .map(&:read)
+    end
+  end
+end

data/lib/license_finder/package_managers/gradle_package.rb

@@ -1,7 +1,12 @@
 module LicenseFinder
   class GradlePackage < Package
     def initialize(spec, options={})
-      _, name, version = spec["name"].split(":")
+      name = spec["name"]
+      if name.scan(":").size == 2
+        _, name, version = name.split(":")
+      else
+        version = "unknown"
+      end
       licenses = Array(spec["license"])
         .map { |l| l["name"] }
         .reject { |name| name == "No license found" }

data/lib/license_finder/package_managers/maven.rb

@@ -3,7 +3,9 @@ require "xmlsimple"
 module LicenseFinder
   class Maven < PackageManager
     def current_packages
-      `mvn license:download-licenses`
+      command = 'mvn license:download-licenses'
+      output, success = Dir.chdir(project_path) { capture(command) }
+      raise "Command '#{command}' failed to execute: #{output}" unless success
 
       xml = license_report.read
 

data/lib/license_finder/package_managers/merged_package.rb

@@ -0,0 +1,43 @@
+module LicenseFinder
+  class MergedPackage
+
+    attr_reader :dependency
+
+    def initialize(dependency, subproject_paths)
+      @dependency = dependency
+      @subproject_paths = subproject_paths.map { |p| Pathname(p) }
+    end
+
+    def name
+      dependency.name
+    end
+
+    def version
+      dependency.version
+    end
+
+    def licenses
+      dependency.licenses
+    end
+
+    def subproject_paths
+      @subproject_paths.map { |p| p.expand_path.to_s }
+    end
+
+    def <=>(other)
+      dependency <=> other.dependency
+    end
+
+    def eql?(other)
+      dependency.eql?(other.dependency)
+    end
+
+    def hash
+      dependency.hash
+    end
+
+    def method_missing(method_name)
+      nil
+    end
+  end
+end

data/lib/license_finder/package_managers/npm.rb

@@ -5,22 +5,46 @@ module LicenseFinder
     DEPENDENCY_GROUPS = ["dependencies", "devDependencies"]
 
     def current_packages
-      json = npm_json
-      dependencies = DEPENDENCY_GROUPS
-        .map { |g| (json[g] || {}).values }
-        .flatten(1)
-        .reject{ |d| d.is_a?(String) }
-
-      pkgs = {} # name => spec
-      dependencies.each { |d| recursive_dependencies(d, pkgs) }
-      pkgs.values.map { |d| NpmPackage.new(d, logger: logger) }
+      packages = {}
+      direct_dependencies.each do |dep|
+        group_name = dep[:group]
+        walk_dependency_tree(dep[:name]) do |dependency|
+          package_id = dependency["name"]
+          packages[package_id] ||= NpmPackage.new(dependency, logger: logger)
+          packages[package_id].groups << group_name unless packages[package_id].groups.include?(group_name)
+        end
+      end
+      packages.values
     end
 
     private
 
+    def direct_dependencies
+      package_json = JSON.parse(File.read(package_path))
+      DEPENDENCY_GROUPS.map do |group|
+        package_json.fetch(group, {}).keys.map do |dependency|
+          {
+            group: group,
+            name: dependency
+          }
+        end
+      end.flatten
+    end
+
+    def walk_dependency_tree(dependency, &block)
+      @json ||= npm_json
+      deps = @json.fetch("dependencies", {}).reject { |_,d| d.is_a?(String) }
+      current_dep = deps[dependency]
+      block.call(current_dep) if current_dep
+      recursive_dependencies(current_dep) do |d|
+        block.call(d)
+      end
+    end
+
     def npm_json
-      command = "npm list --json --long"
-      output, success = capture(command)
+      command = 'npm list --json --long'
+      output, success = Dir.chdir(project_path) { capture(command) }
+
       if success
         json = JSON(output)
       else
@@ -30,32 +54,26 @@ module LicenseFinder
                  nil
                end
         if json
-          $stderr.puts "Command #{command} returned error but parsing succeeded."
+          $stderr.puts "Command '#{command}' returned an error but parsing succeeded."
         else
-          raise "Command #{command} failed to execute: #{output}"
+          raise "Command '#{command}' failed to execute: #{output}"
         end
       end
-      json
-    end
 
-    def capture(command)
-      [`#{command}`, $?.success?]
+      json
     end
 
     def package_path
       project_path.join('package.json')
     end
 
-    # node_module can be empty hash if it is included elsewhere
-    def recursive_dependencies(node_module, memo)
-      key = node_module['name']
-      memo[key] ||= {}
-      memo[key].merge!(node_module)
+    def recursive_dependencies(node_module, &block)
+      return unless node_module # node_module can be empty hash if it is included elsewhere
+      block.call(node_module)
       node_module.fetch('dependencies', {}).each do |dep_key, data|
         data['name'] ||= dep_key
-        recursive_dependencies(data, memo)
+        recursive_dependencies(data, &block)
       end
-      memo
     end
   end
 end

data/lib/license_finder/package_managers/nuget.rb

@@ -0,0 +1,50 @@
+require "rexml/document"
+
+module LicenseFinder
+  class Nuget < PackageManager
+    def package_path
+      project_path.join('packages')
+    end
+
+    def assemblies
+      Dir[project_path.join("**", "packages.config")].map do |d|
+        path = Pathname.new(d).dirname
+        name = path.basename.to_s
+        Assembly.new path, name
+      end
+    end
+
+    def current_packages
+      dependencies.reduce({}) do |memo, dep|
+        memo[dep.name] ||= NugetPackage.new(dep.name, dep.version)
+        memo[dep.name].groups << dep.assembly if !memo[dep.name].groups.include? dep.assembly
+        memo
+      end.values
+    end
+
+    def dependencies
+      assemblies.flat_map(&:dependencies)
+    end
+
+    class Assembly
+      attr_reader :name, :path
+      def initialize(path, name)
+        @path = path
+        @name = name
+      end
+
+      def dependencies
+        xml = REXML::Document.new(File.read(path.join("packages.config")))
+        packages = REXML::XPath.match(xml, "//package")
+        packages.map do |p|
+          attrs = p.attributes
+          Dependency.new(attrs["id"], attrs["version"], self.name)
+        end
+      end
+    end
+
+    class Dependency < Struct.new(:name, :version, :assembly)
+    end
+  end
+end
+

data/lib/license_finder/package_managers/nuget_package.rb

@@ -0,0 +1,4 @@
+module LicenseFinder
+  class NugetPackage < Package
+  end
+end

data/lib/license_finder/package_managers/pip_package.rb

@@ -19,6 +19,7 @@ module LicenseFinder
         name,
         version,
         options.merge(
+          authors: spec["author"],
           summary: spec["summary"],
           description: spec["description"],
           homepage: spec["home_page"],

data/lib/license_finder/package_managers/rebar.rb

@@ -22,8 +22,8 @@ module LicenseFinder
 
     def rebar_ouput
       command = "#{@command} list-deps"
-      output, success = capture(command)
-      raise "Command #{command} failed to execute: #{output}" unless success
+      output, success = Dir.chdir(project_path) { capture(command) }
+      raise "Command '#{command}' failed to execute: #{output}" unless success
 
       output
         .each_line
@@ -31,10 +31,6 @@ module LicenseFinder
         .map { |line| line.split(" ") }
     end
 
-    def capture(command)
-      [`#{command}`, $?.success?]
-    end
-
     def package_path
       project_path.join('rebar.config')
     end

data/lib/license_finder/platform.rb

@@ -3,6 +3,9 @@ module LicenseFinder
     def self.darwin?
       RUBY_PLATFORM =~ /darwin/
     end
+
+    def self.windows?
+      RUBY_PLATFORM =~ /mswin|cygwin|mingw/
+    end
   end
 end
-

data/lib/license_finder/project_finder.rb

@@ -0,0 +1,56 @@
+module LicenseFinder
+  class ProjectFinder
+    def initialize(main_project_path)
+      @package_managers = LicenseFinder::PackageManager.package_managers
+      @main_project_path = main_project_path
+    end
+
+    def find_projects
+      project_paths = []
+      all_paths = find_all_paths
+      until all_paths.empty?
+        project_paths << collect_project_path(all_paths)
+        all_paths.shift
+      end
+      project_paths.compact
+    end
+
+    def collect_project_path(all_paths)
+      potential_project_path = all_paths.first
+      if active_project?(potential_project_path)
+        remove_nested(potential_project_path, all_paths)
+        return potential_project_path.to_s
+      end
+    end
+
+    private
+
+    def find_all_paths
+      Dir.glob("#{@main_project_path}/**/").map { |path| full_path(path) }
+    end
+
+    def remove_nested(pathname, paths)
+      return if project_root?(pathname)
+      paths.reject! { |path| nested_path?(path, pathname) }
+    end
+
+    def project_root?(pathname)
+      full_path(@main_project_path).to_s == pathname.to_s
+    end
+
+    def active_project?(project_path)
+      active_project = @package_managers.map do |pm|
+        pm.new(project_path: project_path).active?
+      end
+      active_project.include?(true)
+    end
+
+    def full_path(rel_path)
+      Pathname.new(rel_path).expand_path
+    end
+
+    def nested_path?(path, pathname)
+      (path.to_s).start_with?(pathname.to_s) && path.to_s != pathname.to_s
+    end
+  end
+end

data/lib/license_finder/report.rb

@@ -13,14 +13,15 @@ module LicenseFinder
     attr_reader :dependencies, :project_name
 
     def sorted_dependencies
-      dependencies.sort_by(&:name)
+      dependencies.sort
     end
   end
 end
 
 require 'license_finder/reports/erb_report'
-
 require 'license_finder/reports/csv_report'
 require 'license_finder/reports/text_report'
+require 'license_finder/reports/diff_report'
+require 'license_finder/reports/merged_report'
 require 'license_finder/reports/html_report'
 require 'license_finder/reports/markdown_report'

data/lib/license_finder/reports/csv_report.rb

@@ -3,12 +3,12 @@ require 'csv'
 module LicenseFinder
   class CsvReport < Report
     COMMA_SEP =  ","
-    AVAILABLE_COLUMNS = %w[name version licenses approved summary description homepage]
+    AVAILABLE_COLUMNS = %w[name version authors licenses approved summary description homepage]
     MISSING_DEPENDENCY_TEXT = "This package is not installed. Please install to determine licenses."
 
     def initialize(dependencies, options)
       super
-      @columns = Array(options[:columns]) & AVAILABLE_COLUMNS
+      @columns = Array(options[:columns]) & self.class::AVAILABLE_COLUMNS
     end
 
     def to_s
@@ -35,6 +35,10 @@ module LicenseFinder
       dep.version
     end
 
+    def format_authors(dep)
+      dep.authors.to_s.strip
+    end
+
     def format_homepage(dep)
       dep.homepage
     end

data/lib/license_finder/reports/diff_report.rb

@@ -0,0 +1,33 @@
+module LicenseFinder
+  class DiffReport < CsvReport
+    AVAILABLE_COLUMNS = AVAILABLE_COLUMNS + %w[status current_version previous_version project_paths]
+
+    def initialize(dependencies, options={})
+      super(dependencies, options.merge(columns: build_columns(dependencies)))
+    end
+
+    def format_status(dep)
+      dep.status
+    end
+
+    def format_current_version(dep)
+      dep.current_version
+    end
+
+    def format_previous_version(dep)
+      dep.previous_version
+    end
+
+    def format_project_paths(dep)
+      dep.subproject_paths.join(self.class::COMMA_SEP)
+    end
+
+    private
+
+    def build_columns(dependencies)
+      columns = %w[status name current_version previous_version licenses]
+      columns << 'project_paths' if dependencies.all? { |delta| delta.merged_package? }
+      columns
+    end
+  end
+end