Release 0.2.2 (#22)

* list all functions in a Rust project

- Remove support for detecting `#[autometrics]` annotation on struct
  statements, as it is not supported in Rust, and simplifies the code

* doc: update changelog

* nit: format, lint

* chore: Release am_list version 0.2.2

Author: gagbo

CHANGELOG.md

@@ -9,6 +9,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased] - ReleaseDate
 
+## [Version 0.2.2] - 2023-06-19
+
+### Added
+
+- [Rust] The `list` subcommand now takes an optional `--all-functions` (short `-a`) flag,
+  which lists all functions/methods in the project instead of only the ones with the
+  autometrics annotation. This allows to get an overview of how many functions are
+  autometricized. The flag will crash on non-Rust implementations for now.
+
 ## [Version 0.2.1] - 2023-06-16
 
 ### Fixed
@@ -53,7 +62,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Security
 
 <!-- next-url -->
-[Unreleased]: https://github.com/gagbo/am_list/compare/v0.2.1...HEAD
+[Unreleased]: https://github.com/autometrics-dev/am_list/compare/v0.2.2...HEAD
+[Version 0.2.2]: https://github.com/gagbo/am_list/compare/v0.2.1...v0.2.2
 [Version 0.2.1]: https://github.com/gagbo/am_list/compare/v0.2.0...v0.2.1
 [Version 0.2.0]: https://github.com/gagbo/am_list/compare/v0.1.0...v0.2.0
 [Version 0.1.0]: https://github.com/gagbo/am_list/releases/tag/v0.1.0

CONTRIBUTING.md

@@ -4,7 +4,18 @@
 
 The complete release cycle is handled and automated by the combination of `cargo-dist` and `cargo-release`.
 
