ruby-dap 0.1.0

data/lib/dap/module_event_body.rb

@@ -0,0 +1,10 @@
+require_relative 'module'
+
+class DAP::ModuleEventBody < DAP::Base
+  # The reason for the event.
+  # Values: 'new', 'changed', 'removed', etc.
+  property :reason # 'new' | 'changed' | 'removed'
+
+  # The new, changed, or removed module. In case of 'removed' only the module id is used.
+  property :module, as: DAP::Module
+end

data/lib/dap/modules_arguments.rb

@@ -0,0 +1,7 @@
+class DAP::ModulesArguments < DAP::Base
+  # The index of the first module to return; if omitted modules start at 0.
+  property :startModule, required: false
+
+  # The number of modules to return. If moduleCount is not specified or 0, all modules are returned.
+  property :moduleCount, required: false
+end

data/lib/dap/modules_response_body.rb

@@ -0,0 +1,9 @@
+require_relative 'module'
+
+class DAP::ModulesResponseBody < DAP::Base
+  # All modules or range of modules.
+  property :modules, as: many(DAP::Module)
+
+  # The total number of modules available.
+  property :totalModules, required: false
+end

data/lib/dap/next_arguments.rb

@@ -0,0 +1,9 @@
+require_relative 'stepping_granularity'
+
+class DAP::NextArguments < DAP::Base
+  # Execute 'next' for this thread.
+  property :threadId
+
+  # Optional granularity to step. If no granularity is specified, a granularity of 'statement' is assumed.
+  property :granularity, required: false, as: DAP::SteppingGranularity
+end

data/lib/dap/output_event_body.rb

@@ -0,0 +1,36 @@
+require_relative 'source'
+
+class DAP::OutputEventBody < DAP::Base
+  # The output category. If not specified, 'console' is assumed.
+  # Values: 'console', 'stdout', 'stderr', 'telemetry', etc.
+  property :category, required: false # 'console' | 'stdout' | 'stderr' | 'telemetry' | string
+
+  # The output to report.
+  property :output
+
+  # Support for keeping an output log organized by grouping related messages.
+  # Values:
+  # 'start': Start a new group in expanded mode. Subsequent output events are members of the group and should be shown indented.
+  # The 'output' attribute becomes the name of the group and is not indented.
+  # 'startCollapsed': Start a new group in collapsed mode. Subsequent output events are members of the group and should be shown indented (as soon as the group is expanded).
+  # The 'output' attribute becomes the name of the group and is not indented.
+  # 'end': End the current group and decreases the indentation of subsequent output events.
+  # A non empty 'output' attribute is shown as the unindented end of the group.
+  # etc.
+  property :group, required: false # 'start' | 'startCollapsed' | 'end'
+
+  # If an attribute 'variablesReference' exists and its value is > 0, the output contains objects which can be retrieved by passing 'variablesReference' to the 'variables' request. The value should be less than or equal to 2147483647 (2^31 - 1).
+  property :variablesReference, required: false
+
+  # An optional source location where the output was produced.
+  property :source, required: false, as: DAP::Source
+
+  # An optional source location line where the output was produced.
+  property :line, required: false
+
+  # An optional source location column where the output was produced.
+  property :column, required: false
+
+  # Optional data to report. For the 'telemetry' category the data will be sent to telemetry, for the other categories the data is shown in JSON format.
+  property :data, required: false
+end

data/lib/dap/pause_arguments.rb

@@ -0,0 +1,4 @@
+class DAP::PauseArguments < DAP::Base
+  # Pause execution for this thread.
+  property :threadId
+end

data/lib/dap/process_event_body.rb

@@ -0,0 +1,21 @@
+class DAP::ProcessEventBody < DAP::Base
+  # The logical name of the process. This is usually the full path to process's executable file. Example: /home/example/myproj/program.js.
+  property :name
+
+  # The system process id of the debugged process. This property will be missing for non-system processes.
+  property :systemProcessId, required: false
+
+  # If true, the process is running on the same computer as the debug adapter.
+  property :isLocalProcess, required: false
+
+  # Describes how the debug engine started debugging this process.
+  # Values:
+  # 'launch': Process was launched under the debugger.
+  # 'attach': Debugger attached to an existing process.
+  # 'attachForSuspendedLaunch': A project launcher component has launched a new process in a suspended state and then asked the debugger to attach.
+  # etc.
+  property :startMethod, required: false # 'launch' | 'attach' | 'attachForSuspendedLaunch'
+
+  # The size of a pointer or address for this process, in bits. This value may be used by clients when formatting addresses for display.
+  property :pointerSize, required: false
+end

