license_finder 1.2 → 2.0.0.rc2

data/lib/license_finder/cli/approvals.rb

@@ -0,0 +1,26 @@
+module LicenseFinder
+  module CLI
+    class Approvals < Base
+      extend Subcommand
+      include MakesDecisions
+
+      auditable
+      desc "add DEPENDENCY...", "Approve one or more dependencies by name"
+      def add(name, *other_names)
+        names = modify_each(name, *other_names) do |name|
+          decisions.approve(name, txn)
+        end
+
+        say "The #{names.join(", ")} dependency has been approved!", :green
+      end
+
+      auditable
+      desc "remove DEPENDENCY", "Unapprove a dependency"
+      def remove(dep)
+        modifying { decisions.unapprove(dep, txn) }
+
+        say "The dependency #{dep} no longer has a manual approval"
+      end
+    end
+  end
+end

data/lib/license_finder/cli/base.rb

@@ -0,0 +1,20 @@
+module LicenseFinder
+  module CLI
+    class Base < Thor
+      class_option :decisions_file, desc: "Where decisions are saved. Defaults to doc/dependency_decisions.yml."
+
+      no_commands do
+        def decisions
+          @decisions ||= Decisions.saved!(config.decisions_file)
+        end
+      end
+
+      private
+
+      def config
+        @config ||= Configuration.with_optional_saved_config(options)
+      end
+    end
+  end
+end
+

data/lib/license_finder/cli/dependencies.rb

@@ -0,0 +1,39 @@
+module LicenseFinder
+  module CLI
+    class Dependencies < Base
+      extend Subcommand
+      include MakesDecisions
+
+      method_option :approve, type: :boolean, desc: "Approve the added dependency"
+      auditable
+      desc "add DEPENDENCY LICENSE [VERSION] [--approve]", "Add a dependency that is not managed by a package manager, optionally approving it at the same time"
+      def add(name, license, version = nil)
+        modifying {
+          decisions.
+            add_package(name, version, txn).
+            license(name, license, txn)
+          decisions.approve(name, txn) if options[:approve]
+        }
+        if options[:approve]
+          say "The #{name} dependency has been added and approved!", :green
+        else
+          say "The #{name} dependency has been added!", :green
+        end
+      end
+
+      auditable
+      desc "remove DEPENDENCY", "Remove a dependency that is not managed by a package manager"
+      def remove(name)
+        modifying { decisions.remove_package(name, txn) }
+
+        say "The #{name} dependency has been removed.", :green
+      end
+
+      desc "list", "List manually added dependencies"
+      def list
+        say "Manually Added Dependencies:", :blue
+        say_each(decisions.packages) { |package| package.name }
+      end
+    end
+  end
+end

data/lib/license_finder/cli/ignored_dependencies.rb

@@ -0,0 +1,30 @@
+module LicenseFinder
+  module CLI
+    class IgnoredDependencies < Base
+      extend Subcommand
+      include MakesDecisions
+
+      desc "list", "List all the ignored dependencies"
+      def list
+        say "Ignored Dependencies:", :blue
+        say_each(decisions.ignored)
+      end
+
+      auditable
+      desc "add DEPENDENCY", "Add a dependency to be ignored"
+      def add(dep)
+        modifying { decisions.ignore(dep, txn) }
+
+        say "Added #{dep} to the ignored dependencies"
+      end
+
+      auditable
+      desc "remove DEPENDENCY", "Remove a dependency from the ignored dependencies"
+      def remove(dep)
+        modifying { decisions.heed(dep, txn) }
+
+        say "Removed #{dep} from the ignored dependencies"
+      end
+    end
+  end
+end

data/lib/license_finder/cli/ignored_groups.rb

@@ -0,0 +1,30 @@
+module LicenseFinder
+  module CLI
+    class IgnoredGroups < Base
+      extend Subcommand
+      include MakesDecisions
+
+      desc "list", "List all the ignored groups"
+      def list
+        say "Ignored Groups:", :blue
+        say_each(decisions.ignored_groups)
+      end
+
+      auditable
+      desc "add GROUP", "Add a group to be ignored"
+      def add(group)
+        modifying { decisions.ignore_group(group, txn) }
+
+        say "Added #{group} to the ignored groups"
+      end
+
+      auditable
+      desc "remove GROUP", "Remove a group from the ignored groups"
+      def remove(group)
+        modifying { decisions.heed_group(group, txn) }
+
+        say "Removed #{group} from the ignored groups"
+      end
+    end
+  end
+end

data/lib/license_finder/cli/licenses.rb

@@ -0,0 +1,24 @@
+module LicenseFinder
+  module CLI
+    class Licenses < Base
+      extend Subcommand
+      include MakesDecisions
+
+      auditable
+      desc "add DEPENDENCY LICENSE", "Set a dependency's licenses, overwriting any license_finder has found"
+      def add(name, license)
+        modifying { decisions.license(name, license, txn) }
+
+        say "The #{name} dependency has been marked as using #{license} license!", :green
+      end
+
+      auditable
+      desc "remove DEPENDENCY LICENSE", "Remove a manually set license"
+      def remove(dep, lic)
+        modifying { decisions.unlicense(dep, lic, txn) }
+
+        say "The dependency #{dep} no longer has a manual license"
+      end
+    end
+  end
+end

