license_finder 1.1.1 → 1.2

data/lib/license_finder/configuration.rb

@@ -102,9 +102,13 @@ module LicenseFinder
       end
 
       def last_refreshed
-        [database_file, text_file, detailed_text_file, html_file, markdown_file].map do |path|
-          File.mtime(path)
-        end.min
+        [
+          database_file,
+          text_file,
+          detailed_text_file,
+          html_file,
+          markdown_file
+        ].map(&:mtime).min
       end
     end
 
@@ -126,7 +130,7 @@ module LicenseFinder
       end
 
       def last_modified
-        File.mtime(file)
+        file.mtime
       end
 
       private

data/lib/license_finder/dependency_manager.rb

@@ -1,8 +1,14 @@
 require 'digest'
 
 module LicenseFinder
-  module DependencyManager
-    def self.sync_with_package_managers
+  class DependencyManager
+    attr_reader :logger
+
+    def initialize options={}
+      @logger = options[:logger] || LicenseFinder::Logger::Default.new
+    end
+
+    def sync_with_package_managers options={}
       modifying {
         current_dependencies = PackageSaver.save_all(current_packages)
 
@@ -10,30 +16,30 @@ module LicenseFinder
       }
     end
 
-    def self.manually_add(license, name, version)
+    def manually_add(license, name, version)
       raise Error.new("#{name} dependency already exists") unless Dependency.where(name: name).empty?
 
       modifying {
         dependency = Dependency.new(added_manually: true, name: name, version: version)
-        dependency.license = License.find_by_name(license)
+        dependency.licenses = [License.find_by_name(license)].to_set
         dependency.save
       }
     end
 
-    def self.manually_remove(name)
+    def manually_remove(name)
       modifying { find_by_name(name, Dependency.added_manually).destroy }
     end
 
-    def self.license!(name, license_name)
+    def license!(name, license_name)
       license = License.find_by_name(license_name)
       modifying { find_by_name(name).set_license_manually!(license) }
     end
 
-    def self.approve!(name, approver = nil, notes = nil)
+    def approve!(name, approver = nil, notes = nil)
       modifying { find_by_name(name).approve!(approver, notes)  }
     end
 
-    def self.modifying
+    def modifying
       checksum_before = checksum
       result = DB.transaction { yield }
       checksum_after = checksum
@@ -49,29 +55,33 @@ module LicenseFinder
 
     private # not really private, but it looks like it is!
 
-    def self.reports_do_not_exist
+    def reports_do_not_exist
       !(LicenseFinder.config.artifacts.html_file.exist?)
     end
 
-    def self.reports_are_stale
+    def reports_are_stale
       LicenseFinder.config.last_modified > LicenseFinder.config.artifacts.last_refreshed
     end
 
-    def self.current_packages
-      package_managers.select(&:active?).map(&:current_packages).flatten
+    def current_packages
+      package_managers.
+        map { |pm| pm.new(logger: logger) }.
+        select(&:active?).
+        map(&:current_packages).
+        flatten
     end
 
-    def self.package_managers
+    def package_managers
       [Bundler, NPM, Pip, Bower, Maven, Gradle, CocoaPods]
     end
 
-    def self.find_by_name(name, scope = Dependency)
+    def find_by_name(name, scope = Dependency)
       dep = scope.first(name: name)
       raise Error.new("could not find dependency named #{name}") unless dep
       dep
     end
 
-    def self.checksum
+    def checksum
       database_file = LicenseFinder.config.artifacts.database_file
       if database_file.exist?
         Digest::SHA2.file(database_file).hexdigest

data/lib/license_finder/license.rb

@@ -54,6 +54,14 @@ module LicenseFinder
       copy(whitelisted: true)
     end
 
+    def eql?(other)
+      name == other.name
+    end
+
+    def hash
+      name.hash
+    end
+
     private
 
     attr_reader :short_name, :pretty_name, :other_names

data/lib/license_finder/logger.rb

