w

Author: orium

src/lib.rs

@@ -48,7 +48,7 @@ pub fn find_first_file_in_ancestors(dir_path: impl AsRef<Path>, filename: &str)
 
 #[derive(Debug)]
 pub enum PackageTarget {
-    Bin { name: String },
+    Bin { crate_name: String },
     Lib,
 }
 
@@ -139,9 +139,9 @@ impl Project {
     }
 
     #[must_use]
-    pub fn get_bin_default_name(&self) -> Option<&str> {
+    pub fn get_bin_default_crate_name(&self) -> Option<&str> {
         match self.bin_path.len() {
-            1 => self.bin_path.keys().next().map(|name| name.as_str()),
+            1 => self.bin_path.keys().next().map(String::as_str),
             _ => None,
         }
     }

src/main.rs

@@ -370,18 +370,19 @@ fn entrypoint<'a>(project: &'a Project, entrypoint_opt: &EntrypointOpt) -> Optio
 }
 
 fn package_target(project: &Project, entrypoint_opt: &EntrypointOpt) -> Option<PackageTarget> {
-    // WIP! it should probably be the package name, not the crate name in bin?
-
-    let bin_default =
-        || project.get_bin_default_name().map(|name| PackageTarget::Bin { name: name.to_owned() });
+    let bin_default = || {
+        project
+            .get_bin_default_crate_name()
+            .map(|name| PackageTarget::Bin { crate_name: name.to_owned() })
+    };
 
     match entrypoint_opt {
         EntrypointOpt::Auto => {
             project.get_lib_entryfile_path().map(|_| PackageTarget::Lib).or_else(bin_default)
         }
         EntrypointOpt::Lib => Some(PackageTarget::Lib),
         EntrypointOpt::BinDefault => bin_default(),
-        EntrypointOpt::BinName(name) => Some(PackageTarget::Bin { name: name.clone() }),
+        EntrypointOpt::BinName(name) => Some(PackageTarget::Bin { crate_name: name.clone() }),
     }
 }
 

src/transform/intralinks/links.rs

@@ -240,8 +240,7 @@ pub fn markdown_link_iterator(markdown: &Markdown) -> MarkdownItemIterator<Markd
 
                 Some((range.into(), link))
             }