data/lib/license_finder/cli/main.rb

@@ -0,0 +1,82 @@
+module LicenseFinder
+  module CLI
+    class Main < Base
+      extend Rootcommand
+
+      FORMATS = {
+        'text' => TextReport,
+        'html' => HtmlReport,
+        'markdown' => MarkdownReport,
+        'csv' => CsvReport
+      }
+
+      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'."
+
+      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 = decision_applier.unapproved
+
+        if unapproved.empty?
+          say "All dependencies are approved for use", :green
+        else
+          say "Dependencies that need approval:", :red
+          say report_of(unapproved)
+          exit 1
+        end
+      end
+
+      default_task :action_items
+
+      desc "report", "Print a report of the project's dependencies to stdout"
+      def report
+        dependencies = decision_applier(Logger.new(quiet: true))
+        say report_of(dependencies.acknowledged)
+      end
+
+      desc "version", "Print the version of LicenseFinder"
+      def version
+        puts LicenseFinder::VERSION
+      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 "project_name", ProjectName, "Set the project name, for display in reports"
+
+      private
+
+      # The core of the system. The saved decisions are applied to the current
+      # packages.
+      def decision_applier(logger = Logger.new(options))
+        DecisionApplier.new(
+          decisions: decisions,
+          packages: current_packages(logger)
+        )
+      end
+
+      def current_packages(logger)
+        PackageManager.current_packages(
+          logger: logger,
+          gradle_command: config.gradle_command,
+          ignore_groups: decisions.ignored_groups
+        )
+      end
+
+      def report_of(content)
+        report = FORMATS[options[:format]]
+        report.of(content, columns: options[:columns], project_name: fetch_project_name)
+      end
+
+      def fetch_project_name
+        decisions.project_name || Pathname.pwd.basename.to_s
+      end
+    end
+  end
+end

data/lib/license_finder/cli/makes_decisions.rb

@@ -0,0 +1,48 @@
+module LicenseFinder
+  module CLI
+    module MakesDecisions
+      def self.included(mod)
+        mod.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def auditable
+          method_option :who, desc: "The person making this decision"
+          method_option :why, desc: "The reason for making this decision"
+        end
+      end
+
+      private
+
+      def say_each(coll)
+        if coll.any?
+          coll.each do |item|
+            say(block_given? ? yield(item) : item)
+          end
+        else
+          say '(none)'
+        end
+      end
+
+      def txn
+        @txn ||= {
+          who: options[:who],
+          why: options[:why],
+          when: Time.now.getutc
+        }
+      end
+
+      def modifying
+        # decisions = Decisions.saved! # is part of Base
+        yield
+        decisions.save!(config.decisions_file)
+      end
+
+      def modify_each(*things)
+        modifying { things.each { |thing| yield thing } }
+        things
+      end
+    end
+  end
+end
+

data/lib/license_finder/cli/patched_thor.rb

@@ -0,0 +1,34 @@
+require 'thor'
+
+module LicenseFinder
+  module CLI
+    module Rootcommand
+      # Helper to auto-generate the documentation for a group of commands
+      def subcommand(namespace, klass, namespace_description)
+        description = "#{namespace} [#{(klass.tasks.keys - ["help"]).join("|")}]"
+        desc description, "#{namespace_description} - see `license_finder #{namespace} help` for more information"
+        super namespace, klass
+      end
+    end
+
+    # Thor fix for `license_finder <subcommand> help <action>`
+    module Subcommand
+      # Hack to override the help message produced by Thor.
+      # https://github.com/wycats/thor/issues/261#issuecomment-16880836
+      def banner(command, namespace = nil, subcommand = nil)
+        "#{basename} #{underscore_name(name)} #{command.usage}"
+      end
+
+      protected
+
+      def underscore_name(name)
+        underscored = name.split("::").last
+        underscored.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        underscored.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        underscored.tr!("-", "_")
+        underscored.downcase
+      end
+    end
+  end
+end
+

data/lib/license_finder/cli/project_name.rb

@@ -0,0 +1,31 @@
+module LicenseFinder
+  module CLI
+    class ProjectName < Base
+      extend Subcommand
+      include MakesDecisions
+
+      desc "show", "Show the project name"
+      def show
+        say "Project Name:", :blue
+        say decisions.project_name
+      end
+
+      auditable
+      desc "add NAME", "Set the project name"
+      def add(name)
+        modifying { decisions.name_project(name, txn) }
+
+        say "Set the project name to #{name}", :green
+      end
+
+      auditable
+      desc "remove", "Remove the project name"
+      def remove
+        modifying { decisions.unname_project(txn) }
+
+        say "Removed the project name"
+      end
+    end
+  end
+end
+

data/lib/license_finder/cli/whitelist.rb

