license_finder 1.2 → 2.0.0.rc2

data/features/features/report/html_spec.rb

@@ -0,0 +1,50 @@
+require 'feature_helper'
+
+describe "HTML report" do
+  # As a non-technical application product owner
+  # I want license finder to generate an easy-to-understand HTML report
+  # So that I can quickly review my application dependencies and licenses
+
+  let(:user) { LicenseFinder::TestingDSL::User.new }
+
+  specify "shows basic dependency data" do
+    gem_name = "a_gem"
+    gem_group = "test"
+    gem_attributes = {
+      license:     "MIT",
+      summary:     "gem is cool",
+      description: "seriously",
+      version:     "0.0.1",
+      homepage:    "http://a_gem.github.com"
+    }
+
+    project = user.create_ruby_app
+    gem = user.create_gem gem_name, gem_attributes
+    project.depend_on gem, groups: [gem_group]
+
+    user.view_html.in_dep(gem_name) do |section|
+      expect(section.find("a[href='#{gem_attributes[:homepage]}']", text: gem_name)).to be
+      expect(section).to have_content gem_attributes[:license]
+      expect(section).to have_content gem_attributes[:summary]
+      expect(section).to have_content gem_attributes[:description]
+      expect(section).to have_content gem_attributes[:version]
+      expect(section).to have_content gem_group
+    end
+  end
+
+  specify "shows approval status of dependencies" do
+    user.create_empty_project
+    user.execute_command 'license_finder dependencies add gpl_dep GPL'
+    user.execute_command 'license_finder dependencies add mit_dep MIT'
+    user.execute_command 'license_finder whitelist add MIT'
+
+    html = user.view_html
+    expect(html).to be_unapproved 'gpl_dep'
+    expect(html).to be_approved 'mit_dep'
+
+    expect(html).to have_content '1 GPL'
+    action_items = html.find('.action-items')
+    expect(action_items).to have_content '(GPL)'
+    expect(action_items).not_to have_content 'MIT'
+  end
+end

data/features/support/testing_dsl.rb

