kmx.io/rbpkg/lib/rbpkg/repo.rb

Branch - branch -master

• Show log

  Commit

• Hash : c586cb54
  Author : Thomas de Grivel
  Date : 2025-09-10T14:37:22
  

  fix uninstall_required_by
  

Download

• lib/rbpkg/repo.rb

• require 'fileutils'
  load "#{File.dirname(__FILE__)}/sha256.rb"
  
  class Rbpkg::Repo
  
    @@remote_default = "origin"
  
    def autogen
      verbose 3, "repo(#{name.inspect}).autogen"
      if File.executable?("#{src_dir}/autogen")
        cmd! "cd #{sh_quote(src_dir)} && #{autogen_env} ./autogen"
      elsif File.exist?("#{src_dir}/autogen.sh")
        cmd! "cd #{sh_quote(src_dir)} && #{autogen_env} sh autogen.sh"
      elsif File.executable?("#{src_dir}/bootstrap")
        cmd! "cd #{sh_quote(src_dir)} && #{autogen_env} ./bootstrap"
      end
    end
  
    def autogen_env
      ""
    end
  
    def build
      verbose 3, "repo(#{name.inspect}).build"
      if ! tag_present?("build-done")
        configure()
        if File.file?("#{src_dir}/Makefile")
          cmd! "cd #{sh_quote(src_dir)} && #{make_cmd}"
        elsif File.file?("#{src_dir}/CMakeLists.txt")
          cmake_cmd
        end
        tag_set("build-done")
      end
    end
  
    def cmake_cmd
      cmd! "cmake -j #{Rbpkg.ncpu} --build #{sh_quote(obj_dir)}"
    end
  
    def make_cmd
      "#{make} -j #{Rbpkg.ncpu}"
    end
  
    def checkout
      verbose(3, "repo(#{name.inspect}).checkout")
      sh_tree=sh_quote(tree)
      cmd! "cd #{sh_quote(src_dir!)} && git fetch --all"
      cmd! "cd #{sh_quote(src_dir!)} && git reset --hard"
      cmd! "cd #{sh_quote(src_dir!)} && git checkout #{sh_tree} --"
      cmd! "cd #{sh_quote(src_dir!)} && git reset --hard"
      cmd! "cd #{sh_quote(src_dir!)} && git submodule update"
    end
  
    def ci(ref, commit)
      verbose(3, "repo(#{name.inspect}).ci(#{ref.inspect}, #{commit.inspect})")
      ref = tree unless ref
      commit = hash unless commit
      Rbpkg::Log.add(ci_log_name_commit(commit))
      sh_name = sh_quote(name)
      sh_ci_dir = sh_quote(ci_dir)
      sh_ci_profile = sh_quote(ci_dir + '/etc/profile')
      cmd! "#{sh_quote(Rbpkg.dir)}/bin/rbpkg_bootstrap -f #{sh_quote(ci_dir)}"
      cmd! ". ~/.profile; export RBPKG_DIR=#{sh_ci_dir}; . #{sh_ci_profile}; rbpkg clone #{sh_name}"
      cmd! ". ~/.profile; export RBPKG_DIR=#{sh_ci_dir}; . #{sh_ci_profile}; rbpkg checkout #{sh_quote(commit)} #{sh_name}" if commit
      cmd! ". ~/.profile; export RBPKG_DIR=#{sh_ci_dir}; . #{sh_ci_profile}; rbpkg info #{sh_name}"
      cmd! ". ~/.profile; export RBPKG_DIR=#{sh_ci_dir}; . #{sh_ci_profile}; rbpkg configure #{sh_name}"
      cmd! ". ~/.profile; export RBPKG_DIR=#{sh_ci_dir}; . #{sh_ci_profile}; rbpkg build #{sh_name}"
      cmd! ". ~/.profile; export RBPKG_DIR=#{sh_ci_dir}; . #{sh_ci_profile}; rbpkg test #{sh_name}"
      cmd! ". ~/.profile; export RBPKG_DIR=#{sh_ci_dir}; . #{sh_ci_profile}; rbpkg install #{sh_name}"
      cmd! ". ~/.profile; export RBPKG_DIR=#{sh_ci_dir}; . #{sh_ci_profile}; rbpkg info #{sh_name}"
      Rbpkg::Log.ok(ci_log_name_commit(commit))
    end
  
    def ci_dir
      @ci_dir || @ci_dir = "#{Rbpkg.ci_build_dir}/#{name}"
    end
  
    def ci_log_name_commit(commit)
      "rbpkg_ci.#{name}.commit_#{commit}"
    end
  
    def ci_log_name_ref(ref)
      "rbpkg_ci.#{name}.ref_#{ref}"
    end
  
    def clean_all
      verbose(3, "repo(#{name.inspect}).clean_all")
      clean_fake
      clean_build
      clean_configure
      clean_sources
    end
  
    def clean_build
      verbose 3, "repo(#{name.inspect}).clean_build"
      if File.file?("#{src_dir}/Makefile")
        cmd! "cd #{sh_quote(src_dir)} && #{make} clean"
      end
      if File.directory?(obj_dir)
        cmd! "rm -rf #{sh_quote(obj_dir)}"
      end
      tag_remove("build-done") if tag_present?("build-done")
    end
  
    def clean_configure
      verbose 3, "repo(#{name.inspect}).clean_configure"
      tag_remove("configure-done") if tag_present?("configure-done")
    end
  
    def clean_fake
      verbose 3, "repo(#{name.inspect}).clean_fake"
      if File.directory?(fake_dir)
        cmd! "rm -rf #{sh_quote(fake_dir)}"
      end
    end
  
    def clean_package
      verbose 3, "repo(#{name.inspect}).clean_package"
      if File.file?(package_checksum)
        cmd! "rm #{sh_quote(package_checksum)}"
      end
      if File.file?(package_tar)
        cmd! "rm #{sh_quote(package_tar)}"
      end
      if File.file?(package_tar_bz2)
        cmd! "rm #{sh_quote(package_tar_bz2)}"
      end
      if File.file?(package_tar_gz)
        cmd! "rm #{sh_quote(package_tar_gz)}"
      end
      if File.file?(package_tar_xz)
        cmd! "rm #{sh_quote(package_tar_xz)}"
      end
    end
  
    def clean_sources
      verbose 3, "repo(#{name.inspect}).clean_sources"
      tag_remove("build-done") if tag_present?("build-done")
      tag_remove("configure-done") if tag_present?("configure-done")
      if File.directory?(src_dir)
        cmd! "rm -rf #{sh_quote(src_dir)}"
      end
      if File.directory?(src_parent_dir) && Dir.new(src_parent_dir).children == []
        cmd! "rmdir #{sh_quote(src_parent_dir)}"
      end
    end
  
    def configure
      verbose 3, "repo(#{name.inspect}).configure"
      install_dependencies
      if ! File.directory?(src_dir)
        git_clone()
      end
      if ! tag_present?("configure-done")
        autogen()
        r = if File.executable?("#{src_dir}/configure")
              cmd! "cd #{sh_quote(src_dir)} && #{configure_env} ./configure --prefix #{sh_quote(Rbpkg.prefix)}"
            elsif File.exist?("#{src_dir}/configure.sh")
              cmd! "cd #{sh_quote(src_dir)} && sh configure.sh --prefix #{sh_quote(Rbpkg.prefix)}"
            elsif File.exist?("#{src_dir}/CMakeLists.txt")
              cmd! "cmake -S #{sh_quote(src_dir)} -B #{sh_quote(obj_dir)} -D CMAKE_INSTALL_PREFIX:PATH=#{sh_quote(Rbpkg.prefix)} -D BUILD_SHARED_LIBS=ON"
            end      
        tag_set("configure-done") if r
        r
      end
    end
  
    def configure_env
      ""
    end
  
    def self.dependencies
      nil
    end
  
    def dependencies
      self.class.dependencies
    end
  
    def dir
      "#{File.basename(File.dirname(git_url))}/#{name}"
    end
  
    def fake
      verbose 3, "repo(#{name.inspect}).fake"
      build()
      if File.directory?(fake_dir)
        cmd! "rm -rf #{sh_quote(fake_dir)}"
      end
      cmd! "mkdir -p #{sh_quote(fake_dir)}"
      if File.file?("#{src_dir}/Makefile")
        cmd! "cd #{sh_quote(src_dir)} && #{make} prefix=#{sh_quote(fake_dir)} install"
      elsif File.file?("#{src_dir}/CMakeLists.txt")
        cmd! "cmake --install #{sh_quote(obj_dir)} --prefix #{sh_quote(fake_dir)}"
      end
    end
  
    def fake_dir
      "#{Rbpkg.fake_dir}/#{dir}#{Rbpkg.prefix}"
    end
  
    def fetch
      verbose 3, "repo(#{name.inspect}).fetch"
      cmd! "cd #{sh_quote(src_dir!)} && git fetch --all"
    end
  
    def git_clone
      verbose 3, "repo(#{name.inspect}).git_clone"
      if File.directory?(src_dir)
        false
      else
        if ! File.directory?(src_parent_dir)
          cmd! "mkdir -p #{sh_quote(src_parent_dir)}"
        end
        cmd! "cd #{sh_quote(src_parent_dir)} && git clone #{sh_quote(git_url)} -b #{sh_quote(tree)} #{sh_quote(name)}"
        cmd! "cd #{sh_quote(src_dir)} && git submodule init && git submodule update"
      end
    end
  
    def git_url
      raise "no git url for #{self}"
    end
  
    def hash
      if File.directory?(src_dir)
        r = `git -C #{sh_quote(src_dir)} show-ref --head HEAD | cut -d ' ' -f 1 | head -n 1`.strip
        raise "git error" unless r
        r
      end
    end
  
    def head
      if File.directory?(src_dir)
        r = `git -C #{sh_quote(src_dir)} show-ref | grep #{sh_quote(hash)} | grep ' refs/heads/' | sed -e 's,^.* refs/heads/,,'`.strip
        raise "git error" unless r
        r
      end
    end
  
    def initialize(tree)
      @tree = tree
    end
  
    def inspect
      """%{
    name: #{name.inspect},
    dir: #{dir.inspect},
    git_url: #{git_url.inspect},
    src_dir: #{src_dir.inspect},
    src_parent_dir: #{src_parent_dir.inspect},
    head: #{tree.inspect},
    hash: #{hash.inspect},
    configure_env: #{configure_env.inspect},
    make: #{make.inspect},
    make_cmd: #{make_cmd.inspect},
    version:           #{version.inspect},
    installed_version: #{installed_version.inspect},
    dependencies: #{dependencies.inspect},
    required_by: #{required_by.inspect}
  }"""
    end
  
    def install
      verbose 3, "repo(#{name.inspect}).install"
      return if system_package?
      return if installed?
      install_dependencies
      build
      package
      cmd! "cd #{sh_quote(Rbpkg.prefix)} && unxz < #{sh_quote(package_tar_xz)} | pax -rd"
      if ! File.directory?(installed_dir)
        cmd! "mkdir -p #{sh_quote(installed_dir)}"
      end
      File.open(installed, "w") do |output|
        output.puts "Version: #{version}"
        File.open(package_checksum, "r") do |input|
          while line = input.gets
            output.write(line)
          end
        end
        output.close
      end
      cmd! "#{Rbpkg.libtool} --mode=finish #{Rbpkg.lib_dir}"
    end
  
    def install_dependencies
      verbose 3, "repo(#{name.inspect}).install_dependencies"
      if dependencies
        Rbpkg.install(dependencies)
      end
    end
  
    def installed
      "#{Rbpkg.installed_dir}/#{dir}"
    end
  
    def installed?
      File.file?(installed)
    end
  
    def installed_dir
      File.dirname(installed)
    end
  
    def installed_version
      if installed?
        File.open(installed, "r") do |input|
          while line = input.gets
            if version = line.scan(/^Version: (.*)$/)[0]
              return version[0]
            end
          end
        end
      end
    end
  
    def make
      "make"
    end
  
    def name
      self.class.repo_name
    end
  
    def self.repo_register
      Rbpkg::Repos.def_repo(repo_name, self)
    end
  
    def obj_dir
      "#{Rbpkg.obj_dir}/#{dir}"
    end
  
    def package
      verbose 3, "repo(#{name.inspect}).package"
      return if File.file?(package_tar_bz2) &&
                File.file?(package_tar_gz) &&
                File.file?(package_tar_xz)
      fake()
      cmd! "mkdir -p #{sh_quote(package_dir)}" unless File.directory?(package_dir)
      package_checksum_compute
      sh_package_tar = sh_quote(package_tar)
      cmd! "cd #{sh_quote(fake_dir)} && pax -w . > #{sh_package_tar} && bzip2 -9 < #{sh_package_tar} > #{sh_quote(package_tar_bz2)} && gzip -9 < #{sh_package_tar} > #{sh_quote(package_tar_gz)} && xz -9 < #{sh_package_tar} > #{sh_quote(package_tar_xz)}"
    end
  
    def package_checksum_compute
      File.open(package_checksum, "w") do |output|
        Dir.chdir(fake_dir) do
          package_checksum_rec(nil, Dir.new(".").children, output)
        end
      end
    end
  
    def package_checksum_rec(path, files, output)
      files.sort.each do |f|
        path_f = path ? "#{path}/#{f}" : f
        if File.directory?(path_f)
          package_checksum_rec(path_f, Dir.new(path_f).children, output)
        else
          digest = Rbpkg::SHA256.file(path_f)
          output.write("SHA256 (#{path_f}) = #{digest}\n")
        end
      end
    end
  
    def package_checksum
      package_path(".SHA256")
    end
  
    def package_dir
      File.dirname(package_path)
    end
  
    def package_path(suffix = "")
      "#{Rbpkg.package_dir}/#{dir}-#{version}#{suffix}"
    end
  
    def package_tar
      package_path(".tar")
    end
  
    def package_tar_bz2
      package_path(".tar.bz2")
    end
  
    def package_tar_gz
      package_path(".tar.gz")
    end
  
    def package_tar_xz
      package_path(".tar.xz")
    end
  
    def pull
      verbose 3, "repo(#{name.inspect}).pull"
      cmd! "cd #{sh_quote(src_dir!)} && { git pull; git submodule init; git submodule update; }"
    end
  
    def pull_possible?
      File.directory?(src_dir) &&
        system("git -C #{sh_quote(src_dir)} symbolic-ref HEAD >/dev/null 2>&1")
    end
  
    def remote
      @@remote_default
    end
  
    @required_by = nil
    def required_by
      @required_by || @required_by =
        begin
          r = []
          Rbpkg::Repos.repos.each do |repo_name, repo_class|
            if repo_class.dependencies&.include?(name)
              r << repo_name
            end
          end
          r
        end
    end
  
    def src_dir
      "#{Rbpkg.src_dir}/#{dir}/tree/#{tree}/#{name}"
    end
  
    def src_dir!
      path = src_dir
      raise "must clone first" unless File.directory?(path)
      path
    end
  
    def src_parent_dir
      File.dirname(src_dir)
    end
  
    def system_package?
      false
    end
  
    def tag_dir
      "#{Rbpkg.tag_dir}/#{dir}/#{version}"
    end
  
    def tag_path(tag)
      "#{tag_dir}/#{tag}"
    end
  
    def tag_present?(tag)
      File.file?(tag_path(tag))
    end
  
    def tag_remove(tag)
      raise "tag not set" unless tag_present?(tag)
      File.delete(tag_path(tag))
    end
  
    def tag_set(tag)
      verbose 3, "repo(#{name.inspect}).tag_set(#{tag})"
      raise "tag already set" if tag_present?(tag)
      FileUtils.mkdir_p tag_dir unless File.directory?(tag_dir)
      File.write(tag_path(tag), "#{Rbpkg.date}\n")
    end
  
    def test
      verbose 3, "repo(#{name.inspect}).test"
      build()
      if File.file?("#{src_dir}/Makefile")
        cmd! "cd #{sh_quote(src_dir)} && #{make_cmd} #{sh_quote(test_make_rule)}"
      end
    end
  
    def test_make_rule
      "test"
    end
  
    def tree
      @tree
    end
  
    def uninstall
      verbose 3, "repo(#{name.inspect}).uninstall"
      if installed?
        uninstall_required_by
        File.open(installed, "r") do |input|
          while line = input.gets
            if (scan = line.scan(/^(SHA256 \((.*)\) = ([0-9A-Fa-f]*))$/)[0])
              line = scan[0]
              file = scan[1]
              hash = scan[2]
              path = "#{Rbpkg.prefix}/#{file}"
              digest = Rbpkg::SHA256.file(path)
              if (hash == digest)
                cmd! "rm #{sh_quote(path)}"
              end
            end
          end
        end
        File.delete(installed)
      end
    end
  
    def uninstall_required_by
      verbose 3, "repo(#{name.inspect}).uninstall_required_by"
      required_by.each do |req|
        Rbpkg::Repos.repo(req, nil).uninstall
      end
    end
  
    def upgrade
      verbose 3, "repo(#{name.inspect}).upgrade"
      pull if pull_possible?
      return if installed_version == version
      package
      uninstall
      install
    end
  
    def version
      if File.directory?(src_dir)
        "#{tree}-#{hash}"
      end
    end
  end
  

Download