-When ready for a release, using `cargo release --(patch|minor|major)` should be enough.
+When ready for a release, using `cargo release --(patch|minor)` or `cargo release NEW_MAJOR` should be enough.
+
+### Prerequisites
+
+Only `cargo-release` is needed to create a new release:
+```console
+$ cargo install --locked cargo-release
+```
+
+Also, you need to have the authorization to both:
+- create and push tags on `release/*` branches in the Github repo
+- create and push crates on `crates-io` registry for [`am_list` crate](https://crates.io/crates/am_list)
 
 ### Release a breaking `0.Y` version
 

Cargo.lock

@@ -1,9 +1,9 @@
 [package]
 name = "am_list"
-version = "0.2.1"
+version = "0.2.2"
 edition = "2021"
-repository = "https://github.com/gagbo/am_list"
-authors = ["Gerry Agbobada <[email protected]>"]
+repository = "https://github.com/autometrics-dev/am_list"
+authors = ["Fiberplane <[email protected]>", "Gerry Agbobada <[email protected]>"]
 description = "A tree-sitter-powered command line tool to list functions marked with Autometrics annotations"
 homepage = "https://autometrics.dev"
 license = "MIT"

Cargo.toml

@@ -16,7 +16,7 @@ Use the installer script to pull the latest version directly from Github
 (change `VERSION` accordingly):
 
 ```console
-VERSION=0.2.0 curl --proto '=https' --tlsv1.2 -LsSf https://github.com/gagbo/am_list/releases/download/v$VERSION/am_list-installer.sh | sh
+VERSION=0.2.0 curl --proto '=https' --tlsv1.2 -LsSf https://github.com/autometrics-dev/am_list/releases/download/v$VERSION/am_list-installer.sh | sh
 ```
 
 And run the binary

README.md

@@ -3,5 +3,5 @@ pre-release-replacements = [
   {file="CHANGELOG.md", search="\\.\\.\\.HEAD", replace="...{{tag_name}}", exactly=1},
   {file="CHANGELOG.md", search="ReleaseDate", replace="{{date}}"},
   {file="CHANGELOG.md", search="<!-- next-header -->", replace="<!-- next-header -->\n\n## [Unreleased] - ReleaseDate", exactly=1},
-  {file="CHANGELOG.md", search="<!-- next-url -->", replace="<!-- next-url -->\n[Unreleased]: https://github.com/gagbo/am_list/compare/{{tag_name}}...HEAD", exactly=1},
+  {file="CHANGELOG.md", search="<!-- next-url -->", replace="<!-- next-url -->\n[Unreleased]: https://github.com/autometrics-dev/am_list/compare/{{tag_name}}...HEAD", exactly=1},
 ]

release.toml

@@ -0,0 +1,22 @@
+((function_item
+  name: (identifier) @func.name))
+
+;; It is impossible to do arbitrary levels of nesting, so we just detect module declarations to
+;; call this query recursively on the declaration_list of the module.
+;; Ref: https://github.com/tree-sitter/tree-sitter/discussions/981
+((mod_item
+  name: (identifier) @mod.name
+  body: (declaration_list) @mod.contents))
+
+;; We want to skip the "bare" function detection (@func.name pattern in this file) when function
+;; is within an impl block. The reason is that we cannot properly report the module name (which should
+;; be the struct type name) if we use this detection method.
+;; Therefore, we skip bare functions that are detected within impl blocks, and instead rely on
+;; recursion to find functions within impl blocks.
+;;
+;; We also consider that an "impl block" is an "in-file" module for the purpose of recursion
+;; This allows to detect functions that have the autometrics annotation within an impl block,
+;; _while allowing to skip functions in impl blocks detected by the main query_.
+((impl_item
+  type: (type_identifier) @impl.type
+  body: (declaration_list) @impl.contents))

runtime/queries/rust/all_functions.scm

@@ -10,7 +10,6 @@
    name: (identifier) @func.name)
  (#eq? @attr "autometrics"))
 
-
 ((attribute_item)*
  .
  (attribute_item
@@ -19,67 +18,11 @@
  .
  (attribute_item)*
  .
- (struct_item
-   name: (type_identifier) @type.target)
-
  (impl_item
    type: (type_identifier) @type.impl
    body: (declaration_list
            (function_item
-             name: (identifier) @func.name)))
-
- (#eq? @attr "autometrics")
- (#eq? @type.impl @type.target))
-
-
-((impl_item
-   type: (type_identifier) @type.impl
-   body: (declaration_list
-           (function_item
-             name: (identifier) @func.name)))
-
- (attribute_item)*
- .
- (attribute_item
-   (attribute
-     (identifier) @attr))
- .
- (attribute_item)*
- .
- (struct_item
-   name: (type_identifier) @type.target)
-
- (#eq? @attr "autometrics")
- (#eq? @type.impl @type.target))
-
-
-((attribute_item)*
- .
- (attribute_item
-   (attribute
-     (identifier) @attr))
- .
- (attribute_item)*
- .
- (struct_item
-   name: (type_identifier) @type.target)
-
- (#eq? @attr "autometrics"))
-
-
-((attribute_item)*
- .
- (attribute_item
-   (attribute
-     (identifier) @attr))
- .
- (attribute_item)*
- .
- (impl_item
-   type: (type_identifier) @type.impl
-   body: (declaration_list
-           (function_item
-             name: (identifier) @func.name)))
+             name: (identifier) @inner.func.name)))
 
  (#eq? @attr "autometrics"))
 
@@ -89,3 +32,16 @@
 ((mod_item
   name: (identifier) @mod.name
   body: (declaration_list) @mod.contents))
+
+;; We want to skip the "bare" function detection (@func.name pattern in this file) when function
+;; is within an impl block. The reason is that we cannot properly report the module name (which should
+;; be the struct type name) if we use this detection method.
+;; Therefore, we skip bare functions that are detected within impl blocks, and instead rely on
+;; recursion to find functions within impl blocks.
+;;
+;; We also consider that an "impl block" is an "in-file" module for the purpose of recursion
+;; This allows to detect functions that have the autometrics annotation within an impl block,
+;; _while allowing to skip functions in impl blocks detected by the main query_.
+((impl_item
+  type: (type_identifier) @impl.type
+  body: (declaration_list) @impl.contents))

runtime/queries/rust/autometrics.scm

@@ -68,6 +68,10 @@ impl ListAmFunctions for Impl {
         result.extend(list.into_iter().flatten());
         Ok(result)
     }
+
+    fn list_all_functions(&mut self, _project_root: &Path) -> Result<Vec<ExpectedAmLabel>> {
+        unimplemented!("listing all functions in Golang")
+    }
 }
 
 fn new_parser() -> Result<Parser> {
@@ -83,10 +87,10 @@ fn query_builder() -> Result<(Query, u32, u32)> {
     )?;
     let idx = query
         .capture_index_for_name(FUNC_NAME_CAPTURE)
-        .ok_or(AmlError::MissingFuncNameCapture)?;
+        .ok_or_else(|| AmlError::MissingFuncNameCapture(FUNC_NAME_CAPTURE.into()))?;
     let mod_idx = query
         .capture_index_for_name(PACK_NAME_CAPTURE)
-        .ok_or(AmlError::MissingFuncNameCapture)?;
+        .ok_or_else(|| AmlError::MissingFuncNameCapture(PACK_NAME_CAPTURE.into()))?;
     Ok((query, idx, mod_idx))
 }
 

src/go.rs

@@ -23,6 +23,7 @@ impl Display for ExpectedAmLabel {
 
 pub trait ListAmFunctions {
     fn list_autometrics_functions(&mut self, project_root: &Path) -> Result<Vec<ExpectedAmLabel>>;
+    fn list_all_functions(&mut self, project_root: &Path) -> Result<Vec<ExpectedAmLabel>>;
 }
 
 pub type Result<T> = std::result::Result<T, AmlError>;
@@ -33,8 +34,8 @@ pub enum AmlError {
     CreateParser(#[from] LanguageError),
     #[error("Issue creating the TreeSitter query")]
     CreateQuery(#[from] QueryError),
-    #[error("The query is missing a function name capture")]
-    MissingFuncNameCapture,
+    #[error("The query is missing a function name capture: {0}")]
+    MissingFuncNameCapture(String),
     #[error("Parsing error")]
     Parsing,
     #[error("Invalid text in source")]

src/lib.rs

@@ -29,6 +29,9 @@ struct ListArgs {
     /// - For Go projects it must be the root of the repository.
     #[arg(value_name = "ROOT")]
     root: PathBuf,
+    /// List all functions instead of only the autometricized ones (defaults to false)
+    #[arg(short, long, default_value = "false")]
+    all_functions: bool,
     /// Pretty print the resulting JSON (defaults to false)
     #[arg(short, long, default_value = "false")]
     pretty: bool,
@@ -68,15 +71,15 @@ fn main() -> anyhow::Result<()> {
             let root = args.root;
             info!("Autometrics functions in {}:", root.display());
 
-            let mut res = match args.language {
-                Language::Rust => {
-                    let mut implementor = am_list::rust::Impl {};
-                    implementor.list_autometrics_functions(&root)?
-                }
-                Language::Go => {
-                    let mut implementor = am_list::go::Impl {};
-                    implementor.list_autometrics_functions(&root)?
-                }
+            let mut implementor: Box<dyn ListAmFunctions> = match args.language {
+                Language::Rust => Box::new(am_list::rust::Impl {}),
+                Language::Go => Box::new(am_list::go::Impl {}),
+            };
+
+            let mut res = if args.all_functions {
+                implementor.list_all_functions(&root)?
+            } else {
+                implementor.list_autometrics_functions(&root)?
             };
 
             res.sort();