license_finder 3.0.4 → 3.1.1

data/lib/license_finder/license/none_matcher.rb

@@ -1,7 +1,7 @@
 module LicenseFinder
   class License
     class NoneMatcher
-      def matches_text?(text)
+      def matches_text?(_text)
         false
       end
     end

data/lib/license_finder/license/template.rb

@@ -1,7 +1,7 @@
 module LicenseFinder
   class License
     class Template
-      TEMPLATE_PATH = ROOT_PATH.join("license", "templates")
+      TEMPLATE_PATH = ROOT_PATH.join('license', 'templates')
 
       def self.named(name)
         new TEMPLATE_PATH.join("#{name}.txt").read

data/lib/license_finder/license/text.rb

@@ -17,4 +17,3 @@ module LicenseFinder
     end
   end
 end
-

data/lib/license_finder/license_aggregator.rb

@@ -18,6 +18,7 @@ module LicenseFinder
     def aggregate_packages
       @subprojects.flat_map do |project_path|
         finder = LicenseFinder::Core.new(@license_finder_config.merge(project_path: project_path))
+        finder.prepare_projects if @license_finder_config[:prepare]
         finder.acknowledged.map { |dep| MergedPackage.new(dep, [project_path]) }
       end
     end

data/lib/license_finder/logger.rb

@@ -1,6 +1,6 @@
 module LicenseFinder
   module Logger
-    def self.new options={}
+    def self.new(options = {})
       klass = if options[:quiet]
                 Quiet
               elsif options[:debug]
@@ -11,79 +11,36 @@ module LicenseFinder
       klass.new
     end
 
-    class Base
-      def installed package_manager, is_installed
-        if String === is_installed
-          log package_manager, is_installed
-        elsif is_installed
-          log package_manager, Logger.green("is installed")
-        else
-          log package_manager, Logger.red("is not installed")
-        end
-      end
-
-      def active package_manager, is_active
-        if is_active
-          log package_manager, Logger.green("is active")
-        else
-          log package_manager, "is not active"
-        end
-      end
-
-      def package package_manager, package
-        dependencies = package.children
-        if dependencies.empty?
-          log package_manager, sprintf("package '%s' has no dependencies", package.name)
-        else
-          log package_manager, sprintf("package '%s' has dependencies:", package.name)
-          dependencies.each do |dep|
-            log package_manager, sprintf("- %s", dep)
-          end
-        end
-      end
-
-      def activation activation
-        preamble = sprintf("package %s:", activation.package.name)
-        if activation.sources.empty?
-          log activation.package.class, sprintf("%s no licenses found", preamble)
-        else
-          activation.sources.each do |source|
-            log activation.package.class, sprintf("%s found license '%s' %s", preamble, activation.license.name, source)
-          end
-        end
-      end
-
-      def log prefix, string
-        raise NotImplementedError, "#log must be implemented"
+    def self.colorize(string, color)
+      case color
+      when :red
+        "\e[31m#{string}\e[0m"
+      when :green
+        "\e[32m#{string}\e[0m"
+      else
+        string
       end
     end
 
-    def self.green string
-      colorize 32, string
-    end
-
-    def self.red string
-      colorize 31, string
-    end
-
-    def self.colorize color_code, string
-      "\e[#{color_code}m#{string}\e[0m"
+    class Base
+      def log(_prefix, _string, _options = {})
+        raise NotImplementedError, '#log must be implemented'
+      end
     end
 
     class Quiet < Base
-      def log prefix, string
-      end
+      def log(prefix, string, options = {}); end
     end
 
     class Progress < Base
-      def log prefix, string
-        print(".") && $stdout.flush
+      def log(_prefix, _string, _options = {})
+        print('.') && $stdout.flush
       end
     end
 
     class Verbose < Base
-      def log prefix, string
-        printf("%s: %s\n", prefix, string)
+      def log(prefix, string, options = {})
+        printf("%s: %s\n", prefix, Logger.colorize(string, options[:color]))
       end
     end
 

data/lib/license_finder/package.rb

@@ -18,27 +18,27 @@ module LicenseFinder
     attr_reader :logger
 
     def self.license_names_from_standard_spec(spec)
-      licenses = spec["licenses"] || [spec["license"]].compact
+      licenses = spec['licenses'] || [spec['license']].compact
       licenses = [licenses] unless licenses.is_a?(Array)
       licenses.map do |license|
         if license.is_a? Hash
-          license["type"]
+          license['type']
         else
           license
         end
       end
     end
 
