command_handler.h

Go to the documentation of this file.

#ifndef YAZE_SRC_CLI_SERVICE_RESOURCES_COMMAND_HANDLER_H_
#define YAZE_SRC_CLI_SERVICE_RESOURCES_COMMAND_HANDLER_H_
 
#include <filesystem>
#include <map>
#include <optional>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "cli/service/resources/command_context.h"
#include "core/asar_wrapper.h"  // For AsarWrapper
#include "core/project.h"       // For YazeProject
#include "rom/rom.h"
 
namespace yaze {
namespace cli {
namespace resources {
 
// Immutable ROM path identity captured for one CommandHandler::Run invocation.
// The source path remains the caller's ROM when sandbox mode swaps the active
// path to a command-local copy.
struct CommandInvocationContext {
  std::optional<std::filesystem::path> source_rom_path;
  std::optional<std::filesystem::path> active_rom_path;
  bool sandbox_enabled = false;
};
 
// Resolve an artifact destination once and reject aliases of either ROM used
// by the invocation, including the original source when sandboxing is enabled.
absl::StatusOr<std::filesystem::path> ResolveStableArtifactPath(
    const std::filesystem::path& path);
absl::StatusOr<bool> PathsAlias(const std::filesystem::path& lhs,
                                const std::filesystem::path& rhs);
absl::Status RejectArtifactRomAliases(
    absl::string_view option_name, const std::filesystem::path& artifact_path,
    const CommandInvocationContext& invocation_context);
 
class CommandHandler {
 public:
  virtual ~CommandHandler() = default;
 
  struct DescriptorEntry {
    std::string name;
    std::string description;
    std::string todo_reference;
  };
 
  struct Descriptor {
    std::string display_name;
    std::string summary;
    std::string todo_reference;
    std::vector<DescriptorEntry> entries;
  };
 
  absl::Status Run(const std::vector<std::string>& args, Rom* rom_context,
                   std::string* captured_output = nullptr);
 
  virtual std::string GetName() const = 0;
 
  virtual Descriptor Describe() const;
 
  virtual std::string GetUsage() const = 0;
 
  virtual bool RequiresRom() const { return true; }
 
  virtual bool RequiresLabels() const { return false; }
 
  virtual void SetProjectContext(project::YazeProject* project) {
    project_ = project;
  }
 
  virtual void SetAsarWrapper(core::AsarWrapper* asar_wrapper) {
    asar_wrapper_ = asar_wrapper;
  }
 
  virtual void SetRomContext(Rom* rom) { rom_ = rom; }
 
  virtual void SetAssemblySymbolTable(
      const std::map<std::string, core::AsarSymbol>* table) {
    assembly_symbol_table_ = table;
  }
 
  virtual void SetSymbolProvider(emu::debug::SymbolProvider* provider) {
    symbol_provider_ = provider;
  }
 
 protected:
  virtual absl::Status ValidateArgs(const ArgumentParser& parser) = 0;
 
  virtual absl::Status Execute(Rom* rom, const ArgumentParser& parser,
                               OutputFormatter& formatter) = 0;
 
  virtual absl::Status ExecuteWithContext(
      Rom* rom, const ArgumentParser& parser, OutputFormatter& formatter,
      const CommandInvocationContext& invocation_context) {
    return Execute(rom, parser, formatter);
  }
 
  virtual std::string GetDefaultFormat() const { return "json"; }
 
  virtual std::string GetOutputTitle() const { return "Result"; }
 
  Rom* rom_ = nullptr;
  emu::debug::SymbolProvider* symbol_provider_ = nullptr;
  project::YazeProject* project_ = nullptr;
  core::AsarWrapper* asar_wrapper_ = nullptr;
  const std::map<std::string, core::AsarSymbol>* assembly_symbol_table_ =
      nullptr;
};
 
#define DEFINE_COMMAND_HANDLER(name, usage_str, validate_body, execute_body) \
  class name##CommandHandler : public CommandHandler {                       \
   public:                                                                   \
    std::string GetName() const override { return #name; }                   \
    std::string GetUsage() const override { return usage_str; }              \
                                                                             \
   protected:                                                                \
    absl::Status ValidateArgs(const ArgumentParser& parser) override         \
        validate_body absl::Status                                           \
        Execute(Rom* rom, const ArgumentParser& parser,                      \
                OutputFormatter& formatter) override execute_body            \
  };
 
}  // namespace resources
}  // namespace cli
}  // namespace yaze
 
#endif  // YAZE_SRC_CLI_SERVICE_RESOURCES_COMMAND_HANDLER_H_