#   https://github.com/rust-lang/cargo/issues/6397

  # But we can set CARGO_HOME locally, which is a good idea anyway to make sure

  # it never writes to ~/.cargo during rpmbuild.

  %__cargo_inspector %{_bindir}/cargo-inspector

  %cargo_registry %{_datadir}/cargo/registry

  replace-with = "local-registry"\

  EOF\

  %{__rm} -f Cargo.lock \

  )

  %__cargo_parse_opts(naf:) %{shrink:\

    CRATE_VERSION=$(%__cargo_inspector --version Cargo.toml)          \

    REG_DIR=%{buildroot}%{cargo_registry}/$CRATE_NAME-$CRATE_VERSION  \

    %{__mkdir} -p $REG_DIR                                            \

    %{__cargo} package -l | xargs -d '\\\n' %{__cp} --parents -a -t $REG_DIR \

    echo '{"files":{},"package":""}' > $REG_DIR/.cargo-checksum.json  \

  fi \

  if %__cargo_is_bin; then                                            \

  XDG_CACHE_HOME = os.getenv("XDG_CACHE_HOME", os.path.expanduser("~/.cache"))

  CACHEDIR = os.path.join(XDG_CACHE_HOME, "rust2rpm")

  API_URL = "https://crates.io/api/v1/"

  def get_default_target():

      # TODO: add fallback for /usr/lib/os-release

          req = requests.get(url, stream=True)

          req.raise_for_status()

          total = int(req.headers["Content-Length"])

              for chunk in tqdm.tqdm(req.iter_content(), f"Downloading {cratef_base}".format(cratef_base),

                                     total=total, unit="B", unit_scale=True):

                  f.write(chunk)

              cratef, crate, version = local_crate(crate, version)

          else:

              if store:

              toml, crate, version = local_toml(crate, version)

              diff = make_patch(toml, enabled=patch, tmpfile=True)

                          help="Do initial patching of Cargo.toml")

      parser.add_argument("-s", "--store-crate", action="store_true",

                          help="Store crate in current directory")

      parser.add_argument("crate", help="crates.io name\n"

                                        "path/to/local.crate\n"

                                        "path/to/project/",

          return

      if args.crate is None:

      crate, diff, metadata = make_diff_metadata(args.crate, args.version,

                                                 patch=args.patch,

      kwargs = {}

      kwargs["crate"] = crate

      kwargs["target"] = args.target

      bins = [tgt for tgt in metadata.targets if tgt.kind == "bin"]

      is_bin = len(bins) > 0

      is_lib = len(libs) > 0

      if is_bin:

      else:

          kwargs["auto_changelog_entry"] = True

          kwargs["include_build_requires"] = True

          kwargs["include_provides"] = False

          kwargs["include_requires"] = False

  def spdx_to_fedora_map():

      with open(SPDX_TO_FEDORA_CSV, newline='') as f:

          reader = _csv.DictReader(f)

                  for line in reader

                  if line['SPDX License Identifier']}

  def dump_sdpx_to_fedora_map(file):

          print(f"{k} → {v}", file=file)

  def translate_license_fedora(license):

              if mapped is None:

                  comments += f'# FIXME: Upstream uses unknown SPDX tag {tag}!'

                  final.append(tag)

                  comments += f"# FIXME: Upstream SPDX tag {tag} not listed in Fedora's good licenses list.\n"

                  comments += "# FIXME: This package might not be allowed in Fedora!\n"

                  final.append(tag)

      @classmethod

      def from_json(cls, metadata):

          return cls(**kwargs)

      @staticmethod

                  # Any means any

                  continue

              ver = req.spec

                  raise NotImplementedError(f"'!=' and empty kinds are not supported: {req}")

              coerced = str(semver.Version.coerce(str(ver)))

              if ver.prerelease:

                  ver = ver.next_patch()

              if req.kind == req.KIND_EQUAL:

                  req.kind = req.KIND_SHORTEQ

                  if ver.major == 0:

                      if ver.minor is not None:

                          if ver.minor != 0 or ver.patch is None:

                      upper = ver.next_minor()

                  reqs.append((">=", coerced))

                  reqs.append(("<", upper))

                                req.KIND_GT,

                                req.KIND_GTE,

                                req.KIND_LT,

                  reqs.append((str(req.kind), coerced))

              else:

                  raise AssertionError(f"Found unhandled kind: {req.kind}")

  ExclusiveArch:  %{rust_arches}

  BuildRequires:  rust-packaging

  {% set buildrequires = normalize_deps(md.requires("default", resolve=True))|sort %}

  {% set buildrequires = normalize_deps(md.all_dependencies)|sort %}

  {% for req in buildrequires %}

  BuildRequires:  {{ req }}

  {% endfor %}

  %cargo_prep

  %build

  %install

  %if %{with check}

  %check

  %endif

  %changelog