@@ -0,0 +1,32 @@
+module LicenseFinder
+  module CLI
+    class Whitelist < Base
+      extend Subcommand
+      include MakesDecisions
+
+      desc "list", "List all the whitelisted licenses"
+      def list
+        say "Whitelisted Licenses:", :blue
+        say_each(decisions.whitelisted) { |license| license.name }
+      end
+
+      auditable
+      desc "add LICENSE...", "Add one or more licenses to the whitelist"
+      def add(license, *other_licenses)
+        licenses = modify_each(license, *other_licenses) do |l|
+          decisions.whitelist(l, txn)
+        end
+        say "Added #{licenses.join(", ")} to the license whitelist"
+      end
+
+      auditable
+      desc "remove LICENSE...", "Remove one or more licenses from the whitelist"
+      def remove(license, *other_licenses)
+        licenses = modify_each(license, *other_licenses) do |l|
+          decisions.unwhitelist(l, txn)
+        end
+        say "Removed #{licenses.join(", ")} from the license whitelist"
+      end
+    end
+  end
+end

data/lib/license_finder/configuration.rb

@@ -1,160 +1,29 @@
-require "delegate"
-
 module LicenseFinder
   class Configuration
-    def self.ensure_default
-      Persistence.init
-      prepare(Persistence.get)
+    def self.with_optional_saved_config(primary_config, project_path = Pathname.new('.'))
+      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
 
-    def last_modified
-      Persistence.last_modified
+    def initialize(primary_config, saved_config)
+      @primary_config = primary_config
+      @saved_config = saved_config
     end
 
-    def self.move!
-      config = prepare(Persistence.get.merge('dependencies_file_dir' => './doc/'))
-      config.save
-
-      FileUtils.mv(Dir["dependencies*"], config.artifacts.dir)
+    def gradle_command
+      get(:gradle_command) || "gradle"
     end
 
-    # It's nice to keep destructive file system manipulation out of the
-    # initializer.  That reduces test polution, but is slightly inconvenient
-    # for methods like Configuration.ensure_default and Configuration.move!,
-    # which need a working artifacts directory. This helper is a compromise.
-    def self.prepare(config)
-      result = new(config)
-      result.artifacts.init
-      result
-    end
-
-    attr_accessor :whitelist, :ignore_groups, :ignore_dependencies, :artifacts, :project_name, :gradle_command
-
-    def initialize(config)
-      @whitelist     = Array(config['whitelist'])
-      @ignore_groups = Array(config["ignore_groups"])
-      @ignore_dependencies = Array(config["ignore_dependencies"])
-      @artifacts     = Artifacts.new(Pathname(config['dependencies_file_dir'] || './doc/'))
-      @project_name  = config['project_name'] || determine_project_name
-      @gradle_command = config['gradle_command'] || 'gradle'
-    end
-
-    def save
-      Persistence.set(to_hash)
+    def decisions_file
+      file_name = get(:decisions_file) || "doc/dependency_decisions.yml"
+      Pathname(file_name)
     end
 
     private
 
-    def to_hash
-      {
-        'whitelist' => whitelist.uniq,
-        'ignore_groups' => ignore_groups.uniq,
-        'ignore_dependencies' => ignore_dependencies.uniq,
-        'dependencies_file_dir' => artifacts.dir.to_s,
-        'project_name' => project_name,
-        'gradle_command' => gradle_command
-      }
-    end
-
-    def determine_project_name
-      Pathname.pwd.basename.to_s
-    end
-
-    class Artifacts < SimpleDelegator
-      def init
-        mkpath
-      end
-
-      def dir
-        __getobj__
-      end
-
-      def database_uri
-        URI.escape(database_file.expand_path.to_s)
-      end
-
-      def database_file
-        join("dependencies.db")
-      end
-
-      def text_file
-        join("dependencies.csv")
-      end
-
-      def detailed_text_file
-        join("dependencies_detailed.csv")
-      end
-
-      def html_file
-        join("dependencies.html")
-      end
-
-      def markdown_file
-        join("dependencies.md")
-      end
-
-      def legacy_yaml_file
-        join("dependencies.yml")
-      end
-
-      def legacy_text_file
-        join("dependencies.txt")
-      end
-
-      def last_refreshed
-        [
-          database_file,
-          text_file,
-          detailed_text_file,
-          html_file,
-          markdown_file
-        ].map(&:mtime).min
-      end
-    end
-
-    module Persistence
-      extend self
-
-      def init
-        init! unless inited?
-      end
-
-      def get
-        return {} unless inited?
-
-        YAML.load(file.read)
-      end
-
-      def set(hash)
-        file.open('w') { |f| f.write(YAML.dump(hash)) }
-      end
-
-      def last_modified
-        file.mtime
-      end
-
-      private
-
-      def inited?
-        file.exist?
-      end
-
-      def init!
-        file_dir.mkpath
-        FileUtils.cp(file_template, file)
-      end
-
-      def file_dir
-        Pathname.new('.').join('config')
-      end
-
-      def file
-        file_dir.join('license_finder.yml')
-      end
-
-      def file_template
-        ROOT_PATH.join('data', 'license_finder.example.yml')
-      end
+    def get(key)
+      @primary_config[key.to_sym] || @saved_config[key.to_s]
     end
   end
 end