data/lib/dap/progress_end_event_body.rb

@@ -0,0 +1,7 @@
+class DAP::ProgressEndEventBody < DAP::Base
+  # The ID that was introduced in the initial 'ProgressStartEvent'.
+  property :progressId
+
+  # Optional, more detailed progress message. If omitted, the previous message (if any) is used.
+  property :message, required: false
+end

data/lib/dap/progress_start_event_body.rb

@@ -0,0 +1,24 @@
+class DAP::ProgressStartEventBody < DAP::Base
+  # An ID that must be used in subsequent 'progressUpdate' and 'progressEnd' events to make them refer to the same progress reporting.
+  # IDs must be unique within a debug session.
+  property :progressId
+
+  # Mandatory (short) title of the progress reporting. Shown in the UI to describe the long running operation.
+  property :title
+
+  # The request ID that this progress report is related to. If specified a debug adapter is expected to emit
+  # progress events for the long running request until the request has been either completed or cancelled.
+  # If the request ID is omitted, the progress report is assumed to be related to some general activity of the debug adapter.
+  property :requestId, required: false
+
+  # If true, the request that reports progress may be canceled with a 'cancel' request.
+  # So this property basically controls whether the client should use UX that supports cancellation.
+  # Clients that don't support cancellation are allowed to ignore the setting.
+  property :cancellable, required: false
+
+  # Optional, more detailed progress message.
+  property :message, required: false
+
+  # Optional progress percentage to display (value range: 0 to 100). If omitted no percentage will be shown.
+  property :percentage, required: false
+end

data/lib/dap/progress_update_event_body.rb

@@ -0,0 +1,10 @@
+class DAP::ProgressUpdateEventBody < DAP::Base
+  # The ID that was introduced in the initial 'progressStart' event.
+  property :progressId
+
+  # Optional, more detailed progress message. If omitted, the previous message (if any) is used.
+  property :message, required: false
+
+  # Optional progress percentage to display (value range: 0 to 100). If omitted no percentage will be shown.
+  property :percentage, required: false
+end

data/lib/dap/protocol_message.rb

@@ -0,0 +1,38 @@
+class DAP::ProtocolMessage < DAP::Base
+  def self.types
+    @types ||= {
+      request: DAP::Request,
+      event: DAP::Event,
+      response: DAP::Response,
+    }
+  end
+
+  def self.from(values)
+    build(values) do |v|
+      key = v[:type]&.to_sym
+      raise "#{name}.type missing" if key.nil?
+      raise "Unknown #{name}.type #{key}" unless types.key?(key)
+
+      types[key]
+    end
+  end
+
+  property :seq, :type
+
+  def initialize(values)
+    super(values)
+    @seq = values[:seq] || DAP::ProtocolMessage.seq
+    @type = self.class.type
+  end
+
+  private
+
+  def self.seq
+    @seq ||= 0
+    @seq += 1
+  end
+end
+
+require_relative 'request'
+require_relative 'event'
+require_relative 'response'

data/lib/dap/read_memory_arguments.rb

@@ -0,0 +1,10 @@
+class DAP::ReadMemoryArguments < DAP::Base
+  # Memory reference to the base location from which data should be read.
+  property :memoryReference
+
+  # Optional offset (in bytes) to be applied to the reference location before reading data. Can be negative.
+  property :offset, required: false
+
+  # Number of bytes to read at the specified location and offset.
+  property :count
+end

data/lib/dap/read_memory_response_body.rb

@@ -0,0 +1,12 @@
+class DAP::ReadMemoryResponseBody < DAP::Base
+  # The address of the first byte of data returned.
+  # Treated as a hex value if prefixed with '0x', or as a decimal value otherwise.
+  property :address
+
+  # The number of unreadable bytes encountered after the last successfully read byte.
+  # This can be used to determine the number of bytes that must be skipped before a subsequent 'readMemory' request will succeed.
+  property :unreadableBytes, required: false
+
+  # The bytes read from memory, encoded using base64.
+  property :data, required: false
+end

data/lib/dap/relation.rb

@@ -0,0 +1,28 @@
+module DAP::Relation
+  def self.supported!(klazz)
+    raise "Unsupported property class #{klazz}" unless klazz < DAP::Base || klazz < DAP::Enum
+  end
+
+  class Many
+    attr_reader :klazz
+
+    def initialize(klazz)
+      DAP::Relation.supported!(klazz)
+      @klazz = klazz
+    end
+  end
+
+  class OneOf
+    attr_reader :types, :key
+
+    def initialize(types)
+      types.values.each { |k| DAP::Relation.supported!(k) }
+      @types = types
+    end
+
+    def with(key)
+      @key = key
+      self
+    end
+  end
+end