@@ -0,0 +1,295 @@
+require 'delegate'
+
+module LicenseFinder::TestingDSL
+  class User
+    def run_license_finder
+      execute_command "license_finder --quiet"
+    end
+
+    def create_empty_project
+      EmptyProject.create
+    end
+
+    def create_ruby_app
+      BundlerProject.create
+    end
+
+    def create_gem(name, options)
+      GemProject.create(name, options)
+    end
+
+    def execute_command(command)
+      @output, @exit_code = Paths.project.shell_out(command, true)
+    end
+
+    def seeing?(content)
+      @output.include? content
+    end
+
+    def seeing_line?(content)
+      seeing_something_like? /^#{Regexp.escape content}$/
+    end
+
+    def seeing_something_like?(regex)
+      @output =~ regex
+    end
+
+    def receiving_exit_code?(code)
+      @exit_code == code
+    end
+
+    def view_html
+      execute_command 'license_finder report --format html'
+      HtmlReport.from_string(@output)
+    end
+  end
+
+  require 'forwardable'
+  class Project
+    extend Forwardable
+    def_delegators :project_dir, :shell_out, :add_to_file, :install_fixture
+
+    def self.create
+      project = new
+      project.add_dep
+      project.install
+      project
+    end
+
+    def initialize
+      Paths.reset_projects!
+      project_dir.make
+    end
+
+    def add_dep
+    end
+
+    def install
+    end
+
+    private
+
+    def project_dir
+      Paths.project
+    end
+  end
+
+  class EmptyProject < Project
+  end
+
+  class PipProject < Project
+    def add_dep
+      add_to_file("requirements.txt", 'argparse==1.2.1')
+    end
+
+    def install
+      shell_out("pip install -r requirements.txt")
+    end
+  end
+
+  class NpmProject < Project
+    def add_dep
+      add_to_file("package.json", '{"dependencies" : {"http-server": "0.6.1"}}')
+    end
+
+    def install
+      shell_out("npm install 2>/dev/null")
+    end
+  end
+
+  class BowerProject < Project
+    def add_dep
+      add_to_file('bower.json', '{"name": "my_app", "dependencies" : {"gmaps": "0.2.30"}}')
+    end
+
+    def install
+      shell_out("bower install 2>/dev/null")
+    end
+  end
+
+  class MavenProject < Project
+    def add_dep
+      install_fixture("pom.xml")
+    end
+
+    def install
+      shell_out("mvn install")
+    end
+  end
+
+  class GradleProject < Project
+    def add_dep
+      install_fixture("build.gradle")
+    end
+  end
+
+  class CocoaPodsProject < Project
+    def add_dep
+      install_fixture("Podfile")
+    end
+
+    def install
+      shell_out("pod install --no-integrate")
+    end
+  end
+
+  class BundlerProject < Project
+    def add_dep
+      add_to_bundler('license_finder', path: Paths.root.to_s)
+    end
+
+    def install
+      shell_out("bundle install")
+    end
+
+    def depend_on(gem, bundler_options = {})
+      add_to_bundler(gem.name, bundler_options.merge(path: gem.project_dir.to_s))
+      install
+    end
+
+    private
+
+    def add_to_bundler(gem_name, options)
+      add_to_file("Gemfile", "gem #{gem_name.inspect}, #{options.inspect}")
+    end
+  end
+
+  class GemProject # lives adjacent to a BundlerProject, so has a different lifecycle from other Projects and doesn't inherit
+    def self.create(name, options)
+      result = new(name)
+      result.define(options)
+      result
+    end
+
+    def initialize(name)
+      @name = name
+      project_dir.make
+    end
+
+    def define(options)
+      project_dir.write_file("#{name}.gemspec", gemspec_string(options))
+    end
+
+    attr_reader :name
+
+    def project_dir
+      Paths.project(name)
+    end
+
+    private
+
+    def gemspec_string(options)
+      <<-GEMSPEC
+      Gem::Specification.new do |s|
+        s.name = "#{name}"
+        s.version = "#{options[:version] || "0.0.0"}"
+        s.license = "#{options.fetch(:license)}"
+        s.author = "license_finder tests"
+        s.summary = "#{options[:summary]}"
+        s.description = "#{options[:description]}"
+        s.homepage = "#{options[:homepage]}"
+      end
+      GEMSPEC
+    end
+  end
+
+  require 'capybara'
+  class HtmlReport < SimpleDelegator # delegates to the parsed html
+    def self.from_string(str)
+      new(Capybara.string(str))
+    end
+
+    def in_dep(dep_name)
+      result = find("##{dep_name}")
+      yield result if block_given?
+      result
+    end
+
+    def approved?(dep_name)
+      classes_of(dep_name).include? "approved"
+    end
+
+    def unapproved?(dep_name)
+      classes_of(dep_name).include? "unapproved"
+    end
+
+    def titled?(title)
+      find("h1").has_content? title
+    end
+
+    private
+
+    def classes_of(dep_name)
+      in_dep(dep_name)[:class].split(' ')
+    end
+  end
+
+  class ProjectDir < SimpleDelegator # delegates to a Pathname
+    def shell_out(command, allow_failures = false)
+      Shell.run("cd #{self} && #{command}", allow_failures)
+    end
+
+    def add_to_file(filename, content)
+      join(filename).open('a') { |file| file.puts content }
+    end
+
+    def write_file(filename, content)
+      join(filename).open('w') { |file| file.write content }
+    end
+
+    def install_fixture(fixture_name)
+      join(fixture_name).make_symlink Paths.fixtures.join(fixture_name)
+    end
+
+    def make
+      mkpath
+    end
+  end
+
+  require 'pathname'
+  module Paths
+    extend self
+
+    def root
+      # where license_finder is installed
+      Pathname.new(__FILE__).dirname.join("..", "..").realpath
+    end
+
+    def fixtures
+      root.join("features", "fixtures")
+    end
+
+    def projects
+      root.join("tmp", "projects")
+    end
+
+    def project(name = "my_app")
+      ProjectDir.new(projects.join(name))
+    end
+
+    def reset_projects!
+      # only destroyed when a test starts, so you can poke around after a failure
+      projects.rmtree if projects.exist?
+      projects.mkpath
+    end
+  end
+
+  module Shell
+    ERROR_MESSAGE_FORMAT = <<EOM
+Command failed: `%s`
+output: %s
+exit: %d
+EOM
+
+    def self.run(command, allow_failures = false)
+      output = `#{command} 2>&1`
+      status = $?
+      unless status.success? || allow_failures
+        message = sprintf ERROR_MESSAGE_FORMAT, command, output.chomp, status.exitstatus
+        raise RuntimeError.new(message)
+      end
+
+      return [output, status.exitstatus]
+    end
+  end
+end

