refactor: pull things into own files, have a library

src/command.rs

@@ -0,0 +1,65 @@
+use crate::meta_commands::{MetaCommand, MetaCommandParseError};
+use crate::statements::{Statement, StatementParseError};
+
+pub enum Command {
+    MetaCommand(MetaCommand),
+    Statement(Statement),
+}
+
+pub enum CommandParseError {
+    MetaCommand(MetaCommandParseError),
+    Statement(StatementParseError),
+}
+
+impl std::fmt::Display for CommandParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CommandParseError::MetaCommand(meta_command_parse_error) => {
+                write!(f, "{meta_command_parse_error}")
+            }
+            CommandParseError::Statement(statement_parse_error) => {
+                write!(f, "{statement_parse_error}")
+            }
+        }
+    }
+}
+
+impl From<MetaCommand> for Command {
+    fn from(value: MetaCommand) -> Self {
+        Command::MetaCommand(value)
+    }
+}
+
+impl From<MetaCommandParseError> for CommandParseError {
+    fn from(value: MetaCommandParseError) -> Self {
+        CommandParseError::MetaCommand(value)
+    }
+}
+
+impl From<Statement> for Command {
+    fn from(value: Statement) -> Self {
+        Command::Statement(value)
+    }
+}
+
+impl From<StatementParseError> for CommandParseError {
+    fn from(value: StatementParseError) -> Self {
+        CommandParseError::Statement(value)
+    }
+}
+
+impl std::str::FromStr for Command {
+    type Err = CommandParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s.starts_with(".") {
+            s.parse::<MetaCommand>()
+                .map(|x| x.into())
+                .map_err(|x| x.into())
+        } else {
+            s.parse::<Statement>()
+                .map(|x| x.into())
+                .map_err(|x| x.into())
+        }
+    }
+}