Renames pestion to pest-ion.

Updates surrounding meta-data and README.

Also renames the following types:
* `PestionResult` => `PestToIonResult`
* `PestionError` => `PestToIonError`

Author: almann

Cargo.toml

@@ -6,5 +6,5 @@ members = [
   "partiql-irgen",
   "partiql-parser",
   "partiql-rewriter",
-  "pestion",
+  "pest-ion",
 ]

pestion/Cargo.toml renamed to pest-ion/Cargo.toml

@@ -1,9 +1,9 @@
 [package]
-name = "pestion"
+name = "pest-ion"
 authors = ["PartiQL Team <[email protected]>"]
 description = "A simple Pest grammar to Ion converter"
-homepage = "https://github.com/partiql/partiql-lang-rust/pestion"
-repository = "https://github.com/partiql/partiql-lang-rust/pestion"
+homepage = "https://github.com/partiql/partiql-lang-rust/pest-ion"
+repository = "https://github.com/partiql/partiql-lang-rust/pest-ion"
 license = "Apache-2.0"
 readme = "README.md"
 keywords = ["parser", "peg", "pest", "ion", "cli"]

pestion/README.md renamed to pest-ion/README.md

@@ -1,4 +1,4 @@
-# Pestion
+# Pest to Ion
 
 This is a simple tool and library for converting [Pest] grammars to [Ion] data format.
 

pestion/src/lib.rs renamed to pest-ion/src/lib.rs

@@ -7,11 +7,11 @@
 //! The easiest way to convert [Pest] grammars to Ion is from a `str` slice:
 //!
 //! ```
-//! use pestion::*;
+//! use pest_ion::*;
 //! use ion_rs::value::*;
 //! use ion_rs::value::reader::*;
 //!
-//! fn main() -> PestionResult<()> {
+//! fn main() -> PestToIonResult<()> {
 //!     // parse a Pest grammar and convert it to Ion element
 //!     let actual = r#"a = @{ "a" | "b" ~ "c" }"#.try_pest_to_element()?;
 //!
@@ -60,7 +60,7 @@ pub trait TryPestToElement {
     ///
     /// This returns `Err` if the the conversion fails. For example, this can happen if the
     /// source is not a valid Pest grammar.
-    fn try_pest_to_element(&self) -> PestionResult<Self::Element>;
+    fn try_pest_to_element(&self) -> PestToIonResult<Self::Element>;
 }
 
 /// Infallible conversion of a Pest grammar (or part of a grammar) into Ion [`Element`].
@@ -78,7 +78,7 @@ impl TryPestToElement for &str {
     type Element = OwnedElement;
 
     /// Parses a `str` slice as a Pest grammar and serializes the AST into [`Element`].
-    fn try_pest_to_element(&self) -> PestionResult<Self::Element> {
+    fn try_pest_to_element(&self) -> PestToIonResult<Self::Element> {
         let pairs = PestParser::parse(Rule::grammar_rules, *self)?;
         let ast = match consume_rules(pairs) {
             Ok(ast) => ast,
@@ -422,7 +422,7 @@ mod tests {
             },
         }"#
     )]
-    fn good<T, S>(#[case] input: T, #[case] ion_literal: S) -> PestionResult<()>
+    fn good<T, S>(#[case] input: T, #[case] ion_literal: S) -> PestToIonResult<()>
     where
         T: TryPestToElement<Element = OwnedElement> + Debug,
         S: AsRef<str>,
@@ -452,9 +452,9 @@ mod tests {
     #[case::empty_rule(r#"a = {}"#)]
     #[case::self_reference(r#"a = { a }"#)]
     #[case::double_rule(r#"a = { "a" }\n a = { "b" }"#)]
-    fn pest_errors<T: TryPestToElement>(#[case] input: T) -> PestionResult<()> {
+    fn pest_errors<T: TryPestToElement>(#[case] input: T) -> PestToIonResult<()> {
         match input.try_pest_to_element() {
-            Err(PestionError::Pest(_)) => {}
+            Err(PestToIonError::Pest(_)) => {}
             something => {
                 unreachable!("Got result we did not expect: {:?}", something);
             }

pestion/src/result.rs renamed to pest-ion/src/result.rs

@@ -5,11 +5,11 @@
 use thiserror::Error;
 
 /// Main [`Result`] type for Pest to Ion.
-pub type PestionResult<T> = Result<T, PestionError>;
+pub type PestToIonResult<T> = Result<T, PestToIonError>;
 
 /// Error type for problems in this crate.
 #[derive(Error, Debug)]
-pub enum PestionError {
+pub enum PestToIonError {
     /// An error working with [`pest_meta`].
     #[error("Pest Error: {0}")]
     Pest(#[from] pest::error::Error<pest_meta::parser::Rule>),
@@ -19,11 +19,11 @@ pub enum PestionError {
     Ion(#[from] ion_rs::result::IonError),
 
     /// General error from this library.
-    #[error("Pestion Error: {0}")]
+    #[error("Pest to Ion Error: {0}")]
     Invalid(String),
 }
 
 /// Convenience function to create a general error result.
-pub fn invalid<T, S: Into<String>>(message: S) -> PestionResult<T> {
-    Err(PestionError::Invalid(message.into()))
+pub fn invalid<T, S: Into<String>>(message: S) -> PestToIonResult<T> {
+    Err(PestToIonError::Invalid(message.into()))
 }