@@ -0,0 +1,59 @@
+module LicenseFinder
+  module Logger
+    def self.new options={}
+      klass = if options[:quiet]
+                Quiet
+              elsif options[:debug]
+                Verbose
+              else
+                Progress
+              end
+      klass.new
+    end
+
+    class Base
+      def active package_manager, is_active
+        log package_manager, sprintf("%s active", (is_active ? "is" : "not"))
+      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 license package, package_name, license, how
+        log package, sprintf("package %s: found license '%s' %s", package_name, license, how)
+      end
+
+      def log prefix, string
+        raise NotImplementedError, "#log must be implemented"
+      end
+    end
+
+    class Quiet < Base
+      def log prefix, string
+      end
+    end
+
+    class Progress < Base
+      def log prefix, string
+        STDOUT.print(".") && STDOUT.flush
+      end
+    end
+
+    class Verbose < Base
+      def log prefix, string
+        STDOUT.printf("%s: %s\n", prefix, string)
+      end
+    end
+
+    Default = Quiet
+  end
+end

data/lib/license_finder/package.rb

@@ -3,9 +3,20 @@ module LicenseFinder
   # systems (gems, npm, pip, etc.) to a common interface.
   #
   # For guidance on adding a new system use the shared behavior
-  #     it_behaves_like "it conforms to interface required by PackageSaver"
-  # and see BundlerPackage, PipPackage and NpmPackage
+  #
+  #     it_behaves_like "a Package"
+  #
+  # Additional guidelines are:
+  #
+  # - if you're going to use Package#licenses ...
+  #   - implement #licenses_names_from_spec
+  #   - implement #install_path
+  # - else
+  #   - implement #licenses
+  #
   class Package
+    attr_reader :logger
+
     def self.license_names_from_standard_spec(spec)
       licenses = spec["licenses"] || [spec["license"]].compact
       licenses = [licenses] unless licenses.is_a?(Array)
@@ -18,54 +29,50 @@ module LicenseFinder
       end
     end
 
-    def license
-      @license ||= determine_license
+    def initialize options={}
+      @logger = options[:logger] || LicenseFinder::Logger::Default.new
     end
 
-    private
+    def licenses
+      @licenses ||= determine_license.to_set
+    end
 
     def determine_license
-      if licenses_from_spec.any?
-        choose_license_from licenses_from_spec
-      elsif licenses_from_files.any?
-        choose_license_from licenses_from_files
-      else
-        default_license
-      end
-    end
+      lfs = licenses_from_spec
+      return lfs if lfs.any?
 
-    def choose_license_from licenses
-      if ( licenses.uniq.size > 1 )
-        License.find_by_name "multiple licenses: #{(licenses).map(&:name).uniq.join(', ')}"
-      else
-        licenses.first
-      end
+      lff = licenses_from_files
+      return lff if lff.any?
+
+      [default_license].to_set
     end
 
     def licenses_from_spec
       license_names_from_spec.map do |name|
-        License.find_by_name(name)
-      end
+        License.find_by_name(name).tap do |license|
+          logger.license self.class, self.name, license.name, "from spec" if license
+        end
+      end.compact.to_set
     end
 
     def licenses_from_files
-      license_files.map(&:license).compact
+      license_files.map do |license_file|
+        license_file.license.tap do |license|
+          logger.license self.class, self.name, license.name, "from file '#{license_file.path}'" if license
+        end
+      end.compact.to_set
     end
 
     def license_files
       PossibleLicenseFiles.find(install_path)
     end
 
-    def multiple_licenses
-      if ( licenses_from_spec.uniq.size > 1 )
-        License.find_by_name "multiple licenses: #{(licenses_from_spec).map(&:name).uniq.join(', ')}"
-      else 
-        License.find_by_name "multiple licenses: #{(licenses_from_files).map(&:name).uniq.join(', ')}"
-      end
-    end
-
     def default_license
       License.find_by_name nil
     end
+
+    def install_path
+      nil
+    end
   end
 end

data/lib/license_finder/package_manager.rb

