class LicenseFinder::Package

  • otherwise, override #licenses_from_spec or #license_files
    the constructor options
    - if the package’s files can be searched for licenses pass :install_path in
    constructor options
    - if the package specs will report license names, pass :spec_licenses in the
    package manager
    - subclass Package, and initialize based on the data you receive from the
    Guidance on adding a new system
    systems (gems, npm, pip, etc.) to a common interface.
    Super-class that adapts data from different package management

def self.license_names_from_standard_spec(spec) 

def self.license_names_from_standard_spec(spec)
  licenses = spec['licenses'] || [spec['license']].compact
  licenses = [licenses] unless licenses.is_a?(Array)
  licenses = licenses.flatten
  licenses.map do |license|
    if license.is_a? Hash
      license['type']
    else
      license
    end
  end
end

def <=>(other) 

def <=>(other)
  eq_name = name <=> other.name
  return eq_name unless eq_name.zero?
  version <=> other.version
end

def activations 

def activations
  licensing.activations.tap do |activations|
    activations.each { |activation| log_activation activation }
  end
end

def approved? 

def approved?
  # Question: is `!restricted?` redundant?
  # DecisionApplier does not call `permitted!` or `approved_manually!`
  # if a Package has been restricted.
  (approved_manually? || permitted?) && !restricted?
end

def approved_manually!(approval) 

def approved_manually!(approval)
  @manual_approval = approval
end

def approved_manually? 

def approved_manually?
  !@manual_approval.nil?
end

def decide_on_license(license) 

def decide_on_license(license)
  @decided_licenses << license
end

def eql?(other) 

def eql?(other)
  name == other.name && version == other.version
end

def hash 

def hash
  [name, version].hash
end

def initialize(name, version = nil, options = {}) 

def initialize(name, version = nil, options = {})
  @logger = options[:logger] || Core.default_logger
  ## DESCRIPTION
  @name = name
  @version = version || ''
  @authors = options[:authors] || ''
  @summary = options[:summary] || ''
  @description = options[:description] || ''
  @homepage = options[:homepage] || ''
  @package_url = options[:package_url].to_s
  @children = options[:children] || []
  @parents = Set.new # will be figured out later by package manager
  @groups = options[:groups] || []
  ## APPROVAL
  @permitted = false
  @restricted = false
  @manual_approval = nil
  ## LICENSING
  @license_names_from_spec = options[:spec_licenses] || []
  @install_path = options[:install_path]
  @missing = options[:missing] || false
  @decided_licenses = Set.new
end

def license_files 

def license_files
  LicenseFiles.find(install_path, logger: logger)
end

def licenses 

def licenses
  @licenses ||= activations.map(&:license).sort_by(&:name).to_set
end

def licenses_from_spec 

def licenses_from_spec
  license_names_from_spec
    .map { |name| License.find_by_name(name) }
    .to_set
end

def licensing 

def licensing
  Licensing.new(self, @decided_licenses, licenses_from_spec, license_files)
end

def log_activation(activation) 

def log_activation(activation)
  preamble = format('package %s:', activation.package.name)
  if activation.sources.empty?
    logger.debug activation.package.class, format('%s no licenses found', preamble)
  else
    activation.sources.each do |source|
      logger.debug activation.package.class, format("%s found license '%s' %s", preamble, activation.license.name, source)
    end
  end
end

def missing? 

def missing?
  @missing
end

def notice_files 

def notice_files
  NoticeFiles.find(install_path, logger: logger)
end

def package_manager 

def package_manager
  'unknown'
end

def permitted! 

def permitted!
  @permitted = true
end

def permitted? 

def permitted?
  @permitted
end

def restricted! 

def restricted!
  @restricted = true
end

def restricted? 

def restricted?
  @restricted
end