feat: support clipboard context on variable copy operation (#917)

* feat: Add support for clipboard context using var_export

* Use property_value to get clipboard evaluation, tests.

* Testing property_value

* Test for eval with stack depth.

* Implement var_export in TS to format property

* Revert eval with context/stackframe as this is not supported by Xdebug.

Author: zobo

CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/) and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.36.0]
+
+- Implement copy to clipboard in var_export format
+
 ## [1.35.0]
 
 - Support for DBGp stream command

src/phpDebug.ts

@@ -19,6 +19,7 @@ import { randomUUID } from 'crypto'
 import { getConfiguredEnvironment } from './envfile'
 import { XdebugCloudConnection } from './cloud'
 import { shouldIgnoreException } from './ignore'
+import { varExportProperty } from './varExport'
 
 if (process.env['VSCODE_NLS_CONFIG']) {
     try {
@@ -247,6 +248,7 @@ class PhpDebugSession extends vscode.DebugSession {
             ],
             supportTerminateDebuggee: true,
             supportsDelayedStackTraceLoading: false,
+            supportsClipboardContext: true,
         }
         this.sendResponse(response)
     }
@@ -1469,22 +1471,28 @@ class PhpDebugSession extends vscode.DebugSession {
             if (args.context === 'hover') {
                 // try to get variable from property_get
                 const ctx = await stackFrame.getContexts() // TODO CACHE THIS
-                const response = await connection.sendPropertyGetNameCommand(args.expression, ctx[0])
-                if (response.property) {
-                    result = response.property
+                const res = await connection.sendPropertyGetNameCommand(args.expression, ctx[0])
+                if (res.property) {
+                    result = res.property
                 }
             } else if (args.context === 'repl') {
                 const uuid = randomUUID()
                 await connection.sendEvalCommand(`$GLOBALS['eval_cache']['${uuid}']=${args.expression}`)
                 const ctx = await stackFrame.getContexts() // TODO CACHE THIS
-                const response = await connection.sendPropertyGetNameCommand(`$eval_cache['${uuid}']`, ctx[1])
-                if (response.property) {
-                    result = response.property
+                const res = await connection.sendPropertyGetNameCommand(`$eval_cache['${uuid}']`, ctx[1])
+                if (res.property) {
+                    result = res.property
                 }
+            } else if (args.context === 'clipboard') {
+                const ctx = await stackFrame.getContexts() // TODO CACHE THIS
+                const res = await connection.sendPropertyGetNameCommand(args.expression, ctx[0])
+                response.body = { result: await varExportProperty(res.property), variablesReference: 0 }
+                this.sendResponse(response)
+                return
             } else {
-                const response = await connection.sendEvalCommand(args.expression)
-                if (response.result) {
-                    result = response.result
+                const res = await connection.sendEvalCommand(args.expression)
+                if (res.result) {
+                    result = res.result
                 }
             }
 

src/test/adapter.ts

@@ -821,6 +821,52 @@ describe('PHP Debug Adapter', () => {
             assert.deepEqual(vars.body.variables[0].name, '0')
             assert.deepEqual(vars.body.variables[0].value, '1')
         })
+        it('should return the eval result for clipboard', async () => {
+            const program = path.join(TEST_PROJECT, 'variables.php')
+
+            await client.launch({
+                program,
+            })
+            await client.setBreakpointsRequest({ source: { path: program }, breakpoints: [{ line: 19 }] })
+            await client.configurationDoneRequest()
+            const { frame } = await assertStoppedLocation('breakpoint', program, 19)
+
+            const response = (
+                await client.evaluateRequest({
+                    context: 'clipboard',
+                    frameId: frame.id,
+                    expression: '$anInt',
+                })
+            ).body
+
+            assert.equal(response.result, '123')
+            assert.equal(response.variablesReference, 0)
+
+            const response2 = (
+                await client.evaluateRequest({
+                    context: 'clipboard',
+                    frameId: frame.id,
+                    expression: '$aString',
+                })
+            ).body
+
+            assert.equal(response2.result, "'123'")
+            assert.equal(response2.variablesReference, 0)
+
+            const response3 = (
+                await client.evaluateRequest({
+                    context: 'clipboard',
+                    frameId: frame.id,
+                    expression: '$anArray',
+                })
+            ).body
+
+            assert.equal(
+                response3.result,
+                'array (\n  0 => 1,\n  test => 2,\n  test2 => \n  array (\n    t => 123,\n  ),\n)'
+            )
+            assert.equal(response3.variablesReference, 0)
+        })
     })
 
     describe.skip('output events', () => {

src/varExport.ts

@@ -0,0 +1,60 @@
+import * as xdebug from './xdebugConnection'
+
+export async function varExportProperty(property: xdebug.Property, indent: string = ''): Promise<string> {
+    if (indent.length >= 20) {
+        // prevent infinite recursion
+        return `...`
+    }
+
+    let displayValue: string
+    if (property.hasChildren || property.type === 'array' || property.type === 'object') {
+        if (!property.children || property.children.length === 0) {
+            // TODO: also take into account the number of children for pagination
+            property.children = await property.getChildren()
+        }
+        displayValue = (
+            await Promise.all(
+                property.children.map(async property => {
+                    const indent2 = indent + '  '
+                    if (property.hasChildren) {
+                        return `${indent2}${property.name} => \n${indent2}${await varExportProperty(
+                            property,
+                            indent2
+                        )},`
+                    } else {
+                        return `${indent2}${property.name} => ${await varExportProperty(property, indent2)},`
+                    }
+                })
+            )
+        ).join('\n')
+
+        if (property.type === 'array') {
+            // for arrays, show the length, like a var_dump would do
+            displayValue = `array (\n${displayValue}\n${indent})`
+        } else if (property.type === 'object' && property.class) {
+            // for objects, show the class name as type (if specified)
+            displayValue = `${property.class}::__set_state(array(\n${displayValue}\n${indent}))`
+        } else {
+            // edge case: show the type of the property as the value
+            displayValue = `?${property.type}?(\n${displayValue})`
+        }
+    } else {
+        // for null, uninitialized, resource, etc. show the type
+        displayValue = property.value || property.type === 'string' ? property.value : property.type
+        if (property.type === 'string') {
+            // escaping ?
+            if (property.size > property.value.length) {
+                // get value
+                const p2 = await property.context.stackFrame.connection.sendPropertyValueNameCommand(
+                    property.fullName,
+                    property.context
+                )
+                displayValue = p2.value
+            }
+            displayValue = `'${displayValue}'`
+        } else if (property.type === 'bool') {
+            displayValue = Boolean(parseInt(displayValue, 10)).toString()
+        }
+    }
+    return displayValue
+}

src/xdebugConnection.ts

@@ -525,6 +525,8 @@ export abstract class BaseProperty {
     hasChildren: boolean
     /** the number of children this property has, if any. Useful for showing array length. */
     numberOfChildren: number
+    /** the size of the value */
+    size: number
     /** the value of the property for primitive types */
     value: string
     /** children that were already included in the response */
@@ -550,6 +552,9 @@ export abstract class BaseProperty {
         if (propertyNode.hasAttribute('facet')) {
             this.facets = propertyNode.getAttribute('facet')!.split(' ')
         }
+        if (propertyNode.hasAttribute('size')) {
+            this.size = parseInt(propertyNode.getAttribute('size') ?? '0')
+        }
         this.hasChildren = !!parseInt(propertyNode.getAttribute('children')!)
         if (this.hasChildren) {
             this.numberOfChildren = parseInt(propertyNode.getAttribute('numchildren')!)
@@ -684,6 +689,33 @@ export class PropertyGetNameResponse extends Response {
     }
 }
 
+/** The response to a property_value command */
+export class PropertyValueResponse extends Response {
+    /** the size of the value */
+    size: number
+    /** the data type of the variable. Can be string, int, float, bool, array, object, uninitialized, null or resource  */
+    type: string
+    /** the value of the property for primitive types */
+    value: string
+    constructor(document: XMLDocument, connection: Connection) {
+        super(document, connection)
+        if (document.documentElement.hasAttribute('size')) {
+            this.size = parseInt(document.documentElement.getAttribute('size') ?? '0')
+        }
+        this.type = document.documentElement.getAttribute('type') ?? ''
+        if (document.documentElement.getElementsByTagName('value').length > 0) {
+            this.value = decodeTag(document.documentElement, 'value')
+        } else {
+            const encoding = document.documentElement.getAttribute('encoding')
+            if (encoding) {
+                this.value = iconv.encode(document.documentElement.textContent!, encoding).toString()
+            } else {
+                this.value = document.documentElement.textContent!
+            }
+        }
+    }
+}
+
 /** class for properties returned from eval commands. These don't have a full name or an ID, but have all children already inlined. */
 export class EvalResultProperty extends BaseProperty {
     children: EvalResultProperty[]
@@ -1119,6 +1151,18 @@ export class Connection extends DbgpConnection {
         )
     }
 
+    /** Sends a property_value by name command and request full data */
+    public async sendPropertyValueNameCommand(name: string, context: Context): Promise<PropertyValueResponse> {
+        const escapedFullName = '"' + name.replace(/("|\\)/g, '\\$1') + '"'
+        return new PropertyValueResponse(
+            await this._enqueueCommand(
+                'property_value',
+                `-m 0 -d ${context.stackFrame.level} -c ${context.id} -n ${escapedFullName}`
+            ),
+            context.stackFrame.connection
+        )
+    }
+
     /** Sends a property_set command */
     public async sendPropertySetCommand(property: Property, value: string): Promise<Response> {
         return new Response(