data/lib/license_finder.rb

@@ -1,60 +1,26 @@
 require 'pathname'
 require 'yaml'
-require 'erb'
 
 module LicenseFinder
-  ROOT_PATH = Pathname.new(__FILE__).dirname
-  BIN_PATH = ROOT_PATH.join("../bin")
-
-  Error = Class.new(StandardError)
+  ROOT_PATH = Pathname.new(__FILE__).dirname.join("license_finder")
+  BIN_PATH = ROOT_PATH.join("../../bin")
+end
 
-  autoload :Logger,               'license_finder/logger'
-  autoload :CLI,                  'license_finder/cli'
-  autoload :PackageManager,       'license_finder/package_manager'
-  autoload :DependencyManager,    'license_finder/dependency_manager'
-  autoload :PackageSaver,         'license_finder/package_saver'
-  autoload :License,              'license_finder/license'
-  autoload :PossibleLicenseFile,  'license_finder/possible_license_file'
-  autoload :PossibleLicenseFiles, 'license_finder/possible_license_files'
-  autoload :Configuration,        'license_finder/configuration'
-  autoload :Platform,             'license_finder/platform'
+require 'license_finder/platform'
+require 'license_finder/version'
+require 'license_finder/logger'
+require 'license_finder/configuration'
 
-  autoload :Package,              'license_finder/package'
-  autoload :Bower,                'license_finder/package_managers/bower'
-  autoload :Bundler,              'license_finder/package_managers/bundler'
-  autoload :NPM,                  'license_finder/package_managers/npm'
-  autoload :Pip,                  'license_finder/package_managers/pip'
-  autoload :Maven,                'license_finder/package_managers/maven'
-  autoload :CocoaPods,            'license_finder/package_managers/cocoa_pods'
-  autoload :Gradle,               'license_finder/package_managers/gradle'
-  autoload :BowerPackage,         'license_finder/package_managers/bower_package'
-  autoload :BundlerPackage,       'license_finder/package_managers/bundler_package'
-  autoload :PipPackage,           'license_finder/package_managers/pip_package'
-  autoload :NpmPackage,           'license_finder/package_managers/npm_package'
-  autoload :MavenPackage,         'license_finder/package_managers/maven_package'
-  autoload :GradlePackage,        'license_finder/package_managers/gradle_package'
-  autoload :CocoaPodsPackage,     'license_finder/package_managers/cocoa_pods_package'
+require 'license_finder/license'
 
+require 'license_finder/possible_license_file'
+require 'license_finder/possible_license_files'
+require 'license_finder/package'
+require 'license_finder/package_manager'
 
-  autoload :BundlerGroup,         'license_finder/tables/bundler_group'
-  autoload :Dependency,           'license_finder/tables/dependency'
-  autoload :ManualApproval,       'license_finder/tables/manual_approval'
-  autoload :YmlToSql,             'license_finder/yml_to_sql'
+require 'license_finder/decisions'
+require 'license_finder/decision_applier'
 
-  autoload :DependencyReport,     'license_finder/reports/dependency_report'
-  autoload :FormattedReport,      'license_finder/reports/formatted_report'
-  autoload :HtmlReport,           'license_finder/reports/html_report'
-  autoload :MarkdownReport,       'license_finder/reports/markdown_report'
-  autoload :Reporter,             'license_finder/reports/reporter'
-  autoload :TextReport,           'license_finder/reports/text_report'
-  autoload :DetailedTextReport,   'license_finder/reports/detailed_text_report'
+require 'license_finder/report'
 
-  def self.config
-    @config ||= Configuration.ensure_default
-  end
-end
-
-unless defined?(LicenseAudit)
-  require 'license_finder/tables'
-  LicenseFinder::YmlToSql.convert_if_required
-end
+require 'license_finder/cli'

