license_finder 2.0.4 → 2.1.0.rc1

data/lib/license_finder/cli.rb

@@ -9,6 +9,7 @@ require 'license_finder/cli/base'
 require 'license_finder/cli/makes_decisions'
 
 require 'license_finder/cli/whitelist'
+require 'license_finder/cli/blacklist'
 require 'license_finder/cli/dependencies'
 require 'license_finder/cli/licenses'
 require 'license_finder/cli/approvals'

data/lib/license_finder/cli/base.rb

@@ -16,12 +16,25 @@ module LicenseFinder
 
       def license_finder
         @lf ||= LicenseFinder::Core.new(license_finder_config)
+        fail "Project path '#{@lf.config.project_path}' does not exist!" unless @lf.config.valid_project_path?
+        @lf
+      end
+
+      def fail(message)
+        say message and exit 1
       end
 
       def license_finder_config
-        result = extract_options(:project_path, :decisions_file, :gradle_command, :rebar_command, :rebar_deps_dir)
-        result[:logger] = logger_config
-        result
+        extract_options(
+          :project_path,
+          :decisions_file,
+          :gradle_command,
+          :rebar_command,
+          :rebar_deps_dir,
+          :save
+        ).merge(
+          logger: logger_config
+        )
       end
 
       def logger_config

data/lib/license_finder/cli/blacklist.rb

@@ -0,0 +1,30 @@
+module LicenseFinder
+  module CLI
+    class Blacklist < Base
+      extend Subcommand
+      include MakesDecisions
+
+      desc "list", "List all the blacklisted licenses"
+      def list
+        say "Blacklisted Licenses:", :blue
+        say_each(decisions.blacklisted) { |license| license.name }
+      end
+
+      auditable
+      desc "add LICENSE...", "Add one or more licenses to the blacklist"
+      def add(*licenses)
+        assert_some licenses
+        modifying { licenses.each { |l| decisions.blacklist(l, txn) } }
+        say "Added #{licenses.join(", ")} to the license blacklist"
+      end
+
+      auditable
+      desc "remove LICENSE...", "Remove one or more licenses from the blacklist"
+      def remove(*licenses)
+        assert_some licenses
+        modifying { licenses.each { |l| decisions.unblacklist(l, txn) } }
+        say "Removed #{licenses.join(", ")} from the license blacklist"
+      end
+    end
+  end
+end

data/lib/license_finder/cli/main.rb

@@ -1,5 +1,9 @@
 require 'license_finder/report'
 require 'license_finder/version'
+require 'license_finder/diff'
+require 'license_finder/package_delta'
+require 'license_finder/license_aggregator'
+require 'license_finder/project_finder'
 
 module LicenseFinder
   module CLI
@@ -15,21 +19,35 @@ module LicenseFinder
 
       class_option :format, desc: "The desired output format.", default: 'text', enum: FORMATS.keys
       class_option :columns, type: :array, desc: "For CSV reports, which columns to print. Pick from: #{CsvReport::AVAILABLE_COLUMNS}", default: %w[name version licenses]
-      class_option :gradle_command, desc: "Command to use when fetching gradle packages. Only meaningful if used with a Java/gradle project. Defaults to 'gradle'."
+      class_option :save, desc: "Save report to a file. Default: 'license_report.csv' in project root.", lazy_default: "license_report"
+      class_option :gradle_command, desc: "Command to use when fetching gradle packages. Only meaningful if used with a Java/gradle project. Defaults to 'gradlew' / 'gradlew.bat' if the wrapper is present, otherwise to 'gradle'."
       class_option :rebar_command, desc: "Command to use when fetching rebar packages. Only meaningful if used with a Erlang/rebar project. Defaults to 'rebar'."
       class_option :rebar_deps_dir, desc: "Path to rebar dependencies directory. Only meaningful if used with a Erlang/rebar project. Defaults to 'deps'."
