Rename new_for_release back to new

Author: andyleejordan

dsc-bicep-ext/src/main.rs

@@ -64,7 +64,7 @@ impl BicepExtension for BicepExtensionService {
 
         let mut dsc = DscManager::new();
         let Some(resource) = dsc
-            .find_resource(&DiscoveryFilter::new_for_resource(
+            .find_resource(&DiscoveryFilter::new(
                 &type_name,
                 version_req,
                 None,
@@ -126,7 +126,7 @@ impl BicepExtension for BicepExtensionService {
 
         let mut dsc = DscManager::new();
         let Some(resource) = dsc
-            .find_resource(&DiscoveryFilter::new_for_resource(
+            .find_resource(&DiscoveryFilter::new(
                 &type_name,
                 version_req,
                 None,
@@ -188,7 +188,7 @@ impl BicepExtension for BicepExtensionService {
 
         let mut dsc = DscManager::new();
         let Some(resource) = dsc
-            .find_resource(&DiscoveryFilter::new_for_resource(
+            .find_resource(&DiscoveryFilter::new(
                 &type_name,
                 version_req,
                 None,
@@ -250,7 +250,7 @@ impl BicepExtension for BicepExtensionService {
 
         let mut dsc = DscManager::new();
         let Some(resource) = dsc
-            .find_resource(&DiscoveryFilter::new_for_resource(
+            .find_resource(&DiscoveryFilter::new(
                 &type_name,
                 version_req,
                 None,

dsc/src/mcp/invoke_dsc_resource.rs

@@ -71,7 +71,7 @@ impl McpServer {
     pub async fn invoke_dsc_resource(&self, Parameters(InvokeDscResourceRequest { operation, resource_type, properties_json }): Parameters<InvokeDscResourceRequest>) -> Result<Json<InvokeDscResourceResponse>, McpError> {
         let result = task::spawn_blocking(move || {
             let mut dsc = DscManager::new();
-            let Some(resource) = dsc.find_resource(&DiscoveryFilter::new_for_resource(&resource_type, None, None)).unwrap_or(None) else {
+            let Some(resource) = dsc.find_resource(&DiscoveryFilter::new(&resource_type, None, None)).unwrap_or(None) else {
                 return Err(McpError::invalid_request(t!("mcp.invoke_dsc_resource.resourceNotFound", resource = resource_type), None));
             };
             match operation {

dsc/src/mcp/list_dsc_resources.rs

@@ -52,7 +52,7 @@ impl McpServer {
             let mut dsc = DscManager::new();
             let adapter_filter = match adapter {
                 Some(adapter) => {
-                    if let Some(resource) = dsc.find_resource(&DiscoveryFilter::new_for_resource(&adapter, None, None)).unwrap_or(None) {
+                    if let Some(resource) = dsc.find_resource(&DiscoveryFilter::new(&adapter, None, None)).unwrap_or(None) {
                         if resource.kind != Kind::Adapter {
                             return Err(McpError::invalid_params(t!("mcp.list_dsc_resources.resourceNotAdapter", adapter = adapter), None));
                         }

dsc/src/mcp/show_dsc_resource.rs

@@ -59,7 +59,7 @@ impl McpServer {
     pub async fn show_dsc_resource(&self, Parameters(ShowResourceRequest { r#type }): Parameters<ShowResourceRequest>) -> Result<Json<DscResource>, McpError> {
         let result = task::spawn_blocking(move || {
             let mut dsc = DscManager::new();
-            let Some(resource) = dsc.find_resource(&DiscoveryFilter::new_for_resource(&r#type, None, None)).unwrap_or(None) else {
+            let Some(resource) = dsc.find_resource(&DiscoveryFilter::new(&r#type, None, None)).unwrap_or(None) else {
                 return Err(McpError::invalid_params(t!("mcp.show_dsc_resource.resourceNotFound", type_name = r#type), None))
             };
             let schema = match resource.schema() {

dsc/src/resource_command.rs

@@ -358,5 +358,5 @@ pub fn export(dsc: &mut DscManager, resource_type: &FullyQualifiedTypeName, vers
 #[must_use]
 pub fn get_resource<'a>(dsc: &'a mut DscManager, resource: &FullyQualifiedTypeName, version: Option<&ResourceVersionReq>) -> Option<&'a DscResource> {
     //TODO: add dynamically generated resource to dsc
-    dsc.find_resource(&DiscoveryFilter::new_for_resource(resource, version.cloned(), None)).unwrap_or(None)
+    dsc.find_resource(&DiscoveryFilter::new(resource, version.cloned(), None)).unwrap_or(None)
 }

dsc/src/subcommand.rs

@@ -501,7 +501,7 @@ pub fn validate_config(config: &Configuration, progress_format: ProgressFormat)
             .as_str()
             .map(|r| ResourceVersionReq::parse(r))
             .transpose()?;
-        resource_types.push(DiscoveryFilter::new_for_resource(type_name, require_version, None));
+        resource_types.push(DiscoveryFilter::new(type_name, require_version, None));
     }
     dsc.find_resources(&resource_types, progress_format)?;
 
@@ -559,22 +559,22 @@ pub fn resource(subcommand: &ResourceSubCommand, progress_format: ProgressFormat
             list_resources(&mut dsc, resource_name, adapter_name.as_ref(), description.as_ref(), tags.as_ref(), output_format.as_ref(), progress_format);
         },
         ResourceSubCommand::Schema { resource , version, output_format } => {
-            if let Err(err) = dsc.find_resources(&[DiscoveryFilter::new_for_resource(resource, version.clone(), None)], progress_format) {
+            if let Err(err) = dsc.find_resources(&[DiscoveryFilter::new(resource, version.clone(), None)], progress_format) {
                 error!("{}: {err}", t!("subcommand.failedDiscoverResource"));
                 exit(EXIT_DSC_ERROR);
             }
             resource_command::schema(&mut dsc, resource, version.as_ref(), output_format.as_ref());
         },
         ResourceSubCommand::Export { resource, version, input, file, output_format } => {
-            if let Err(err) = dsc.find_resources(&[DiscoveryFilter::new_for_resource(resource, version.clone(), None)], progress_format) {
+            if let Err(err) = dsc.find_resources(&[DiscoveryFilter::new(resource, version.clone(), None)], progress_format) {
                 error!("{}: {err}", t!("subcommand.failedDiscoverResource"));
                 exit(EXIT_DSC_ERROR);
             }
             let parsed_input = get_input(input.as_ref(), file.as_ref());
             resource_command::export(&mut dsc, resource, version.as_ref(), &parsed_input, output_format.as_ref());
         },
         ResourceSubCommand::Get { resource, version, input, file: path, all, output_format } => {
-            if let Err(err) = dsc.find_resources(&[DiscoveryFilter::new_for_resource(resource, version.clone(), None)], progress_format) {
+            if let Err(err) = dsc.find_resources(&[DiscoveryFilter::new(resource, version.clone(), None)], progress_format) {
                 error!("{}: {err}", t!("subcommand.failedDiscoverResource"));
                 exit(EXIT_DSC_ERROR);
             }
@@ -591,23 +591,23 @@ pub fn resource(subcommand: &ResourceSubCommand, progress_format: ProgressFormat
             }
         },
         ResourceSubCommand::Set { resource, version, input, file: path, output_format, what_if } => {
-            if let Err(err) = dsc.find_resources(&[DiscoveryFilter::new_for_resource(resource, version.clone(), None)], progress_format) {
+            if let Err(err) = dsc.find_resources(&[DiscoveryFilter::new(resource, version.clone(), None)], progress_format) {
                 error!("{}: {err}", t!("subcommand.failedDiscoverResource"));
                 exit(EXIT_DSC_ERROR);
             }
             let parsed_input = get_input(input.as_ref(), path.as_ref());
             resource_command::set(&mut dsc, resource, version.as_ref(), &parsed_input, output_format.as_ref(), *what_if);
         },
         ResourceSubCommand::Test { resource, version, input, file: path, output_format } => {
-            if let Err(err) = dsc.find_resources(&[DiscoveryFilter::new_for_resource(resource, version.clone(), None)], progress_format) {
+            if let Err(err) = dsc.find_resources(&[DiscoveryFilter::new(resource, version.clone(), None)], progress_format) {
                 error!("{}: {err}", t!("subcommand.failedDiscoverResource"));
                 exit(EXIT_DSC_ERROR);
             }
             let parsed_input = get_input(input.as_ref(), path.as_ref());
             resource_command::test(&mut dsc, resource, version.as_ref(), &parsed_input, output_format.as_ref());
         },
         ResourceSubCommand::Delete { resource, version, input, file: path, output_format, what_if } => {
-            if let Err(err) = dsc.find_resources(&[DiscoveryFilter::new_for_resource(resource, version.clone(), None)], progress_format) {
+            if let Err(err) = dsc.find_resources(&[DiscoveryFilter::new(resource, version.clone(), None)], progress_format) {
                 error!("{}: {err}", t!("subcommand.failedDiscoverResource"));
                 exit(EXIT_DSC_ERROR);
             }

lib/dsc-lib/src/configure/mod.rs

@@ -46,7 +46,7 @@ pub struct Configurator {
 
 /// Invokes the [`Discovery::find_resource`] method to retrieve a specific resource or raise a
 /// [`DscError::ResourceNotFound`] if the resource cannot be found.
-/// 
+///
 /// # Arguments
 ///
 /// * `variable` - The variable to bind the found resource to.
@@ -55,19 +55,19 @@ pub struct Configurator {
 /// * `adapter` - An optional adapter requirement to include in the discovery filter.
 ///
 /// # Examples
-/// 
+///
 /// The following snippet shows how the `find_resource_or_error!` macro can be used within a method
 /// of the `Configurator` struct to find a resource and return an error if it's not found:
-/// 
+///
 /// ```ignore
 /// find_resource_or_error!(dsc_resource, discovery, resource, adapter);
 /// ```
-/// 
+///
 /// Which expands to:
-/// 
+///
 /// ```ignore
 /// let Some(dsc_resource) = discovery.find_resource(
-///     &DiscoveryFilter::new_for_resource(
+///     &DiscoveryFilter::new(
 ///         &resource.resource_type,
 ///         resource.require_version.clone(),
 ///         adapter
@@ -82,7 +82,7 @@ pub struct Configurator {
 macro_rules! find_resource_or_error {
     ($variable:ident, $discovery: ident, $resource:ident, $adapter:ident) => {
         let Some($variable) = $discovery.find_resource(
-            &DiscoveryFilter::new_for_resource(
+            &DiscoveryFilter::new(
                 &$resource.resource_type,
                 $resource.require_version.clone(),
                 $adapter
@@ -1233,7 +1233,7 @@ impl Configurator {
             let config_copy = config.clone();
             for resource in config_copy.resources {
                 let adapter = get_require_adapter_from_directive(&resource.directives);
-                let filter = DiscoveryFilter::new_for_resource(
+                let filter = DiscoveryFilter::new(
                     &resource.resource_type,
                     resource.require_version.clone(),
                     adapter
@@ -1257,7 +1257,7 @@ impl Configurator {
             // now check that each resource in the config was found
             for resource in config.resources.iter() {
                 let adapter = get_require_adapter_from_directive(&resource.directives);
-                let Some(_dsc_resource) = self.discovery.find_resource(&DiscoveryFilter::new_for_resource(&resource.resource_type, resource.require_version.clone(), adapter))? else {
+                let Some(_dsc_resource) = self.discovery.find_resource(&DiscoveryFilter::new(&resource.resource_type, resource.require_version.clone(), adapter))? else {
                     return Err(DscError::ResourceNotFound(
                         resource.resource_type.to_string(),
                         resource.require_version.as_ref().map(|r| r.to_string()).unwrap_or("".to_string())

lib/dsc-lib/src/discovery/discovery_trait.rs

@@ -24,20 +24,20 @@ pub struct DiscoveryFilter {
 impl DiscoveryFilter {
     /// Construct a [`DiscoveryFilter`] for a resource with the specified type name, optional
     /// version requirement, and optional adapter requirement.
-    /// 
+    ///
     /// # Arguments
-    /// 
+    ///
     /// - `type_name` - The [`FullyQualifiedTypeName`] of the resource.
     /// - `require_version` - An optional [`ResourceVersionReq`] specifying the version requirement
     ///   for the resource. The version requirement can be semantic or date-based, depending on the
     ///   resource's versioning scheme.
     /// - `require_adapter` - An optional [`FullyQualifiedTypeName`] specifying the adapter that
     ///   the resource is expected to require.
-    /// 
+    ///
     /// # Returns
-    /// 
+    ///
     /// A new instance of [`DiscoveryFilter`] initialized with the provided parameters.
-    pub fn new_for_resource(
+    pub fn new(
         type_name: &FullyQualifiedTypeName,
         require_version: Option<ResourceVersionReq>,
         require_adapter: Option<FullyQualifiedTypeName>
@@ -51,17 +51,17 @@ impl DiscoveryFilter {
 
     /// Construct a [`DiscoveryFilter`] for an extension with the specified type name and optional
     /// version requirement.
-    /// 
+    ///
     /// # Arguments
-    /// 
+    ///
     /// - `type_name` - The [`FullyQualifiedTypeName`] of the extension.
     /// - `require_version` - An optional [`SemanticVersionReq`] specifying the semantic version
     ///    requirement for the extension.
-    /// 
+    ///
     /// # Returns
     ///
     /// A new instance of [`DiscoveryFilter`] initialized with the provided parameters.
-    /// 
+    ///
     /// Note that extensions do not have an adapter requirement, so the `require_adapter` field is
     /// always set to `None`.
     pub fn new_for_extension(

lib/dsc-lib/src/dscresources/dscresource.rs

@@ -291,7 +291,7 @@ impl DscResource {
     }
 
     fn get_adapter_resource(configurator: &mut Configurator, adapter: &FullyQualifiedTypeName) -> Result<DscResource, DscError> {
-        if let Some(adapter_resource) = configurator.discovery().find_resource(&DiscoveryFilter::new_for_resource(adapter, None, None))? {
+        if let Some(adapter_resource) = configurator.discovery().find_resource(&DiscoveryFilter::new(adapter, None, None))? {
             return Ok(adapter_resource.clone());
         }
         Err(DscError::Operation(t!("dscresources.dscresource.adapterResourceNotFound", adapter = adapter).to_string()))