data/lib/license_finder/cli.rb

@@ -1,259 +1,19 @@
-require 'thor'
-
 module LicenseFinder
   module CLI
-    class Base < Thor
-      def self.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
-
-      private
-
-      def sync_with_package_managers options={}
-        die_on_error {
-          logger = LicenseFinder::Logger.new options
-          DependencyManager.new(logger: logger).sync_with_package_managers
-        }
-      end
-
-      def die_on_error
-        yield
-      rescue LicenseFinder::Error => e
-        say e.message, :red
-        exit 1
-      end
-    end
-
-    # Thor fix for `license_finder <subcommand> help <action>`
-    class Subcommand < Base
-      # Hack to override the help message produced by Thor.
-      # https://github.com/wycats/thor/issues/261#issuecomment-16880836
-      def self.banner(command, namespace = nil, subcommand = nil)
-        "#{basename} #{underscore_name(name)} #{command.usage}"
-      end
-
-      protected
-
-      def self.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
-
-    class Dependencies < Subcommand
-      method_option :approve, type: :boolean, desc: "Approve the added dependency"
-      method_option :approver, desc: "The person granting the approval"
-      method_option :message, desc: "The reason for the approval"
-      desc "add LICENSE DEPENDENCY_NAME [VERSION] [--approve] [--approver APPROVER_NAME] [--message APPROVAL_MESSAGE]", "Add a dependency that is not managed by a package manager, optionally storing who approved the dependency and why"
-      def add(license, name, version = nil)
-        die_on_error {
-          DependencyManager.new.tap do |dependency_manager|
-            dependency_manager.manually_add(license, name, version)
-            dependency_manager.approve!(name, options[:approver], options[:message]) if options[:approve]
-          end
-        }
-        if options[:approve]
-          say "The #{name} dependency has been added and approved!", :green
-        else
-          say "The #{name} dependency has been added!", :green
-        end
-      end
-
-      desc "remove DEPENDENCY_NAME", "Remove a dependency that is not managed by a package manager"
-      def remove(name)
-        die_on_error {
-          DependencyManager.new.manually_remove(name)
-        }
-
-        say "The #{name} dependency has been removed.", :green
-      end
-    end
-
-    class ConfigSubcommand < Subcommand
-      private
-
-      def modifying
-        die_on_error {
-          yield
-
-          LicenseFinder.config.save
-          sync_with_package_managers
-        }
-      end
-    end
-
-    class Whitelist < ConfigSubcommand
-      desc "list", "List all the whitelisted licenses"
-      def list
-        whitelist = LicenseFinder.config.whitelist
-
-        say "Whitelisted Licenses:", :blue
-        whitelist.each do |license|
-          say license
-        end
-      end
-
-      desc "add LICENSE...", "Add one or more licenses to the whitelist"
-      def add(license, *other_licenses)
-        licenses = other_licenses.unshift license
-        modifying {
-          licenses.each do |license|
-            LicenseFinder.config.whitelist.push(license)
-          end
-        }
-        say "Added #{licenses.join(", ")} to the license whitelist"
-      end
-
-      desc "remove LICENSE...", "Remove one or more licenses from the whitelist"
-      def remove(license, *other_licenses)
-        licenses = other_licenses.unshift license
-        modifying {
-          licenses.each do |license|
-            LicenseFinder.config.whitelist.delete(license)
-          end
-        }
-        say "Removed #{licenses.join(", ")} from the license whitelist"
-      end
-    end
-
-    class ProjectName < ConfigSubcommand
-      desc "set NAME", "Set the project name"
-      def set(name)
-        modifying {
-          LicenseFinder.config.project_name = name
-        }
-        say "Set the project name to #{name}", :green
-      end
-    end
-
-    class IgnoredBundlerGroups < ConfigSubcommand
-      desc "list", "List all the ignored bundler groups"
-      def list
-        ignored = LicenseFinder.config.ignore_groups
-
-        say "Ignored Bundler Groups:", :blue
-        ignored.each do |group|
-          say group
-        end
-      end
-
-      desc "add GROUP", "Add a bundler group to be ignored"
-      def add(group)
-        modifying {
-          LicenseFinder.config.ignore_groups.push(group)
-        }
-        say "Added #{group} to the ignored bundler groups"
-      end
-
-      desc "remove GROUP", "Remove a bundler group from the ignored bundler groups"
-      def remove(group)
-        modifying {
-          LicenseFinder.config.ignore_groups.delete(group)
-        }
-        say "Removed #{group} from the ignored bundler groups"
-      end
-    end
-
-    class IgnoredDependencies < ConfigSubcommand
-      desc "list", "List all the ignored dependencies"
-      def list
-        ignored = LicenseFinder.config.ignore_dependencies
-
-        say "Ignored Dependencies:", :blue
-        if ignored.any?
-          ignored.each do |group|
-            say group
-          end
-        else
-          say '(none)'
-        end
-      end
-
-      desc "add DEPENDENCY", "Add a dependency to be ignored"
-      def add(group)
-        modifying {
-          LicenseFinder.config.ignore_dependencies.push(group)
-        }
-        say "Added #{group} to the ignored dependencies"
-      end
-
-      desc "remove DEPENDENCY", "Remove a dependency from the ignored dependencies"
-      def remove(group)
-        modifying {
-          LicenseFinder.config.ignore_dependencies.delete(group)
-        }
-        say "Removed #{group} from the ignored dependencies"
-      end
-    end
-
-    class Main < Base
-      method_option :quiet, type: :boolean, desc: "silences loading output"
-      method_option :debug, type: :boolean, desc: "emit detailed info about what LicenseFinder is doing"
-      desc "rescan", "Find new dependencies. (Default action)"
-      def rescan
-        sync_with_package_managers options
-        show_results
-      end
-
-      desc "show_results", "Display ignored dependencies and action items"
-      def show_results
-        IgnoredDependencies.new.list
-        action_items
-      end
-
-      default_task :rescan
-
-      method_option :approver, desc: "The person granting the approval"
-      method_option :message, desc: "The reason for the approval"
-      desc "approve DEPENDENCY_NAME... [--approver APPROVER_NAME] [--message APPROVAL_MESSAGE]", "Approve one or more dependencies by name, optionally storing who approved the dependency and why"
-      def approve(name, *other_names)
-        names = other_names.unshift name
-        die_on_error {
-          names.each { |name| DependencyManager.new.approve!(name, options[:approver], options[:message]) }
-        }
-
-        say "The #{names.join(", ")} dependency has been approved!", :green
-      end
-
-      desc "license LICENSE DEPENDENCY_NAME", "Update a dependency's license"
-      def license(license, name)
-        die_on_error {
-          DependencyManager.new.license!(name, license)
-        }
-
-        say "The #{name} dependency has been marked as using #{license} license!", :green
-      end
-
-      desc "move", "Move dependency.* files from root directory to doc/"
-      def move
-        Configuration.move!
-        say "Congratulations, you have cleaned up your root directory!'", :green
-      end
+  end
+end
 
