text: # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  # http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  
  """ Definition of java_single_jar. """
  
  def _check_non_empty(value, name):
      if not value:
          fail("%s must be non-empty" % name)
  
  def _java_single_jar(ctx):
      _check_non_empty(ctx.attr.root_packages, "root_packages")
  
      inputs = depset()
      source_jars = depset()
      for dep in ctx.attr.deps:
          inputs = depset(transitive = [inputs, dep.java.transitive_runtime_deps])
          source_jars = depset(transitive = [source_jars, dep.java.source_jars])
          for td in dep.java.transitive_runtime_deps:
              if hasattr(td, "java"):
                  source_jars = depset(transitive = [source_jars, td.java.source_jars])
  
      compress = ""
      if ctx.attr.compress == "preserve":
          compress = "--dont_change_compression"
      elif ctx.attr.compress == "yes":
          compress = "--compression"
      elif ctx.attr.compress == "no":
          pass
      else:
          fail("\"compress\" attribute (%s) must be: yes, no, preserve." % ctx.attr.compress)
  
      if ctx.attr.source_jar:
          inputs = source_jars
          compress = ""
  
      args = ctx.actions.args()
      args.add("--sources")
      args.add_all(inputs)
      args.use_param_file(
          "@%s",
          use_always = True,
      )
      args.set_param_file_format("multiline")
  
      include_prefixes = " ".join([x.replace(".", "/") for x in ctx.attr.root_packages])
  
      ctx.actions.run(
          inputs = inputs,
          outputs = [ctx.outputs.jar],
          arguments = [
                          args,
                          "--output",
                          ctx.outputs.jar.path,
                          "--include_prefixes",
                          include_prefixes,
                          "--normalize",
                      ] +
                      # Deal with limitation of singlejar flags: tool's default behavior is
                      # "no", but you get that behavior only by absence of compression flags.
                      ([] if not compress else [compress]),
          progress_message = "Merging into %s" % ctx.outputs.jar.short_path,
          mnemonic = "JavaSingleJar",
          executable = ctx.executable._singlejar,
      )
  
  java_single_jar = rule(
      attrs = {
          "deps": attr.label_list(providers = ["java"]),
          "_singlejar": attr.label(
              default = Label("@bazel_tools//tools/jdk:singlejar"),
              cfg = "host",
              allow_single_file = True,
              executable = True,
          ),
          "source_jar": attr.bool(default = False),
          "compress": attr.string(default = "preserve"),
          "root_packages": attr.string_list(),
      },
      outputs = {
          "jar": "%{name}.jar",
      },
      implementation = _java_single_jar,
  )
  """
  Collects Java dependencies and jar files into a single jar
  
  Args:
    deps: The Java targets (including java_import and java_library) to collect
        transitive dependencies from. Both compile-time dependencies (deps,
        exports) and runtime dependencies (runtime_deps) are collected.
        Resources are also collected. Native cc_library or java_wrap_cc
        dependencies are not.
    compress: Whether to always deflate ("yes"), always store ("no"), or pass
        through unmodified ("preserve"). The default is "preserve", and is the
        most efficient option -- no extra work is done to inflate or deflate.
    source_jar: Whether to combine the source jars of input to create a single
        output source jar.
    root_packages: Java packages to include in generated jar.
  
  Outputs:
    {name}.jar: A single jar containing all of the input.
  """
  