license_finder 3.0.4 → 3.1.1

data/lib/license_finder/package_managers/bower_package.rb

@@ -1,27 +1,27 @@
 module LicenseFinder
   class BowerPackage < Package
-    def initialize(bower_module, options={})
-      spec = bower_module.fetch("pkgMeta", Hash.new)
+    def initialize(bower_module, options = {})
+      spec = bower_module.fetch('pkgMeta', {})
 
       if spec.empty?
-        endpoint = bower_module.fetch("endpoint", Hash.new)
-        name = endpoint["name"]
-        version = endpoint["target"]
+        endpoint = bower_module.fetch('endpoint', {})
+        name = endpoint['name']
+        version = endpoint['target']
       else
-        name = spec["name"]
-        version = spec["version"]
+        name = spec['name']
+        version = spec['version']
       end
 
       super(
         name,
         version,
         options.merge(
-          summary: spec["description"],
-          description: spec["readme"],
-          homepage: spec["homepage"],
+          summary: spec['description'],
+          description: spec['readme'],
+          homepage: spec['homepage'],
           spec_licenses: Package.license_names_from_standard_spec(spec),
-          install_path: bower_module["canonicalDir"],
-          missing: bower_module["missing"]
+          install_path: bower_module['canonicalDir'],
+          missing: bower_module['missing']
         )
       )
     end

data/lib/license_finder/package_managers/bundler.rb

@@ -1,24 +1,24 @@
-require "bundler"
+require 'bundler'
 
 module LicenseFinder
   class Bundler < PackageManager
-    def initialize options={}
+    def initialize(options = {})
       super
       @ignored_groups = options[:ignored_groups]
-      @definition    = options[:definition] # dependency injection for tests
+      @definition = options[:definition] # dependency injection for tests
     end
 
     def current_packages
       logger.log self.class, "including groups #{included_groups.inspect}"
       details.map do |gem_detail, bundle_detail|
         BundlerPackage.new(gem_detail, bundle_detail, logger: logger).tap do |package|
-          logger.package self.class, package
+          log_package_dependencies package
         end
       end
     end
 
     def self.package_management_command
-      "bundle"
+      'bundle'
     end
 
     private
@@ -27,12 +27,12 @@ module LicenseFinder
 
     def definition
       # DI
-      @definition ||= ::Bundler::Definition.build(package_path, lockfile_path, nil)
+      @definition ||= ::Bundler::Definition.build(detected_package_path, lockfile_path, nil)
     end
 
     def details
       gem_details.map do |gem_detail|
-        bundle_detail = bundler_details.detect { |bundle_detail| bundle_detail.name == gem_detail.name }
+        bundle_detail = bundler_details.detect { |bundler_detail| bundler_detail.name == gem_detail.name }
         [gem_detail, bundle_detail]
       end
     end
@@ -49,12 +49,24 @@ module LicenseFinder
       definition.groups - ignored_groups.map(&:to_sym)
     end
 
-    def package_path
-      project_path.join("Gemfile")
+    def possible_package_paths
+      [project_path.join('Gemfile')]
     end
 
     def lockfile_path
       project_path.join('Gemfile.lock')
     end
+
+    def log_package_dependencies(package)
+      dependencies = package.children
+      if dependencies.empty?
+        logger.log self.class, format("package '%s' has no dependencies", package.name)
+      else
+        logger.log self.class, format("package '%s' has dependencies:", package.name)
+        dependencies.each do |dep|
+          logger.log self.class, format('- %s', dep)
+        end
+      end
+    end
   end
 end

data/lib/license_finder/package_managers/bundler_package.rb

@@ -1,6 +1,6 @@
 module LicenseFinder
   class BundlerPackage < Package
-    def initialize(spec, bundler_def, options={})
+    def initialize(spec, bundler_def, options = {})
       children = spec.dependencies.map(&:name)
       groups = Array(bundler_def && bundler_def.groups).map(&:to_s)
 

data/lib/license_finder/package_managers/carthage.rb

