oh-my-customcode 0.1.0

package/templates/guides/python/zen-of-python.md

@@ -0,0 +1,79 @@
+# The Zen of Python (PEP 20)
+
+> Source: https://peps.python.org/pep-0020/
+
+Long time Pythoneer Tim Peters succinctly channels the BDFL's guiding principles for Python's design into 20 aphorisms, only 19 of which have been written down.
+
+```
+>>> import this
+```
+
+## The 19 Aphorisms
+
+1. **Beautiful is better than ugly.**
+   - Write elegant, readable code
+
+2. **Explicit is better than implicit.**
+   - Don't hide behavior; make intentions clear
+
+3. **Simple is better than complex.**
+   - Choose straightforward solutions
+
+4. **Complex is better than complicated.**
+   - When complexity is needed, keep it manageable
+
+5. **Flat is better than nested.**
+   - Avoid deep nesting; keep structures flat
+
+6. **Sparse is better than dense.**
+   - Don't pack too much into one line
+
+7. **Readability counts.**
+   - Code is read more often than written
+
+8. **Special cases aren't special enough to break the rules.**
+   - Consistency matters
+
+9. **Although practicality beats purity.**
+   - Be pragmatic when needed
+
+10. **Errors should never pass silently.**
+    - Handle or propagate errors explicitly
+
+11. **Unless explicitly silenced.**
+    - Intentional suppression is acceptable
+
+12. **In the face of ambiguity, refuse the temptation to guess.**
+    - Ask for clarification; don't assume
+
+13. **There should be one-- and preferably only one --obvious way to do it.**
+    - Python favors one canonical approach
+
+14. **Although that way may not be obvious at first unless you're Dutch.**
+    - (A nod to Guido van Rossum)
+
+15. **Now is better than never.**
+    - Don't over-plan; start implementing
+
+16. **Although never is often better than *right* now.**
+    - But don't rush without thought
+
+17. **If the implementation is hard to explain, it's a bad idea.**
+    - Complexity is a warning sign
+
+18. **If the implementation is easy to explain, it may be a good idea.**
+    - Simplicity suggests good design
+
+19. **Namespaces are one honking great idea -- let's do more of those!**
+    - Organize code into clear namespaces
+
+## Application
+
+When writing Python code, ask yourself:
+- Is this beautiful or ugly?
+- Is this explicit or implicit?
+- Is this simple or complex?
+- Is this readable?
+- Could I easily explain this to someone else?
+
+The Zen of Python is not just style guidance—it's a philosophy for writing maintainable, understandable code.

package/templates/guides/rust/error-handling.md

