{"id":5431,"date":"2012-10-25T12:52:00","date_gmt":"2012-10-25T20:52:00","guid":{"rendered":"http:\/\/www.sapien.com\/blog\/?p=5431"},"modified":"2012-10-25T12:56:59","modified_gmt":"2012-10-25T20:56:59","slug":"revisiting-the-packager-and-command-line-arguments","status":"publish","type":"post","link":"https:\/\/dev.sapien.com\/blog\/2012\/10\/25\/revisiting-the-packager-and-command-line-arguments\/","title":{"rendered":"Revisiting The Packager and Command Line Arguments"},"content":{"rendered":"

The original The Packager and Command line Arguments<\/a> blog article discussed how to pass parameters to a packaged executable. In this article we will revisit this subject and update the functions introduced in the previous article. The article will also cover how to simulate the packager parameters so that you can test your script without having to package it each time. This article\u2019s example uses PowerShell Studio 2012, but it is also applicable to PrimalScript 2012.<\/p>\n

Command Line Parsing Functions:<\/strong><\/p>\n

The original Convert-ArgumentsToDictionary<\/font> function is no longer valid since PowerShell converts the Dictionary to an array when you return the object down the pipeline. Therefore, the function was updated so the Dictionary is passed to the function as a reference instead of being returned via the pipeline. The new function no longer requires you to call the Parse-Commandline<\/font> function beforehand and thus it was renamed to Convert-CommandLineToDictionary<\/font> to reflect these changes.<\/p>\n

function<\/span> <\/span>Convert-CommandLineToDictionary<\/span> \r\n{ \r\n    <\/span><#\r\n    .SYNOPSIS\r\n        Parses and converts the command line of a packaged executable into a Dictionary\r\n\r\n    .DESCRIPTION\r\n        Parses and converts the command line of a packaged executable into a Dictionary\r\n\r\n    .PARAMETER  Dictionary\r\n        The Dictionary to load the value pairs into.\r\n\r\n    .PARAMETER  CommandLine\r\n        The command line of the package executable\r\n\r\n    .PARAMETER  ParamIndicator\r\n        The character used to indicate what is a parameter.\r\n    \r\n    .EXAMPLE\r\n        $Dictionary = New-Object System.Collections.Specialized.StringDictionary\r\n        Convert-CommandLineToDictionary -Dictionary $Dictionary `
 -CommandLine $Commandline  -ParamIndicator '-'\r\n    #><\/span>\r\n    <\/span>Param<\/span>(  [ValidateNotNull()]\r\n            [System.Collections.Specialized.StringDictionary]<\/span>$Dictionary<\/span>,\r\n            [string]<\/span>$CommandLine<\/span>, \r\n            [char] <\/span>$ParamIndicator<\/span>) \r\n\r\n    <\/span>$Params<\/span> <\/span>=<\/span> <\/span>Parse-Commandline<\/span> <\/span>$CommandLine<\/span>\r\n    \r\n    <\/span>for<\/span>(<\/span>$index<\/span> <\/span>=<\/span> <\/span>0<\/span>; <\/span>$index<\/span> <\/span>-lt<\/span> <\/span>$Params<\/span>.Count; <\/span>$index<\/span>++<\/span>) \r\n    { \r\n        [string]<\/span>$param<\/span> <\/span>=<\/span> <\/span>$Params<\/span>[<\/span>$index<\/span>] \r\n        <\/span>#Clear the values <\/span>\r\n        <\/span>$key<\/span> <\/span>=<\/span> <\/span>\"\"<\/span> \r\n        <\/span>$value<\/span> <\/span>=<\/span> <\/span>\"\"<\/span> \r\n\r\n        <\/span>if<\/span>(<\/span>$param<\/span>.StartsWith(<\/span>$ParamIndicator<\/span>)) \r\n        { \r\n            <\/span>#Remove the indicator <\/span>\r\n            <\/span>$key<\/span> <\/span>=<\/span> <\/span>$param<\/span>.Remove(<\/span>0<\/span>,<\/span>1<\/span>) \r\n            <\/span>if<\/span>(<\/span>$index<\/span>  <\/span>+<\/span> <\/span>1<\/span> <\/span>-lt<\/span> <\/span>$Params<\/span>.Count) \r\n            { \r\n                <\/span>#Check if the next Argument is a parameter <\/span>\r\n                [string]<\/span>$param<\/span> <\/span>=<\/span> <\/span>$Params<\/span>[<\/span>$index<\/span> <\/span>+<\/span> <\/span>1<\/span>] \r\n                <\/span>if<\/span>(<\/span>$param<\/span>.StartsWith(<\/span>$ParamIndicator<\/span>) <\/span>-ne<\/span> <\/span>$true<\/span> ) \r\n                { \r\n                    <\/span>#If it isn\u2019t a parameter then set it as the value <\/span>\r\n                    <\/span>$value<\/span> <\/span>=<\/span> <\/span>$param<\/span> \r\n                    <\/span>$index<\/span>++<\/span> \r\n                } \r\n            } \r\n            <\/span>$Dictionary<\/span>[<\/span>$key<\/span>] <\/span>=<\/span> <\/span>$value<\/span> \r\n        }<\/span>#else skip <\/span>\r\n    } \r\n}<\/span><\/pre>\n
The following is the updated Parse-Commandline<\/font> function:<\/p>\n
function<\/span> <\/span>Parse-Commandline<\/span> \r\n{ \r\n<\/span><#\r\n    .SYNOPSIS\r\n        Parses the command line of a package executable\r\n\r\n    .DESCRIPTION\r\n        Parses the command line of a package executable\r\n\r\n    .PARAMETER  Commandline\r\n        The command line of the package executable\r\n\r\n    .EXAMPLE\r\n        $arguments = Parse-Commandline -Commandline $Commandline\r\n\r\n    .INPUTS\r\n        System.String\r\n\r\n    .OUTPUTS\r\n        System.Collections.Specialized.StringCollection\r\n#><\/span>\r\n\r\n    [OutputType([System.Collections.Specialized.StringCollection])]\r\n    <\/span>Param<\/span>([string]<\/span>$CommandLine<\/span>) \r\n    \r\n    <\/span>$Arguments<\/span> <\/span>=<\/span> <\/span>New-Object<\/span> System.Collections.Specialized.StringCollection \r\n    \r\n    <\/span>if<\/span>(<\/span>$CommandLine<\/span>)\r\n    {\r\n        <\/span>#Find First Quote <\/span>\r\n        <\/span>$index<\/span> <\/span>=<\/span> <\/span>$CommandLine<\/span>.IndexOf(<\/span>'\"'<\/span>) \r\n\r\n        <\/span>while<\/span> ( <\/span>$index<\/span> <\/span>-ne<\/span> <\/span>-<\/span>1<\/span>) \r\n        {<\/span>#Continue as along as we find a quote <\/span>\r\n            <\/span>#Find Closing Quote <\/span>\r\n            <\/span>$closeIndex<\/span> <\/span>=<\/span> <\/span>$CommandLine<\/span>.IndexOf(<\/span>'\"'<\/span>,<\/span>$index<\/span> <\/span>+<\/span> <\/span>1<\/span>) \r\n            <\/span>if<\/span>(<\/span>$closeIndex<\/span> <\/span>-eq<\/span> <\/span>-<\/span>1<\/span>) \r\n            { \r\n                <\/span>break<\/span> <\/span>#Can\u2019t find a match <\/span>\r\n            } \r\n            <\/span>$value<\/span> <\/span>=<\/span> <\/span>$CommandLine<\/span>.Substring(<\/span>$index<\/span> <\/span>+<\/span> <\/span>1<\/span>,<\/span>$closeIndex<\/span> \u2013 (<\/span>$index<\/span> <\/span>+<\/span> <\/span>1<\/span>)) \r\n            [void]<\/span>$Arguments<\/span>.Add(<\/span>$value<\/span>) \r\n            <\/span>$index<\/span> <\/span>=<\/span> <\/span>$closeIndex<\/span> \r\n\r\n            <\/span>#Find First Quote <\/span>\r\n            <\/span>$index<\/span> <\/span>=<\/span> <\/span>$CommandLine<\/span>.IndexOf(<\/span>'\"'<\/span>,<\/span>$index<\/span> <\/span>+<\/span> <\/span>1<\/span>) \r\n        } \r\n    }\r\n    <\/span>return<\/span> <\/span>$Arguments<\/span> \r\n}<\/span><\/pre>\n
 <\/p>\n
Simulating Packager Command line:<\/strong><\/font><\/p>\n
There are times you might want to test your command line inputs but don\u2019t want to make debugging more difficult by having to package the script. As an alternative, you can simulate the packager\u2019s command line and pass it as an argument to the debugger, thus bypassing the packaging stage.<\/p>\n
Preparation:<\/strong><\/p>\n
A PowerShell Studio project is used as a basis for this example, but the same steps can apply to a single Form file (GUI Script) or a typical script. <\/p>\n
Step 1: Define a parameter to accept the test command line<\/em><\/p>\n
In the project\u2019s startup.pfs file we define a parameter block as follows:<\/p>\n
Param<\/span> (<\/span>$TestCommandline<\/span>)\r\n<\/span><\/pre>\n
Note: Parameter blocks should always be defined at the top of the script. The same hold true if you are working with a Form.<\/p>\n
 <\/p>\n
Step 2: Replacing $CommandLine variable with the test variable<\/em><\/p>\n
The packager creates the $CommandLine variable which contains the command line arguments that were used to call the packaged executable. In this case, we want to use a simulated command line but at the same time ensure our script will still run when packaged. In order to accommodate this, one must check if the $CommandLine variable has any contents before replacing its value. <\/p>\n
In the case of a project, we add the check in the project\u2019s Main function and only replace the $Commandline variable if its content is empty or null. Afterwards you can use the parsing functions to handle the $Commandline variable.<\/p>\n
function<\/span> <\/span>Main<\/span> {\r\n    <\/span>Param<\/span> ([String]<\/span>$Commandline<\/span>)\r\n    \r\n    <\/span>if<\/span>(<\/span>-not<\/span> <\/span>$Commandline<\/span>)\r\n    {\r\n        <\/span>$Commandline<\/span>  <\/span>=<\/span> <\/span>$TestCommandline<\/span>    \r\n    }\r\n    <\/span>$Dictionary<\/span> <\/span>=<\/span> <\/span>New-Object<\/span> System.Collections.Specialized.StringDictionary\r\n    Convert-CommandLineToDictionary <\/span>-<\/span>Dictionary <\/span>$Dictionary<\/span> <\/span>-<\/span>CommandLine <\/span>$Commandline<\/span>  <\/span>-<\/span>ParamIndicator <\/span>'-'<\/span>\r\n    <\/span>#Output the original command line string <\/span>\r\n    <\/span>\"Command Line: {0}`r`n\"<\/span> <\/span>-f<\/span> <\/span>$CommandLine<\/span> <\/span>|<\/span> <\/span>Write-Output<\/span>     <\/span>#Display all the parsed command line values:<\/span>\r\n    <\/span>$Dictionary<\/span> <\/span>|<\/span> <\/span>Format-Table<\/span> @{label<\/span>=<\/span>\"Key\"<\/span>;Expression<\/span>=<\/span>{<\/span>$_<\/span>.Key}},@{label<\/span>=<\/span>\"Value\"<\/span>;Expression<\/span>=<\/span>{<\/span>$_<\/span>.Value}} <\/span>|<\/span> <\/span>Write-Output<\/span>\r\n    \r\n    <\/span>..<\/span>.<\/span><\/pre>\n
 <\/p>\n
In normal scripts, insert the check right after the parameter definition. <\/p>\n
For Form files you might want to consider calling the parsing functions in the Form\u2019s Load event.<\/p>\n
 <\/p>\n
Step 3: Format the input to match that of the packager<\/em><\/p>\n
In the original article we discussed how the $Commandline variable contains the parameters passed to the packaged exe. The packager\u2019s $Commandline variable has each parameter and parameter value surrounded by individual double quotes. <\/p>\n
For example:<\/p>\n
mypackage.exe -Parameter1 Value1 -Parameter2 Value2 <\/p>\n
Results in $CommandLine variable containing the following string: <\/p>\n
\n
\u201c-Parameter1\u201d \u201cValue1\u201d \u201c-Parameter2\u201d \u201cValue2\u201d<\/p>\n<\/blockquote>\n
In order to simulate the packager arguments you must alter your test parameter input as follows: <\/p>\n
1. Wrap each individual parameter and parameter value in Double Quotes in order to mirror the packager\u2019s behavior. <\/p>\n
2. Wrap the whole parameters \/ values within single quotes<\/strong>, so that PowerShell treats it as a single string: <\/p>\n
\n
\u2018<\/strong><\/font>\u201c-Parameter1\u201d \u201cValue1\u201d \u201c-Parameter2\u201d \u201cValue2\u201d\u2019<\/strong><\/font> <\/p>\n
If you do not make the parameters into a single string, the TestCommandline variable would only contain the first item (in this case would be \u201c-Parameter1\u201d). <\/p>\n<\/blockquote>\n
Now you are ready to simulate and test the packager command line! <\/p>\n
When the script is executed, the $Commandline variable will be replaced with the $TestCommandline\u2019s contents and you will be able to process the results correctly: <\/p>\n
\"Output\" <\/p>\n
Debugging Tip:<\/strong> <\/p>\n
In some instances you want to use the same test parameters every time you debug a particular script; therefore, we recommend using the DebugParameters meta-tag at the top of the script:<\/p>\n
# %DebugParameters% = '\"-Parameter1\" \"Value1\" \"-Parameter2\" \"Value2\"' <\/span><\/pre>\n
Now when you debug the script, the specified parameters will be automatically selected. <\/p>\n
New Snippet:<\/strong> <\/p>\n
Snippets containing the command line parsing functions are included in PowerShell Studio 2012<\/a> v3.1.9 or greater and PrimalScript 2012<\/a> v6.5.134 or greater.<\/p>\n","protected":false},"excerpt":{"rendered":"
The original The Packager and Command line Arguments blog article discussed how to pass parameters to a packaged executable. In this article we will revisit this subject and update the functions introduced in the previous article. The article will also cover how to simulate the packager parameters so that you can test your script without […]<\/p>\n","protected":false},"author":10,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"categories":[283,705,410,25],"tags":[294,282,437,152,28,1016,37,782,302],"class_list":["post-5431","post","type-post","status-publish","format-standard","hentry","category-howto","category-powershell-studio-2012","category-primalscript-software-news","category-windows-powershell","tag-commandline","tag-functions","tag-packager","tag-parameter","tag-powershell","tag-powershell-studio","tag-primalscript","tag-script-to-exe","tag-snippet"],"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts\/5431","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/users\/10"}],"replies":[{"embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/comments?post=5431"}],"version-history":[{"count":16,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts\/5431\/revisions"}],"predecessor-version":[{"id":5484,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts\/5431\/revisions\/5484"}],"wp:attachment":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/media?parent=5431"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/categories?post=5431"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/tags?post=5431"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}