@@ -0,0 +1,66 @@
+require 'json'
+
+module LicenseFinder
+  class Carthage < PackageManager
+    class CarthageError < RuntimeError; end
+
+    def current_packages
+      cartfile.each_line.map do |line|
+        name, version = name_version_from_line line
+
+        CarthagePackage.new(
+          name,
+          version,
+          license_text(name),
+          logger: logger,
+          install_path: project_checkout(name)
+        )
+      end
+    end
+
+    def self.package_management_command
+      LicenseFinder::Platform.darwin? ? 'carthage' : nil
+    end
+
+    private
+
+    def cartfile
+      if File.exist?(resolved_path)
+        @cartfile ||= IO.read(resolved_path)
+      else
+        raise CarthageError, 'No Cartfile.resolved found.
+          Please install your dependencies first.'
+      end
+    end
+
+    def possible_package_paths
+      [public_dependency_path]
+    end
+
+    def public_dependency_path
+      project_path.join('Cartfile')
+    end
+
+    def resolved_path
+      project_path.join('Cartfile.resolved')
+    end
+
+    def project_checkout(name)
+      project_path.join('Carthage', 'Checkouts', name)
+    end
+
+    def license_text(name)
+      license_path = license_pattern(name).find { |f| File.exist?(f) }
+      license_path.nil? ? nil : IO.read(license_path)
+    end
+
+    def license_pattern(name)
+      checkout_path = project_checkout(name)
+      Dir.glob(checkout_path.join('LICENSE*'), File::FNM_CASEFOLD)
+    end
+
+    def name_version_from_line(cartfile_line)
+      cartfile_line.split(' ')[1, 2].map { |f| f.split('/').last.delete('"').gsub('.git', '') }
+    end
+  end
+end

data/lib/license_finder/package_managers/carthage_package.rb

@@ -0,0 +1,16 @@
+module LicenseFinder
+  class CarthagePackage < Package
+    def initialize(name, version, license_text, options = {})
+      super(name, version, options)
+      @license = License.find_by_text(license_text.to_s)
+    end
+
+    def licenses_from_spec
+      [@license].compact
+    end
+
+    def package_manager
+      'Carthage'
+    end
+  end
+end

data/lib/license_finder/package_managers/cocoa_pods.rb

@@ -1,11 +1,11 @@
-require "json"
+require 'json'
 
 module LicenseFinder
   class CocoaPods < PackageManager
     def current_packages
       podfile = YAML.load_file(lockfile_path)
 
-      podfile["PODS"].map do |pod|
+      podfile['PODS'].map do |pod|
         pod = pod.keys.first if pod.is_a?(Hash)
 
         name, version = pod.scan(/(.*)\s\((.*)\)/).flatten
@@ -20,34 +20,34 @@ module LicenseFinder
     end
 
     def self.package_management_command
-      LicenseFinder::Platform.darwin? ? "pod" : nil
+      LicenseFinder::Platform.darwin? ? 'pod' : nil
     end
 
     private
 
-    def package_path
-      project_path.join("Podfile")
+    def possible_package_paths
+      [project_path.join('Podfile')]
     end
 
     def lockfile_path
-      project_path.join("Podfile.lock")
+      project_path.join('Podfile.lock')
     end
 
     def license_texts
       # package name => license text
-      @license_texts ||= read_plist(acknowledgements_path)["PreferenceSpecifiers"]
-        .each_with_object({}) { |hash, memo| memo[hash["Title"]] = hash["FooterText"] }
+      @license_texts ||= read_plist(acknowledgements_path)['PreferenceSpecifiers']
+                         .each_with_object({}) { |hash, memo| memo[hash['Title']] = hash['FooterText'] }
     end
 
     def acknowledgements_path
-      search_paths = [ "Pods/Pods-acknowledgements.plist",
-                       "Pods/Target Support Files/Pods/Pods-acknowledgements.plist",
-                       "Pods/Target Support Files/Pods-*/Pods-*-acknowledgements.plist" ]
+      search_paths = ['Pods/Pods-acknowledgements.plist',
+                      'Pods/Target Support Files/Pods/Pods-acknowledgements.plist',
+                      'Pods/Target Support Files/Pods-*/Pods-*-acknowledgements.plist']
 
-      Dir[*search_paths.map {|path| File.join(project_path, path) }].first
+      Dir[*search_paths.map { |path| File.join(project_path, path) }].first
     end
 
-    def read_plist pathname
+    def read_plist(pathname)
       JSON.parse(`plutil -convert json -o - '#{pathname}'`)
     end
   end

data/lib/license_finder/package_managers/cocoa_pods_package.rb

@@ -1,6 +1,6 @@
 module LicenseFinder
   class CocoaPodsPackage < Package
-    def initialize(name, version, license_text, options={})
+    def initialize(name, version, license_text, options = {})
       super(name, version, options)
       @license = License.find_by_text(license_text.to_s)
     end

data/lib/license_finder/package_managers/conan.rb

