license_finder-rubyzip3 7.2.1.1

data/lib/license_finder/package_utils/notice_files.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'license_finder/package_utils/possible_license_file'
+
+module LicenseFinder
+  class NoticeFiles
+    CANDIDATE_FILE_NAMES = %w[NOTICE Notice].freeze
+    CANDIDATE_PATH_WILDCARD_STRICT = "{#{CANDIDATE_FILE_NAMES.join(',')}}*"
+    CANDIDATE_PATH_WILDCARD = "*#{CANDIDATE_PATH_WILDCARD_STRICT}"
+
+    def self.find(install_path, options = {})
+      new(install_path).find(options)
+    end
+
+    def initialize(install_path)
+      @install_path = install_path ? Pathname(install_path) : nil
+    end
+
+    def find(options = {})
+      paths_of_candidate_files
+        .map { |path| PossibleLicenseFile.new(path, options) } # Not really possible license files, but that class has all we need.
+    end
+
+    private
+
+    attr_reader :install_path
+
+    def paths_of_candidate_files
+      candidate_files_and_dirs
+        .flat_map { |path| !path.is_a?(Zip::Entry) && path.directory? ? path.children : path }
+        .reject(&:directory?)
+        .uniq
+    end
+
+    def candidate_files_and_dirs
+      return [] if install_path.nil?
+
+      if !install_path.extname.casecmp('.jar').zero?
+        Pathname.glob(install_path.join('**', CANDIDATE_PATH_WILDCARD))
+      else
+        candidates_from_zip
+      end
+    end
+
+    def candidates_from_zip
+      Zip::File.open(install_path.to_s) do |zip_file|
+        zip_file.glob("*/#{CANDIDATE_PATH_WILDCARD_STRICT}", File::FNM_EXTGLOB)
+      end
+    end
+  end
+end

data/lib/license_finder/package_utils/possible_license_file.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module LicenseFinder
+  class PossibleLicenseFile
+    def initialize(path, options = {})
+      if !path.is_a?(Zip::Entry)
+        @path = Pathname(path)
+      else
+        @zip_entry = path
+      end
+      @logger = options[:logger]
+    end
+
+    def path
+      @path.to_s
+    end
+
+    def license
+      License.find_by_text(text)
+    end
+
+    def text
+      if @zip_entry
+        @zip_entry.get_input_stream.read
+      elsif @path.exist?
+        @text ||= (@path.respond_to?(:binread) ? @path.binread : @path.read)
+      else
+        @logger.info('ERROR', "#{@path} does not exists", color: :red)
+        ''
+      end
+    end
+  end
+end

data/lib/license_finder/package_utils/pypi.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'openssl'
+
+module LicenseFinder
+  class PyPI
+    CONNECTION_ERRORS = [
+      EOFError,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::ECONNRESET,
+      Errno::EHOSTUNREACH,
+      Errno::EINVAL,
+      Net::OpenTimeout,
+      Net::ProtocolError,
+      Net::ReadTimeout,
+      OpenSSL::OpenSSLError,
+      OpenSSL::SSL::SSLError,
+      SocketError,
+      Timeout::Error
+    ].freeze
+
+    class << self
+      def definition(name, version)
+        response = request("https://pypi.org/pypi/#{name}/#{version}/json")
+        response.is_a?(Net::HTTPSuccess) ? JSON.parse(response.body).fetch('info', {}) : {}
+      rescue *CONNECTION_ERRORS => e
+        raise e, "Unable to read package from pypi.org #{name} #{version}: #{e}" unless @prepare_no_fail
+
+        {}
+      end
+
+      def request(location, limit = 10)
+        uri = URI(location)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        response = http.get(uri.request_uri).response
+        response.is_a?(Net::HTTPRedirection) && limit.positive? ? request(response['location'], limit - 1) : response
+      end
+    end
+  end
+end

data/lib/license_finder/package_utils/sbt_dependency_finder.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module LicenseFinder
+  class SbtDependencyFinder
+    def initialize(project_path)
+      @project_path = project_path
+    end
+
+    def dependencies
+      Pathname
+        .glob(@project_path.join('**', 'target', 'license-reports', '*.csv'))
+        .map(&:read)
+    end
+  end
+end