data/lib/dap/request.rb

@@ -0,0 +1,91 @@
+require_relative 'cancel_arguments'
+require_relative 'run_in_terminal_request_arguments'
+require_relative 'initialize_request_arguments'
+require_relative 'launch_request_arguments'
+require_relative 'attach_request_arguments'
+require_relative 'disconnect_arguments'
+require_relative 'terminate_arguments'
+require_relative 'breakpoint_locations_arguments'
+require_relative 'set_breakpoints_arguments'
+require_relative 'set_function_breakpoints_arguments'
+require_relative 'set_exception_breakpoints_arguments'
+require_relative 'data_breakpoint_info_arguments'
+require_relative 'set_data_breakpoints_arguments'
+require_relative 'set_instruction_breakpoints_arguments'
+require_relative 'continue_arguments'
+require_relative 'next_arguments'
+require_relative 'step_in_arguments'
+require_relative 'step_out_arguments'
+require_relative 'step_back_arguments'
+require_relative 'reverse_continue_arguments'
+require_relative 'restart_frame_arguments'
+require_relative 'goto_arguments'
+require_relative 'pause_arguments'
+require_relative 'stack_trace_arguments'
+require_relative 'scopes_arguments'
+require_relative 'variables_arguments'
+require_relative 'set_variable_arguments'
+require_relative 'source_arguments'
+require_relative 'terminate_threads_arguments'
+require_relative 'modules_arguments'
+require_relative 'evaluate_arguments'
+require_relative 'set_expression_arguments'
+require_relative 'step_in_targets_arguments'
+require_relative 'goto_targets_arguments'
+require_relative 'completions_arguments'
+require_relative 'exception_info_arguments'
+require_relative 'read_memory_arguments'
+require_relative 'disassemble_arguments'
+
+class DAP::Request < DAP::ProtocolMessage
+  def self.type
+    'request'
+  end
+
+  property :command
+
+  property :arguments, as: one_of(
+    cancel: DAP::CancelArguments,
+    runInTerminal: DAP::RunInTerminalRequestArguments,
+    initialize: DAP::InitializeRequestArguments,
+    configurationDone: empty,
+    launch: DAP::LaunchRequestArguments,
+    attach: DAP::AttachRequestArguments,
+    restart: empty,
+    disconnect: DAP::DisconnectArguments,
+    terminate: DAP::TerminateArguments,
+    breakpointLocations: DAP::BreakpointLocationsArguments,
+    setBreakpoints: DAP::SetBreakpointsArguments,
+    setFunctionBreakpoints: DAP::SetFunctionBreakpointsArguments,
+    setExceptionBreakpoints: DAP::SetExceptionBreakpointsArguments,
+    dataBreakpointInfo: DAP::DataBreakpointInfoArguments,
+    setDataBreakpoints: DAP::SetDataBreakpointsArguments,
+    setInstructionBreakpoints: DAP::SetInstructionBreakpointsArguments,
+    continue: DAP::ContinueArguments,
+    next: DAP::NextArguments,
+    stepIn: DAP::StepInArguments,
+    stepOut: DAP::StepOutArguments,
+    stepBack: DAP::StepBackArguments,
+    reverseContinue: DAP::ReverseContinueArguments,
+    restartFrame: DAP::RestartFrameArguments,
+    goto: DAP::GotoArguments,
+    pause: DAP::PauseArguments,
+    stackTrace: DAP::StackTraceArguments,
+    scopes: DAP::ScopesArguments,
+    variables: DAP::VariablesArguments,
+    setVariable: DAP::SetVariableArguments,
+    source: DAP::SourceArguments,
+    threads: empty,
+    terminateThreads: DAP::TerminateThreadsArguments,
+    modules: DAP::ModulesArguments,
+    loadedSources: empty,
+    evaluate: DAP::EvaluateArguments,
+    setExpression: DAP::SetExpressionArguments,
+    stepInTargets: DAP::StepInTargetsArguments,
+    gotoTargets: DAP::GotoTargetsArguments,
+    completions: DAP::CompletionsArguments,
+    exceptionInfo: DAP::ExceptionInfoArguments,
+    readMemory: DAP::ReadMemoryArguments,
+    disassemble: DAP::DisassembleArguments,
+  ).with(:command)
+end

data/lib/dap/response.rb

