license_finder 0.9.4-java → 0.9.5-java

data/lib/license_finder/bundler_package.rb

@@ -0,0 +1,33 @@
+module LicenseFinder
+  class BundlerPackage < Package
+    extend Forwardable
+    def_delegators :gem_def, :summary, :description, :name, :homepage
+
+    attr_reader :gem_def
+    attr_accessor :children
+
+    def initialize(gem_def, bundler_def)
+      @gem_def = gem_def
+      @bundler_def = bundler_def
+      @children = []
+    end
+
+    def groups
+      Array(@bundler_def && @bundler_def.groups)
+    end
+
+    def version
+      gem_def.version.to_s
+    end
+
+    private
+
+    def install_path
+      gem_def.full_gem_path
+    end
+
+    def license_from_spec
+      gem_def.license
+    end
+  end
+end

data/lib/license_finder/cli.rb

@@ -40,10 +40,10 @@ module LicenseFinder
 
     class Dependencies < Subcommand
       method_option :approve, type: :boolean, desc: "Approve the added dependency"
-      desc "add LICENSE DEPENDENCY_NAME [VERSION] [--approve]", "Add a dependency that is not managed by Bundler"
+      desc "Add LICENSE DEPENDENCY_NAME [VERSION] [--approve]", "Add a dependency that is not managed by Bundler, NPM, etc"
       def add(license, name, version = nil)
         die_on_error {
-          DependencyManager.create_non_bundler(license, name, version)
+          DependencyManager.create_manually_managed(license, name, version)
           DependencyManager.approve!(name) if options[:approve]
         }
         if options[:approve]
@@ -53,17 +53,30 @@ module LicenseFinder
         end
       end
 
-      desc "remove DEPENDENCY_NAME", "Remove a dependency that is not managed by Bundler"
+      desc "Remove DEPENDENCY_NAME", "Remove a dependency that is not managed by Bundler, NPM, etc"
       def remove(name)
         die_on_error {
-          DependencyManager.destroy_non_bundler(name)
+          DependencyManager.destroy_manually_managed(name)
         }
 
         say "The #{name} dependency has been removed.", :green
       end
     end
 
-    class Whitelist < Subcommand
+    class ConfigSubcommand < Subcommand
+      private
+
+      def modifying
+        die_on_error {
+          yield
+
+          LicenseFinder.config.save
+          Reporter.write_reports
+        }
+      end
+    end
+
+    class Whitelist < ConfigSubcommand
       desc "list", "List all the whitelisted licenses"
       def list
         whitelist = LicenseFinder.config.whitelist
@@ -76,45 +89,36 @@ module LicenseFinder
 
       desc "add LICENSE", "Add one ore more licenses to the whitelist"
       def add(*licenses)