data/lib/license_finder/packages/bower_package.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'open-uri'
+module LicenseFinder
+  class BowerPackage < Package
+    def initialize(bower_module, options = {})
+      spec = bower_module.fetch('pkgMeta', {})
+
+      if spec.empty?
+        endpoint = bower_module.fetch('endpoint', {})
+        name = endpoint['name']
+        version = endpoint['target']
+      else
+        name = spec['name']
+        version = spec['version']
+      end
+
+      super(
+        name,
+        version,
+        options.merge(
+          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']
+        )
+      )
+    end
+
+    def package_manager
+      'Bower'
+    end
+
+    def package_url
+      meta = if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.5.0')
+               JSON.parse(open("https://registry.bower.io/packages/#{CGI.escape(name)}").read)
+             else
+               JSON.parse(URI.open("https://registry.bower.io/packages/#{CGI.escape(name)}").read)
+             end
+      meta['url']
+    end
+  end
+end

data/lib/license_finder/packages/bundler_package.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module LicenseFinder
+  class BundlerPackage < Package
+    def initialize(spec, bundler_def, options = {})
+      children = spec.dependencies.map(&:name)
+      groups = Array(bundler_def && bundler_def.groups).map(&:to_s)
+
+      super(
+        spec.name,
+        spec.version.to_s,
+        options.merge(
+          authors: Array(spec.authors).join(', '),
+          summary: spec.summary,
+          description: spec.description,
+          homepage: spec.homepage,
+          children: children,
+          groups: groups,
+          spec_licenses: spec.licenses,
+          install_path: spec.full_gem_path
+        )
+      )
+    end
+
+    def package_manager
+      'Bundler'
+    end
+
+    def package_url
+      "https://rubygems.org/gems/#{CGI.escape(name)}/versions/#{CGI.escape(version)}"
+    end
+  end
+end

data/lib/license_finder/packages/cargo_package.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module LicenseFinder
+  class CargoPackage < Package
+    def initialize(crate, options = {})
+      crate = crate.reject { |_, v| v.nil? || v == '' }
+      children = crate.fetch('dependencies', []).map { |p| p['name'] }
+      licenses = crate.fetch('license', '').split('/')
+      super(
+        crate['name'],
+        crate['version'],
+        options.merge(
+          summary: crate.fetch('description', '').strip,
+          spec_licenses: licenses.compact,
+          children: children
+        )
+      )
+    end
+
+    def package_manager
+      'Cargo'
+    end
+
+    def package_url
+      "https://crates.io/crates/#{CGI.escape(name)}/#{CGI.escape(version)}"
+    end
+  end
+end

data/lib/license_finder/packages/carthage_package.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+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/packages/cocoa_pods_package.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module LicenseFinder
+  class CocoaPodsPackage < 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
+      'CocoaPods'
+    end
+
+    def package_url
+      "https://cocoapods.org/pods/#{CGI.escape(name)}"
+    end
+  end
+end

data/lib/license_finder/packages/composer_package.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module LicenseFinder
+  class ComposerPackage < Package
+    def package_manager
+      'Composer'
+    end
+
+    def package_url
+      "https://packagist.org/packages/#{CGI.escape(name)}##{CGI.escape(version)}"
+    end
+  end
+end

data/lib/license_finder/packages/conan_package.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+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
+
+    def package_url
+      "https://conan.io/center/#{CGI.escape(name)}/#{CGI.escape(version)}"
+    end
+  end
+end