@@ -0,0 +1,86 @@
+require_relative 'capabilities'
+require_relative 'error_response_body'
+require_relative 'run_in_terminal_response_body'
+require_relative 'breakpoint_locations_response_body'
+require_relative 'set_breakpoints_response_body'
+require_relative 'set_function_breakpoints_response_body'
+require_relative 'data_breakpoint_info_response_body'
+require_relative 'set_data_breakpoints_response_body'
+require_relative 'set_instruction_breakpoints_response_body'
+require_relative 'continue_response_body'
+require_relative 'stack_trace_response_body'
+require_relative 'scopes_response_body'
+require_relative 'variables_response_body'
+require_relative 'set_variable_response_body'
+require_relative 'source_response_body'
+require_relative 'threads_response_body'
+require_relative 'modules_response_body'
+require_relative 'loaded_sources_response_body'
+require_relative 'evaluate_response_body'
+require_relative 'set_expression_response_body'
+require_relative 'step_in_targets_response_body'
+require_relative 'goto_targets_response_body'
+require_relative 'completions_response_body'
+require_relative 'exception_info_response_body'
+require_relative 'read_memory_response_body'
+require_relative 'disassemble_response_body'
+
+class DAP::Response < DAP::ProtocolMessage
+  def self.type
+    'response'
+  end
+
+  def validate!
+    return unless success
+
+    super
+  end
+
+  property :request_seq, :success, :command, :message, :body
+
+  property :body, as: one_of(
+    initialize: DAP::Capabilities,
+    error: DAP::ErrorResponseBody,
+    cancel: empty,
+    runInTerminal: DAP::RunInTerminalResponseBody,
+    configurationDone: empty,
+    launch: empty,
+    attach: empty,
+    restart: empty,
+    disconnect: empty,
+    terminate: empty,
+    breakpointLocations: DAP::BreakpointLocationsResponseBody,
+    setBreakpoints: DAP::SetBreakpointsResponseBody,
+    setFunctionBreakpoints: DAP::SetFunctionBreakpointsResponseBody,
+    setExceptionBreakpoints: empty,
+    dataBreakpointInfo: DAP::DataBreakpointInfoResponseBody,
+    setDataBreakpoints: DAP::SetDataBreakpointsResponseBody,
+    setInstructionBreakpoints: DAP::SetInstructionBreakpointsResponseBody,
+    continue: DAP::ContinueResponseBody,
+    next: empty,
+    stepIn: empty,
+    stepOut: empty,
+    stepBack: empty,
+    reverseContinue: empty,
+    restartFrame: empty,
+    goto: empty,
+    pause: empty,
+    stackTrace: DAP::StackTraceResponseBody,
+    scopes: DAP::ScopesResponseBody,
+    variables: DAP::VariablesResponseBody,
+    setVariable: DAP::SetVariableResponseBody,
+    source: DAP::SourceResponseBody,
+    threads: DAP::ThreadsResponseBody,
+    terminateThreads: empty,
+    modules: DAP::ModulesResponseBody,
+    loadedSources: DAP::LoadedSourcesResponseBody,
+    evaluate: DAP::EvaluateResponseBody,
+    setExpression: DAP::SetExpressionResponseBody,
+    stepInTargets: DAP::StepInTargetsResponseBody,
+    gotoTargets: DAP::GotoTargetsResponseBody,
+    completions: DAP::CompletionsResponseBody,
+    exceptionInfo: DAP::ExceptionInfoResponseBody,
+    readMemory: DAP::ReadMemoryResponseBody,
+    disassemble: DAP::DisassembleResponseBody,
+  ).with(:command)
+end

data/lib/dap/restart_frame_arguments.rb

@@ -0,0 +1,4 @@
+class DAP::RestartFrameArguments < DAP::Base
+  # Restart this stackframe.
+  property :frameId
+end

data/lib/dap/reverse_continue_arguments.rb

@@ -0,0 +1,4 @@
+class DAP::ReverseContinueArguments < DAP::Base
+  # Execute 'reverseContinue' for this thread.
+  property :threadId
+end

data/lib/dap/run_in_terminal_request_arguments.rb

@@ -0,0 +1,17 @@
+class DAP::RunInTerminalRequestArguments < DAP::Base
+  # What kind of terminal to launch.
+  # Values: 'integrated', 'external', etc.
+  property :kind, required: false # 'integrated' | 'external'
+
+  # Optional title of the terminal.
+  property :title, required: false
+
+  # Working directory of the command.
+  property :cwd
+
+  # List of arguments. The first argument is the command to run.
+  property :args
+
+  # Environment key-value pairs that are added to or removed from the default environment.
+  property :env, required: false # { [key: string]: string | null; }
+end