+      class_option :subprojects, type: :array, desc: "Generate a single report for multiple sub-projects. Ex: --subprojects='path/to/project1', 'path/to/project2'"
+      class_option :recursive, desc: "Recursively runs License Finder on all sub-projects."
 
       method_option :quiet, type: :boolean, desc: "silences progress report"
       method_option :debug, type: :boolean, desc: "emit detailed info about what LicenseFinder is doing"
       desc "action_items", "List unapproved dependencies (the default action for `license_finder`)"
+
       def action_items
         unapproved = license_finder.unapproved
+        blacklisted = license_finder.blacklisted
 
         if unapproved.empty?
           say "All dependencies are approved for use", :green
         else
-          say "Dependencies that need approval:", :red
-          say report_of(unapproved)
+          unless blacklisted.empty?
+            say "Blacklisted dependencies:", :red
+            say report_of(blacklisted)
+          end
+
+          other_unapproved = unapproved - blacklisted
+          unless other_unapproved.empty?
+            say "Dependencies that need approval:", :yellow
+            say report_of(other_unapproved)
+          end
+
           exit 1
         end
       end
@@ -37,30 +55,70 @@ module LicenseFinder
       default_task :action_items
 
       desc "report", "Print a report of the project's dependencies to stdout"
+
       def report
         logger_config[:quiet] = true
-        say report_of(license_finder.acknowledged)
+
+        subproject_paths = options[:subprojects] if subprojects?
+        subproject_paths = ProjectFinder.new(license_finder.config.project_path).find_projects if recursive?
+
+        if subproject_paths && !subproject_paths.empty?
+          finder = LicenseAggregator.new(license_finder_config, subproject_paths)
+          report = MergedReport.new(finder.dependencies)
+        else
+          report = report_of(license_finder.acknowledged)
+        end
+        save? ? save_report(report, options[:save]) : say(report)
       end
 
       desc "version", "Print the version of LicenseFinder"
+
       def version
         puts LicenseFinder::VERSION
       end
 
+      desc "diff OLDFILE NEWFILE", "Command to view the differences between two generated reports (csv)."
+
+      def diff(file1, file2)
+        f1 = IO.read(file1)
+        f2 = IO.read(file2)
+        report = DiffReport.new(Diff.compare(f1, f2))
+        save? ? save_report(report, options[:save]) : say(report)
+      end
+
       subcommand "dependencies", Dependencies, "Add or remove dependencies that your package managers are not aware of"
       subcommand "licenses", Licenses, "Set a dependency's licenses, if the licenses found by license_finder are missing or wrong"
       subcommand "approvals", Approvals, "Manually approve dependencies, even if their licenses are not whitelisted"
       subcommand "ignored_groups", IgnoredGroups, "Exclude test and development dependencies from action items and reports"
       subcommand "ignored_dependencies", IgnoredDependencies, "Exclude individual dependencies from action items and reports"
       subcommand "whitelist", Whitelist, "Automatically approve any dependency that has a whitelisted license"
+      subcommand "blacklist", Blacklist, "Forbid approval of any dependency whose licenses are all blacklisted"
       subcommand "project_name", ProjectName, "Set the project name, for display in reports"
 
       private
 
+      def save_report(content, file_name)
+        File.open(file_name, 'w') do |f|
+          f.write(content)
+        end
+      end
+
       def report_of(content)
         report = FORMATS[options[:format]]
         report.of(content, columns: options[:columns], project_name: license_finder.project_name)
       end
+
+      def save?
+        !!options[:save]
+      end
+
+      def recursive?
+        !!options[:recursive]
+      end
+
+      def subprojects?
+        !!options[:subprojects]
+      end
     end
   end
 end

data/lib/license_finder/configuration.rb

@@ -1,7 +1,10 @@
+require_relative 'platform'
+
 module LicenseFinder
   class Configuration