@@ -0,0 +1,26 @@
+require_relative 'conan_info_parser'
+
+module LicenseFinder
+  class Conan < PackageManager
+    def possible_package_paths
+      [project_path.join('conanfile.txt')]
+    end
+
+    def current_packages
+      install_command = 'conan install'
+      info_command = 'conan info'
+      Dir.chdir(project_path) { Cmd.run(install_command) }
+      info_output, _stderr, _status = Dir.chdir(project_path) { Cmd.run(info_command) }
+
+      info_parser = ConanInfoParser.new
+
+      deps = info_parser.parse(info_output)
+      deps.map do |dep|
+        name, version = dep['name'].split('@').first.split('/')
+        url = dep['URL']
+        license_file_path = Dir.glob("#{project_path}/licenses/#{name}/**/LICENSE*").first
+        ConanPackage.new(name, version, File.open(license_file_path).read, url) unless name == 'PROJECT'
+      end.compact
+    end
+  end
+end

data/lib/license_finder/package_managers/conan_info_parser.rb

@@ -0,0 +1,74 @@
+module LicenseFinder
+  class ConanInfoParser
+    def parse(info)
+      @lines = info.lines.map(&:chomp)
+      @state = :project_level # state of the state machine
+      @projects = [] # list of projects
+      @current_project = nil # current project being populated in the SM
+      @current_vals = [] # current val list being populate in the SM
+      @current_key = nil # current key to be associated with the current val
+      while (line = @lines.shift)
+        next if line == ''
+        case @state
+        when :project_level
+          @current_project = {}
+          @current_project['name'] = line.strip
+          @state = :key_val
+        when :key_val
+          parse_key_val(line)
+        when :val_list
+          parse_val_list(line)
+        end
+      end
+      wrap_up
+    end
+
+    private
+
+    def parse_key_val(line)
+      key, val = key_val(line)
+      if val
+        @current_project[key] = val
+      elsif line.start_with?(' ')
+        @current_key = key
+        @current_vals = []
+        @state = :val_list
+      else
+        change_to_new_project_state line
+      end
+    end
+
+    def parse_val_list(line)
+      if val_list_level(line)
+        @current_vals << line.strip
+      else
+        @current_project[@current_key] = @current_vals
+        if line.start_with?(' ')
+          @state = :key_val
+          @lines.unshift(line)
+        else
+          change_to_new_project_state line
+        end
+      end
+    end
+
+    def wrap_up
+      if @current_vals.count && @current_key then @current_project[@current_key] = @current_vals end
+      @projects << @current_project
+    end
+
+    def val_list_level(line)
+      line.start_with?('        ')
+    end
+
+    def change_to_new_project_state(line)
+      @state = :project_level
+      @projects << @current_project
+      @lines.unshift(line)
+    end
+
+    def key_val(info)
+      info.split(':', 2).map(&:strip!)
+    end
+  end
+end

data/lib/license_finder/package_managers/conan_package.rb

@@ -0,0 +1,17 @@
+module LicenseFinder
+  class ConanPackage < Package
+    def initialize(name, version, license_text, url, options = {})
+      super(name, version, options)
+      @license = License.find_by_text(license_text.to_s)
+      @homepage = url
+    end
+
+    def licenses_from_spec
+      [@license].compact
+    end
+
+    def package_manager
+      'Conan'
+    end
+  end
+end

data/lib/license_finder/package_managers/dep.rb

@@ -0,0 +1,33 @@
+require 'toml'
+
+module LicenseFinder
+  class Dep < PackageManager
+    def possible_package_paths
+      [project_path.join('Gopkg.lock')]
+    end
+
+    def current_packages
+      toml = TOML.load_file(detected_package_path)
+      projects = toml['projects']
+      projects.map do |project|
+        GoPackage.from_dependency({
+                                    'ImportPath' => project['name'],
+                                    'InstallPath' => project_path.join('vendor', project['name']),
+                                    'Rev' => project['revision']
+                                  }, nil, true)
+      end
+    end
+
+    def self.takes_priority_over
+      Go15VendorExperiment
+    end
+
+    def self.prepare_command
+      'dep ensure'
+    end
+
+    def self.package_management_command
+      'dep'
+    end
+  end
+end

data/lib/license_finder/package_managers/glide.rb

@@ -0,0 +1,30 @@
+module LicenseFinder
+  class Glide < PackageManager
+    def possible_package_paths
+      [project_path.join('src', 'glide.lock'), project_path.join('glide.lock')]
+    end
+
+    def current_packages
+      YAML.load_file(detected_package_path).fetch('imports').map do |package_hash|
+        import_path = package_hash.fetch('name')
+        GoPackage.from_dependency({
+                                    'ImportPath' => import_path,
+                                    'InstallPath' => project_path.join('src', 'vendor', import_path),
+                                    'Rev' => package_hash.fetch('version')
+                                  }, nil, true)
+      end
+    end
+
+    def self.takes_priority_over
+      Go15VendorExperiment
+    end
+
+    def self.package_management_command
+      'glide'
+    end
+
+    def self.prepare_command
+      'glide install'
+    end
+  end
+end