-      desc "action_items", "List unapproved dependencies"
-      def action_items
-        unapproved = Dependency.unapproved
+require 'license_finder/cli/patched_thor'
 
-        if unapproved.empty?
-          say "All dependencies are approved for use", :green
-        else
-          say "Dependencies that need approval:", :red
-          say TextReport.new(unapproved)
-          exit 1
-        end
-      end
+require 'license_finder/cli/base'
+require 'license_finder/cli/makes_decisions'
 
-      subcommand "dependencies", Dependencies, "Manually manage dependencies that your package managers are not aware of"
-      subcommand "ignored_bundler_groups", IgnoredBundlerGroups, "Manage ignored Bundler groups"
-      subcommand "ignored_dependencies", IgnoredDependencies, "Manage ignored dependencies"
-      subcommand "whitelist", Whitelist, "Manage whitelisted licenses"
-      subcommand "project_name", ProjectName, "Manage the project name"
+require 'license_finder/cli/whitelist'
+require 'license_finder/cli/dependencies'
+require 'license_finder/cli/licenses'
+require 'license_finder/cli/approvals'
+require 'license_finder/cli/ignored_groups'
+require 'license_finder/cli/ignored_dependencies'
+require 'license_finder/cli/project_name'
 
-    end
-  end
-end
+require 'license_finder/cli/main'