Struct Selector

pub struct Selector {
    pub operation: Operation,
    pub anchor: String,
    pub end: Option<String>,
}

Fields

operation: Operation

The type of edit operation to perform.

Insert Operations

• insert_before - Insert content immediately before the anchor text
• insert_after - Insert content immediately after the anchor text
• insert_after_node - Insert content after the complete AST node containing the anchor

Replace Operations

• replace_exact - Replace only the exact anchor text
• replace_node - Replace the entire AST node containing the anchor
• replace_range - Replace everything from anchor to end (requires end field)

Choosing the Right Operation

For adding new code:

• Use insert_before or insert_after for precise placement
• Use insert_after_node when you want to add after a complete statement/declaration

For changing existing code:

• Use replace_exact for small, precise text changes
• Use replace_node for changing entire functions, classes, blocks, or statements
• Use replace_range for changing multi-line sections with clear start/end boundaries

anchor: String

Text to locate in the source code as the target for the operation.

Should be a short, distinctive piece of text that uniquely identifies the location. For range operations, this marks the start of the range. For node operations, this should cover the start of the ast node.

Tips for Good Anchors

• Keep anchors short but unique - “fn main” instead of the entire function signature
• Use distinctive text - function names, keywords, or unique comments work well
• Avoid whitespace-only anchors - they’re often not unique enough
• Test your anchor - if it appears multiple times, the tool will find the best placement

Examples

• "fn main() {" - Targets a function definition
• "struct User {" - Targets a struct definition
• "// TODO: implement" - Targets a specific comment
• "import React" - Targets an import statement

end: Option<String>

End boundary for replace range operations only.

When specified, defines the end of the text range to be replaced. Use this to avoid repeating long blocks of content just to replace them.

Example

{
  "operation": "replace_range",
  "anchor": "// Start replacing here",
  "end": "// Stop replacing here"
}

Implementations

impl Selector

pub fn operation_name(&self) -> &str

pub fn validate(&self) -> Result<(), String>

Validate that the selector is properly formed

Trait Implementations

impl Clone for Selector

fn clone(&self) -> Selector

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Selector

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Selector

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Selector

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for Selector

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.