data/lib/license_finder/packages/conda_package.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module LicenseFinder
+  class CondaPackage < Package
+    attr_accessor :identifier, :json
+
+    def initialize(conda_json)
+      @json = conda_json
+      @identifier = Identifier.from_hash(conda_json)
+      super(@identifier.name,
+            @identifier.version,
+            spec_licenses: Package.license_names_from_standard_spec(conda_json),
+            children: children)
+    end
+
+    def ==(other)
+      other.is_a?(CondaPackage) && @identifier == other.identifier
+    end
+
+    def to_s
+      @identifier.to_s
+    end
+
+    def package_manager
+      'Conda'
+    end
+
+    def package_url
+      @json['url']
+    end
+
+    def children
+      @json.fetch('depends', []).map { |constraint| constraint.split.first }
+    end
+
+    class Identifier
+      attr_accessor :name, :version
+
+      def initialize(name, version)
+        @name = name
+        @version = version
+      end
+
+      def self.from_hash(hash)
+        name = hash['name']
+        version = hash['version']
+        return nil if name.nil? || version.nil?
+
+        Identifier.new(name, version)
+      end
+
+      def ==(other)
+        other.is_a?(Identifier) && @name == other.name && @version == other.version
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        [@name, @version].hash
+      end
+
+      def <=>(other)
+        sort_name = @name <=> other.name
+        sort_name.zero? ? @version <=> other.version : sort_name
+      end
+
+      def to_s
+        "#{@name} - #{@version}"
+      end
+    end
+  end
+end

data/lib/license_finder/packages/erlangmk_package.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+
+class InvalidErlangmkPackageError < ArgumentError
+end
+
+module LicenseFinder
+  class ErlangmkPackage < Package
+    attr_reader :dep_parent,
+                :dep_name,
+                :dep_fetch_method,
+                :dep_repo_unformatted,
+                :dep_version_unformatted,
+                :dep_absolute_path
+
+    def initialize(dep_string_from_query_deps)
+      @dep_parent,
+      @dep_name,
+      @dep_fetch_method,
+      @dep_repo_unformatted,
+      @dep_version_unformatted,
+      @dep_absolute_path = dep_string_from_query_deps.split
+
+      raise_invalid(dep_string_from_query_deps) unless all_parts_valid?
+
+      super(
+        dep_name,
+        dep_version,
+        homepage: dep_repo,
+        install_path: dep_absolute_path
+      )
+    end
+
+    def package_manager
+      'Erlangmk'
+    end
+
+    def dep_version
+      @dep_version ||= dep_version_unformatted.sub(version_prefix_re, '')
+    end
+
+    def dep_repo
+      @dep_repo ||= dep_repo_unformatted
+                    .chomp('.git')
+                    .sub('git@github.com:', 'https://github.com/')
+    end
+
+    def raise_invalid(dep_string)
+      invalid_dep_message = "'#{dep_string}' does not look like a valid Erlank.mk dependency"
+      valid_dep_example = "A valid dependency example: 'lager: goldrush git https://github.com/DeadZen/goldrush.git 0.1.9 /absolute/path/to/dep'"
+      raise(InvalidErlangmkPackageError, "#{invalid_dep_message}. #{valid_dep_example}")
+    end
+
+    def all_parts_valid?
+      dep_part_valid?(dep_parent) &&
+        dep_part_valid?(dep_name) &&
+        set?(dep_fetch_method) &&
+        dep_repo_valid? &&
+        dep_version_valid? &&
+        set?(dep_absolute_path)
+    end
+
+    private
+
+    def dep_part_valid?(dep_part)
+      set?(dep_part) &&
+        word?(dep_part)
+    end
+
+    def set?(dep_part)
+      !dep_part.nil? &&
+        !dep_part.empty?
+    end
+
+    def word?(dep_part)
+      dep = dep_part.chomp(':')
+      dep =~ word_re
+    end
+
+    def dep_repo_valid?
+      set?(dep_repo_unformatted) &&
+        URI.parse(dep_repo)
+    end
+
+    def dep_version_valid?
+      return false unless set?(dep_version_unformatted)
+
+      if dep_version&.match?(version_re)
+        Gem::Version.correct?(dep_version)
+      else
+        dep_version =~ word_dot_re
+      end
+    end
+
+    def version_re
+      @version_re ||= Regexp.new('\d+\.\d+\.\d+')
+    end
+
+    def version_prefix_re
+      @version_prefix_re ||= Regexp.new('^v')
+    end
+
+    def word_re
+      @word_re ||= Regexp.new('^\w+$')
+    end
+
+    def word_dot_re
+      @word_dot_re ||= Regexp.new('^[.\w]+$')
+    end
+  end
+end