-    def initialize(name, version = nil, options={})
+    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] || ""
+      @authors = options[:authors] || ''
+      @summary = options[:summary] || ''
+      @description = options[:description] || ''
+      @homepage = options[:homepage] || ''
       @children = options[:children] || []
       @parents = Set.new # will be figured out later by package manager
       @groups = options[:groups] || []
@@ -100,7 +100,7 @@ module LicenseFinder
 
     def <=>(other)
       eq_name = name <=> other.name
-      return eq_name unless eq_name == 0
+      return eq_name unless eq_name.zero?
       version <=> other.version
     end
 
@@ -109,7 +109,7 @@ module LicenseFinder
     end
 
     def hash
-      [name,version].hash
+      [name, version].hash
     end
 
     ## LICENSING
@@ -123,7 +123,7 @@ module LicenseFinder
 
     def activations
       licensing.activations.tap do |activations|
-        activations.each { |activation| logger.activation(activation) }
+        activations.each { |activation| log_activation activation }
       end
     end
 
@@ -146,12 +146,23 @@ module LicenseFinder
     end
 
     def package_manager
-      "unknown"
+      'unknown'
     end
 
     def missing?
       @missing
     end
+
+    def log_activation(activation)
+      preamble = format('package %s:', activation.package.name)
+      if activation.sources.empty?
+        logger.log activation.package.class, format('%s no licenses found', preamble)
+      else
+        activation.sources.each do |source|
+          logger.log activation.package.class, format("%s found license '%s' %s", preamble, activation.license.name, source)
+        end
+      end
+    end
   end
 end
 
@@ -164,6 +175,9 @@ require 'license_finder/package_managers/npm_package'
 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/carthage_package'
 require 'license_finder/package_managers/rebar_package'
+require 'license_finder/package_managers/mix_package'
 require 'license_finder/package_managers/merged_package'
 require 'license_finder/package_managers/nuget_package'
+require 'license_finder/package_managers/conan_package'

data/lib/license_finder/package_delta.rb

@@ -1,6 +1,6 @@
 module LicenseFinder
   class PackageDelta
-    STATUSES = [:added, :removed, :unchanged]
+    STATUSES = %i[added removed unchanged].freeze
 
     def initialize(status, current_package, previous_package)
       @status = status
@@ -16,14 +16,11 @@ module LicenseFinder
       pick_package.version
     end
 
-
     def subproject_paths
       pick_package.subproject_paths
     end
 
-    def status
-      @status
-    end
+    attr_reader :status
 
     def licenses
       pick_package.licenses
@@ -33,7 +30,7 @@ module LicenseFinder
       pick_package.class == MergedPackage
     end
 
-    def method_missing(method_name)
+    def method_missing(_method_name)
       nil
     end
 

data/lib/license_finder/package_manager.rb

@@ -9,72 +9,107 @@ module LicenseFinder
   # Additional guidelines are:
   #
   # - implement #current_packages, to return a list of `Package`s this package manager is tracking
-  # - implement #package_path, a `Pathname` which, if the file exists, indicates the package manager is in use on this project
-  #
+  # - implement #possible_package_paths, an array of `Pathname`s which are the possible locations which contain a configuration file/folder indicating the package manager is in use.
+  # - implement(Optional) #package_management_command, string for invoking the package manager
+  # - implement(Optional) #prepare_command, string for fetching dependencies for package manager (runs when the --prepare flag is passed to license_finder)
+
   class PackageManager
-    def self.package_managers
-      [GoDep, GoWorkspace, GoVendor, Bundler, NPM, Pip, Bower, Maven, Gradle, CocoaPods, Rebar, Nuget]
-    end
+    include LicenseFinder::SharedHelpers
 
-    def self.current_packages(options)
-      active_package_managers = package_managers
-        .map { |pm| pm.new(options) }
-        .select(&:active?)
-      active_package_managers.flat_map(&:current_packages_with_relations)
-    end
+    class << self
+      def package_managers
+        [GoDep, GoWorkspace, Go15VendorExperiment, Glide, Gvt, Govendor, Dep, Bundler, NPM, Pip,
+         Yarn, Bower, Maven, Gradle, CocoaPods, Rebar, Nuget, Carthage, Mix, Conan]
+      end
 
-    def self.installed?(logger=Core.default_logger)
-      if package_management_command.nil?
-        logger.installed self, "no command defined" # TODO comment me out
-        return true
+      def active_packages(options)
+        active_package_managers(options).flat_map(&:current_packages_with_relations)
       end
 
-      if command_exists?(package_management_command)
-        logger.installed self, true
-        return true
+      def active_package_managers(options = { project_path: Pathname.new('') })
+        active_pm_classes = package_managers.select { |pm_class| pm_class.new(options).active? }
+        active_pm_classes -= active_pm_classes.map(&:takes_priority_over)
+        active_pm_classes.map { |pm_class| pm_class.new(options) }
       end
 
