classify.rb

#!/usr/bin/env ruby
# frozen_string_literal: true

require "fileutils"
require "json"
require "optparse"
require "yaml"

require_relative "lib/resource_classifier"

base_directory = File.expand_path(__dir__)
options = {
  analysis: File.join(base_directory, "data", "analysis.json"),
  source_scan: File.join(base_directory, "data", "source-scan.json"),
  classifications: File.join(base_directory, "classifications.yml"),
  output: File.join(base_directory, "data", "classified-shared-resources.json")
}

OptionParser.new do |parser|
  parser.banner = "Usage: ruby classify.rb [options]"
  parser.on("--analysis PATH", "Analysis JSON") { |value| options[:analysis] = value }
  parser.on("--source-scan PATH", "Source scan JSON") { |value| options[:source_scan] = value }
  parser.on("--classifications PATH", "Classification YAML") { |value| options[:classifications] = value }
  parser.on("--output PATH", "Classified resource JSON") { |value| options[:output] = value }
end.parse!

source = JSON.parse(File.read(options.fetch(:source_scan)))
analysis = JSON.parse(File.read(options.fetch(:analysis)))
ecosystems = {
  "Ruby" => "gem",
  "JavaScript" => "npm",
  "Rust" => "cargo",
  "Python" => "pypi",
  "C/C++" => "native"
}

resources = source.fetch("shared_resource_locations").flat_map do |language, entries|
  entries.map do |entry|
    ecosystem = ecosystems.fetch(language)
    {
      "identity" => "#{ecosystem}:#{entry.fetch("component")}",
      "name" => entry.fetch("component"),
      "ecosystem" => ecosystem,
      "consumers" => entry.fetch("uses").keys.sort,
      "uses" => entry.fetch("uses")
    }
  end
end.to_h { |resource| [resource.fetch("identity"), resource] }

analysis.dig("dependency_ecosystems", "cargo", "shared_libraries").each do |entry|
  identity = entry.fetch("identity")
  resource = resources[identity] ||= {
    "identity" => identity,
    "name" => entry.fetch("name"),
    "ecosystem" => "cargo",
    "consumers" => [],
    "uses" => {}
  }
  entry.fetch("managers").each do |manager|
    resource.fetch("uses")[manager] ||= [{
      "kind" => "direct_manifest",
      "path" => entry.fetch("paths").fetch(manager),
      "requirement" => entry.fetch("requirements").fetch(manager)
    }]
  end
  resource["consumers"] = resource.fetch("uses").keys.sort
end

rules = YAML.safe_load_file(options.fetch(:classifications), aliases: false)
categories = PackageManagerReuse::ResourceClassifier.new(rules).call(resources.values)
output = {
  "categories" => categories,
  "resource_count" => resources.length
}
FileUtils.mkdir_p(File.dirname(options.fetch(:output)))
File.write(options.fetch(:output), JSON.pretty_generate(output) + "\n")
puts "Wrote #{options.fetch(:output)}"