data/lib/license_finder/packages/go_package.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module LicenseFinder
+  class GoPackage < Package
+    def package_manager
+      'Go'
+    end
+
+    def package_url
+      "https://pkg.go.dev/#{CGI.escape(name)}@#{CGI.escape(version)}"
+    end
+
+    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'].gsub('+incompatible', '') : hash['Rev'][0..6]
+        homepage = hash['Homepage']
+        new(name, version, install_path: install_path, package_manager: 'Go', homepage: homepage)
+      end
+
+      private
+
+      def install_path(path)
+        Pathname(path).cleanpath.to_s
+      end
+    end
+  end
+end

data/lib/license_finder/packages/gradle_package.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module LicenseFinder
+  class GradlePackage < Package
+    def initialize(spec, options = {})
+      name = spec['name']
+      if name.scan(':').size >= 1
+        group, name, version = name.split(':')
+      else
+        version = 'unknown'
+      end
+
+      name = options[:include_groups] ? "#{group}:#{name}" : name
+
+      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
+
+    def package_manager
+      'Gradle'
+    end
+
+    def package_url
+      "https://plugins.gradle.org/plugin/#{CGI.escape(name)}/#{CGI.escape(version)}"
+    end
+  end
+end

data/lib/license_finder/packages/manual_package.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module LicenseFinder
+  class ManualPackage < Package
+    def ==(other)
+      eql? other
+    end
+
+    def eql?(other)
+      name == other.name
+    end
+
+    def hash
+      name.hash
+    end
+
+    private
+
+    def licenses_from_spec
+      Set.new
+    end
+
+    def licenses_from_files
+      Set.new
+    end
+  end
+end

data/lib/license_finder/packages/maven_package.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module LicenseFinder
+  class MavenPackage < Package
+    def initialize(spec, options = {})
+      name = spec['artifactId']
+      name = "#{spec['groupId']}:#{name}" if options[:include_groups]
+      @jar_file = spec['jarFile']
+
+      super(
+        name,
+        spec['version'],
+        options.merge(
+          spec_licenses: Array(spec['licenses']).map { |l| l['name'] },
+          groups: Array(spec['groupId']),
+          summary: spec['summary'],
+          description: spec['description'],
+          homepage: spec['homepage']
+        )
+      )
+    end
+
+    def package_manager
+      'Maven'
+    end
+
+    def package_url
+      "https://search.maven.org/artifact/#{CGI.escape(groups.first)}/#{CGI.escape(name.split(':').last)}/#{CGI.escape(version)}/jar"
+    end
+
+    def license_files
+      LicenseFiles.find(@jar_file, logger: logger)
+    end
+
+    def notice_files
+      NoticeFiles.find(@jar_file, logger: logger)
+    end
+  end
+end

data/lib/license_finder/packages/merged_package.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module LicenseFinder
+  class MergedPackage < Package
+    extend Forwardable
+    attr_reader :dependency
+
+    def initialize(package, aggregate_paths)
+      @dependency = package
+      @aggregate_paths = aggregate_paths.map { |p| Pathname(p) }
+      super(package.name, package.version)
+    end
+
+    def_delegators :@dependency, :name, :version, :authors, :summary, :description, :homepage, :package_url, :children, :parents,
+                   :groups, :permitted, :restricted, :manual_approval, :install_path, :licenses, :approved_manually?,
+                   :approved_manually!, :approved?, :permitted!, :permitted?, :restricted!, :restricted?, :hash,
+                   :activations, :missing, :license_names_from_spec, :decided_licenses, :licensing, :decide_on_license,
+                   :license_files, :package_manager, :missing?, :log_activation, :notice_files
+
+    def aggregate_paths
+      @aggregate_paths.map { |p| p.expand_path.to_s }
+    end
+
+    def <=>(other)
+      dependency <=> other.dependency
+    end
+
+    def eql?(other)
+      if other.instance_of? MergedPackage
+        other.dependency.eql?(dependency)
+      else
+        dependency.eql?(other)
+      end
+    end
+
+    def ==(other)
+      dependency.eql?(other.dependency) && aggregate_paths.eql?(other.aggregate_paths)
+    end
+
+    def method_missing(_method_name)
+      nil
+    end
+  end
+end