license_finder 3.0.4 → 3.1.1

data/lib/license_finder/package_managers/{go_vendor.rb → go_15vendorexperiment.rb}

@@ -1,45 +1,40 @@
 require 'json'
 
 module LicenseFinder
-  class GoVendor < PackageManager
-
-    def initialize(options={})
+  class Go15VendorExperiment < PackageManager
+    def initialize(options = {})
       super
       @full_version = options[:go_full_version]
     end
 
     def active?
-      return false unless self.class.installed?(@logger)
-
-      (has_go_files? && package_path.exist?).tap do |is_active|
-        logger.active self.class, is_active
-      end
+      super && go_files_exist?
     end
 
-    def has_go_files?
-      !Dir[project_path.join("**/*.go")].empty?
+    def go_files_exist?
+      !Dir[project_path.join('**/*.go')].empty?
     end
 
-    def package_path
-      project_path.join("vendor")
+    def possible_package_paths
+      [project_path.join('vendor')]
     end
 
     def project_sha(path)
       Dir.chdir(path) do
-        val = capture('git rev-list --max-count 1 HEAD')
-        raise 'git rev-list failed' unless val.last
-        val.first.strip
+        stdout, _stderr, status = Cmd.run('git rev-list --max-count 1 HEAD')
+        raise 'git rev-list failed' unless status.success?
+        stdout.strip
       end
     end
 
     def current_packages
       deps = go_list
-      vendored_deps = deps.select { |dep| package_path.join(dep).exist? }
+      vendored_deps = deps.select { |dep| detected_package_path.join(dep).exist? }
       vendored_deps.map do |dep|
         GoPackage.from_dependency({
-                                   'ImportPath' => dep,
-                                   'InstallPath' => package_path.join(dep),
-                                   'Rev' => 'vendored-' + project_sha(package_path.join(dep))
+                                    'ImportPath' => dep,
+                                    'InstallPath' => detected_package_path.join(dep),
+                                    'Rev' => 'vendored-' + project_sha(detected_package_path.join(dep))
                                   }, nil, true)
       end
     end
@@ -57,16 +52,16 @@ module LicenseFinder
         # with status code 1. Setting GOPATH to nil removes those warnings.
         orig_gopath = ENV['GOPATH']
         ENV['GOPATH'] = nil
-        val = capture('go list -f "{{join .Deps \"\n\"}}" ./...')
+        val, _stderr, status = Cmd.run('go list -f "{{join .Deps \"\n\"}}" ./...')
         ENV['GOPATH'] = orig_gopath
-        return [] unless val.last
+        return [] unless status.success?
         # Select non-standard packages. `go list std` returns the list of standard
         # dependencies. We then filter those dependencies out of the full list of
         # dependencies.
-        deps = val.first.split("\n")
-        capture('go list std').first.split("\n").each do |std|
+        deps = val.split("\n")
+        Cmd.run('go list std').first.split("\n").each do |std|
           deps.delete_if do |dep|
