Refactor

1.2.25

bin/Refactor.xml

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Refactor</name>
    </assembly>
    <members>
        <member name="T:Refactor.AstToken">
            <summary>
            Generic AST token.
            </summary>
        </member>
        <member name="P:Refactor.AstToken.Type">
            <summary>
            The kind of token this is.
            Must match the name of the token provider to use.
            </summary>
        </member>
        <member name="P:Refactor.AstToken.Text">
            <summary>
            The actual Text within the file that should be replaced after executing transform.
            </summary>
        </member>
        <member name="P:Refactor.AstToken.StartOffset">
            <summary>
            The start offset within the original code.
            Used to identify the code's position in the original text when replacing with transformed content.
            </summary>
        </member>
        <member name="P:Refactor.AstToken.Length">
            <summary>
            Total length of the ast
            </summary>
        </member>
        <member name="F:Refactor.AstToken.NewText">
            <summary>
            The text the Ast should have
            </summary>
        </member>
        <member name="M:Refactor.AstToken.#ctor(System.Management.Automation.Language.Ast)">
            <summary>
            Create a new ast token based off an ast object.
            </summary>
            <param name="AstObject">The AST describing a powershell element</param>
        </member>
        <member name="M:Refactor.AstToken.GetChanges">
            <summary>
            The changes applied to this token.
            </summary>
            <returns>The changes applied to this token.</returns>
        </member>
        <member name="T:Refactor.BreakingChange">
            <summary>
            Result Container for a Breaking Change Scan
            </summary>
        </member>
        <member name="F:Refactor.BreakingChange.Path">
            <summary>
            Path to the file being scanned
            </summary>
        </member>
        <member name="F:Refactor.BreakingChange.Name">
            <summary>
            Name of the file being scanned
            </summary>
        </member>
        <member name="F:Refactor.BreakingChange.Line">
            <summary>
            Line within the file where the result was found
            </summary>
        </member>
        <member name="F:Refactor.BreakingChange.Command">
            <summary>
            Name of the command that represents a breaking change
            </summary>
        </member>
        <member name="F:Refactor.BreakingChange.Parameter">
            <summary>
            Name of the parameter affected by the breaking change
            </summary>
        </member>
        <member name="F:Refactor.BreakingChange.Type">
            <summary>
            What kind of break message is this. Generally only errors or warnings.
            </summary>
        </member>
        <member name="F:Refactor.BreakingChange.Description">
            <summary>
            Description of the breaking change
            </summary>
        </member>
        <member name="F:Refactor.BreakingChange.Module">
            <summary>
            Name of the module the command is from
            </summary>
        </member>
        <member name="F:Refactor.BreakingChange.Version">
            <summary>
            Version in which the breaking change was introduced
            </summary>
        </member>
        <member name="F:Refactor.BreakingChange.Tags">
            <summary>
            Tags assigned to this breaking change
            </summary>
        </member>
        <member name="T:Refactor.Change">
            <summary>
            Type representing a single script change / string replacement operation
            </summary>
        </member>
        <member name="F:Refactor.Change.Before">
            <summary>
            The text before applying the change
            </summary>
        </member>
        <member name="F:Refactor.Change.After">
            <summary>
            The text after applying the change
            </summary>
        </member>
        <member name="F:Refactor.Change.Offset">
            <summary>
            The starting index in the source code from where to begin the replacement
            </summary>
        </member>
        <member name="F:Refactor.Change.Path">
            <summary>
            Path of the file in which changes should be applied
            </summary>
        </member>
        <member name="F:Refactor.Change.Token">
            <summary>
            The token generating this change
            </summary>
        </member>
        <member name="F:Refactor.Change.Data">
            <summary>
            Any additional data that should be included in this change object
            </summary>
        </member>
        <member name="T:Refactor.CommandToken">
            <summary>
            Object representing a single command in a script
            </summary>
        </member>
        <member name="P:Refactor.CommandToken.Type">
            <summary>
            The kind of token this is.
            Must match the name of the token provider to use.
            </summary>
        </member>
        <member name="P:Refactor.CommandToken.Text">
            <summary>
            The actual Text within the file that should be replaced after executing transform.
            </summary>
        </member>
        <member name="P:Refactor.CommandToken.StartOffset">
            <summary>
            The start offset within the original code.
            Used to identify the code's position in the original text when replacing with transformed content.
            </summary>
        </member>
        <member name="F:Refactor.CommandToken.NewText">
            <summary>
            The updated text after running the token transformation
            </summary>
        </member>
        <member name="F:Refactor.CommandToken.Parameters">
            <summary>
            The parameters that are KNOWN to be used in the command
            </summary>
        </member>
        <member name="F:Refactor.CommandToken.ParametersKnown">
            <summary>
            Whether we are confident having identified all the parameters used
            </summary>
        </member>
        <member name="F:Refactor.CommandToken.Splats">
            <summary>
            Any splats used in this command
            </summary>
        </member>
        <member name="F:Refactor.CommandToken.HasSplat">
            <summary>
            Whether this command has any splats
            </summary>
        </member>
        <member name="F:Refactor.CommandToken.ParameterChanges">
            <summary>
            Store additional changes here as needed.
            Intended to catch parameter renames that need to be applied to splatting hashtables.
            </summary>
        </member>
        <member name="M:Refactor.CommandToken.#ctor(System.Management.Automation.Language.CommandAst)">
            <summary>
            Create a new command token off a CommandAst object
            </summary>
            <param name="Command">The Ast off which to build the Command Token</param>
        </member>
        <member name="M:Refactor.CommandToken.IsSplat(System.Management.Automation.Language.Ast)">
            <summary>
            Whether a given Ast object is a splat.
            </summary>
            <param name="AstObject">The Ast object to check</param>
            <returns>Whether a given Ast object is a splat.</returns>
        </member>
        <member name="M:Refactor.CommandToken.GetChanges">
            <summary>
            Returns changes the token would apply.
            Run after calling transform
            </summary>
            <returns>The changes applied by this token after its transformation</returns>
        </member>
        <member name="M:Refactor.CommandToken.AddChange(System.String,System.String,System.Int32,System.Object)">
            <summary>
            Add a new change to this token
            </summary>
            <param name="Before">The text before the change</param>
            <param name="After">The text after the change</param>
            <param name="Offset">The starting offset in the source text being modified</param>
            <param name="Data">Any additional data to include (such as the Ast maybe)</param>
        </member>
        <member name="T:Refactor.Component.AstResult">
            <summary>
            Result set of an Ast Token scan. Returned by Read-ReAstComponent, processed by Write-ReAstComponent.
            </summary>
        </member>
        <member name="P:Refactor.Component.AstResult.Type">
            <summary>
            What kind of AST was it?
            </summary>
        </member>
        <member name="P:Refactor.Component.AstResult.FileName">
            <summary>
            Name of the file the AST token was generated from.
            </summary>
        </member>
        <member name="P:Refactor.Component.AstResult.Line">
            <summary>
            Starting line in the file that the AST token was generated from.
            </summary>
        </member>
        <member name="P:Refactor.Component.AstResult.Path">
            <summary>
            Path of the file the AST token was generated from.
            </summary>
        </member>
        <member name="P:Refactor.Component.AstResult.Text">
            <summary>
            Text of the AST
            </summary>
        </member>
        <member name="P:Refactor.Component.AstResult.NewText">
            <summary>
            New text of the AST
            </summary>
        </member>
        <member name="P:Refactor.Component.AstResult.Ast">
            <summary>
            Ast object found
            </summary>
        </member>
        <member name="F:Refactor.Component.AstResult.Token">
            <summary>
            The token generated from the AST token provider
            </summary>
        </member>
        <member name="F:Refactor.Component.AstResult.File">
            <summary>
            The open ScriptFile, used for applying changes
            </summary>
        </member>
        <member name="F:Refactor.Component.AstResult.Result">
            <summary>
            The scan result of any given target processed by Read-ReAstComponent.
            In case you need to link all results from a single scan.
            </summary>
        </member>
        <member name="M:Refactor.Component.AstResult.#ctor(Refactor.AstToken,Refactor.ScriptFile,Refactor.Component.ScriptResult)">
            <summary>
            Generate a new AST Result
            </summary>
            <param name="Token">The token being represented</param>
            <param name="File">The scriptfile scanned</param>
            <param name="Result">The result object containing all tokens from a given scan.</param>
        </member>
        <member name="T:Refactor.Component.ScriptFileConverted">
            <summary>
            A summary object of a post-conversion scriptfile that was generated from Write-ReAstComponent.
            </summary>
        </member>
        <member name="F:Refactor.Component.ScriptFileConverted.Name">
            <summary>
            Name of the file converted
            </summary>
        </member>
        <member name="F:Refactor.Component.ScriptFileConverted.Path">
            <summary>
            Path to the file that was converted (whether in situ or via OutPath to another path, this points at the original source)
            </summary>
        </member>
        <member name="F:Refactor.Component.ScriptFileConverted.Text">
            <summary>
            Text-content of the file after it was transformed.
            </summary>
        </member>
        <member name="P:Refactor.Component.ScriptFileConverted.ConversionID">
            <summary>
            The ID of the search result that was converted. Just in case one needs to track things.
            </summary>
        </member>
        <member name="M:Refactor.Component.ScriptFileConverted.#ctor(Refactor.Component.ScriptResult)">
            <summary>
            Create a new script file object representing a converted object.
            </summary>
            <param name="Result">The search result that was applied.</param>
        </member>
        <member name="T:Refactor.Component.ScriptResult">
            <summary>
            Result of a single token scan using Read-ReAstComponent
            </summary>
        </member>
        <member name="F:Refactor.Component.ScriptResult.File">
            <summary>
            The scriptfile scanned
            </summary>
        </member>
        <member name="F:Refactor.Component.ScriptResult.Tokens">
            <summary>
            The list of tokens found
            </summary>
        </member>
        <member name="F:Refactor.Component.ScriptResult.Types">
            <summary>
            The types of AST scanned for.
            </summary>
        </member>
        <member name="F:Refactor.Component.ScriptResult.ID">
            <summary>
            Unique ID to differentiate between the executions
            </summary>
        </member>
        <member name="M:Refactor.Component.ScriptResult.ToString">
            <summary>
            Default string display of this object
            </summary>
            <returns>The ID of the scan</returns>
        </member>
        <member name="T:Refactor.FunctionToken">
            <summary>
            Token representing a function definition
            </summary>
        </member>
        <member name="P:Refactor.FunctionToken.Type">
            <summary>
            The kind of token this is.
            Must match the name of the token provider to use.
            </summary>
        </member>
        <member name="P:Refactor.FunctionToken.Text">
            <summary>
            The actual Text within the file that should be replaced after executing transform.
            </summary>
        </member>
        <member name="P:Refactor.FunctionToken.StartOffset">
            <summary>
            The start offset within the original code.
            Used to identify the code's position in the original text when replacing with transformed content.
            </summary>
        </member>
        <member name="P:Refactor.FunctionToken.Length">
            <summary>
            Total length of the function definition
            </summary>
        </member>
        <member name="F:Refactor.FunctionToken.Changes">
            <summary>
            The changes applied to this Token.
            Filled by calling Transform()
            </summary>
        </member>
        <member name="M:Refactor.FunctionToken.#ctor(System.Management.Automation.Language.FunctionDefinitionAst)">
            <summary>
            Create a new function token based off a function definition ast.
            </summary>
            <param name="Definition">The AST describing a function definition</param>
        </member>
        <member name="M:Refactor.FunctionToken.GetChanges">
            <summary>
            The changes applied to this token.
            </summary>
            <returns>The changes applied to this token.</returns>
        </member>
        <member name="M:Refactor.FunctionToken.AddChange(System.String,System.String,System.Int32,System.Object)">
            <summary>
            Add a new change to this token
            </summary>
            <param name="Before">The text before the change</param>
            <param name="After">The text after the change</param>
            <param name="Offset">The starting offset in the source text being modified</param>
            <param name="Data">Any additional data to include (such as the Ast maybe)</param>
        </member>
        <member name="T:Refactor.GenericToken">
            <summary>
            A generic token class, intended for all-script Token provider
            </summary>
        </member>
        <member name="P:Refactor.GenericToken.Type">
            <summary>
            The kind of token this is.
            Must match the name of the token provider to use.
            </summary>
        </member>
        <member name="F:Refactor.GenericToken.Data">
            <summary>
            A free field to add arbitrary data
            </summary>
        </member>
        <member name="F:Refactor.GenericToken.Changes">
            <summary>
            The changes to apply during transform
            </summary>
        </member>
        <member name="M:Refactor.GenericToken.GetChanges">
            <summary>
            Returns changes the token would apply.
            Run after calling transform
            </summary>
            <returns>The changes applied by this token after its transformation</returns>
        </member>
        <member name="M:Refactor.GenericToken.AddChange(System.String,System.String,System.Int32,System.Object)">
            <summary>
            Add a new change to this token
            </summary>
            <param name="Before">The text before the change</param>
            <param name="After">The text after the change</param>
            <param name="Offset">The starting offset in the source text being modified</param>
            <param name="Data">Any additional data to include (such as the Ast maybe)</param>
        </member>
        <member name="M:Refactor.GenericToken.#ctor(System.String,System.String)">
            <summary>
            Create a new generic token object
            </summary>
            <param name="Type">The type of the token. Must match the Token Provider name employing the object.</param>
            <param name="Name">The name of the token. used to match against transforms.</param>
        </member>
        <member name="T:Refactor.Host">
            <summary>
            Global tools, data and settings related to the Refactor module library
            </summary>
        </member>
        <member name="F:Refactor.Host.ProviderCommand">
            <summary>
            Command used to list all available token providers
            </summary>
        </member>
        <member name="F:Refactor.Host.TransformCommand">
            <summary>
            Command used convert tokens
            </summary>
        </member>
        <member name="T:Refactor.Message">
            <summary>
            Status message of a transformation action
            </summary>
        </member>
        <member name="F:Refactor.Message.Type">
            <summary>
            What level of information are we talking about?
            </summary>
        </member>
        <member name="F:Refactor.Message.Text">
            <summary>
            The actual message text
            </summary>
        </member>
        <member name="F:Refactor.Message.Data">
            <summary>
            Any additional data to attach to the message
            </summary>
        </member>
        <member name="F:Refactor.Message.Token">
            <summary>
            The Token on which things went wrong
            </summary>
        </member>
        <member name="M:Refactor.Message.#ctor(Refactor.MessageType,System.String,System.Object,Refactor.ScriptToken)">
            <summary>
            Create a new message object
            </summary>
            <param name="Type">What level of information are we talking about?</param>
            <param name="Text">The actual message text</param>
            <param name="Data">Any additional data to attach to the message</param>
            <param name="Token">The Token on which things went wrong</param>
        </member>
        <member name="M:Refactor.Message.ToString">
            <summary>
            Text representation of the message
            </summary>
            <returns>text</returns>
        </member>
        <member name="T:Refactor.MessageType">
            <summary>
            The category of a Message object
            </summary>
        </member>
        <member name="F:Refactor.MessageType.Information">
            <summary>
            General Information
            </summary>
        </member>
        <member name="F:Refactor.MessageType.Warning">
            <summary>
            Something was not entirely a success
            </summary>
        </member>
        <member name="F:Refactor.MessageType.Error">
            <summary>
            Something went really wrong
            </summary>
        </member>
        <member name="T:Refactor.PSHelp">
            <summary>
            Represents the Comment Based Help of a function
            </summary>
        </member>
        <member name="T:Refactor.PSHelpExample">
            <summary>
            An example text for the help of a function
            </summary>
        </member>
        <member name="F:Refactor.PSHelpExample.Code">
            <summary>
            The example code, showing how to use this command
            </summary>
        </member>
        <member name="F:Refactor.PSHelpExample.Description">
            <summary>
            The text describing what is happening
            </summary>
        </member>
        <member name="T:Refactor.ScriptFile">
            <summary>
            Wrapper around a scriptfile, base from which tokens are generated and transform results are written back to
            </summary>
        </member>
        <member name="P:Refactor.ScriptFile.Path">
            <summary>
            Path to the file being processed
            </summary>
        </member>
        <member name="F:Refactor.ScriptFile.Ast">
            <summary>
            Original AST of the file being processed
            </summary>
        </member>
        <member name="F:Refactor.ScriptFile.Modifiers">
            <summary>
            Any modification loci and length that have previously been applied to the file.
            This is to ensure, that anything modified does not affect other transformations that were generated before said modification.
            </summary>
        </member>
        <member name="F:Refactor.ScriptFile.Content">
            <summary>
            Actual string content of the file after modifications
            </summary>
        </member>
        <member name="P:Refactor.ScriptFile.Saved">
            <summary>
            Whether the current modifications have been written back to file
            </summary>
        </member>
        <member name="P:Refactor.ScriptFile.FromFile">
            <summary>
            Whether the scriptfile was originally generated from an actual file
            </summary>
        </member>
        <member name="M:Refactor.ScriptFile.#ctor(System.String)">
            <summary>
            Generate a new scriptfile object off the path to a scriptfile
            </summary>
            <param name="Path">Path to the file being wrapped</param>
        </member>
        <member name="M:Refactor.ScriptFile.#ctor(System.String,System.String)">
            <summary>
            Generate a new scriptfile object off the content of a scriptcode without any backing file
            </summary>
            <param name="Name">The name of the content</param>
            <param name="Content">The actual script code / content of the script</param>
        </member>
        <member name="M:Refactor.ScriptFile.Reload">
            <summary>
            Applies the current state of the wrapped file to this in-memory object
            </summary>
        </member>
        <member name="M:Refactor.ScriptFile.Save(System.Boolean)">
            <summary>
            Writes back the current Content back to file, saving all modifications applied so far.
            </summary>
            <param name="Backup">Whether to create a backup of the previous state. This will create a copy of that file in the same folder with ".backup" appended to the name.</param>
        </member>
        <member name="M:Refactor.ScriptFile.WriteTo(System.String,System.String)">
            <summary>
            Writes the stored script content to the specified path.
            </summary>
            <param name="Path">The folder to write ti. Must exist.</param>
            <param name="Name">Name of the file to write. Defaults to the original filename if not specified.</param>
            <exception cref="T:System.ArgumentNullException">Not specifying a path is a pretty bad idea</exception>
            <exception cref="T:System.ArgumentException">If for some reason no filename can be determined, this error will happen. This would happen when generating a ScriptFile object with a combination of Name &amp; Content with the Name being an empty string.</exception>
            <exception cref="T:System.IO.InvalidDataException">If the resulting path is not a legal path or the parent folder does not exist, that would be an issue.</exception>
        </member>
        <member name="M:Refactor.ScriptFile.GetEffectiveIndex(System.Int32)">
            <summary>
            Returnes the starting index (or offset) in a file for a given original index, after taking modifications into consideration.
            </summary>
            <param name="Index">Index number as originally parsed out of the file</param>
            <returns>The effective index number / offset to use instead for the current state.</returns>
        </member>
        <member name="M:Refactor.ScriptFile.GetTokens(System.String[])">
            <summary>
            Returns a list of all tokens, generated from all token providers that have been registered
            </summary>
            <param name="Provider">A list of provider-names to filter by</param>
            <returns>The processed tokens</returns>
        </member>
        <member name="M:Refactor.ScriptFile.Transform(Refactor.ScriptToken[])">
            <summary>
            Apply all transforms to the tokens specified
            </summary>
            <param name="Tokens">The tokens to transform</param>
            <returns>A result object, reporting the state of each individual transformation</returns>
        </member>
        <member name="M:Refactor.ScriptFile.GetAst(System.String)">
            <summary>
            Get the Ast representing the code in the file specified.
            Ignores all syntax errors
            </summary>
            <param name="Path">Path to the file to parse</param>
            <returns>The Ast object representing the file specified</returns>
        </member>
        <member name="M:Refactor.ScriptFile.GetAstFromText(System.String)">
            <summary>
            Get the Ast representing the code in the text specified.
            Ignores all syntax errors
            </summary>
            <param name="Content">The text content to parse</param>
            <returns>The Ast object representing the text specified</returns>
        </member>
        <member name="M:Refactor.ScriptFile.GetStringContent(System.String,System.Int32,System.Int32)">
            <summary>
            Safely returns the substring of the input string without exception.
            Bad indexes will result in either an empty string or a string of unexpected length.
            </summary>
            <param name="Content">The source string to process</param>
            <param name="Start">The start index from where to read</param>
            <param name="Length">How many characters to read</param>
            <returns>The selected substring</returns>
        </member>
        <member name="M:Refactor.ScriptFile.IsValidPath(System.String)">
            <summary>
            Checks, whether a path is fundamentally valid.
            It does not check for existence or whether the path is rooted or relative.
            </summary>
            <param name="Path">The path to validate</param>
            <returns>Whether the path is valid</returns>
        </member>
        <member name="T:Refactor.ScriptToken">
            <summary>
            The base class for token objects.
            Extend from this if you want to define your own custom token type
            </summary>
        </member>
        <member name="F:Refactor.ScriptToken.Name">
            <summary>
            Name of the token.
            Used for identifying transforms and matched against their index.
            </summary>
        </member>
        <member name="F:Refactor.ScriptToken.Ast">
            <summary>
            AST object representing the code content of the Token.
            Is optional
            </summary>
        </member>
        <member name="P:Refactor.ScriptToken.Type">
            <summary>
            The kind of token this is.
            Must match the name of the token provider to use.
            </summary>
        </member>
        <member name="P:Refactor.ScriptToken.Line">
            <summary>
            The first line of the token.
            Cosmetic property for user convenience.
            </summary>
        </member>
        <member name="F:Refactor.ScriptToken.AllowPartial">
            <summary>
            Whether the changes wrought by the token can be applied if only some of them remain valid
            </summary>
        </member>
        <member name="F:Refactor.ScriptToken.Messages">
            <summary>
            List of messages that happened while either transforming or generating the token
            </summary>
        </member>
        <member name="M:Refactor.ScriptToken.WriteMessage(Refactor.MessageType,System.String,System.Object)">
            <summary>
            Writes a message to the token
            </summary>
            <param name="Type">What kind of message?</param>
            <param name="Message">The message to write</param>
            <param name="Data">Any additional data to append</param>
        </member>
        <member name="M:Refactor.ScriptToken.Transform">
            <summary>
            Convert the token-related text by applying transformation rule as implemented by the provider
            </summary>
            <returns>The new text that should replace the original text represented by this token.</returns>
        </member>
        <member name="M:Refactor.ScriptToken.GetChanges">
            <summary>
            Returns changes the token would apply.
            Run after calling transform
            </summary>
            <returns>The changes applied by this token after its transformation</returns>
        </member>
        <member name="M:Refactor.ScriptToken.ToString">
            <summary>
            The default string representation of a token
            </summary>
            <returns>The default string representation of a token</returns>
        </member>
        <member name="T:Refactor.SearchResult">
            <summary>
            Result of an Ast search
            </summary>
        </member>
        <member name="P:Refactor.SearchResult.Start">
            <summary>
            Starting line in the file
            </summary>
        </member>
        <member name="P:Refactor.SearchResult.End">
            <summary>
            Ending line in the file
            </summary>
        </member>
        <member name="P:Refactor.SearchResult.FileName">
            <summary>
            name of the file from which the searchresult came
            </summary>
        </member>
        <member name="P:Refactor.SearchResult.File">
            <summary>
            Path to the file searched
            </summary>
        </member>
        <member name="P:Refactor.SearchResult.Data">
            <summary>
            The actual Ast object
            </summary>
        </member>
        <member name="P:Refactor.SearchResult.Type">
            <summary>
            What kind of object it is
            </summary>
        </member>
        <member name="M:Refactor.SearchResult.#ctor(System.Management.Automation.Language.Ast)">
            <summary>
            Create a new search result
            </summary>
            <param name="Ast">The Ast object found</param>
        </member>
        <member name="T:Refactor.Splat">
            <summary>
            A splat object, including the resolved parameters it will potentially bind
            </summary>
        </member>
        <member name="F:Refactor.Splat.Ast">
            <summary>
            Ast of the splat binding.
            NOT of where the hashtable is first declared, but where it is ultimately used.
            </summary>
        </member>
        <member name="F:Refactor.Splat.Parameters">
            <summary>
            Parameters bound through the splat
            </summary>
        </member>
        <member name="F:Refactor.Splat.ParametersKnown">
            <summary>
            Whether we can authoratively claim to know which parameters may be bound through this splat.
            </summary>
        </member>
        <member name="F:Refactor.Splat.Assignments">
            <summary>
            Additional instances where the hashtable is modified before being used for splatting.
            Allows transforms of Command to rename hashtable properties on parameter renames
            </summary>
        </member>
        <member name="T:Refactor.TokenProvider">
            <summary>
            All the information needed to process a specific tokentype
            </summary>
        </member>
        <member name="F:Refactor.TokenProvider.Name">
            <summary>
            Name of the provider
            </summary>
        </member>
        <member name="F:Refactor.TokenProvider.TransformIndex">
            <summary>
            The property to use for indexing transforms
            </summary>
        </member>
        <member name="F:Refactor.TokenProvider.TransformParametersMandatory">
            <summary>
            The parameters that must be specified when registering transforms
            </summary>
        </member>
        <member name="F:Refactor.TokenProvider.TransformParameters">
            <summary>
            The parameters that may be specified when registering transforms.
            Use to build out dynamic parameters for the specific register call
            </summary>
        </member>
        <member name="F:Refactor.TokenProvider.Tokenizer">
            <summary>
            Code that parses an Ast provided and generates tokens from it
            </summary>
        </member>
        <member name="F:Refactor.TokenProvider.Converter">
            <summary>
            Code that takes a token and applies relevant transforms to it
            </summary>
        </member>
        <member name="T:Refactor.TransformationResult">
            <summary>
            Result of all changes applied to a single file
            </summary>
        </member>
        <member name="F:Refactor.TransformationResult.Path">
            <summary>
            path to the file being transformed
            </summary>
        </member>
        <member name="P:Refactor.TransformationResult.FileName">
            <summary>
            Name of the file being transformed
            </summary>
        </member>
        <member name="P:Refactor.TransformationResult.Success">
            <summary>
            Whether the transformation was 100 successful
            </summary>
        </member>
        <member name="P:Refactor.TransformationResult.Count">
            <summary>
            Count of transformations executed
            </summary>
        </member>
        <member name="P:Refactor.TransformationResult.SuccessCount">
            <summary>
            Count of successful transformations executed
            </summary>
        </member>
        <member name="P:Refactor.TransformationResult.InfoCount">
            <summary>
            Number of information messages written during the transformation
            </summary>
        </member>
        <member name="P:Refactor.TransformationResult.WarningCount">
            <summary>
            Number of warning messages written during the transformation
            </summary>
        </member>
        <member name="P:Refactor.TransformationResult.ErrorCount">
            <summary>
            Number of error messages written during the transformation
            </summary>
        </member>
        <member name="F:Refactor.TransformationResult.Results">
            <summary>
            All individual transformation results that have been applied - successful or otherwise
            </summary>
        </member>
        <member name="M:Refactor.TransformationResult.#ctor(System.String)">
            <summary>
            Create a new transformation result report
            </summary>
            <param name="Path">Path to the script file being transformed</param>
        </member>
        <member name="F:Refactor.TransformationResult.Messages">
            <summary>
            The messages that happened during this transformation
            </summary>
        </member>
        <member name="M:Refactor.TransformationResult.DrainMessages(Refactor.ScriptToken)">
            <summary>
            Copy over all messages from the token object and restore the original messages
            </summary>
            <param name="Token">The token to drain the messages from</param>
        </member>
        <member name="M:Refactor.TransformationResult.PrepMessages(Refactor.ScriptToken)">
            <summary>
            Cache the current messages and create a new list just for this transformation
            </summary>
            <param name="Token">The Token for which to prep the messages</param>
        </member>
        <member name="T:Refactor.TransformationResultEntry">
            <summary>
            Result of a single token transformation
            </summary>
        </member>
        <member name="F:Refactor.TransformationResultEntry.Success">
            <summary>
            Whether the transformation was successful
            </summary>
        </member>
        <member name="F:Refactor.TransformationResultEntry.Change">
            <summary>
            The change implemented
            </summary>
        </member>
        <member name="F:Refactor.TransformationResultEntry.Token">
            <summary>
            The Token the transformation was applied to
            </summary>
        </member>
        <member name="F:Refactor.TransformationResultEntry.Message">
            <summary>
            Any message included in the transformation
            </summary>
        </member>
        <member name="F:Refactor.TransformationResultEntry.Error">
            <summary>
            Any errors that happened during execution
            </summary>
        </member>
        <member name="F:Refactor.TransformationResultEntry.Path">
            <summary>
            Path to the file being transformed
            </summary>
        </member>
        <member name="M:Refactor.TransformationResultEntry.#ctor">
            <summary>
            Create a new, empty transformation result entry
            </summary>
        </member>
        <member name="M:Refactor.TransformationResultEntry.#ctor(System.String,System.Boolean,Refactor.Change,Refactor.ScriptToken,System.String,System.Exception)">
            <summary>
            Create a new, filled out transformation result entry
            </summary>
            <param name="Path">Path to the file being transformed</param>
            <param name="Success">Whether the transformation was successful</param>
            <param name="Change">The actual change that was performed</param>
            <param name="Token">The Token the transformation was applied to</param>
            <param name="Message">Any message included in the transformation</param>
            <param name="Error">Any errors that happened during execution</param>
        </member>
    </members>
</doc>