@@ -0,0 +1,262 @@
+# Rust Error Handling
+
+> Reference for error handling patterns in Rust
+
+## Result Type
+
+```rust
+enum Result<T, E> {
+    Ok(T),
+    Err(E),
+}
+```
+
+### Basic Usage
+
+```rust
+use std::fs::File;
+
+fn main() {
+    let f = File::open("hello.txt");
+
+    let f = match f {
+        Ok(file) => file,
+        Err(error) => panic!("Problem opening file: {:?}", error),
+    };
+}
+```
+
+### Matching Different Errors
+
+```rust
+use std::fs::File;
+use std::io::ErrorKind;
+
+fn main() {
+    let f = File::open("hello.txt");
+
+    let f = match f {
+        Ok(file) => file,
+        Err(error) => match error.kind() {
+            ErrorKind::NotFound => match File::create("hello.txt") {
+                Ok(fc) => fc,
+                Err(e) => panic!("Problem creating file: {:?}", e),
+            },
+            other_error => panic!("Problem opening file: {:?}", other_error),
+        },
+    };
+}
+```
+
+### Shortcuts
+
+```rust
+// unwrap: panics on error
+let f = File::open("hello.txt").unwrap();
+
+// expect: panics with custom message
+let f = File::open("hello.txt").expect("Failed to open hello.txt");
+
+// unwrap_or: provides default value
+let f = File::open("hello.txt").unwrap_or(default_file);
+
+// unwrap_or_else: computes default on error
+let f = File::open("hello.txt").unwrap_or_else(|error| {
+    panic!("Problem opening file: {:?}", error)
+});
+```
+
+## Propagating Errors
+
+### With match
+
+```rust
+use std::fs::File;
+use std::io::{self, Read};
+
+fn read_username() -> Result<String, io::Error> {
+    let f = File::open("hello.txt");
+
+    let mut f = match f {
+        Ok(file) => file,
+        Err(e) => return Err(e),
+    };
+
+    let mut s = String::new();
+
+    match f.read_to_string(&mut s) {
+        Ok(_) => Ok(s),
+        Err(e) => Err(e),
+    }
+}
+```
+
+### With ? Operator
+
+```rust
+use std::fs::File;
+use std::io::{self, Read};
+
+fn read_username() -> Result<String, io::Error> {
+    let mut f = File::open("hello.txt")?;
+    let mut s = String::new();
+    f.read_to_string(&mut s)?;
+    Ok(s)
+}
+
+// Chained version
+fn read_username_chained() -> Result<String, io::Error> {
+    let mut s = String::new();
+    File::open("hello.txt")?.read_to_string(&mut s)?;
+    Ok(s)
+}
+```
+
+## Custom Error Types
+
+### Simple Custom Error
+
+```rust
+use std::fmt;
+
+#[derive(Debug)]
+struct MyError {
+    message: String,
+}
+
+impl fmt::Display for MyError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.message)
+    }
+}
+
+impl std::error::Error for MyError {}
+```
+
+### Error Enum
+
+```rust
+use std::io;
+use std::num::ParseIntError;
+
+#[derive(Debug)]
+enum AppError {
+    Io(io::Error),
+    Parse(ParseIntError),
+    Custom(String),
+}
+
+impl fmt::Display for AppError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            AppError::Io(e) => write!(f, "IO error: {}", e),
+            AppError::Parse(e) => write!(f, "Parse error: {}", e),
+            AppError::Custom(msg) => write!(f, "{}", msg),
+        }
+    }
+}
+
+impl std::error::Error for AppError {}
+
+impl From<io::Error> for AppError {
+    fn from(error: io::Error) -> Self {
+        AppError::Io(error)
+    }
+}
+
+impl From<ParseIntError> for AppError {
+    fn from(error: ParseIntError) -> Self {
+        AppError::Parse(error)
+    }
+}
+```
+
+## Option Type
+
+```rust
+enum Option<T> {
+    Some(T),
+    None,
+}
+```
+
+### Usage
+
+```rust
+fn divide(a: f64, b: f64) -> Option<f64> {
+    if b == 0.0 {
+        None
+    } else {
+        Some(a / b)
+    }
+}
+
+// Pattern matching
+match divide(10.0, 2.0) {
+    Some(result) => println!("Result: {}", result),
+    None => println!("Cannot divide by zero"),
+}
+
+// Combinators
+let result = divide(10.0, 2.0)
+    .map(|x| x * 2.0)
+    .unwrap_or(0.0);
+```
+
+## Panic
+
+### When to Panic
+
+```rust
+// Unrecoverable errors
+panic!("crash and burn");
+
+// Assertion failures
+assert!(x > 0, "x must be positive");
+assert_eq!(a, b, "values must be equal");
+
+// Unreachable code
+unreachable!("this should never happen");
+```
+
+### Panic vs Result
+
+- Use `Result` for recoverable errors
+- Use `panic!` for unrecoverable errors
+- Library code should return `Result`
+- `main` can panic or return `Result`
+
+## Best Practices
+
+```rust
+// 1. Use ? for propagation
+fn process() -> Result<Data, Error> {
+    let input = read_input()?;
+    let parsed = parse(input)?;
+    Ok(transform(parsed))
+}
+
+// 2. Add context with map_err
+let file = File::open(&path)
+    .map_err(|e| format!("Failed to open {}: {}", path, e))?;
+
+// 3. Use anyhow for applications
+use anyhow::{Context, Result};
+
+fn main() -> Result<()> {
+    let config = read_config()
+        .context("Failed to read configuration")?;
+    Ok(())
+}
+
+// 4. Use thiserror for libraries
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum DataError {
+    #[error("Invalid input: {0}")]
+    InvalidInput(String),
+    #[error("IO error")]
+    Io(#[from] std::io::Error),
+}
+```

package/templates/guides/rust/index.yaml

@@ -0,0 +1,26 @@
+# Rust Guide
+
+metadata:
+  name: rust
+  description: Rust language reference documentation
+
+source:
+  type: external
+  origin: rust-lang.org
+  urls:
+    - https://doc.rust-lang.org/book/
+    - https://rust-lang.github.io/api-guidelines/
+    - https://doc.rust-lang.org/nightly/style-guide/
+  last_fetched: "2026-01-22"
+
+documents:
+  - name: ownership
+    path: ./ownership.md
+    description: Ownership, borrowing, and lifetimes
+
+  - name: error-handling
+    path: ./error-handling.md
+    description: Error handling patterns in Rust
+
+used_by:
+  - rust-expert