-        die_on_error {
+        modifying {
           licenses.each do |license|
             LicenseFinder.config.whitelist.push(license)
           end
-          LicenseFinder.config.save
-
-          Reporter.write_reports
         }
         say "Added #{licenses.join(", ")} to the license whitelist"
       end
 
       desc "remove LICENSE", "Remove one ore more licenses from the whitelist"
       def remove(*licenses)
-        die_on_error {
+        modifying {
           licenses.each do |license|
             LicenseFinder.config.whitelist.delete(license)
           end
-          LicenseFinder.config.save
-
-          Reporter.write_reports
         }
         say "Removed #{licenses.join(", ")} from the license whitelist"
       end
     end
 
-    class ProjectName < Subcommand
+    class ProjectName < ConfigSubcommand
       desc "set NAME", "Set the project name"
       def set(name)
-        die_on_error {
+        modifying {
           LicenseFinder.config.project_name = name
-          LicenseFinder.config.save
-
-          Reporter.write_reports
         }
         say "Set the project name to #{name}", :green
       end
     end
 
-    class IgnoredBundlerGroups < Subcommand
+    class IgnoredBundlerGroups < ConfigSubcommand
       desc "list", "List all the ignored bundler groups"
       def list
         ignored = LicenseFinder.config.ignore_groups
@@ -127,22 +131,16 @@ module LicenseFinder
 
       desc "add GROUP", "Add a bundler group to be ignored"
       def add(group)
-        die_on_error {
+        modifying {
           LicenseFinder.config.ignore_groups.push(group)
-          LicenseFinder.config.save
-
-          Reporter.write_reports
         }
         say "Added #{group} to the ignored bundler groups"
       end
 
       desc "remove GROUP", "Remove a bundler group from the ignored bundler groups"
       def remove(group)
-        die_on_error {
+        modifying {
           LicenseFinder.config.ignore_groups.delete(group)
-          LicenseFinder.config.save
-
-          Reporter.write_reports
         }
         say "Removed #{group} from the ignored bundler groups"
       end
@@ -154,7 +152,7 @@ module LicenseFinder
       def rescan
         die_on_error {
           spinner {
-            DependencyManager.sync_with_bundler
+            DependencyManager.sync_with_package_managers
           }
         }
 
@@ -162,7 +160,7 @@ module LicenseFinder
       end
       default_task :rescan
 
-      desc "approve DEPENDENCY_NAME", "Approve one ore more dependencies by name."
+      desc "approve DEPENDENCY_NAME", "Approve one ore more dependencies by name"
       def approve(*names)
         die_on_error {
           names.each { |name| DependencyManager.approve!(name) }
@@ -171,7 +169,7 @@ module LicenseFinder
         say "The #{names.join(", ")} dependency has been approved!", :green
       end
 
-      desc "license LICENSE DEPENDENCY_NAME", "Update a dependency's license."
+      desc "license LICENSE DEPENDENCY_NAME", "Update a dependency's license"
       def license(license, name)
         die_on_error {
           DependencyManager.license!(name, license)
@@ -180,7 +178,7 @@ module LicenseFinder
         say "The #{name} dependency has been marked as using #{license} license!", :green
       end
 
-      desc "move", "Move dependency.* files from root directory to doc/."
+      desc "move", "Move dependency.* files from root directory to doc/"
       def move
         Configuration.move!
         say "Congratulations, you have cleaned up your root directory!'", :green
@@ -199,10 +197,10 @@ module LicenseFinder
         end
       end
 
-      subcommand "dependencies", Dependencies, "manage non-Bundler dependencies"
-      subcommand "ignored_bundler_groups", IgnoredBundlerGroups, "manage ignored bundler groups"
-      subcommand "whitelist", Whitelist, "manage whitelisted licenses"
-      subcommand "project_name", ProjectName, "manage the project name"
+      subcommand "dependencies", Dependencies, "Manually manage dependencies outside of Bundler, NPM, pip, etc"
+      subcommand "ignored_bundler_groups", IgnoredBundlerGroups, "Manage ignored bundler groups"
+      subcommand "whitelist", Whitelist, "Manage whitelisted licenses"
+      subcommand "project_name", ProjectName, "Manage the project name"
 
       private
 

data/lib/license_finder/dependency_manager.rb

@@ -2,43 +2,26 @@ require 'digest'
 
 module LicenseFinder
   module DependencyManager
-    def self.sync_with_bundler
+    def self.sync_with_package_managers
       modifying {
-        current_dependencies = []
+        current_dependencies = PackageSaver.save_all(current_packages)
 
-        if Bundle.has_gemfile?
-          current_dependencies += PackageSaver.save_packages(Bundle.current_gems(LicenseFinder.config))
-        end
-
-        if Pip.has_requirements?
-          current_dependencies += PackageSaver.save_packages(Pip.current_dists())
-        end
-
-        if NPM.has_package?
-          current_dependencies += PackageSaver.save_packages(NPM.current_modules())
-        end
-
-        if Bower.has_package_file?
-          current_dependencies += PackageSaver.save_packages(Bower.current_packages())
-        end
-
-        Dependency.bundler.obsolete(current_dependencies).each(&:destroy)
+        Dependency.managed.obsolete(current_dependencies).each(&:destroy)
       }
     end
 
-    def self.create_non_bundler(license, name, version)
+    def self.create_manually_managed(license, name, version)
       raise Error.new("#{name} dependency already exists") unless Dependency.where(name: name).empty?
 
       modifying {
         dependency = Dependency.new(manual: true, name: name, version: version)
         dependency.license = LicenseAlias.create(name: license)
-        dependency.approval = Approval.create
         dependency.save
       }
     end
 
-    def self.destroy_non_bundler(name)
-      modifying { find_by_name(name, Dependency.non_bundler).destroy }
+    def self.destroy_manually_managed(name)
+      modifying { find_by_name(name, Dependency.manually_managed).destroy }
     end
 
     def self.license!(name, license)
@@ -68,6 +51,14 @@ module LicenseFinder
 
     private # not really private, but it looks like it is!
 
+    def self.current_packages
+      package_managers.select(&:active?).map(&:current_packages).flatten
+    end
+
+    def self.package_managers
+      [Bundler, NPM, Pip, Bower]
+    end
+
     def self.find_by_name(name, scope = Dependency)
       dep = scope.first(name: name)
       raise Error.new("could not find dependency named #{name}") unless dep

data/lib/license_finder/license/apache2.rb

@@ -1,5 +1,5 @@
 class LicenseFinder::License::Apache2 < LicenseFinder::License::Base
-  self.alternative_names = ["Apache 2.0", "Apache2", "Apache-2.0", "Apache Software License", "Apache License 2.0", "Apache License Version 2.0"]
+  self.alternative_names = ["Apache 2.0", "Apache2", "Apache-2.0", "Apache Software License", "Apache License 2.0", "Apache License Version 2.0", "Apache Public License 2.0"]
   self.license_url       = "http://www.apache.org/licenses/LICENSE-2.0.txt"
 
   def self.pretty_name

data/lib/license_finder/license/lgpl.rb

@@ -1,3 +1,4 @@
 class LicenseFinder::License::LGPL < LicenseFinder::License::Base
+  self.alternative_names = ["LGPL-3", "LGPLv3", "LGPL-3.0"]
   self.license_url = "http://www.gnu.org/licenses/lgpl.txt"
 end

data/lib/license_finder/npm.rb

@@ -1,39 +1,40 @@
 require 'json'
-require 'license_finder/package'
 
 module LicenseFinder
   class NPM
-
     DEPENDENCY_GROUPS = ["dependencies", "devDependencies", "bundleDependencies", "bundledDependencies"]
 
-    def self.current_modules
-      return @modules if @modules
+    def self.current_packages
+      json = npm_json
+      dependencies = DEPENDENCY_GROUPS.map { |g| (json[g] || {}).values }.flatten(1).reject{ |d| d.is_a?(String) }
 
-      command = "npm list --json --long"
-      output, success = capture(command)
-      raise "Command #{command} failed to execute: #{output}" unless success
-
-      json = JSON(output)
-      dependencies = DEPENDENCY_GROUPS.map { |g| (json[g] || {}).values }.flatten(1)
-
-      @modules = dependencies.map do |node_module|
-        Package.new(OpenStruct.new(
-          :name => node_module.fetch("name", nil),
-          :version => node_module.fetch("version", nil),
-          :full_gem_path => node_module.fetch("path", nil),
-          :license => self.harvest_license(node_module),
-          :summary => node_module.fetch("description", nil),
-          :description => node_module.fetch("readme", nil)
-        ))
+      dependencies.map do |node_module|
+        NpmPackage.new(node_module)
       end
     end
 
-    def self.has_package?
+    def self.active?
       File.exists?(package_path)
     end
 
     private
 
+    def self.npm_json
+      command = "npm list --json --long"
+      output, success = capture(command)
+      if success
+        json = JSON(output)
+      else
+        json = JSON(output) rescue nil
+        if json
+          $stderr.puts "Command #{command} returned error but parsing succeeded." unless ENV['test_run']
+        else
+          raise "Command #{command} failed to execute: #{output}"
+        end
+      end
+      json
+    end
+
     def self.capture(command)
       [`#{command}`, $?.success?]
     end
@@ -41,23 +42,5 @@ module LicenseFinder
     def self.package_path
       Pathname.new('package.json').expand_path
     end
-
-    def self.harvest_license(node_module)
-      license = node_module.fetch("licenses", []).first
-
-      if license.is_a? Hash
-        license = license.fetch("type", nil)
-      end
-
-      if license.nil?
-        license = node_module.fetch("license", nil)
-
-        if license.is_a? Hash
-          license = license.fetch("type", nil)
-        end
-      end
-
-      license
-    end
   end
 end

data/lib/license_finder/npm_package.rb

@@ -0,0 +1,61 @@
+module LicenseFinder
+  class NpmPackage < Package
+    def initialize(node_module)
+      @node_module = node_module
+    end
+
+    def name
+      node_module["name"]
+    end
+
+    def version
+      node_module["version"]
+    end
+
+    def summary
+      node_module["description"]
+    end
+
+    def description
+      node_module["readme"]
+    end
+
+    def children
+      [] # no way to determine child deps from npm (maybe?)
+    end
+
+    def groups
+      [] # no concept of dev/test groups in npm (maybe?)
+    end
+
+    def homepage
+      nil # no way to extract homepage from npm (maybe?)
+    end
+
+    private
+
+    attr_reader :node_module
+
+    def install_path
+      node_module["path"]
+    end
+
+    def license_from_spec
+      license = node_module.fetch("licenses", []).first
+
+      if license
+        license = license.fetch("type", nil)
+      end
+
+      if license.nil?
+        license = node_module.fetch("license", nil)
+
+        if license.is_a? Hash
+          license = license.fetch("type", nil)
+        end
+      end
+
+      license
+    end
+  end
+end

data/lib/license_finder/package.rb

@@ -1,97 +1,31 @@
 module LicenseFinder
+  # Super-class that adapts data from different package management
+  # 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
   class Package
-    attr_reader :parents, :spec, :bundler_dependency, :children
-
-    def initialize(spec, bundler_dependency = nil)
-      @spec = spec
-      @bundler_dependency = bundler_dependency
-      @children = []
-    end
-
-    def name
-      "#{dependency_name} #{dependency_version}"
-    end
-
-    def parents
-      @parents ||= []
-    end
-
-    def dependency_name
-      @spec.name
-    end
-
-    def dependency_version
-      @spec.version.to_s
-    end
-
-    def summary
-      @spec.summary
-    end
-
-    def description
-      @spec.description
-    end
-
-    def groups
-      @groups ||= bundler_dependency ? bundler_dependency.groups : []
-    end
-
     def license
       @license ||= determine_license
     end
 
-    def sort_order
-      dependency_name.downcase
-    end
-
-    def license_files
-      PossibleLicenseFiles.new(@spec.full_gem_path).find
-    end
-
-    def children=(childs)
-      @children = childs
-    end
-
     private
 
     def determine_license
-      return @spec.license if @spec.license
-
-      license = license_files.map(&:license).compact.first
-      license || "other"
+      license_from_spec || license_from_files || default_license
     end
-  end
 
-  class PythonPackage < Package
-    def determine_license
-      return @spec.license if @spec.license
-
-      license = super
-
-      if !license || license == "other"
-        license = Pip.license_for self
-      end
-
-      license
-    end
-
-    def summary
-      json.fetch("summary", "")
+    def license_from_files
+      license_files.map(&:license).compact.first
     end
 
-    def description
-      json.fetch("description", "")
+    def license_files
+      PossibleLicenseFiles.find(install_path)
     end
 
-    def json
-      return @json if @json
-
-      response = HTTParty.get("https://pypi.python.org/pypi/#{dependency_name}/#{dependency_version}/json")
-      if response.code == 200
-        @json = JSON.parse(response.body).fetch("info", {})
-      end
-
-      @json ||= {}
+    def default_license
+      "other"
     end
   end
-end
+end