init: serde feature

Cargo.toml

@@ -14,3 +14,7 @@ keywords = ["heraclitus", "compiler", "parser"]
 colored = "2.0.0"
 pad = "0.1.6"
 capitalize = "0.3.4"
+serde = { version = "1.0.210", default-features = false, optional = true, features = [ "derive" ] }
+
+[features]
+serde = [ "dep:serde" ]

src/compiling/compiler.rs

@@ -9,10 +9,14 @@ use crate::error_pos;
 
 use super::lexer::Lexer;
 
+#[cfg(feature = "serde")]
+use serde::{Serialize, Deserialize};
+
 /// How do you want to separate expressions?
 ///
 /// Separator mode determines how do you want to handle separators (in many languages the semicolon)
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum SeparatorMode {
     /// Manual separators require user to manually write them all
     Manual,
@@ -32,6 +36,7 @@ pub enum SeparatorMode {
 /// For instance do you want to use blocks like `{ ... }` or `if ... fi`
 /// or do you want to use intents like in languages such as Python or Yaml.
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum ScopingMode {
     /// Scopes are going to be contained between two specified tokens
     Block,
@@ -62,6 +67,7 @@ pub enum ScopingMode {
 /// # }
 /// ```
 #[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Compiler {
     /// Name of your language
     pub name: String,

src/compiling/failing/failure.rs

@@ -3,6 +3,9 @@
 use crate::compiling::failing::message::Message;
 use crate::compiling::failing::position_info::PositionInfo;
 
+#[cfg(feature = "serde")]
+use serde::{Serialize, Deserialize};
+
 /// Failure enum
 /// 
 /// This enum returns two types of errors - `Quiet` and `Loud`.
@@ -15,6 +18,7 @@ use crate::compiling::failing::position_info::PositionInfo;
 /// The Loud failure is used when the parser cannot continue. It contains detailed information
 /// about the error such as token position and length, but also a message, comment and a full traceback.
 #[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum Failure {
     /// Failure that is not important
     Quiet(PositionInfo),

src/compiling/failing/logger.rs

@@ -1,15 +1,18 @@
 //! This is a logger module which is used by compiler to log errors, warnings and info messages
 
-#![allow(dead_code)]
 use colored::{Colorize, Color};
 use pad::PadStr;
 use crate::compiling::failing::position_info::PositionInfo;
 use crate::compiling::failing::message::MessageType;
 use crate::prelude::Position;
 
+#[cfg(feature = "serde")]
+use serde::{Serialize, Deserialize};
+
 /// This is a logger that is used to log messages to the user
 /// The logger is being used internally by the Message struct
 /// when invoking the `show` method
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Logger {
     kind: MessageType,
     trace: Vec<PositionInfo>

src/compiling/failing/message.rs

@@ -5,13 +5,16 @@
 //! However, if you need more specific functionality - it is encouraged to create your
 //! own implementation of such mechanism.
 
-#![allow(dead_code)]
 use crate::compiling::{Metadata, Token};
 use crate::compiling::failing::logger::Logger;
 use crate::compiling::failing::position_info::PositionInfo;
 
+#[cfg(feature = "serde")]
+use serde::{Serialize, Deserialize};
+
 /// Type of the message that logger shall display
 #[derive(Clone, Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum MessageType {
     /// Error message
     Error,
@@ -38,6 +41,7 @@ pub enum MessageType {
 ///     .show();
 /// ```
 #[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Message {
     /// Type of the message
     pub kind: MessageType,

src/compiling/failing/position_info.rs

@@ -7,8 +7,12 @@ use std::fs::File;
 use std::io::*;
 use crate::compiling::{Metadata, Token};
 
+#[cfg(feature = "serde")]
+use serde::{Serialize, Deserialize};
+
 /// Store position of some error
 #[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum Position {
     /// Explicit row and column
     Pos(usize, usize),
@@ -18,6 +22,7 @@ pub enum Position {
 
 /// Struct that is used to return a simple error
 #[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PositionInfo {
     /// Path of the file
     pub path: Option<String>,

src/compiling/lexing/compound_handler.rs

@@ -2,14 +2,19 @@ use std::collections::HashMap;
 use crate::compiling_rules::Rules;
 use super::reader::Reader;
 
+#[cfg(feature = "serde")]
+use serde::{Serialize, Deserialize};
+
 #[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum CompoundReaction {
     Begin,
     Keep,
     End,
     Pass
 }
 
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct CompoundHandler {
     compound_tree: HashMap<char, Vec<char>>,
     is_triggered: bool

src/compiling/lexing/lexer.rs

@@ -14,8 +14,12 @@ use super::{
     LexerError, LexerErrorType,
 };
 
+#[cfg(feature = "serde")]
+use serde::{Serialize, Deserialize};
+
 ///  Lexer
 #[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Lexer {
     rules: Rules,
     /// Path to the lexed file
@@ -28,6 +32,7 @@ pub struct Lexer {
     pub scoping_mode: ScopingMode,
 }
 
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 struct LexState<'a> {
     word: String,
     is_indenting: bool,

src/compiling/lexing/mod.rs

@@ -9,8 +9,12 @@ pub mod lexer;
 mod reader;
 mod region_handler;
 
+#[cfg(feature = "serde")]
+use serde::{Serialize, Deserialize};
+
 /// Lexer's error type
 #[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum LexerErrorType {
     /// Unspillable region has been spilled
     Singleline,