@contextlib.contextmanager

  def files_from_crate(cratef, crate, version):

      with tempfile.TemporaryDirectory() as tmpdir:

          target_dir = f"{tmpdir}/"

          with tarfile.open(cratef, "r") as archive:

                  if not os.path.abspath(os.path.join(target_dir, n)).startswith(target_dir):

                      raise Exception("Unsafe filenames!")

              archive.extractall(target_dir)

          if not os.path.isfile(toml):

              raise IOError("crate does not contain Cargo.toml file")

          root_path = f"{tmpdir}/{crate}-{version}"

          license_files = get_license_files(root_path)

          yield toml, doc_files, license_files

          return []

      editor = detect_editor()

  @sortify

  def get_license_files(path):

      exclude = { "vendor", "example", "examples", "_example", "_examples",

                  "testdata", "_testdata", ".github", "tests", "test" }

      for root, dirs, files in os.walk(path, topdown=True):

  @sortify

  def get_doc_files(path):

      plus = re.compile(r"""

          .*\.(?:md|markdown|mdown|mkdn|rst|txt)|AUTHORS|

          AUTHORS[.-].*|CONTRIBUTORS|CONTRIBUTORS[.-].*|README|

                  yield os.path.relpath(os.path.join(root, f), path)

  def get_package_info(package):

      url = requests.compat.urljoin(DIST_GIT_URL, f"rpms/{package}")

      req = requests.get(url, headers={"User-Agent": "rust2rpm"})

      json = req.json()

      return json

      if _is_path(crate):

          # Only things that look like a paths are considered local arguments

          if crate.endswith(".crate"):

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

          else:

                  raise ValueError("--store-crate can only be used for a crate")

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

              metadata = Metadata.from_file(toml)

              if len(metadata) > 1:

                  print(f"Warning: multiple metadata for {toml}")

          if not license_files:

              print(f"Warning: no license files detected in {crate}")

          metadata = Metadata.from_file(toml)

          if len(metadata) > 1:

          metadata = metadata[0]

          shutil.copy2(cratef, os.path.join(os.getcwd(), f"{metadata.name}-{version}.crate"))

      return crate, diff, metadata, doc_files, license_files

      return list(filter(None, (l.strip() for l in s.splitlines())))

  def detect_rpmautospec(default_target, spec_file):

      # We default to on only for selected distros for now…

      if default_target not in {"fedora"}:

          return False

                          help="Print license mappings and exit")

      parser.add_argument("--translate-license", action="store_true",

                          help="Print mapping for specified license and exit")

                          help="Do not generate a changelog entry")

                          help="Do not check whether the package already exists in dist-git")

      parser.add_argument("-", "--stdout", action="store_true",

                          help="Print spec and patches into stdout")

                          default=None,

                          help="Use autorelease and autochangelog features")

      parser.add_argument("--no-rpmautospec", action="store_false",

                          help="Do not use rpmautospec")

      parser.add_argument("--relative-license-paths", action="store_true",

                          help="Put all license files in main license directory")

      parser.add_argument("--all-features", action="store_true",

                          help="Activate all available features")

      parser.add_argument("--dynamic-buildrequires", action="store_true",

                          help="Use dynamic BuildRequires feature")

                          help="Do not use dynamic BuildRequires feature")

      parser.add_argument("--suffix", action="store",

                          help="Package suffix")

      if args.crate is None:

          parser.error("required crate/path argument missing")

      JINJA_ENV.globals["normalize_deps"] = normalize_deps

      JINJA_ENV.globals["to_list"] = to_list

      kwargs["pkg_suffix"] = suffix

      spec_file = pathlib.Path(f"rust-{metadata.name}{suffix}.spec")

          # No specfile, so this is probably a new package

          package_info = get_package_info(f"rust-{metadata.name}{suffix}")

          if package_info:

              print("Re-run with --no-existence-check if you still want to convert it.")

              sys.exit(1)

      rpmautospec = args.rpmautospec

          rpmautospec = detect_rpmautospec(args.target, spec_file)

      kwargs["rpmautospec"] = rpmautospec

      else:

          kwargs["pkg_release"] = "1%{?dist}"

      kwargs["generate_buildrequires"] = args.dynamic_buildrequires

  def translate_license(target, license):

      license = translate_slashes(license)

          return translate_license_fedora(license)

      return license, None