-      logger.installed self, false
-      return false
-    end
+      def takes_priority_over
+        nil
+      end
+
+      def installed?(logger = Core.default_logger)
+        if package_management_command.nil?
+          logger.log self, 'no command defined' # TODO: comment me out
+          true
+        elsif command_exists?(package_management_command)
+          logger.log self, 'is installed', color: :green
+          true
+        else
+          logger.log self, 'is not installed', color: :red
+          false
+        end
+      end
 
-    def self.package_management_command
-      nil
+      # see class description
+      def package_management_command
+        nil
+      end
+
+      # see class description
+      def prepare_command
+        nil
+      end
     end
 
-    def initialize options={}
+    def initialize(options = {})
       @logger       = options[:logger] || Core.default_logger
       @project_path = options[:project_path]
     end
 
     def active?
+      path = detected_package_path
       self.class.installed?(logger) &&
-        package_path.exist?.tap { |is_active| logger.active self.class, is_active }
+        !path.nil? &&
+        path.exist?.tap do |is_active|
+          if is_active
+            logger.log self.class, 'is active', color: :green
+          else
+            logger.log self.class, 'is not active'
+          end
+        end
     end
 
-    def capture(command)
-      [`#{command}`, $?.success?]
+    def detected_package_path
+      possible_package_paths.find(&:exist?)
+    end
+
+    def prepare
+      if self.class.prepare_command
+        _stdout, _stderr, status = Cmd.run(self.class.prepare_command)
+        raise "Prepare command '#{self.class.prepare_command}' failed" unless status.success?
+      else
+        logger.log self.class, 'no prepare step provided', color: :red
+      end
     end
 
     def current_packages_with_relations
       packages = current_packages
       packages.each do |parent|
         parent.children.each do |child_name|
-          child = packages.detect { |child| child.name == child_name }
+          child = packages.detect { |child_package| child_package.name == child_name }
           child.parents << parent.name if child
         end
       end
       packages
     end
 
-    def self.command_exists? command
+    def self.command_exists?(command)
       if LicenseFinder::Platform.windows?
-        `where #{command} 2>NUL`
+        _stdout, _stderr, status = Cmd.run("where #{command} 2>NUL")
       else
-        `which #{command} 2>/dev/null`
+        _stdout, _stderr, status = Cmd.run("which #{command} 2>/dev/null")
       end
-      status = $?
-      return status.success?
+
+      status.success?
     end
 
     private
@@ -85,15 +120,23 @@ end
 
 require 'license_finder/package_managers/bower'
 require 'license_finder/package_managers/go_workspace'
-require 'license_finder/package_managers/go_vendor'
+require 'license_finder/package_managers/go_15vendorexperiment'
 require 'license_finder/package_managers/go_dep'
+require 'license_finder/package_managers/gvt'
+require 'license_finder/package_managers/glide'
+require 'license_finder/package_managers/govendor'
 require 'license_finder/package_managers/bundler'
 require 'license_finder/package_managers/npm'
+require 'license_finder/package_managers/yarn'
 require 'license_finder/package_managers/pip'
 require 'license_finder/package_managers/maven'
+require 'license_finder/package_managers/mix'
 require 'license_finder/package_managers/cocoa_pods'
+require 'license_finder/package_managers/carthage'
 require 'license_finder/package_managers/gradle'
 require 'license_finder/package_managers/rebar'
 require 'license_finder/package_managers/nuget'
+require 'license_finder/package_managers/dep'
+require 'license_finder/package_managers/conan'
 
 require 'license_finder/package'

data/lib/license_finder/package_managers/bower.rb

@@ -9,23 +9,23 @@ module LicenseFinder
     end
 
     def self.package_management_command
-      "bower"
+      'bower'
     end
 
     private
 
     def bower_output
-      command = "#{Bower::package_management_command} list --json -l action --allow-root"
-      output, success = Dir.chdir(project_path) { capture(command) }
-      raise "Command '#{command}' failed to execute: #{output}" unless success
+      command = "#{Bower.package_management_command} list --json -l action --allow-root"
+      stdout, stderr, status = Dir.chdir(project_path) { Cmd.run(command) }
+      raise "Command '#{command}' failed to execute: #{stderr}" unless status.success?
 
-      JSON(output)
-        .fetch("dependencies", {})
+      JSON(stdout)
+        .fetch('dependencies', {})
         .values
     end
 
-    def package_path
-      project_path.join('bower.json')
+    def possible_package_paths
+      [project_path.join('bower.json')]
     end
   end
 end