PoshCode Logo PowerShell Code Repository

PowerWatin 0.5 by Joel Bennett 3 years ago (modification of post by Joel Bennett view diff)
diff | embed code: <script type="text/javascript" src="http://PoshCode.org/embed/2434"></script>download | new post

Make it easier to use Watin automation via PowerShell

NOTE: this is basically the code I used in my “Automating the World” presentation October 19, 2010 — I still expect to clean it up in some future iteration

  1. ## CHANGE this to point to your WatiN.Core.dll
  2. $WatinPath = Convert-Path (Resolve-Path "$(Split-Path $Profile)\Libraries\Watin2\WatiN.Core.dll")
  3. ## Load the assembly
  4. $global:watin = [Reflection.Assembly]::LoadFrom( $WatinPath )
  5.  
  6. $WFind = [Watin.Core.Find]
  7.  
  8. ## The rest of this is generated ... I've pasted the generation code in a comment at the bottom
  9.  
  10.  
  11. Function get-InternetExplorer {
  12.    param(
  13.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  14.    ,
  15.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  16.       [ScriptBlock]$Where = {$true}
  17.    )
  18.    process {
  19.       $InputObject.get_InternetExplorer() | Where $Where
  20.    }
  21. }
  22.  
  23. Function get-AutoClose {
  24.    param(
  25.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  26.    ,
  27.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  28.       [ScriptBlock]$Where = {$true}
  29.    )
  30.    process {
  31.       $InputObject.get_AutoClose() | Where $Where
  32.    }
  33. }
  34.  
  35. Function set-AutoClose {
  36.    param(
  37.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  38.    ,
  39.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  40.       [ScriptBlock]$Where = {$true}
  41.    )
  42.    process {
  43.       $InputObject.set_AutoClose() | Where $Where
  44.    }
  45. }
  46.  
  47. Function get-HtmlDialogs {
  48.    param(
  49.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  50.    ,
  51.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  52.       [ScriptBlock]$Where = {$true}
  53.    )
  54.    process {
  55.       $InputObject.get_HtmlDialogs() | Where $Where
  56.    }
  57. }
  58.  
  59. Function get-HtmlDialogsNoWait {
  60.    param(
  61.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  62.    ,
  63.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  64.       [ScriptBlock]$Where = {$true}
  65.    )
  66.    process {
  67.       $InputObject.get_HtmlDialogsNoWait() | Where $Where
  68.    }
  69. }
  70.  
  71. Function get-NativeBrowser {
  72.    param(
  73.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  74.    ,
  75.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  76.       [ScriptBlock]$Where = {$true}
  77.    )
  78.    process {
  79.       $InputObject.get_NativeBrowser() | Where $Where
  80.    }
  81. }
  82.  
  83. Function get-Visible {
  84.    param(
  85.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  86.    ,
  87.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  88.       [ScriptBlock]$Where = {$true}
  89.    )
  90.    process {
  91.       $InputObject.get_Visible() | Where $Where
  92.    }
  93. }
  94.  
  95. Function set-Visible {
  96.    param(
  97.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  98.    ,
  99.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  100.       [ScriptBlock]$Where = {$true}
  101.    )
  102.    process {
  103.       $InputObject.set_Visible() | Where $Where
  104.    }
  105. }
  106.  
  107. Function get-hWnd {
  108.    param(
  109.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  110.    ,
  111.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  112.       [ScriptBlock]$Where = {$true}
  113.    )
  114.    process {
  115.       $InputObject.get_hWnd() | Where $Where
  116.    }
  117. }
  118.  
  119. Function get-ProcessID {
  120.    param(
  121.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  122.    ,
  123.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  124.       [ScriptBlock]$Where = {$true}
  125.    )
  126.    process {
  127.       $InputObject.get_ProcessID() | Where $Where
  128.    }
  129. }
  130.  
  131. Function get-NativeDocument {
  132.    param(
  133.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  134.    ,
  135.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  136.       [ScriptBlock]$Where = {$true}
  137.    )
  138.    process {
  139.       $InputObject.get_NativeDocument() | Where $Where
  140.    }
  141. }
  142.  
  143. Function get-DialogWatcher {
  144.    param(
  145.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  146.    ,
  147.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  148.       [ScriptBlock]$Where = {$true}
  149.    )
  150.    process {
  151.       $InputObject.get_DialogWatcher() | Where $Where
  152.    }
  153. }
  154.  
  155. Function get-Html {
  156.    param(
  157.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  158.    ,
  159.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  160.       [ScriptBlock]$Where = {$true}
  161.    )
  162.    process {
  163.       $InputObject.get_Html() | Where $Where
  164.    }
  165. }
  166.  
  167. Function get-Body {
  168.    param(
  169.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  170.    ,
  171.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  172.       [ScriptBlock]$Where = {$true}
  173.    )
  174.    process {
  175.       $InputObject.get_Body() | Where $Where
  176.    }
  177. }
  178.  
  179. Function get-Text {
  180.    param(
  181.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  182.    ,
  183.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  184.       [ScriptBlock]$Where = {$true}
  185.    )
  186.    process {
  187.       $InputObject.get_Text() | Where $Where
  188.    }
  189. }
  190.  
  191. Function get-Uri {
  192.    param(
  193.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  194.    ,
  195.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  196.       [ScriptBlock]$Where = {$true}
  197.    )
  198.    process {
  199.       $InputObject.get_Uri() | Where $Where
  200.    }
  201. }
  202.  
  203. Function get-Url {
  204.    param(
  205.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  206.    ,
  207.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  208.       [ScriptBlock]$Where = {$true}
  209.    )
  210.    process {
  211.       $InputObject.get_Url() | Where $Where
  212.    }
  213. }
  214.  
  215. Function get-Title {
  216.    param(
  217.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  218.    ,
  219.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  220.       [ScriptBlock]$Where = {$true}
  221.    )
  222.    process {
  223.       $InputObject.get_Title() | Where $Where
  224.    }
  225. }
  226.  
  227. Function get-ActiveElement {
  228.    param(
  229.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  230.    ,
  231.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  232.       [ScriptBlock]$Where = {$true}
  233.    )
  234.    process {
  235.       $InputObject.get_ActiveElement() | Where $Where
  236.    }
  237. }
  238.  
  239. Function get-Frames {
  240.    param(
  241.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  242.    ,
  243.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  244.       [ScriptBlock]$Where = {$true}
  245.    )
  246.    process {
  247.       $InputObject.get_Frames() | Where $Where
  248.    }
  249. }
  250.  
  251. Function get-DomContainer {
  252.    param(
  253.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  254.    ,
  255.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  256.       [ScriptBlock]$Where = {$true}
  257.    )
  258.    process {
  259.       $InputObject.get_DomContainer() | Where $Where
  260.    }
  261. }
  262.  
  263. Function set-DomContainer {
  264.    param(
  265.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  266.    ,
  267.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  268.       [ScriptBlock]$Where = {$true}
  269.    )
  270.    process {
  271.       $InputObject.set_DomContainer() | Where $Where
  272.    }
  273. }
  274.  
  275. Function get-Areas {
  276.    param(
  277.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  278.    ,
  279.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  280.       [ScriptBlock]$Where = {$true}
  281.    )
  282.    process {
  283.       $InputObject.get_Areas() | Where $Where
  284.    }
  285. }
  286.  
  287. Function get-Buttons {
  288.    param(
  289.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  290.    ,
  291.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  292.       [ScriptBlock]$Where = {$true}
  293.    )
  294.    process {
  295.       $InputObject.get_Buttons() | Where $Where
  296.    }
  297. }
  298.  
  299. Function get-CheckBoxes {
  300.    param(
  301.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  302.    ,
  303.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  304.       [ScriptBlock]$Where = {$true}
  305.    )
  306.    process {
  307.       $InputObject.get_CheckBoxes() | Where $Where
  308.    }
  309. }
  310.  
  311. Function get-Elements {
  312.    param(
  313.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  314.    ,
  315.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  316.       [ScriptBlock]$Where = {$true}
  317.    )
  318.    process {
  319.       $InputObject.get_Elements() | Where $Where
  320.    }
  321. }
  322.  
  323. Function get-FileUploads {
  324.    param(
  325.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  326.    ,
  327.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  328.       [ScriptBlock]$Where = {$true}
  329.    )
  330.    process {
  331.       $InputObject.get_FileUploads() | Where $Where
  332.    }
  333. }
  334.  
  335. Function get-Forms {
  336.    param(
  337.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  338.    ,
  339.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  340.       [ScriptBlock]$Where = {$true}
  341.    )
  342.    process {
  343.       $InputObject.get_Forms() | Where $Where
  344.    }
  345. }
  346.  
  347. Function get-Labels {
  348.    param(
  349.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  350.    ,
  351.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  352.       [ScriptBlock]$Where = {$true}
  353.    )
  354.    process {
  355.       $InputObject.get_Labels() | Where $Where
  356.    }
  357. }
  358.  
  359. Function get-Links {
  360.    param(
  361.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  362.    ,
  363.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  364.       [ScriptBlock]$Where = {$true}
  365.    )
  366.    process {
  367.       $InputObject.get_Links() | Where $Where
  368.    }
  369. }
  370.  
  371. Function get-Paras {
  372.    param(
  373.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  374.    ,
  375.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  376.       [ScriptBlock]$Where = {$true}
  377.    )
  378.    process {
  379.       $InputObject.get_Paras() | Where $Where
  380.    }
  381. }
  382.  
  383. Function get-RadioButtons {
  384.    param(
  385.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  386.    ,
  387.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  388.       [ScriptBlock]$Where = {$true}
  389.    )
  390.    process {
  391.       $InputObject.get_RadioButtons() | Where $Where
  392.    }
  393. }
  394.  
  395. Function get-SelectLists {
  396.    param(
  397.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  398.    ,
  399.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  400.       [ScriptBlock]$Where = {$true}
  401.    )
  402.    process {
  403.       $InputObject.get_SelectLists() | Where $Where
  404.    }
  405. }
  406.  
  407. Function get-Tables {
  408.    param(
  409.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  410.    ,
  411.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  412.       [ScriptBlock]$Where = {$true}
  413.    )
  414.    process {
  415.       $InputObject.get_Tables() | Where $Where
  416.    }
  417. }
  418.  
  419. Function get-TableBodies {
  420.    param(
  421.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  422.    ,
  423.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  424.       [ScriptBlock]$Where = {$true}
  425.    )
  426.    process {
  427.       $InputObject.get_TableBodies() | Where $Where
  428.    }
  429. }
  430.  
  431. Function get-TableCells {
  432.    param(
  433.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  434.    ,
  435.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  436.       [ScriptBlock]$Where = {$true}
  437.    )
  438.    process {
  439.       $InputObject.get_TableCells() | Where $Where
  440.    }
  441. }
  442.  
  443. Function get-TableRows {
  444.    param(
  445.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  446.    ,
  447.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  448.       [ScriptBlock]$Where = {$true}
  449.    )
  450.    process {
  451.       $InputObject.get_TableRows() | Where $Where
  452.    }
  453. }
  454.  
  455. Function get-TextFields {
  456.    param(
  457.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  458.    ,
  459.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  460.       [ScriptBlock]$Where = {$true}
  461.    )
  462.    process {
  463.       $InputObject.get_TextFields() | Where $Where
  464.    }
  465. }
  466.  
  467. Function get-Spans {
  468.    param(
  469.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  470.    ,
  471.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  472.       [ScriptBlock]$Where = {$true}
  473.    )
  474.    process {
  475.       $InputObject.get_Spans() | Where $Where
  476.    }
  477. }
  478.  
  479. Function get-Divs {
  480.    param(
  481.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  482.    ,
  483.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  484.       [ScriptBlock]$Where = {$true}
  485.    )
  486.    process {
  487.       $InputObject.get_Divs() | Where $Where
  488.    }
  489. }
  490.  
  491. Function get-Images {
  492.    param(
  493.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  494.    ,
  495.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  496.       [ScriptBlock]$Where = {$true}
  497.    )
  498.    process {
  499.       $InputObject.get_Images() | Where $Where
  500.    }
  501. }
  502.  
  503. Function get-Description {
  504.    param(
  505.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  506.    ,
  507.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  508.       [ScriptBlock]$Where = {$true}
  509.    )
  510.    process {
  511.       $InputObject.get_Description() | Where $Where
  512.    }
  513. }
  514.  
  515. Function set-Description {
  516.    param(
  517.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  518.    ,
  519.       [Parameter(ValueFromPipeline=$true, Position = 0)]
  520.       [ScriptBlock]$Where = {$true}
  521.    )
  522.    process {
  523.       $InputObject.set_Description() | Where $Where
  524.    }
  525. }
  526.  
  527. Function Find-Area {
  528.    param(
  529.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  530.                 ,
  531.                 [Parameter(Position=0, ParameterSetName='Set0')]
  532.                 [String]$Id
  533.                 ,
  534.                 [Parameter(Position=0, ParameterSetName='Set1')]
  535.                 [Regex]$Pattern
  536.                 ,
  537.                 [Parameter(Position=0, ParameterSetName='Set2')]
  538.                 [WatiN.Core.Constraints.Constraint]$findBy
  539.                 ,
  540.                 [Parameter(Position=0, ParameterSetName='Set3')]
  541.                 [ScriptBlock]$Where
  542.    )
  543.    process {
  544.      
  545.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.Area( $Id ) }
  546.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.Area( $Pattern ) }
  547.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.Area( $findBy ) }
  548.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.Area( $Where ) }
  549.    }
  550. }
  551.  
  552. Function Find-Button {
  553.    param(
  554.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  555.                 ,
  556.                 [Parameter(Position=0, ParameterSetName='Set0')]
  557.                 [String]$Id
  558.                 ,
  559.                 [Parameter(Position=0, ParameterSetName='Set1')]
  560.                 [Regex]$Pattern
  561.                 ,
  562.                 [Parameter(Position=0, ParameterSetName='Set2')]
  563.                 [ScriptBlock]$Where
  564.                 ,
  565.                 [Parameter(Position=0, ParameterSetName='Set3')]
  566.                 [WatiN.Core.Constraints.Constraint]$findBy
  567.    )
  568.    process {
  569.      
  570.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.Button( $Id ) }
  571.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.Button( $Pattern ) }
  572.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.Button( $Where ) }
  573.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.Button( $findBy ) }
  574.    }
  575. }
  576.  
  577. Function Find-CheckBox {
  578.    param(
  579.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  580.                 ,
  581.                 [Parameter(Position=0, ParameterSetName='Set0')]
  582.                 [String]$Id
  583.                 ,
  584.                 [Parameter(Position=0, ParameterSetName='Set1')]
  585.                 [Regex]$Pattern
  586.                 ,
  587.                 [Parameter(Position=0, ParameterSetName='Set2')]
  588.                 [ScriptBlock]$Where
  589.                 ,
  590.                 [Parameter(Position=0, ParameterSetName='Set3')]
  591.                 [WatiN.Core.Constraints.Constraint]$findBy
  592.    )
  593.    process {
  594.      
  595.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.CheckBox( $Id ) }
  596.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.CheckBox( $Pattern ) }
  597.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.CheckBox( $Where ) }
  598.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.CheckBox( $findBy ) }
  599.    }
  600. }
  601.  
  602. Function Find-Element {
  603.    param(
  604.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  605.                 ,
  606.                 [Parameter(Position=0, ParameterSetName='Set0')]
  607.                 [String]$Id
  608.                 ,
  609.                 [Parameter(Position=0, ParameterSetName='Set1')]
  610.                 [Regex]$Pattern
  611.                 ,
  612.                 [Parameter(Position=0, ParameterSetName='Set2')]
  613.                 [WatiN.Core.Constraints.Constraint]$findBy
  614.                 ,
  615.                 [Parameter(Position=0, ParameterSetName='Set3')]
  616.                 [ScriptBlock]$Where
  617.    )
  618.    process {
  619.      
  620.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.Element( $Id ) }
  621.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.Element( $Pattern ) }
  622.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.Element( $findBy ) }
  623.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.Element( $Where ) }
  624.    }
  625. }
  626.  
  627. Function Find-ElementWithTag {
  628.    param(
  629.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  630.                 ,
  631.                 [Parameter(Position=0, ParameterSetName='Set0')]
  632.                 [System.String]$tagName
  633.                 ,
  634.                 [Parameter(Position=1, ParameterSetName='Set0')]
  635.                 [WatiN.Core.Constraints.Constraint]$findBy
  636.                 ,
  637.                 [Parameter(Position=2, ParameterSetName='Set0')]
  638.                 [System.String[]]$inputTypes
  639.    )
  640.    process {
  641.      
  642.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.ElementWithTag( $inputTypes
  643.                 ,
  644.                 $inputTypes
  645.                 ,
  646.                 $inputTypes ) }
  647.    }
  648. }
  649.  
  650. Function Find-ElementOfType {
  651.    param(
  652.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  653.                 ,
  654.                 [Parameter(Position=0, ParameterSetName='Set0')]
  655.                 [String]$Id
  656.                 ,
  657.                 [Parameter(Position=0, ParameterSetName='Set1')]
  658.                 [Regex]$Pattern
  659.                 ,
  660.                 [Parameter(Position=0, ParameterSetName='Set2')]
  661.                 [WatiN.Core.Constraints.Constraint]$findBy
  662.                 ,
  663.                 [Parameter(Position=0, ParameterSetName='Set3')]
  664.                 []$predicate
  665.    )
  666.    process {
  667.      
  668.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.ElementOfType( $Id ) }
  669.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.ElementOfType( $Pattern ) }
  670.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.ElementOfType( $findBy ) }
  671.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.ElementOfType( $predicate ) }
  672.    }
  673. }
  674.  
  675. Function Find-ElementsOfType {
  676.    param(
  677.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  678.    )
  679.    process {
  680.      
  681.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.ElementsOfType(  ) }
  682.    }
  683. }
  684.  
  685. Function Find-FileUpload {
  686.    param(
  687.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  688.                 ,
  689.                 [Parameter(Position=0, ParameterSetName='Set0')]
  690.                 [String]$Id
  691.                 ,
  692.                 [Parameter(Position=0, ParameterSetName='Set1')]
  693.                 [Regex]$Pattern
  694.                 ,
  695.                 [Parameter(Position=0, ParameterSetName='Set2')]
  696.                 [WatiN.Core.Constraints.Constraint]$findBy
  697.                 ,
  698.                 [Parameter(Position=0, ParameterSetName='Set3')]
  699.                 [ScriptBlock]$Where
  700.    )
  701.    process {
  702.      
  703.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.FileUpload( $Id ) }
  704.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.FileUpload( $Pattern ) }
  705.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.FileUpload( $findBy ) }
  706.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.FileUpload( $Where ) }
  707.    }
  708. }
  709.  
  710. Function Find-Form {
  711.    param(
  712.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  713.                 ,
  714.                 [Parameter(Position=0, ParameterSetName='Set0')]
  715.                 [String]$Id
  716.                 ,
  717.                 [Parameter(Position=0, ParameterSetName='Set1')]
  718.                 [Regex]$Pattern
  719.                 ,
  720.                 [Parameter(Position=0, ParameterSetName='Set2')]
  721.                 [WatiN.Core.Constraints.Constraint]$findBy
  722.                 ,
  723.                 [Parameter(Position=0, ParameterSetName='Set3')]
  724.                 [ScriptBlock]$Where
  725.    )
  726.    process {
  727.      
  728.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.Form( $Id ) }
  729.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.Form( $Pattern ) }
  730.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.Form( $findBy ) }
  731.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.Form( $Where ) }
  732.    }
  733. }
  734.  
  735. Function Find-Label {
  736.    param(
  737.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  738.                 ,
  739.                 [Parameter(Position=0, ParameterSetName='Set0')]
  740.                 [String]$Id
  741.                 ,
  742.                 [Parameter(Position=0, ParameterSetName='Set1')]
  743.                 [Regex]$Pattern
  744.                 ,
  745.                 [Parameter(Position=0, ParameterSetName='Set2')]
  746.                 [WatiN.Core.Constraints.Constraint]$findBy
  747.                 ,
  748.                 [Parameter(Position=0, ParameterSetName='Set3')]
  749.                 [ScriptBlock]$Where
  750.    )
  751.    process {
  752.      
  753.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.Label( $Id ) }
  754.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.Label( $Pattern ) }
  755.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.Label( $findBy ) }
  756.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.Label( $Where ) }
  757.    }
  758. }
  759.  
  760. Function Find-Link {
  761.    param(
  762.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  763.                 ,
  764.                 [Parameter(Position=0, ParameterSetName='Set0')]
  765.                 [String]$Id
  766.                 ,
  767.                 [Parameter(Position=0, ParameterSetName='Set1')]
  768.                 [Regex]$Pattern
  769.                 ,
  770.                 [Parameter(Position=0, ParameterSetName='Set2')]
  771.                 [WatiN.Core.Constraints.Constraint]$findBy
  772.                 ,
  773.                 [Parameter(Position=0, ParameterSetName='Set3')]
  774.                 [ScriptBlock]$Where
  775.    )
  776.    process {
  777.      
  778.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.Link( $Id ) }
  779.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.Link( $Pattern ) }
  780.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.Link( $findBy ) }
  781.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.Link( $Where ) }
  782.    }
  783. }
  784.  
  785. Function Find-Para {
  786.    param(
  787.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  788.                 ,
  789.                 [Parameter(Position=0, ParameterSetName='Set0')]
  790.                 [String]$Id
  791.                 ,
  792.                 [Parameter(Position=0, ParameterSetName='Set1')]
  793.                 [Regex]$Pattern
  794.                 ,
  795.                 [Parameter(Position=0, ParameterSetName='Set2')]
  796.                 [WatiN.Core.Constraints.Constraint]$findBy
  797.                 ,
  798.                 [Parameter(Position=0, ParameterSetName='Set3')]
  799.                 [ScriptBlock]$Where
  800.    )
  801.    process {
  802.      
  803.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.Para( $Id ) }
  804.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.Para( $Pattern ) }
  805.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.Para( $findBy ) }
  806.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.Para( $Where ) }
  807.    }
  808. }
  809.  
  810. Function Find-RadioButton {
  811.    param(
  812.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  813.                 ,
  814.                 [Parameter(Position=0, ParameterSetName='Set0')]
  815.                 [String]$Id
  816.                 ,
  817.                 [Parameter(Position=0, ParameterSetName='Set1')]
  818.                 [Regex]$Pattern
  819.                 ,
  820.                 [Parameter(Position=0, ParameterSetName='Set2')]
  821.                 [WatiN.Core.Constraints.Constraint]$findBy
  822.                 ,
  823.                 [Parameter(Position=0, ParameterSetName='Set3')]
  824.                 [ScriptBlock]$Where
  825.    )
  826.    process {
  827.      
  828.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.RadioButton( $Id ) }
  829.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.RadioButton( $Pattern ) }
  830.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.RadioButton( $findBy ) }
  831.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.RadioButton( $Where ) }
  832.    }
  833. }
  834.  
  835. Function Find-SelectList {
  836.    param(
  837.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  838.                 ,
  839.                 [Parameter(Position=0, ParameterSetName='Set0')]
  840.                 [String]$Id
  841.                 ,
  842.                 [Parameter(Position=0, ParameterSetName='Set1')]
  843.                 [Regex]$Pattern
  844.                 ,
  845.                 [Parameter(Position=0, ParameterSetName='Set2')]
  846.                 [WatiN.Core.Constraints.Constraint]$findBy
  847.                 ,
  848.                 [Parameter(Position=0, ParameterSetName='Set3')]
  849.                 [ScriptBlock]$Where
  850.    )
  851.    process {
  852.      
  853.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.SelectList( $Id ) }
  854.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.SelectList( $Pattern ) }
  855.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.SelectList( $findBy ) }
  856.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.SelectList( $Where ) }
  857.    }
  858. }
  859.  
  860. Function Find-Table {
  861.    param(
  862.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  863.                 ,
  864.                 [Parameter(Position=0, ParameterSetName='Set0')]
  865.                 [String]$Id
  866.                 ,
  867.                 [Parameter(Position=0, ParameterSetName='Set1')]
  868.                 [Regex]$Pattern
  869.                 ,
  870.                 [Parameter(Position=0, ParameterSetName='Set2')]
  871.                 [WatiN.Core.Constraints.Constraint]$findBy
  872.                 ,
  873.                 [Parameter(Position=0, ParameterSetName='Set3')]
  874.                 [ScriptBlock]$Where
  875.    )
  876.    process {
  877.      
  878.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.Table( $Id ) }
  879.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.Table( $Pattern ) }
  880.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.Table( $findBy ) }
  881.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.Table( $Where ) }
  882.    }
  883. }
  884.  
  885. Function Find-TableBody {
  886.    param(
  887.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  888.                 ,
  889.                 [Parameter(Position=0, ParameterSetName='Set0')]
  890.                 [String]$Id
  891.                 ,
  892.                 [Parameter(Position=0, ParameterSetName='Set1')]
  893.                 [Regex]$Pattern
  894.                 ,
  895.                 [Parameter(Position=0, ParameterSetName='Set2')]
  896.                 [WatiN.Core.Constraints.Constraint]$findBy
  897.                 ,
  898.                 [Parameter(Position=0, ParameterSetName='Set3')]
  899.                 [ScriptBlock]$Where
  900.    )
  901.    process {
  902.      
  903.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.TableBody( $Id ) }
  904.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.TableBody( $Pattern ) }
  905.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.TableBody( $findBy ) }
  906.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.TableBody( $Where ) }
  907.    }
  908. }
  909.  
  910. Function Find-TableCell {
  911.    param(
  912.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  913.                 ,
  914.                 [Parameter(Position=0, ParameterSetName='Set0', Mandatory = $true)]
  915.                 [Parameter(Position=0, ParameterSetName='Set1', Mandatory = $true)]
  916.                 [String]$Id
  917.                 ,
  918.                 [Parameter(Position=1, ParameterSetName='Set1', Mandatory = $true)]
  919.                 [Parameter(Position=1, ParameterSetName='Set2', Mandatory = $true)]
  920.                 [System.Int32]$index
  921.                 ,
  922.                 [Parameter(Position=0, ParameterSetName='Set2', Mandatory = $true)]
  923.                 [Parameter(Position=0, ParameterSetName='Set3', Mandatory = $true)]
  924.                 [Regex]$Pattern
  925.                 ,
  926.                 [Parameter(Position=0, ParameterSetName='Set4')]
  927.                 [WatiN.Core.Constraints.Constraint]$findBy
  928.                 ,
  929.                 [Parameter(Position=0, ParameterSetName='Set5')]
  930.                 [ScriptBlock]$Where
  931.    )
  932.    process {
  933.      
  934.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.TableCell( $Id ) }
  935.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.TableCell( $Id, $index ) }
  936.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.TableCell( $Pattern, $index ) }
  937.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.TableCell( $Pattern ) }
  938.                 if($PSCmdlet.ParameterSetName -eq 'Set4'){ $InputObject.TableCell( $findBy ) }
  939.                 if($PSCmdlet.ParameterSetName -eq 'Set5'){ $InputObject.TableCell( $Where ) }
  940.    }
  941. }
  942.  
  943. Function Find-TableRow {
  944.    param(
  945.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  946.                 ,
  947.                 [Parameter(Position=0, ParameterSetName='Set0')]
  948.                 [String]$Id
  949.                 ,
  950.                 [Parameter(Position=0, ParameterSetName='Set1')]
  951.                 [Regex]$Pattern
  952.                 ,
  953.                 [Parameter(Position=0, ParameterSetName='Set2')]
  954.                 [WatiN.Core.Constraints.Constraint]$findBy
  955.                 ,
  956.                 [Parameter(Position=0, ParameterSetName='Set3')]
  957.                 [ScriptBlock]$Where
  958.    )
  959.    process {
  960.      
  961.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.TableRow( $Id ) }
  962.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.TableRow( $Pattern ) }
  963.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.TableRow( $findBy ) }
  964.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.TableRow( $Where ) }
  965.    }
  966. }
  967.  
  968. Function Find-TextField {
  969.    param(
  970.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  971.                 ,
  972.                 [Parameter(Position=0, ParameterSetName='Set0')]
  973.                 [String]$Id
  974.                 ,
  975.                 [Parameter(Position=0, ParameterSetName='Set1')]
  976.                 [Regex]$Pattern
  977.                 ,
  978.                 [Parameter(Position=0, ParameterSetName='Set2')]
  979.                 [WatiN.Core.Constraints.Constraint]$findBy
  980.                 ,
  981.                 [Parameter(Position=0, ParameterSetName='Set3')]
  982.                 [ScriptBlock]$Where
  983.    )
  984.    process {
  985.      
  986.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.TextField( $Id ) }
  987.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.TextField( $Pattern ) }
  988.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.TextField( $findBy ) }
  989.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.TextField( $Where ) }
  990.    }
  991. }
  992.  
  993. Function Find-Span {
  994.    param(
  995.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  996.                 ,
  997.                 [Parameter(Position=0, ParameterSetName='Set0')]
  998.                 [String]$Id
  999.                 ,
  1000.                 [Parameter(Position=0, ParameterSetName='Set1')]
  1001.                 [Regex]$Pattern
  1002.                 ,
  1003.                 [Parameter(Position=0, ParameterSetName='Set2')]
  1004.                 [WatiN.Core.Constraints.Constraint]$findBy
  1005.                 ,
  1006.                 [Parameter(Position=0, ParameterSetName='Set3')]
  1007.                 [ScriptBlock]$Where
  1008.    )
  1009.    process {
  1010.      
  1011.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.Span( $Id ) }
  1012.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.Span( $Pattern ) }
  1013.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.Span( $findBy ) }
  1014.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.Span( $Where ) }
  1015.    }
  1016. }
  1017.  
  1018. Function Find-Div {
  1019.    param(
  1020.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  1021.                 ,
  1022.                 [Parameter(Position=0, ParameterSetName='Set0')]
  1023.                 [String]$Id
  1024.                 ,
  1025.                 [Parameter(Position=0, ParameterSetName='Set1')]
  1026.                 [Regex]$Pattern
  1027.                 ,
  1028.                 [Parameter(Position=0, ParameterSetName='Set2')]
  1029.                 [WatiN.Core.Constraints.Constraint]$findBy
  1030.                 ,
  1031.                 [Parameter(Position=0, ParameterSetName='Set3')]
  1032.                 [ScriptBlock]$Where
  1033.    )
  1034.    process {
  1035.      
  1036.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.Div( $Id ) }
  1037.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.Div( $Pattern ) }
  1038.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.Div( $findBy ) }
  1039.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.Div( $Where ) }
  1040.    }
  1041. }
  1042.  
  1043. Function Find-Image {
  1044.    param(
  1045.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  1046.                 ,
  1047.                 [Parameter(Position=0, ParameterSetName='Set0')]
  1048.                 [String]$Id
  1049.                 ,
  1050.                 [Parameter(Position=0, ParameterSetName='Set1')]
  1051.                 [Regex]$Pattern
  1052.                 ,
  1053.                 [Parameter(Position=0, ParameterSetName='Set2')]
  1054.                 [WatiN.Core.Constraints.Constraint]$findBy
  1055.                 ,
  1056.                 [Parameter(Position=0, ParameterSetName='Set3')]
  1057.                 [ScriptBlock]$Where
  1058.    )
  1059.    process {
  1060.      
  1061.                 if($PSCmdlet.ParameterSetName -eq 'Set0'){ $InputObject.Image( $Id ) }
  1062.                 if($PSCmdlet.ParameterSetName -eq 'Set1'){ $InputObject.Image( $Pattern ) }
  1063.                 if($PSCmdlet.ParameterSetName -eq 'Set2'){ $InputObject.Image( $findBy ) }
  1064.                 if($PSCmdlet.ParameterSetName -eq 'Set3'){ $InputObject.Image( $Where ) }
  1065.    }
  1066. }
  1067.  
  1068.  
  1069.  
  1070.  
  1071.  
  1072.  
  1073. Function New-WatinIE {
  1074. PARAM(
  1075.    [string]$URL = "http://www.PoshCode.org"
  1076. ,
  1077.    [switch]$Passthru
  1078. )
  1079.    ## Create an initial window (I'm creating IE, but WatiN handles Firefox too)
  1080.    $global:WatinIE = new-object WatiN.Core.IE $URL
  1081.    if($Passthru) { $global:WatinIE }
  1082. }
  1083.  
  1084. Function Get-WatinIE {
  1085. PARAM(
  1086.    [string]$URL = "http://www.PoshCode.org"
  1087. ,
  1088.    [switch]$Passthru
  1089. )
  1090.    ## Find an existing window (I'm using IE, but WatiN handles Firefox too)
  1091.    $global:WatinIE = [WatiN.Core.IE]::InternetExplorers()[0]
  1092.    if($Passthru) { $global:WatinIE }
  1093.    Set-WatinUrl $url
  1094. }
  1095.  
  1096. function Set-WatinUrl {
  1097.    Param($url)
  1098.    $global:WatinIE.Goto( $url )
  1099. }
  1100.  
  1101. function Send-Text {
  1102.    param(
  1103.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  1104.    ,
  1105.       [Parameter(Position=0)]
  1106.       [string]$text
  1107.    ,
  1108.       [switch]$passthru
  1109.    ,
  1110.       [switch]$append
  1111.    )
  1112.    process {
  1113.       if($append) {
  1114.          $InputObject.AppendText( $text )
  1115.       } else {
  1116.          $InputObject.TypeText( $text )
  1117.       }
  1118.       if($Passthru){$InputObject}
  1119.    }
  1120. }
  1121.  
  1122. function Send-Click {
  1123.    param(
  1124.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  1125.    ,
  1126.       [switch]$passthru
  1127.    )
  1128.    process {
  1129.       $InputObject.Click()
  1130.    }
  1131. }
  1132.  
  1133. function Select-Element {
  1134.    param(
  1135.       [Parameter(ValueFromPipeline=$true)]$InputObject = $global:WatinIE
  1136.    ,
  1137.       [switch]$passthru
  1138.    )
  1139.    process {
  1140.       $InputObject.Select()
  1141.    }
  1142. }
  1143.  
  1144.  
  1145.  
  1146.  
  1147.  
  1148. ###################################################################################################
  1149. ## This is the code to generate the functions above... Note at the end it puts it on the clipboard.
  1150. ###################################################################################################
  1151. ##  $methods     = [WatiN.Core.IE].GetMethods( "Public, Instance, InvokeMethod" ) | Group Name
  1152. ##  
  1153. ##  $properties  = $methods | where { $_.Count -eq 1 -and $_.Name -match "_" }
  1154. ##  $getproperties = $properties | %{if($_.Name -match "get_"){ $_.Group }} | Group { $_.Name -replace "get_" } | sort Name
  1155. ##  
  1156. ##  $lessmethods = $methods | where { $_.Name -notmatch "_" }
  1157. ##  
  1158. ##  $findMethods = $lessmethods | Where {
  1159. ##                                $type =  @($_.Group)[0].ReturnType
  1160. ##                                   $type.IsSubclassOf( ([WatiN.Core.Element]) ) -or
  1161. ##                                   $type.Equals( ([WatiN.Core.Element]) ) -or
  1162. ##                                  ($type.IsGenericType -and $type.GetGenericArguments()[0].IsSubclassOf( ([WatiN.Core.Element]) ))
  1163. ##                             } | sort Name
  1164. ##  
  1165. ##  $lessmethods = $lessmethods | Where { $findMethods -notcontains $_ }
  1166. ##  
  1167. ##  $newline     = "`n`t`t"
  1168. ##  
  1169. ##  $function    = New-Object System.Text.StringBuilder
  1170. ##  
  1171. ##  ## All of this bit indented here is just to line up the properties with the methods
  1172. ##     $matchedProperties  = @($getproperties | ? { $_.Name -eq "TableBodies" })
  1173. ##     $matchedFindMethods = @($findMethods | ? { $_.Name -eq "TableBody" })
  1174. ##  
  1175. ##     foreach($f in $findMethods) {
  1176. ##        foreach($p in $getproperties) {
  1177. ##           if($p.Name -match "^$($f.Name).{1,3}$") {
  1178. ##              $matchedProperties += $p
  1179. ##              $matchedFindMethods += $f
  1180. ##           }
  1181. ##        }
  1182. ##     }
  1183. ##  
  1184. ##  $lessproperties = $properties | Where { @($matchedProperties | %{ $_.Group } | Select -Expand Name) -notcontains $_.Name }
  1185. ##  $lessfindMethods = $findMethods | Where { @($matchedFindMethods | %{ $_.Group } | Select -Expand Name) -notcontains $_.Name }
  1186. ##    
  1187. ##  foreach($property in $lessproperties | %{ $_.Group }) {
  1188. ##     $name = $property.Name -replace "^get_","Get-" -replace "^set_","Set-"
  1189. ##    
  1190. ##  $null = $function.Append(@"
  1191. ##  
  1192. ##  Function $name {
  1193. ##     param(
  1194. ##        [Parameter(ValueFromPipeline=`$true)]`$InputObject = `$global:WatinIE
  1195. ##     ,
  1196. ##        [Parameter(ValueFromPipeline=`$true, Position = 0)]
  1197. ##        [ScriptBlock]`$Where = {`$true}
  1198. ##     )
  1199. ##     process {
  1200. ##        `$InputObject.$($property.Name)() | Where `$Where
  1201. ##     }
  1202. ##  }
  1203. ##  
  1204. ##  "@)
  1205. ##  }
  1206. ##  
  1207. ##  
  1208. ##  
  1209. ##  for($i = 0; $i -lt $matchedProperties.Length; $i++) {
  1210. ##  
  1211. ##  $Property = $MatchedProperties[$i]
  1212. ##  $Method   = $MatchedFindMethods[$i]
  1213. ##  
  1214. ##  foreach($property in $properties | %{ $_.Group }) {
  1215. ##     $name = $property.Name -replace "_","-"
  1216. ##    
  1217. ##  $null = $function.Append(@"
  1218. ##  
  1219. ##  Function $name {
  1220. ##     param(
  1221. ##        [Parameter(ValueFromPipeline=`$true)]`$InputObject = `$global:WatinIE
  1222. ##     ,
  1223. ##        [Parameter(ValueFromPipeline=`$true, Position = 0)]
  1224. ##        [ScriptBlock]`$Where = {`$true}
  1225. ##     )
  1226. ##     process {
  1227. ##        `$InputObject.$($property.Name)() | Where `$Where
  1228. ##     }
  1229. ##  }
  1230. ##  
  1231. ##  "@)
  1232. ##  }
  1233. ##  
  1234. ##  foreach($method in $findMethods) {
  1235. ##     $name = $method.Name
  1236. ##     $ParameterSet = 0
  1237. ##     $Parameters = "[Parameter(ValueFromPipeline=`$true)]`$InputObject = `$global:WatinIE"
  1238. ##     $CodeBlock = ""
  1239. ##     foreach($m in $method.Group) {
  1240. ##        $Position   = 0;
  1241. ##        $SetName    = "Set$ParameterSet"
  1242. ##        $ParameterSet++
  1243. ##        $params     = $m.GetParameters() | % {
  1244. ##           $TypeName = $_.ParameterType.FullName
  1245. ##           $ParamName = $_.Name
  1246. ##           if($TypeName -match "System.Predicate") { $TypeName = "ScriptBlock"; $ParamName = "Where" }
  1247. ##           if($TypeName -match "System.Text.RegularExpressions.Regex" -and $ParamName -eq "elementId") { $TypeName = "Regex"; $ParamName = "Pattern" }
  1248. ##           if($TypeName -match "System.String" -and $ParamName -eq "elementId") { $TypeName = "String"; $ParamName = "Id" }
  1249. ##           "[Parameter(Position=$($Position; $Position++), ParameterSetName='$SetName')]${newline}[$TypeName]`$$ParamName"
  1250. ##        }
  1251. ##        if(@($m.GetParameters()).Length) {
  1252. ##           $Parameters = @(@($Parameters)+@($params)) -join "$newline,$newline"
  1253. ##        }
  1254. ##        $block      = $m.GetParameters() | % { "`$$ParamName" }
  1255. ##        $CodeBlock += "${newline}if(`$PSCmdlet.ParameterSetName -eq '$SetName'){ `$InputObject.$Name( $(@($block) -join "$newline,$newline") ) }"
  1256. ##     }
  1257. ##  $null = $function.Append(@"
  1258. ##  
  1259. ##  Function Find-$name {
  1260. ##     param(
  1261. ##        $Parameters
  1262. ##     )
  1263. ##     process {
  1264. ##        $CodeBlock
  1265. ##     }
  1266. ##  }
  1267. ##  
  1268. ##  "@)
  1269. ##  }
  1270. ##  
  1271. ##  $function.ToString() | clip
  1272. ##

Submit a correction or amendment below (
click here to make a fresh posting)
After submitting an amendment, you'll be able to view the differences between the old and new posts easily.

Syntax highlighting:


Remember me