Method: Yast::CommandLineClass#ProcessSystemCommands

Defined in:

library/commandline/src/modules/CommandLine.rb

#ProcessSystemCommands(command) ⇒ Object

Handle the system-wide commands, like help etc.

Parameters:

• a map of the current command

Returns:

• true, if the command was handled

# File 'library/commandline/src/modules/CommandLine.rb', line 876

def ProcessSystemCommands(command)
  command = deep_copy(command)
  # handle help for specific command
  # this needs to be before general help, so "help help" works
  if Ops.get(command, ["options", "help"])
    PrintHead()
    PrintActionHelp(Ops.get_string(command, "command", ""))
    return true
  end

  # Process command "interactive"
  if Ops.get_string(command, "command", "") == "interactive"
    @interactive = true
    return true
  end

  # Process command "exit"
  if Ops.get_string(command, "command", "") == "exit"
    @done = true
    @aborted = false
    return true
  end

  # Process command "abort"
  if Ops.get_string(command, "command", "") == "abort"
    @done = true
    @aborted = true
    return true
  end

  if Ops.get_string(command, "command", "") == "help"
    # don't print header when custom help is defined
    PrintHead() if !Builtins.haskey(@modulecommands, "customhelp")
    PrintGeneralHelp()
    return true
  end

  if Ops.get_string(command, "command", "") == "longhelp"
    PrintHead()
    PrintGeneralHelp()
    Builtins.foreach(Ops.get_map(@allcommands, "actions", {})) do |action, _def|
      PrintActionHelp(action)
    end
    return true
  end

  if Ops.get_string(command, "command", "") == "xmlhelp"
    if Builtins.haskey(Ops.get_map(command, "options", {}), "xmlfile") == false
      # error message - command line option xmlfile is missing
      Print(
        _(
          "Target file name ('xmlfile' option) is missing. Use xmlfile=<target_XML_file> command line option."
        )
      )
      return false
    end

    xmlfilename = Ops.get_string(command, ["options", "xmlfile"], "")

    if xmlfilename.nil? || xmlfilename == ""
      # error message - command line option xmlfile is missing
      Print(
        _(
          "Target file name ('xmlfile' option) is empty. Use xmlfile=<target_XML_file> command line option."
        )
      )
      return false
    end

    doc = {}

    #      TODO: DTD specification
    Ops.set(
      doc,
      "listEntries",
      "commands" => "command",
      "options"  => "option",
      "examples" => "example"
    )
    #      doc["cdataSections"] = [];
    Ops.set(
      doc,
      "systemID",
      Ops.add(Directory.schemadir, "/commandline.dtd")
    )
    #      doc["nameSpace"] = "http://www.suse.com/1.0/yast2ns";
    Ops.set(doc, "typeNamespace", "http://www.suse.com/1.0/configns")

    Ops.set(doc, "rootElement", "commandline")
    XML.xmlCreateDoc(:xmlhelp, doc)

    exportmap = {}
    commands = []

    actions = Ops.get_map(@cmdlinespec, "actions", {})
    mappings = Ops.get_map(@cmdlinespec, "mappings", {})
    options = Ops.get_map(@cmdlinespec, "options", {})

    Builtins.y2debug("cmdlinespec: %1", @cmdlinespec)

    Builtins.foreach(actions) do |action, description|
      help = ""
      # help text might be a simple string or a multiline text (list<string>)
      help_value = Ops.get(description, "help")
      if Ops.is_string?(help_value)
        help = Convert.to_string(help_value)
      elsif Ops.is(help_value, "list <string>")
        help = Builtins.mergestring(
          Convert.convert(
            help_value,
            from: "any",
            to:   "list <string>"
          ),
          "\n"
        )
      else
        Builtins.y2error(
          "Unsupported data type for 'help' key: %1, use 'string' or 'list<string>' type!",
          help_value
        )
      end
      opts = []
      Builtins.foreach(Ops.get(mappings, action, [])) do |option|
        optn = {
          "name" => option,
          "help" => Ops.get_string(options, [option, "help"], "")
        }
        # add type specification if it's present
        if Ops.get_string(options, [option, "type"], "") != ""
          optn = Builtins.add(
            optn,
            "type",
            Ops.get_string(options, [option, "type"], "")
          )
        end
        opts = Builtins.add(opts, optn)
      end
      actiondescr = { "help" => help, "name" => action, "options" => opts }
      # add example if it's present
      if Builtins.haskey(Ops.get(actions, action, {}), "example")
        example = Ops.get(actions, [action, "example"])
        examples = Array(example)
        actiondescr = Builtins.add(actiondescr, "examples", examples)
      end
      commands = Builtins.add(commands, actiondescr)
    end

    Ops.set(exportmap, "commands", commands)
    Ops.set(exportmap, "module", Ops.get_string(@cmdlinespec, "id", ""))

    begin
      XML.YCPToXMLFile(:xmlhelp, exportmap, xmlfilename)
    rescue XMLSerializationError => e
      # error message - creation of xml failed
      Print(
        _("Failed to create XML file.")
      )
      Builtins.y2error("Failed to serialize xml help: #{e.inspect}")
      return false
    end

    Builtins.y2milestone("exported XML map: %1", exportmap)
    return true
  end

  false
end