feat: add support for setVariablesRequest (#70)

* Add support for setVariablesRequest

* Add pending tests

* Code fixes after rebase.

* Readme.

* Tests for setVariables

* Changelog.

Author: felixfbecker

CHANGELOG.md

@@ -7,6 +7,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 ## [1.23.0]
 
 - When `env` is specified in launch configuration it will be merged the process environment.
+- Set variable support.
 
 ## [1.22.0]
 

README.md

@@ -115,6 +115,7 @@ Options specific to CLI debugging:
 - Arrays & objects (including classname, private and static properties)
 - Debug console
 - Watches
+- Set variables
 - Run as CLI
 - Run without debugging
 - DBGp Proxy registration and unregistration support

src/phpDebug.ts

@@ -195,6 +195,7 @@ class PhpDebugSession extends vscode.DebugSession {
             supportsFunctionBreakpoints: true,
             supportsLogPoints: true,
             supportsHitConditionalBreakpoints: true,
+            supportsSetVariable: true,
             exceptionBreakpointFilters: [
                 {
                     filter: 'Notice',
@@ -891,6 +892,42 @@ class PhpDebugSession extends vscode.DebugSession {
         this.sendResponse(response)
     }
 
+    protected async setVariableRequest(
+        response: VSCodeDebugProtocol.SetVariableResponse,
+        args: VSCodeDebugProtocol.SetVariableArguments
+    ) {
+        try {
+            let properties: xdebug.Property[]
+            if (this._properties.has(args.variablesReference)) {
+                // variablesReference is a property
+                const container = this._properties.get(args.variablesReference)!
+                if (!container.hasChildren) {
+                    throw new Error('Cannot edit property without children')
+                }
+                if (container.children.length === container.numberOfChildren) {
+                    properties = container.children
+                } else {
+                    properties = await container.getChildren()
+                }
+            } else if (this._contexts.has(args.variablesReference)) {
+                const context = this._contexts.get(args.variablesReference)!
+                properties = await context.getProperties()
+            } else {
+                throw new Error('Unknown variable reference')
+            }
+            const property = properties.find(child => child.name === args.name)
+            if (!property) {
+                throw new Error('Property not found')
+            }
+            await property.set(args.value)
+            response.body = { value: args.value }
+        } catch (error) {
+            this.sendErrorResponse(response, error)
+            return
+        }
+        this.sendResponse(response)
+    }
+
     protected async variablesRequest(
         response: VSCodeDebugProtocol.VariablesResponse,
         args: VSCodeDebugProtocol.VariablesArguments
@@ -927,6 +964,8 @@ class PhpDebugSession extends vscode.DebugSession {
                     } else {
                         properties = []
                     }
+                    // SHOULD WE CACHE?
+                    property.children = <xdebug.Property[]>properties
                 } else if (this._evalResultProperties.has(variablesReference)) {
                     // the children of properties returned from an eval command are always inlined, so we simply resolve them
                     const property = this._evalResultProperties.get(variablesReference)!

src/test/adapter.ts

@@ -664,6 +664,72 @@ describe('PHP Debug Adapter', () => {
         }
     })
 
+    describe('setVariables', () => {
+        const program = path.join(TEST_PROJECT, 'variables.php')
+
+        let localScope: DebugProtocol.Scope | undefined
+        let localVariables: DebugProtocol.Variable[]
+        let variables: { [name: string]: string } = Object.create(null)
+
+        beforeEach(async () => {
+            client.launch({ program })
+            await client.waitForEvent('initialized')
+            await client.setBreakpointsRequest({ source: { path: program }, breakpoints: [{ line: 19 }] })
+            const [, event] = await Promise.all([
+                client.configurationDoneRequest(),
+                client.waitForEvent('stopped') as Promise<DebugProtocol.StoppedEvent>,
+            ])
+            const stackFrame = (await client.stackTraceRequest({ threadId: event.body.threadId! })).body.stackFrames[0]
+            const scopes = (await client.scopesRequest({ frameId: stackFrame.id })).body.scopes
+            localScope = scopes.find(scope => scope.name === 'Locals')
+        })
+
+        async function getLocals() {
+            localVariables = (await client.variablesRequest({ variablesReference: localScope!.variablesReference }))
+                .body.variables
+            variables = Object.create(null)
+            for (const variable of localVariables) {
+                variables[variable.name] = variable.value
+            }
+        }
+
+        it('should set the value of an integer', async () => {
+            await getLocals()
+            assert.propertyVal(variables, '$anInt', '123')
+            await client.setVariableRequest({
+                variablesReference: localScope!.variablesReference,
+                name: '$anInt',
+                value: '100',
+            })
+            await getLocals()
+            assert.propertyVal(variables, '$anInt', '100')
+        })
+        it('should set the value of a string', async () => {
+            await getLocals()
+            assert.propertyVal(variables, '$aString', '"123"')
+            await client.setVariableRequest({
+                variablesReference: localScope!.variablesReference,
+                name: '$aString',
+                value: '"aaaa"',
+            })
+            await getLocals()
+            assert.propertyVal(variables, '$aString', '"aaaa"')
+        })
+        it('should set the value of an nested property', async () => {
+            await getLocals()
+            let anArray = localVariables.find(variable => variable.name === '$anArray')
+            assert.propertyVal(anArray!, 'value', 'array(3)')
+            await client.setVariableRequest({
+                variablesReference: localScope!.variablesReference,
+                name: '$anArray',
+                value: 'array(1,2)',
+            })
+            await getLocals()
+            anArray = localVariables.find(variable => variable.name === '$anArray')
+            assert.propertyVal(anArray!, 'value', 'array(2)')
+        })
+    })
+
     describe('virtual sources', () => {
         it('should break on an exception inside eval code')
         it('should return the eval code with a source request')

src/xdebugConnection.ts

@@ -576,6 +576,14 @@ export class Property extends BaseProperty {
             )
         }
     }
+
+    /**
+     * Sets the value of this property through a property_set command
+     */
+    public set(value: string): Promise<Response> {
+        return this.context.stackFrame.connection.sendPropertySetCommand(this, value)
+    }
+
     /**
      * Returns the child properties of this property by doing another property_get
      * @returns Promise.<Property[]>
@@ -706,6 +714,13 @@ interface Command {
     isExecuteCommand: boolean
 }
 
+/**
+ * Escapes a value to pass it as an argument in an XDebug command
+ */
+function escape(value: string): string {
+    return '"' + value.replace(/("|\\)/g, '\\$1') + '"'
+}
+
 /**
  * This class represents a connection to Xdebug and is instantiated with a socket.
  */
@@ -1021,18 +1036,31 @@ export class Connection extends DbgpConnection {
         )
     }
 
+    // ------------------------------ property --------------------------------------
+
     /** Sends a property_get command */
     public async sendPropertyGetCommand(property: Property): Promise<PropertyGetResponse> {
-        const escapedFullName = '"' + property.fullName.replace(/("|\\)/g, '\\$1') + '"'
         return new PropertyGetResponse(
             await this._enqueueCommand(
                 'property_get',
-                `-d ${property.context.stackFrame.level} -c ${property.context.id} -n ${escapedFullName}`
+                `-d ${property.context.stackFrame.level} -c ${property.context.id} -n ${escape(property.fullName)}`
             ),
             property
         )
     }
 
+    /** Sends a property_set command */
+    public async sendPropertySetCommand(property: Property, value: string): Promise<Response> {
+        return new Response(
+            await this._enqueueCommand(
+                'property_set',
+                `-d ${property.context.stackFrame.level} -c ${property.context.id} -n ${escape(property.fullName)}`,
+                value
+            ),
+            property.context.stackFrame.connection
+        )
+    }
+
     // ------------------------------- eval -----------------------------------------
 
     /** sends an eval command */