-            Some(_) => None,
-            None => None,
+            Some(_) | None => None,
         },
         _ => {
             if in_link.is_some() {
@@ -266,9 +265,7 @@ fn parse_raw_reference_link_definition(
     // We need to parse things manually here, because the pulldown-cmark parser escapes the title
     // and the link.  We need the raw version to emit them later.
 
-    let Some(link_and_title) = raw_ref_def.get(label.len() + 3..).map(str::trim) else {
-        return None;
-    };
+    let link_and_title = raw_ref_def.get(label.len() + 3..).map(str::trim)?;
 
     assert_eq!(
         raw_ref_def.get(label.len() + 1..label.len() + 3),

src/transform/intralinks/mod.rs

@@ -53,7 +53,7 @@ pub struct IntralinksConfig {
 }
 
 pub struct DocTransformIntralinks<F> {
-    crate_name: String,
+    package_name: String,
     package_target: PackageTarget,
     workspace_package: Option<String>,
     manifest_path: PathBuf,
@@ -66,15 +66,15 @@ where
     F: Fn(&str),
 {
     pub fn new(
-        crate_name: impl Into<String>,
+        package_name: impl Into<String>,
         package_target: PackageTarget,
         workspace_package: Option<String>,
         manifest_path: PathBuf,
         emit_warning: F,
         config: Option<IntralinksConfig>,
     ) -> DocTransformIntralinks<F> {
         DocTransformIntralinks {
-            crate_name: crate_name.into(),
+            package_name: package_name.into(),
             package_target,
             workspace_package,
             manifest_path,
@@ -91,7 +91,7 @@ struct ItemPath<'a> {
 
 impl<'a> ItemPath<'a> {
     fn new(segments: &'a [String]) -> ItemPath<'a> {
-        assert!(segments.len() > 0, "path item must not be empty");
+        assert!(!segments.is_empty(), "path item must not be empty");
 
         ItemPath { segments: Cow::Borrowed(segments) }
     }
@@ -116,7 +116,7 @@ impl<'a> ItemPath<'a> {
 impl Display for ItemPath<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         // TODO Use standard library intersperse() one it stabilizes (https://github.com/rust-lang/rust/issues/79524).
-        let iter = Itertools::intersperse(self.segments.iter().map(|s| s.as_str()), "::");
+        let iter = Itertools::intersperse(self.segments.iter().map(String::as_str), "::");
 
         for s in iter {
             f.write_str(s)?;
@@ -160,13 +160,13 @@ where
             true => {
                 // WIP! ideally we wouldn't create an intralink resolver if we dont need it
                 // see other WIP to split the strip links into another place.
-                IntralinkResolver::new(self.crate_name.as_str(), &self.config.docs_rs)
+                IntralinkResolver::new(self.package_name.as_str(), &self.config.docs_rs)
             }
             // We only load symbols type information when we need them.
             false => {
                 // WIP! ideally we would want to return
                 create_intralink_resolver(
-                    self.crate_name.as_str(),
+                    self.package_name.as_str(),
                     &self.package_target,
                     self.workspace_package.as_deref(),
                     &self.manifest_path,
@@ -216,9 +216,9 @@ fn markdown_link(
     intralink_resolver: &IntralinkResolver,
     emit_warning: &impl Fn(&str),
 ) -> MarkdownLinkAction {
-    assert!(IntralinkResolver::is_intralink(&link));
+    assert!(IntralinkResolver::is_intralink(link));
 
-    match intralink_resolver.resolve_link(&link) {
+    match intralink_resolver.resolve_link(link) {
         None => {
             emit_warning(&format!("Could not resolve definition of `{}`.", link.symbol()));
 

src/transform/intralinks/rustdoc.rs

@@ -72,7 +72,7 @@ impl<'a> ItemInfo<'a> {
             return None;
         }
 
-        if self.parent_kind.zip(other.parent_kind).map(|(s, o)| s != o).unwrap_or(false) {
+        if self.parent_kind.zip(other.parent_kind).is_some_and(|(s, o)| s != o) {
             return None;
         }
 
@@ -251,7 +251,7 @@ fn get_item_info<'a>(
     rustdoc_crate: &'a Crate,
 ) -> Option<ItemInfo<'a>> {
     match rustdoc_crate.paths.get(item_id) {
-        Some(item_summary) => Some(ItemInfo::from(&item_summary, parent_kind, item_context)),
+        Some(item_summary) => Some(ItemInfo::from(item_summary, parent_kind, item_context)),
         None => rustdoc_crate.index.get(item_id).map(|item| {
             let path = match item.name.as_ref() {
                 None => parent_path.clone(),
@@ -324,12 +324,12 @@ fn transitive_items<'a>(
 pub struct IntralinkResolver<'a> {
     link_url: HashMap<Link, String>,
     config: &'a IntralinksDocsRsConfig,
-    crate_name: &'a str,
+    package_name: &'a str,
 }
 
 impl<'a> IntralinkResolver<'a> {
-    pub fn new(crate_name: &'a str, config: &'a IntralinksDocsRsConfig) -> IntralinkResolver<'a> {
-        IntralinkResolver { link_url: HashMap::new(), crate_name, config }
+    pub fn new(package_name: &'a str, config: &'a IntralinksDocsRsConfig) -> IntralinkResolver<'a> {
+        IntralinkResolver { link_url: HashMap::new(), package_name, config }
     }
 
     fn url_segment(kind: ItemKind, name: &str) -> String {
@@ -390,16 +390,15 @@ impl<'a> IntralinkResolver<'a> {
         // WIP! improve this mess!
         // 0 means local crate.
         if item_info.crate_id == 0 {
-            let base_url =
-                self.config.docs_rs_base_url.as_ref().map_or("https://docs.rs", String::as_str);
-            let version = self.config.docs_rs_version.as_ref().map_or("latest", String::as_str);
-            // WIP!simple do we need this?  can we extract it from somewhere?
-            let crate_name = &self.crate_name;
+            let base_url = self.config.docs_rs_base_url.as_deref().unwrap_or("https://docs.rs");
+            let version = self.config.docs_rs_version.as_deref().unwrap_or("latest");
+            let package_name = &self.package_name;
 
-            let url = format!("{base_url}/{crate_name}/{version}/{url_path}");
+            let url = format!("{base_url}/{package_name}/{version}/{url_path}");
 
             self.link_url.insert(link, url);
         } else {
+            // WIP!simple how about links to crates that are not the standard library?
             if let Some(rustdoc_types::ExternalCrate {
                 // WIP!simple how about package name vs crate name
                 html_root_url: Some(ref base_url),
@@ -409,9 +408,9 @@ impl<'a> IntralinkResolver<'a> {
                 // TODO Once we are able to use the stable version we can remove this
                 //      (https://github.com/rust-lang/rust/issues/76578).
                 let base_url = base_url
+                    // WIP!simple we should probably only do this if we are actually talking about a standard lib item.
                     .strip_suffix("/nightly/")
-                    .map(|p| format!("{}/stable/", p))
-                    .unwrap_or_else(|| base_url.to_owned());
+                    .map_or_else(|| base_url.to_owned(), |p| format!("{p}/stable/"));
 
                 let url = format!("{base_url}{url_path}");
 
@@ -424,7 +423,7 @@ impl<'a> IntralinkResolver<'a> {
         self.link_url.get(link).map(String::as_str)
     }
 
-    // WIP! does this belong here?
+    // WIP!simple does this belong here?
     pub fn is_intralink(link: &Link) -> bool {
         let has_lone_colon = || link.raw_link.replace("::", "").contains(':');
 
@@ -441,7 +440,9 @@ fn run_rustdoc(
 
     let rustdoc_json_path: PathBuf = {
         let target: rustdoc_json::PackageTarget = match package_target {
-            PackageTarget::Bin { name } => rustdoc_json::PackageTarget::Bin(name.clone()),
+            PackageTarget::Bin { crate_name } => {
+                rustdoc_json::PackageTarget::Bin(crate_name.clone())
+            }
             PackageTarget::Lib => rustdoc_json::PackageTarget::Lib,
         };
         let mut stderr = Vec::new();
@@ -451,7 +452,7 @@ fn run_rustdoc(
             .toolchain("nightly")
             .manifest_path(manifest_path)
             .document_private_items(true)
-            // WIP! We need to parameterize the features based on the configuration
+            // WIP!simple We need to parameterize the features based on the configuration
             // also "no default features"
             .all_features(true)
             .quiet(true)
@@ -489,7 +490,7 @@ fn run_rustdoc(
 }
 
 pub fn create_intralink_resolver<'a>(
-    crate_name: &'a str,
+    package_name: &'a str,
     package_target: &PackageTarget,
     workspace_package: Option<&str>,
     manifest_path: &PathBuf,
@@ -501,14 +502,14 @@ pub fn create_intralink_resolver<'a>(
         HashMap::with_capacity(rustdoc_crate.index.len());
 
     // WIP!simple this should be in a function of it's own.
-    for (item_id, item_summary) in rustdoc_crate.paths.iter() {
+    for (item_id, item_summary) in &rustdoc_crate.paths {
         let item_info = ItemInfo::from(item_summary, None, ItemContext::Normal);
 
         transitive_items(item_id, &item_info, ItemContext::Normal, &rustdoc_crate, &mut items_info);
     }
 
     let links_items_id = crate_rustdoc_intralinks(&rustdoc_crate);
-    let mut intralink_resolver = IntralinkResolver::new(crate_name, &config.docs_rs);
+    let mut intralink_resolver = IntralinkResolver::new(package_name, &config.docs_rs);
 
     for (link, item_id) in links_items_id {
         let link = Link::new(link.clone());

tests/tests.rs

@@ -458,3 +458,8 @@ fn integration_test_transform_intralinks_skip_rustdoc_when_no_intralinks() {
 fn integration_test_transform_intralinks_item_path_collision() {
     run_test("transform_intralinks_item_path_collision");
 }
+
+#[test]
+fn integration_test_transform_intralinks_package_and_crate_names() {
+    run_test("transform_intralinks_package_and_crate_names");
+}