@@ -0,0 +1,20 @@
+module LicenseFinder
+  class PackageManager
+    attr_reader :logger
+
+    def initialize options={}
+      @logger       = options[:logger] || LicenseFinder::Logger::Default.new
+      @package_path = options[:package_path] # dependency injection for tests
+    end
+
+    def active?
+      injected_package_path.exist?.tap { |is_active| logger.active self.class, is_active }
+    end
+
+    private
+
+    def injected_package_path
+      @package_path || package_path
+    end
+  end
+end

data/lib/license_finder/package_managers/bower.rb

@@ -1,25 +1,20 @@
 require 'json'
 
 module LicenseFinder
-  class Bower
-
-    def self.current_packages
+  class Bower < PackageManager
+    def current_packages
       output = `bower list --json`
 
       json = JSON(output)
 
       json.fetch("dependencies",[]).map do |package|
-        BowerPackage.new(package[1])
+        BowerPackage.new(package[1], logger: logger)
       end
     end
 
-    def self.active?
-      package_path.exist?
-    end
-
     private
 
-    def self.package_path
+    def package_path
       Pathname.new('bower.json')
     end
   end

data/lib/license_finder/package_managers/bower_package.rb

@@ -1,6 +1,7 @@
 module LicenseFinder
   class BowerPackage < Package
-    def initialize(bower_module)
+    def initialize(bower_module, options={})
+      super options
       @bower_module = bower_module
       @module_metadata = bower_module.fetch("pkgMeta", Hash.new)
     end

data/lib/license_finder/package_managers/bundler.rb

@@ -1,48 +1,41 @@
 require "bundler"
 
 module LicenseFinder
-  class Bundler
-    class << self
-      def current_packages(ignore_groups = LicenseFinder.config.ignore_groups, bundler_definition=nil)
-        new(ignore_groups, bundler_definition).packages
-      end
-
-      def active?
-        gemfile_path.exist?
-      end
-
-      def gemfile_path
-        Pathname.new("Gemfile").expand_path
-      end
+  class Bundler < PackageManager
+    def initialize options={}
+      super
+      @ignore_groups = options[:ignore_groups] # dependency injection for tests
+      @definition    = options[:definition]    # dependency injection for tests
     end
 
-    def initialize(ignore_groups, bundler_definition=nil)
-      @definition = bundler_definition || ::Bundler::Definition.build(self.class.gemfile_path, lockfile_path, nil)
-      @ignore_groups = ignore_groups
-    end
-
-    def packages
-      top_level_gems = Set.new
-
-      packages = definition.specs_for(included_groups).map do |gem_def|
+    def current_packages
+      logger.log self.class, "including groups #{included_groups.inspect}"
+      definition.specs_for(included_groups).map do |gem_def|
         bundler_def = bundler_defs.detect { |bundler_def| bundler_def.name == gem_def.name }
-
-        top_level_gems << format_name(gem_def)
-
-        BundlerPackage.new(gem_def, bundler_def)
+        BundlerPackage.new(gem_def, bundler_def, logger: logger).tap do |package|
+          logger.package self.class, package
+        end
       end
+    end
 
-      packages.each do |gem|
-        gem.children = children_for(gem, top_level_gems)
-      end
+    private
 
-      packages
+    def definition
+      # DI
+      @definition ||= ::Bundler::Definition.build(package_path, lockfile_path, nil)
     end
 
-    private
-    attr_reader :definition, :ignore_groups
+    def ignore_groups
+      # DI
+      @ignore_groups ||= LicenseFinder.config.ignore_groups
+    end
+
+    def package_path
+      Pathname.new("Gemfile")
+    end
 
     def bundler_defs
+      # memoized
       @bundler_defs ||= definition.dependencies
     end
 
@@ -51,15 +44,7 @@ module LicenseFinder
     end
 
     def lockfile_path
-      self.class.gemfile_path.dirname.join('Gemfile.lock')
-    end
-
-    def children_for(gem, top_level_gems)
-      gem.gem_def.dependencies.map(&:name).select { |name| top_level_gems.include? name }
-    end
-
-    def format_name(gem)
-      gem.name.split(" ")[0]
+      package_path.dirname.join('Gemfile.lock')
     end
   end
 end