-    def self.with_optional_saved_config(primary_config, project_path)
-      config_file = project_path.join('config', 'license_finder.yml')
+    def self.with_optional_saved_config(primary_config)
+      project_path = Pathname(primary_config.fetch(:project_path, Pathname.pwd)).expand_path
+      config_file =  project_path.join('config', 'license_finder.yml')
       saved_config = config_file.exist? ? YAML.load(config_file.read) : {}
       new(primary_config, saved_config)
     end
@@ -11,27 +14,55 @@ module LicenseFinder
       @saved_config = saved_config
     end
 
+    def valid_project_path?
+      if get(:project_path)
+        return project_path.exist?
+      end
+      true
+    end
+
     def gradle_command
-      get(:gradle_command) || "gradle"
+      get(:gradle_command) || (
+        if Platform.windows?
+          wrapper = 'gradlew.bat'
+          gradle = 'gradle.bat'
+        else
+          wrapper = 'gradlew'
+          gradle = 'gradle'
+        end
+
+        File.exist?(wrapper) ? wrapper : gradle
+      )
     end
 
     def rebar_command
-      get(:rebar_command) || "rebar"
+      get(:rebar_command) || 'rebar'
     end
 
     def rebar_deps_dir
-      get(:rebar_deps_dir) || "deps"
+      path = get(:rebar_deps_dir) || 'deps'
+      project_path.join(path).expand_path
     end
 
-    def decisions_file
-      file_name = get(:decisions_file) || "doc/dependency_decisions.yml"
-      Pathname(file_name)
+    def decisions_file_path
+      path = get(:decisions_file) || 'doc/dependency_decisions.yml'
+      project_path.join(path).expand_path
+    end
+
+    def project_path
+      Pathname(path_prefix).expand_path
     end
 
     private
 
+    attr_reader :saved_config
+
     def get(key)
       @primary_config[key.to_sym] || @saved_config[key.to_s]
     end
+
+    def path_prefix
+      get(:project_path) || ''
+    end
   end
 end

data/lib/license_finder/core.rb

@@ -11,6 +11,8 @@ require 'forwardable'
 module LicenseFinder
   # Coordinates setup
   class Core
+    attr_reader :config
+
     def self.default_logger
       Logger::Default.new
     end
@@ -26,40 +28,41 @@ module LicenseFinder
     # }
     def initialize(options = {})
       @logger = Logger.new(options.fetch(:logger, {}))
-      @project_path = Pathname(options.fetch(:project_path, Pathname.pwd))
-      @config = Configuration.with_optional_saved_config(options, project_path)
-      @decisions = Decisions.saved!(config.decisions_file)
+      @config = Configuration.with_optional_saved_config(options)
     end
 
     def modifying
       yield
-      decisions.save!(config.decisions_file)
+      decisions.save!(config.decisions_file_path)
     end
 
     extend Forwardable
-    def_delegators :decision_applier, :acknowledged, :unapproved
-    attr_reader :decisions
+    def_delegators :decision_applier, :acknowledged, :unapproved, :blacklisted
 
     def project_name
-      decisions.project_name || project_path.basename.to_s
+      decisions.project_name || config.project_path.basename.to_s
+    end
+
+    def decisions
+      @decisions ||= Decisions.fetch_saved(config.decisions_file_path)
     end
 
     private
 
-    attr_reader :config, :logger, :project_path
+    attr_reader :logger
 
     # The core of the system. The saved decisions are applied to the current
     # packages.
     def decision_applier
       # lazy, do not move to `initialize`