-            dep =~ /(\/|^)#{std}(\/|$)/
+            dep =~ %r{(\/|^)#{std}(\/|$)}
           end
         end
         deps.map do |d|

data/lib/license_finder/package_managers/go_dep.rb

@@ -2,22 +2,21 @@ require 'json'
 
 module LicenseFinder
   class GoDep < PackageManager
-
-    def initialize(options={})
+    def initialize(options = {})
       super
       @full_version = options[:go_full_version]
     end
 
     def current_packages
-      json = JSON.parse(package_path.read)
+      json = JSON.parse(detected_package_path.read)
       # godep includes subpackages as a seperate dependency, we can de-dup that
 
-      dependencies_info = json['Deps'].map do |json|
+      dependencies_info = json['Deps'].map do |dep_json|
         {
-            'Homepage' => homepage(json),
-            'ImportPath' => import_path(json),
-            'InstallPath' => json['InstallPath'],
-            'Rev' => json['Rev']
+          'Homepage' => homepage(dep_json),
+          'ImportPath' => import_path(dep_json),
+          'InstallPath' => dep_json['InstallPath'],
+          'Rev' => dep_json['Rev']
         }
       end
       dependencies_info.uniq.map do |info|
@@ -25,18 +24,22 @@ module LicenseFinder
       end
     end
 
-    def package_path
-      project_path.join('Godeps/Godeps.json')
+    def possible_package_paths
+      [project_path.join('Godeps/Godeps.json')]
     end
 
     def self.package_management_command
-      "godep"
+      'godep'
     end
 
     private
 
     def install_prefix
-      go_path = workspace_dir.exist? ? workspace_dir : Pathname(ENV['GOPATH'])
+      go_path = if workspace_dir.directory?
+                  workspace_dir
+                else
+                  Pathname(ENV['GOPATH'] || ENV['HOME'] + '/go')
+                end
       go_path.join('src')
     end
 

data/lib/license_finder/package_managers/go_package.rb

@@ -1,22 +1,24 @@
 module LicenseFinder
   class GoPackage < Package
-    def self.from_dependency(hash, prefix, full_version)
-      name = hash['ImportPath']
-      install_path = hash['InstallPath']
-      install_path ||= install_path(prefix.join(name))
-      version = full_version ? hash['Rev'] : hash['Rev'][0..6]
-      homepage = hash['Homepage']
-      self.new(name, version, {install_path: install_path, package_manager: "Go", homepage: homepage })
-    end
-
     def package_manager
-      "Go"
+      'Go'
     end
 
-    private
+    class << self
+      def from_dependency(hash, prefix, full_version)
+        name = hash['ImportPath']
+        install_path = hash['InstallPath']
+        install_path ||= install_path(prefix.join(name))
+        version = full_version ? hash['Rev'] : hash['Rev'][0..6]
+        homepage = hash['Homepage']
+        new(name, version, install_path: install_path, package_manager: 'Go', homepage: homepage)
+      end
+
+      private
 
-    def self.install_path(path)
-      Pathname(path).cleanpath.to_s
+      def install_path(path)
+        Pathname(path).cleanpath.to_s
+      end
     end
   end
 end

data/lib/license_finder/package_managers/go_workspace.rb

@@ -5,49 +5,58 @@ module LicenseFinder
     Submodule = Struct.new :install_path, :revision
     ENVRC_REGEXP = /GOPATH|GO15VENDOREXPERIMENT/
 
-    def initialize(options={})
+    def initialize(options = {})
       super
       @full_version = options[:go_full_version]
     end
 
+    def self.package_management_command
+      'go'
+    end
+
     def current_packages
       go_list_packages = go_list
       git_modules.map do |submodule|
         # We are filtering the non-standard packages because the word "net"
         # seems to be common that can give false positive when filtering the git submodules
-        import_path = go_list_packages.select { |gp|
+        import_path = go_list_packages.select do |gp|
           submodule.install_path =~ /#{repo_name(gp)}$/
-        }.first
-        if import_path then
-          dependency_info = {
-              'ImportPath' => repo_name(import_path),
-              'Homepage' => repo_name(import_path),
-              'InstallPath' => submodule.install_path,
-              'Rev' => submodule.revision
-          }
-          GoPackage.from_dependency(dependency_info, nil, @full_version)
-        end
+        end.first
+        next unless import_path
+        dependency_info = {
+          'ImportPath' => repo_name(import_path),
+          'Homepage' => repo_name(import_path),
+          'InstallPath' => submodule.install_path,
+          'Rev' => submodule.revision
+        }
+        GoPackage.from_dependency(dependency_info, nil, @full_version)
       end.compact
     end
 
-    def package_path
-      envrc_path.dirname
+    def possible_package_paths
+      [envrc_path.dirname]
     end
 
     def active?
       return false unless self.class.installed?(logger)
 
-      godep = LicenseFinder::GoDep.new({project_path: Pathname(project_path)})
+      godep = LicenseFinder::GoDep.new(project_path: Pathname(project_path))
       # go workspace is only active if GoDep wasn't. There are some projects
       # that will use the .envrc and have a Godep folder as well.
-      active = !! (!godep.active? && envrc_path && ENVRC_REGEXP.match(IO.read(envrc_path)))
-      active.tap { |is_active| logger.active self.class, is_active }
+      active = !!(!godep.active? && envrc_path && ENVRC_REGEXP.match(IO.read(envrc_path)))
+      active.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
 
     private
 
-    def repo_name import_path
-      import_path.split("/")[0..2].join("/")
+    def repo_name(import_path)
+      import_path.split('/')[0..2].join('/')
     end
 
     def project_src
@@ -56,11 +65,7 @@ module LicenseFinder
 
     def envrc_path
       p = Pathname.new project_path
-      4.times.reduce([p]) { |memo, _| memo << memo.last.parent }.map { |p| p.join('.envrc') }.select(&:exist?).first
-    end
-
-    def self.package_management_command
-      'go'
+      4.times.reduce([p]) { |memo, _| memo << memo.last.parent }.map { |path| path.join('.envrc') }.select(&:exist?).first
     end
 
     def go_list
@@ -72,16 +77,16 @@ module LicenseFinder
         # with status code 1. Setting GOPATH to nil removes those warnings.
         orig_gopath = ENV['GOPATH']
         ENV['GOPATH'] = nil
-        val = capture('go list -f "{{join .Deps \"\n\"}}" ./...')
+        val, _stderr, status = Cmd.run('go list -f "{{join .Deps \"\n\"}}" ./...')
         ENV['GOPATH'] = orig_gopath
-        raise 'go list failed' unless val.last
+        raise 'go list failed' unless status.success?
         # Select non-standard packages. `go list std` returns the list of standard
         # dependencies. We then filter those dependencies out of the full list of
         # dependencies.
-        deps = val.first.split("\n")
-        capture('go list std').first.split("\n").each do |std|
+        deps = val.split("\n")
+        Cmd.run('go list std').first.split("\n").each do |std|
           deps.delete_if do |dep|
-            dep =~ /(\/|^)#{std}(\/|$)/
+            dep =~ %r{(\/|^)#{std}(\/|$)}
           end
         end
         deps
@@ -89,12 +94,12 @@ module LicenseFinder
     end
 
     def git_modules
-      Dir.chdir(package_path) do |d|
-        result = capture('git submodule status')
-        raise 'git submodule status failed' unless result[1]
-        result.first.lines.map do |l|
+      Dir.chdir(detected_package_path) do |_d|
+        result, _stderr, status = Cmd.run('git submodule status')
+        raise 'git submodule status failed' unless status.success?
+        result.lines.map do |l|
           columns = l.split.map(&:strip)
-          Submodule.new File.join(package_path, columns[1]), columns[0]
+          Submodule.new File.join(detected_package_path, columns[1]), columns[0]
         end
       end
     end

data/lib/license_finder/package_managers/govendor.rb

@@ -0,0 +1,32 @@
+module LicenseFinder
+  class Govendor < PackageManager
+    def possible_package_paths
+      [project_path.join('vendor', 'vendor.json')]
+    end
+
+    def current_packages
+      file = File.read(detected_package_path)
+      json = JSON.parse(file)
+      packages = json['package']
+      packages.map do |package|
+        GoPackage.from_dependency({
+                                    'ImportPath' => package['path'],
+                                    'InstallPath' => project_path.join('vendor', package['path']),
+                                    'Rev' => package['revision']
+                                  }, nil, true)
+      end
+    end
+
+    def self.takes_priority_over
+      Go15VendorExperiment
+    end
+
+    def self.package_management_command
+      'govendor'
+    end
+
+    def self.prepare_command
+      'govendor sync'
+    end
+  end
+end

data/lib/license_finder/package_managers/gradle.rb

@@ -4,21 +4,21 @@ require_relative 'gradle_dependency_finder'
 
 module LicenseFinder
   class Gradle < PackageManager
-    def initialize(options={})
+    def initialize(options = {})
       super
       @command = options[:gradle_command] || package_management_command
       @include_groups = options[:gradle_include_groups]
     end
 
     def current_packages
-      WithEnv.with_env({"TERM" => "dumb"}) do
+      WithEnv.with_env('TERM' => 'dumb') do
         command = "#{@command} downloadLicenses"
-        output, success = Dir.chdir(project_path) { capture(command) }
-        raise "Command '#{command}' failed to execute: #{output}" unless success
+        _stdout, stderr, status = Dir.chdir(project_path) { Cmd.run(command) }
+        raise "Command '#{command}' failed to execute: #{stderr}" unless status.success?
 
         dependencies = GradleDependencyFinder.new(project_path).dependencies
         packages = dependencies.flat_map do |xml_file|
-          options = {'GroupTags' => {'dependencies' => 'dependency'}}
+          options = { 'GroupTags' => { 'dependencies' => 'dependency' } }
           contents = XmlSimple.xml_in(xml_file, options).fetch('dependency', [])
           contents.map do |dep|
             GradlePackage.new(dep, logger: logger, include_groups: @include_groups)
@@ -29,20 +29,20 @@ module LicenseFinder
     end
 
     def package_management_command
-        if Platform.windows?
-          wrapper = 'gradlew.bat'
-          gradle = 'gradle.bat'
-        else
-          wrapper = './gradlew'
-          gradle = 'gradle'
-        end
+      if Platform.windows?
+        wrapper = 'gradlew.bat'
+        gradle = 'gradle.bat'
+      else
+        wrapper = './gradlew'
+        gradle = 'gradle'
+      end
 
-        File.exist?(File.join(project_path, wrapper)) ? wrapper : gradle
+      File.exist?(File.join(project_path, wrapper)) ? wrapper : gradle
     end
 
     private
 
-    def package_path
+    def detected_package_path
       alternate_build_file = build_file_from_settings(project_path)
       return alternate_build_file if alternate_build_file
 
@@ -52,7 +52,7 @@ module LicenseFinder
     def build_file_from_settings(project_path)
       settings_gradle_path = project_path.join 'settings.gradle'
 
-      return nil unless File.exists? settings_gradle_path
+      return nil unless File.exist? settings_gradle_path
 
       settings_gradle = File.read settings_gradle_path
 
@@ -60,7 +60,7 @@ module LicenseFinder
 
       return nil unless match
 
-      return project_path.join match[:build_file]
+      project_path.join match[:build_file]
     end
   end
 end

data/lib/license_finder/package_managers/gradle_package.rb

@@ -1,18 +1,18 @@
 module LicenseFinder
   class GradlePackage < Package
-    def initialize(spec, options={})
-      name = spec["name"]
-      if name.scan(":").size >= 1
-        group, name, version = name.split(":")
+    def initialize(spec, options = {})
+      name = spec['name']
+      if name.scan(':').size >= 1
+        group, name, version = name.split(':')
       else
-        version = "unknown"
+        version = 'unknown'
       end
 
       name = options[:include_groups] ? "#{group}:#{name}" : name
 
-      licenses = Array(spec["license"])
-        .map { |l| l["name"] }
-        .reject { |name| name == "No license found" }
+      licenses = Array(spec['license'])
+                 .map { |l| l['name'] }
+                 .reject { |reject_name| reject_name == 'No license found' }
 
       super(name, version, options.merge(spec_licenses: licenses))
     end

data/lib/license_finder/package_managers/gvt.rb

@@ -0,0 +1,61 @@
+module LicenseFinder
+  class Gvt < PackageManager
+    def possible_package_paths
+      potential_path_list = Dir.glob project_path.join('*', 'vendor', 'manifest')
+      potential_path_list << project_path.join('vendor', 'manifest')
+      potential_path_list.map { |path| Pathname path }
+    end
+
+    def self.package_management_command
+      'gvt'
+    end
+
+    def self.prepare_command
+      'gvt restore'
+    end
+
+    def current_packages
+      split_project_path = project_path.to_s.split('/')
+      project_root_depth = split_project_path.length - 1
+
+      split_package_path = detected_package_path.to_s.split('/')
+      vendor_dir_depth = split_package_path.index('vendor')
+      return [] if vendor_dir_depth.nil?
+      vendor_dir_parent_depth = vendor_dir_depth - 1
+
+      is_project_root_parent_of_vendor_dir = project_root_depth == vendor_dir_parent_depth
+
+      if is_project_root_parent_of_vendor_dir
+        shell_command = 'gvt list -f "{{.Importpath}} {{.Revision}} {{.Repository}}"'
+        path = project_path.join('vendor')
+      else
+        vendor_dir_parent = split_package_path[vendor_dir_parent_depth]
+        shell_command = "cd #{vendor_dir_parent} && gvt list -f \"{{.Importpath}} {{.Revision}} {{.Repository}}\""
+        path = project_path.join(vendor_dir_parent, 'vendor')
+      end
+
+      stdout, _stderr, status = Cmd.run(shell_command)
+      return [] unless status.success?
+      packages_from_output(stdout, path)
+    end
+
+    def self.takes_priority_over
+      Go15VendorExperiment
+    end
+
+    private
+
+    def packages_from_output(output, path)
+      package_lines = output.split("\n")
+      package_lines.map do |package_line|
+        import_path, revision, repo = package_line.split
+        GoPackage.from_dependency({
+                                    'ImportPath' => import_path,
+                                    'InstallPath' => path.join(import_path),
+                                    'Rev' => revision,
+                                    'Homepage' => repo
+                                  }, nil, true)
+      end
+    end
+  end
+end