package/templates/guides/rust/ownership.md

@@ -0,0 +1,180 @@
+# Rust Ownership
+
+> Reference for ownership, borrowing, and lifetimes
+
+## Ownership Rules
+
+1. Each value has exactly one owner
+2. When the owner goes out of scope, the value is dropped
+3. Values can be moved or borrowed
+
+## Move Semantics
+
+```rust
+// Move ownership
+let s1 = String::from("hello");
+let s2 = s1; // s1 is moved to s2
+// s1 is no longer valid
+
+// Clone to copy
+let s1 = String::from("hello");
+let s2 = s1.clone(); // s1 is still valid
+
+// Copy types (stack-only data)
+let x = 5;
+let y = x; // x is still valid (i32 implements Copy)
+```
+
+## Borrowing
+
+### Immutable References
+
+```rust
+fn main() {
+    let s1 = String::from("hello");
+    let len = calculate_length(&s1); // borrow s1
+    println!("The length of '{}' is {}.", s1, len);
+}
+
+fn calculate_length(s: &String) -> usize {
+    s.len()
+}
+```
+
+### Mutable References
+
+```rust
+fn main() {
+    let mut s = String::from("hello");
+    change(&mut s);
+}
+
+fn change(some_string: &mut String) {
+    some_string.push_str(", world");
+}
+```
+
+### Borrowing Rules
+
+```rust
+// Rule 1: At any time, either ONE mutable reference
+// OR any number of immutable references
+let mut s = String::from("hello");
+
+let r1 = &s; // OK
+let r2 = &s; // OK
+// let r3 = &mut s; // ERROR: cannot borrow as mutable
+
+let r3 = &mut s; // OK after r1 and r2 are done
+```
+
+## Lifetimes
+
+### Basic Syntax
+
+```rust
+// Lifetime annotation
+fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
+    if x.len() > y.len() {
+        x
+    } else {
+        y
+    }
+}
+```
+
+### Struct Lifetimes
+
+```rust
+struct ImportantExcerpt<'a> {
+    part: &'a str,
+}
+
+impl<'a> ImportantExcerpt<'a> {
+    fn level(&self) -> i32 {
+        3
+    }
+
+    fn announce_and_return_part(&self, announcement: &str) -> &str {
+        println!("Attention please: {}", announcement);
+        self.part
+    }
+}
+```
+
+### Lifetime Elision
+
+```rust
+// These are equivalent:
+fn first_word(s: &str) -> &str { ... }
+fn first_word<'a>(s: &'a str) -> &'a str { ... }
+
+// Elision rules:
+// 1. Each reference parameter gets its own lifetime
+// 2. If exactly one input lifetime, it's assigned to all outputs
+// 3. If &self or &mut self, its lifetime is assigned to outputs
+```
+
+### Static Lifetime
+
+```rust
+// 'static: lives for entire program duration
+let s: &'static str = "I have a static lifetime.";
+
+// All string literals have 'static lifetime
+```
+
+## Common Patterns
+
+### Returning References
+
+```rust
+// Cannot return reference to local variable
+fn dangle() -> &String { // ERROR
+    let s = String::from("hello");
+    &s // s goes out of scope!
+}
+
+// Return owned value instead
+fn no_dangle() -> String {
+    let s = String::from("hello");
+    s
+}
+```
+
+### Struct with References
+
+```rust
+// Struct holding reference must have lifetime
+struct Config<'a> {
+    query: &'a str,
+    filename: &'a str,
+}
+
+// Implementation with lifetime
+impl<'a> Config<'a> {
+    fn new(args: &'a [String]) -> Config<'a> {
+        Config {
+            query: &args[1],
+            filename: &args[2],
+        }
+    }
+}
+```
+
+### Multiple Lifetimes
+
+```rust
+fn longest_with_announcement<'a, 'b>(
+    x: &'a str,
+    y: &'a str,
+    ann: &'b str,
+) -> &'a str {
+    println!("Announcement: {}", ann);
+    if x.len() > y.len() {
+        x
+    } else {
+        y
+    }
+}
+```