-      DecisionApplier.new(decisions: decisions, packages: current_packages)
+      @applier ||= DecisionApplier.new(decisions: decisions, packages: current_packages)
     end
 
     def current_packages
       # lazy, do not move to `initialize`
       PackageManager.current_packages(
         logger: logger,
-        project_path: project_path,
+        project_path: config.project_path,
         ignore_groups: decisions.ignored_groups,
         gradle_command: config.gradle_command,
         rebar_command: config.rebar_command,

data/lib/license_finder/decision_applier.rb

@@ -2,31 +2,34 @@ module LicenseFinder
   class DecisionApplier
     def initialize(options)
       @decisions = options.fetch(:decisions)
-      @system_packages = options.fetch(:packages)
+      @acknowledged = apply_decisions(options.fetch(:packages))
     end
 
+    attr_reader :acknowledged
+
     def unapproved
       acknowledged.reject(&:approved?)
     end
 
-    def acknowledged
-      packages.reject { |package| ignored?(package) }
+    def blacklisted
+      acknowledged.select(&:blacklisted?)
     end
 
     private
 
-    attr_reader :system_packages, :decisions
+    attr_reader :decisions
 
-    def packages
-      result = decisions.packages + system_packages
-      result
+    def apply_decisions(system_packages)
+      all_packages = decisions.packages + system_packages
+      all_packages
         .map { |package| with_decided_licenses(package) }
         .map { |package| with_approval(package) }
+        .reject { |package| ignored?(package) }
     end
 
     def ignored?(package)
       decisions.ignored?(package.name) ||
-        package.groups.any? { |group| decisions.ignored_group?(group) }
+        (package.groups.any? && package.groups.all? { |group| decisions.ignored_group?(group) })
     end
 
     def with_decided_licenses(package)
@@ -37,7 +40,9 @@ module LicenseFinder
     end
 
     def with_approval(package)
-      if decisions.approved?(package.name)
+      if package.licenses.all? { |license| decisions.blacklisted?(license) }
+        package.blacklisted!
+      elsif decisions.approved?(package.name)
         package.approved_manually!(decisions.approval_of(package.name))
       elsif package.licenses.any? { |license| decisions.whitelisted?(license) }
         package.whitelisted!

data/lib/license_finder/decisions.rb

@@ -4,7 +4,7 @@ module LicenseFinder
     # READ
     ######
 
-    attr_reader :packages, :whitelisted, :ignored, :ignored_groups, :project_name
+    attr_reader :packages, :whitelisted, :blacklisted, :ignored, :ignored_groups, :project_name
 
     def licenses_of(name)
       @licenses[name]
@@ -22,6 +22,10 @@ module LicenseFinder
       @whitelisted.include?(lic)
     end
 
+    def blacklisted?(lic)
+      @blacklisted.include?(lic)
+    end
+
     def ignored?(name)
       @ignored.include?(name)
     end
@@ -46,6 +50,7 @@ module LicenseFinder
       @licenses = Hash.new { |h, k| h[k] = Set.new }
       @approvals = {}
       @whitelisted = Set.new
+      @blacklisted = Set.new
       @ignored = Set.new
       @ignored_groups = Set.new
     end
@@ -98,6 +103,18 @@ module LicenseFinder
       self
     end
 
+    def blacklist(lic, txn = {})
+      @decisions << [:blacklist, lic, txn]
+      @blacklisted << License.find_by_name(lic)
+      self
+    end
+
+    def unblacklist(lic, txn = {})
+      @decisions << [:unblacklist, lic, txn]
+      @blacklisted.delete(License.find_by_name(lic))
+      self
+    end
+
     def ignore(name, txn = {})
       @decisions << [:ignore, name, txn]
       @ignored << name
@@ -138,7 +155,7 @@ module LicenseFinder
     # PERSIST
     #########
 
-    def self.saved!(file)
+    def self.fetch_saved(file)
       restore(read!(file))
     end
 
@@ -148,10 +165,11 @@ module LicenseFinder
 
     def self.restore(persisted)
       result = new
-      if persisted
-        YAML.load(persisted).each do |action, *args|
-          result.send(action, *args)
-        end
+      return result unless persisted
+
+      actions = YAML.load(persisted)
+      (actions || []).each do |action, *args|
+        result.send(action, *args)
       end
       result
     end