15 changed files with 204 additions and 269 deletions
--- a/.dockerignore
+++ b/.dockerignore
@ -0,0 +1,4 @@
+/target
+
+.env*
+!.envrc
--- a/.envrc
+++ b/.envrc
@ -0,0 +1 @@
+use flake
--- a/.gitignore
+++ b/.gitignore
@ -1,11 +1,4 @@
-# build
 /target
-/result

-# environments
 .env*
 !.env.example
-
-# direnv
-.envrc
-.direnv
--- a/Cargo.lock
+++ b/Cargo.lock
@ -37,6 +37,7 @@ dependencies = [
 "clap_lex",
 "indexmap",
 "once_cell",
+ "strsim",
 "termcolor",
 "textwrap",
 ]
@ -154,6 +155,12 @@ dependencies = [
 "proc-macro2",
 ]

+[[package]]
+name = "strsim"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
 [[package]]
 name = "syn"
 version = "1.0.98"
@ -194,11 +201,9 @@ checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"

 [[package]]
 name = "vnetod"
-version = "0.4.0"
+version = "0.2.2"
 dependencies = [
- "atty",
 "clap",
- "termcolor",
 ]

 [[package]]
--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,10 +1,9 @@
 [package]
 name = "vnetod"
-description = "Are you still switching sections in your dotenv file manually? Try this dotenv section switcher"
-version = "0.4.0"
+description = "Dotenv state switcher"
+version = "0.3.0"
 edition = "2021"
 license = "GPL-3.0+"
-homepage = "https://github.com/pleshevskiy/vnetod/discussions"
 repository = "https://git.pleshevski.ru/pleshevskiy/vnetod.git"
 keywords = ["env", "dotenv", "switcher", "change"]
 categories = ["command-line-interface", "config", "development-tools"]
@ -12,9 +11,6 @@ categories = ["command-line-interface", "config", "development-tools"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-clap = { version = "3.2.15", default-features = false, features = ["std", "env", "derive"] }
-atty = { version = "0.2.14", optional = true }
-termcolor = { version = "1.1.3", optional = true }
+clap = { version = "3.2.15", features = ["derive"] }

 [features]
-color = ["clap/color", "dep:atty", "dep:termcolor"]
--- a/22
+++ b/22
@ -0,0 +1,22 @@
+FROM rust:1.62.0-slim-buster
+
+WORKDIR /app
+
+RUN cargo init .
+
+COPY Cargo.* ./
+
+RUN cargo build --release \
+  && rm -rf src
+
+COPY ./src ./src
+
+RUN cargo install --bin vnetod --path . \
+  && rm -rf ./src Cargo.*
+
+VOLUME ["/data"]
+
+WORKDIR /data
+
+ENTRYPOINT ["/usr/local/cargo/bin/vnetod"]
+
--- a/README.md
+++ b/README.md
@ -1,20 +1,17 @@
-# vnetod*
+# vnetod

-<small><strong>*</strong> inverted word "dotenv"</small>
+Dotenv state switcher

-Are you still switching sections in your dotenv file manually? Try this dotenv
-section switcher!
-
-You can create many sections in your `.env` and switch between them.
+You can create many states in your `.env` and switch between them.

 Rules:

- Section name starts on a new line with `###` symbols (Ex. `### local`)
- Section can contain multiple comma-separated names (Ex.
+- State name starts on a new line with `###` symbols (Ex. `### local`)
+- State name can contain multiple comma-separated sections (Ex.
  `### local,staging`)
- Each section name may specify a namespace (Ex. `### debug:on,dev:on`). If a
-  section doesn't contain a namespace, it's a global namespace.
- Section ends if line is empty or contains a new section name.
+- Each section may specify a namespace (Ex. `### debug:on,dev:on`). If a section
+  doesn't contain a namespace, it's a global namespace.
+- State ends if line is empty or contains a new state name.

 You can see the [full example].

@ -85,13 +82,6 @@ docker run --rm -it -v $PWD:/data pleshevskiy/vnetod --help
 nix run git+https://git.pleshevski.ru/pleshevskiy/vnetod -- --help
 ```

-# Contact me
-
- [send feedback](https://github.com/pleshevskiy/vnetod/discussions)
- [make an issue](https://github.com/pleshevskiy/vnetod/issues)
- matrix: @pleshevskiy:matrix.org
- email: dmitriy@pleshevski.ru
-
 # License

 GNU General Public License v3.0 or later
--- a/docker/README.md
+++ b/docker/README.md
@ -1,25 +1,11 @@
 # Supported tags

 - latest
- 0.4
+- 0.3

-# vnetod*
+# vnetod

-<small><strong>*</strong> inverted word "dotenv"</small>
-
-Are you still switching sections in your dotenv file manually? Try this dotenv
-section switcher!
-
-You can create many sections in your `.env` and switch between them.
-
-Rules:
-
- Section name starts on a new line with `###` symbols (Ex. `### local`)
- Section can contain multiple comma-separated names (Ex.
-  `### local,staging`)
- Each section name may specify a namespace (Ex. `### debug:on,dev:on`). If a
-  section doesn't contain a namespace, it's a global namespace.
- Section ends if line is empty or contains a new section name.
+Dotenv state switcher

 # Usage

--- a/flake.lock
+++ b/flake.lock
@ -1,21 +1,39 @@
 {
  "nodes": {
-    "flake-utils": {
+    "naersk": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      },
      "locked": {
-        "lastModified": 1667395993,
-        "narHash": "sha256-nuEHfE/LcWyuSWnS8t12N1wc105Qtau+/OdUAjtQ0rA=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "5aed5285a952e0b949eb3ba02c12fa4fcfef535f",
+        "lastModified": 1655042882,
+        "narHash": "sha256-9BX8Fuez5YJlN7cdPO63InoyBy7dm3VlJkkmTt6fS1A=",
+        "owner": "nix-community",
+        "repo": "naersk",
+        "rev": "cddffb5aa211f50c4b8750adbec0bbbdfb26bb9f",
        "type": "github"
      },
      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
+        "owner": "nix-community",
+        "ref": "master",
+        "repo": "naersk",
        "type": "github"
      }
    },
    "nixpkgs": {
+      "locked": {
+        "lastModified": 1659190188,
+        "narHash": "sha256-LudYrDFPFaQMW0l68TYkPWRPKmqpxIFU1nWfylIp9AQ=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "a3fddd46a7f3418d7e3940ded94701aba569161d",
+        "type": "github"
+      },
+      "original": {
+        "id": "nixpkgs",
+        "type": "indirect"
+      }
+    },
+    "nixpkgs_2": {
      "locked": {
        "lastModified": 1659190188,
        "narHash": "sha256-LudYrDFPFaQMW0l68TYkPWRPKmqpxIFU1nWfylIp9AQ=",
@ -33,8 +51,24 @@
    },
    "root": {
      "inputs": {
-        "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs"
+        "naersk": "naersk",
+        "nixpkgs": "nixpkgs_2",
+        "utils": "utils"
+      }
+    },
+    "utils": {
+      "locked": {
+        "lastModified": 1656928814,
+        "narHash": "sha256-RIFfgBuKz6Hp89yRr7+NR5tzIAbn52h8vT6vXkYjZoM=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "7e2a3b3dfd9af950a856d66b0a7d01e3c18aa249",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
      }
    }
  },
--- a/flake.nix
+++ b/flake.nix
@ -1,77 +1,46 @@
 {
  inputs = {
+    naersk.url = "github:nix-community/naersk/master";
    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
-    flake-utils.url = "github:numtide/flake-utils";
+    utils.url = "github:numtide/flake-utils";
  };

-  outputs = { self, nixpkgs, flake-utils }:
-    let
-      inherit (builtins) fromTOML readFile substring;
-
-      cargoToml = fromTOML (readFile ./Cargo.toml);
-      version = "${cargoToml.package.version}+${substring 0 8 self.lastModifiedDate}.${self.shortRev or "dirty"}";
-
-      mkVnetod = { lib, rustPlatform, vnetodFeatures ? [ ], ... }:
-        rustPlatform.buildRustPackage {
-          name = "vnetod-${version}";
-
-          src = lib.cleanSource ./.;
-          cargoLock.lockFile = ./Cargo.lock;
-
-          buildFeatures = vnetodFeatures;
-
-          doCheck = true;
-        };
-    in
-    {
-      overlays = {
-        minimal = final: prev: {
-          vnetod = final.callPackage mkVnetod { };
-        };
-        default = final: prev: {
-          vnetod = final.callPackage mkVnetod {
-            vnetodFeatures = [ "color" ];
-          };
-        };
-      };
-    }
-    // flake-utils.lib.eachDefaultSystem (system:
+  outputs = { self, nixpkgs, utils, naersk }:
+    utils.lib.eachDefaultSystem (system:
      let
+        name = "vnetod";
        pkgs = import nixpkgs { inherit system; };
-
-        vnetod = pkgs.callPackage mkVnetod { vnetodFeatures = [ "color" ]; };
-        minimalVnetod = pkgs.callPackage mkVnetod { };
-
-        docker = pkgs.dockerTools.buildLayeredImage {
-          name = "pleshevskiy/vnetod";
-          tag = cargoToml.package.version;
-          config = {
-            Volumes."/data" = { };
-            WorkingDir = "/data";
-            Entrypoint = [ "${vnetod}/bin/vnetod" ];
+        naersk-lib = pkgs.callPackage naersk { };
+      in
+      rec {
+        # Executes by `nix build .#<name>`
+        packages = {
+         ${name} = naersk.lib.${system}.buildPackage {
+            pname = name;
+            root = ./.;
          };
        };
+        # Executes by `nix build .`
+        packages.default = packages.${name};
+        # the same but deprecated in Nix 2.7
+        defaultPackage = packages.default;

-        mkApp = prog: {
-          type = "app";
-          program = "${vnetod}/bin/vnetod";
-        };
-      in
-      {
+        # Executes by `nix run .#<name> -- <args?>` 
        apps = {
-          default = mkApp vnetod;
-          minimal = mkApp minimalVnetod;
+          ${name} = utils.lib.mkApp {
+            inherit name;
+            drv = packages.${name};
+          };
        };
+        # Executes by `nix run . -- <args?>`
+        apps.default = apps.${name};
+        # the same but deprecated in Nix 2.7
+        defaultApp = apps.default;

-        packages = {
-          inherit docker vnetod;
-          default = vnetod;
-          minimal = minimalVnetod;
-        };
-
-        devShell = pkgs.mkShell {
-          packages = with pkgs; [ cargo rustc rustfmt clippy rust-analyzer ];
-          RUST_SRC_PATH = pkgs.rustPlatform.rustLibSrc;
+        # Used by `nix develop`
+        devShell = with pkgs; mkShell {
+          buildInputs = [ cargo rustc rustfmt pre-commit rustPackages.clippy ];
+          RUST_SRC_PATH = rustPlatform.rustLibSrc;
        };
      });
 }
--- a/src/cli.rs
+++ b/src/cli.rs
@ -1,4 +1,4 @@
-//! Copyright (C) 2022, Dmitriy Pleshevskiy <dmitriy@pleshevski.ru>
+//! Copyright (C) 2022, Dmitriy Pleshevskiy <dmitriy@ideascup.me>
 //!
 //! vnetod is free software: you can redistribute it and/or modify
 //! it under the terms of the GNU General Public License as published by
@ -20,14 +20,14 @@ use std::path::PathBuf;

 use clap::Parser;

-#[derive(Parser, Debug)]
+#[derive(Parser)]
 #[clap(
    author,
    version,
    about = "\
 Dotenv state switcher
 ---------------------------------------------------------------------
-vnetod  Copyright (C) 2022  Dmitriy Pleshevskiy <dmitriy@pleshevski.ru>
+vnetod  Copyright (C) 2022  Dmitriy Pleshevskiy <dmitriy@ideascup.me>
 This program comes with ABSOLUTELY NO WARRANTY;
 This is free software, and you are welcome to redistribute it
 under certain conditions;
@ -39,15 +39,14 @@ pub struct Args {
        short = 'f',
        long,
        default_value = ".env",
-        env = "VNETOD_FILE",
-        help = "Change source file with environment variables."
+        help = "Change source file with environment variables"
    )]
    pub file: PathBuf,

    #[clap(
        short = 'o',
        long,
-        help = "Change output file with modified environment variables. It uses `file` argument by default if the output is not specified."
+        help = "Change output file with modified environment variables. It uses `file` argument by default if the output is not specified"
    )]
    pub output: Option<PathBuf>,

@ -59,66 +58,7 @@ pub struct Args {

    #[clap(
        value_parser,
-        help = "Environment varible sections that will be enabled."
+        help = "Environment varible sections that will be enabled"
    )]
    pub sections: Vec<String>,
-
-    #[cfg(feature = "color")]
-    #[clap(
-        long,
-        value_enum,
-        default_value = "auto",
-        help = "This flag controls when to use colors.",
-        long_help = "
-This flag controls when to use colors. The default setting is 'auto', which
-means vnetod will try to guess when to use colors. For example, if vnetod is
-printing to a terminal, then it will use colors, but if it is redirected to a
-file or a pipe, then it will suppress color output. vnetod will suppress color
-output in some other circumstances as well. For example, if the TERM
-environment variable is not set or set to 'dumb', then vnetod will not use
-colors.
-
-The possible values for this flag are:
-
-never    Colors will never be used.
-auto     The default. vnetod tries to be smart.
-always   Colors will always be used regardless of where output is sent.
-ansi     Like 'always', but emits ANSI escapes (even in a Windows console).
-"
-    )]
-    pub color: ColorVariant,
-}
-
-#[cfg(feature = "color")]
-#[derive(clap::ValueEnum, Clone, Debug)]
-pub enum ColorVariant {
-    Auto,
-    Always,
-    Ansi,
-    Never,
-}
-
-#[cfg(feature = "color")]
-impl From<ColorVariant> for termcolor::ColorChoice {
-    fn from(col: ColorVariant) -> Self {
-        match col {
-            ColorVariant::Never => Self::Never,
-            ColorVariant::Always => Self::Always,
-            ColorVariant::Ansi => Self::AlwaysAnsi,
-            ColorVariant::Auto => {
-                if atty::is(atty::Stream::Stdout) {
-                    // Otherwise let's `termcolor` decide by inspecting the environment. From the [doc]:
-                    // - If `NO_COLOR` is set to any value, then colors will be suppressed.
-                    // - If `TERM` is set to dumb, then colors will be suppressed.
-                    // - In non-Windows environments, if `TERM` is not set, then colors will be suppressed.
-                    //
-                    // [doc]: https://github.com/BurntSushi/termcolor#automatic-color-selection
-                    Self::Auto
-                } else {
-                    // Colors should be deactivated if the terminal is not a tty.
-                    Self::Never
-                }
-            }
-        }
-    }
 }
--- a/src/cli/switch.rs
+++ b/src/cli/switch.rs
@ -1,4 +1,4 @@
-//! Copyright (C) 2022, Dmitriy Pleshevskiy <dmitriy@pleshevski.ru>
+//! Copyright (C) 2022, Dmitriy Pleshevskiy <dmitriy@ideascup.me>
 //!
 //! vnetod is free software: you can redistribute it and/or modify
 //! it under the terms of the GNU General Public License as published by
@ -14,24 +14,21 @@
 //! along with vnetod.  If not, see <https://www.gnu.org/licenses/>.
 //!

-#[cfg(feature = "color")]
-use termcolor::{Color, ColorSpec, StandardStream, WriteColor};
-
 use crate::{cli::Args, domain};
 use std::fs::File;
-use std::io::Write;
+use std::io::{stdout, Write};

 #[derive(Debug)]
 pub enum Error {
    OpenFile,
-    WriteFile,
+    Switch(domain::switch::Error),
 }

 impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::OpenFile => f.write_str("Cannot open file"),
-            Error::WriteFile => f.write_str("Cannot write file"),
+            Error::Switch(inner) => write!(f, "Cannot switch between states: {}", inner),
        }
    }
 }
@ -41,51 +38,19 @@ impl std::error::Error for Error {}
 pub fn execute(args: &Args) -> Result<(), Error> {
    let content = std::fs::read_to_string(&args.file).map_err(|_| Error::OpenFile)?;

-    if args.dry_run {
-        println!("Your file will be changed to the following")
-    }
+    let writer: Box<dyn Write> = if args.dry_run {
+        Box::new(stdout())
+    } else {
+        Box::new(
+            File::create(args.output.as_ref().unwrap_or(&args.file))
+                .map_err(|_| Error::OpenFile)?,
+        )
+    };

-    let fs_writer = (!args.dry_run)
-        .then(|| {
-            File::create(args.output.as_ref().unwrap_or(&args.file)).map_err(|_| Error::OpenFile)
-        })
-        .transpose()?;
-
-    #[cfg(feature = "color")]
-    let color = args.color.clone();
-
-    println!();
-
-    let new_content = domain::switch::execute(domain::switch::Request {
-        content: &content.trim(),
+    domain::switch::execute(domain::switch::Request {
+        content: &content,
+        writer,
        sections: &args.sections,
-        on_line: Some(Box::new(move |line| {
-            #[cfg(feature = "color")]
-            print_line(line, color.clone());
-            #[cfg(not(feature = "color"))]
-            print!("{}", line)
-        })),
-    });
-
-    println!();
-
-    if let Some(mut fs_writer) = fs_writer {
-        fs_writer
-            .write_all(new_content.as_bytes())
-            .map_err(|_| Error::WriteFile)?;
-    }
-
-    Ok(())
-}
-
-#[cfg(feature = "color")]
-fn print_line(line: &String, color: crate::cli::ColorVariant) {
-    let mut stdout = StandardStream::stdout(color.into());
-    let color = line
-        .starts_with("###")
-        .then_some(Color::Yellow)
-        .or_else(|| (!line.starts_with("#")).then_some(Color::Green));
-    stdout.set_color(ColorSpec::new().set_fg(color)).ok();
-    write!(&mut stdout, "{}", line).unwrap();
-    stdout.reset().ok();
+    })
+    .map_err(Error::Switch)
 }
--- a/src/domain.rs
+++ b/src/domain.rs
@ -1,4 +1,4 @@
-//! Copyright (C) 2022, Dmitriy Pleshevskiy <dmitriy@pleshevski.ru>
+//! Copyright (C) 2022, Dmitriy Pleshevskiy <dmitriy@ideascup.me>
 //!
 //! vnetod is free software: you can redistribute it and/or modify
 //! it under the terms of the GNU General Public License as published by
@ -44,7 +44,7 @@ impl Section {
    }
 }

-pub struct SectionInfo {
+struct SectionInfo {
    enable_variable: bool,
    disable_variable: bool,
 }
--- a/src/domain/switch.rs
+++ b/src/domain/switch.rs
@ -1,4 +1,4 @@
-//! Copyright (C) 2022, Dmitriy Pleshevskiy <dmitriy@pleshevski.ru>
+//! Copyright (C) 2022, Dmitriy Pleshevskiy <dmitriy@ideascup.me>
 //!
 //! vnetod is free software: you can redistribute it and/or modify
 //! it under the terms of the GNU General Public License as published by
@ -14,32 +14,54 @@
 //! along with vnetod.  If not, see <https://www.gnu.org/licenses/>.
 //!

+use std::io::{BufWriter, Write};
+
 use super::{Section, SectionInfo};

-pub type OnLineFn = Box<dyn Fn(&String)>;
-
-pub struct Request<'args> {
-    pub content: &'args str,
-    pub sections: &'args [String],
-    pub on_line: Option<OnLineFn>,
+#[derive(Debug)]
+pub enum Error {
+    WriteData,
 }

-pub fn execute(req: Request) -> String {
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::WriteData => f.write_str("Cannot write data"),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+pub struct Request<'args, W>
+where
+    W: Write,
+{
+    pub content: &'args str,
+    pub writer: W,
+    pub sections: &'args [String],
+}
+
+pub fn execute<W>(req: Request<W>) -> Result<(), Error>
+where
+    W: Write,
+{
+    let mut writer = BufWriter::new(req.writer);
+
    let choose_sections = req
        .sections
        .iter()
        .map(|s| Section::parse(s.as_str()))
        .collect::<Vec<_>>();

-    let mut current_section: Option<SectionInfo> = None;
-    let mut new_content = String::new();
+    let mut current_sections: Option<SectionInfo> = None;

    for line in req.content.split_inclusive('\n') {
        let new_line = if is_section_end(line) {
-            current_section = None;
+            current_sections = None;
            line.to_string()
        } else if let Some(section_info) = line.strip_prefix("### ") {
-            current_section = section_info.split_whitespace().next().map(|r| {
+            current_sections = section_info.split_whitespace().next().map(|r| {
                let current_sections = r.split(',').map(Section::parse).collect::<Vec<_>>();
                SectionInfo {
                    enable_variable: should_enable_variable(&choose_sections, &current_sections),
@ -47,7 +69,7 @@ pub fn execute(req: Request) -> String {
                }
            });
            line.to_string()
-        } else if let Some(section_info) = current_section.as_ref() {
+        } else if let Some(section_info) = current_sections.as_ref() {
            let trimmed_line = line.trim_start_matches(['#', ' ']);
            let is_var = is_variable(trimmed_line);
            if is_var && section_info.enable_variable {
@ -61,13 +83,12 @@ pub fn execute(req: Request) -> String {
            line.to_string()
        };

-        new_content.push_str(&new_line);
-        if let Some(on_line) = req.on_line.as_ref() {
-            on_line(&new_line);
-        }
+        writer
+            .write_all(new_line.as_bytes())
+            .map_err(|_| Error::WriteData)?;
    }

-    new_content
+    writer.flush().map_err(|_| Error::WriteData)
 }

 fn is_variable(trimmed_line: &str) -> bool {
@ -123,19 +144,28 @@ fn should_disable_variable(choose_sections: &[Section], current_sections: &[Sect
 #[cfg(test)]
 mod tests {
    use super::*;
+    use std::io::Cursor;

    const BASE_ENV: &str = include_str!("../../test_data/base_env");

    fn make_test(input: &str, expected_output: &str, sections: Vec<&str>) {
-        let output_data = execute(Request {
+        let mut output_data = vec![];
+        let writer = Cursor::new(&mut output_data);
+
+        match execute(Request {
            content: input,
+            writer,
            sections: &sections.into_iter().map(String::from).collect::<Vec<_>>(),
-            on_line: None,
-        });
-        assert_eq!(
-            output_data.lines().collect::<Vec<_>>(),
-            expected_output.lines().collect::<Vec<_>>()
-        );
+        }) {
+            Ok(()) => {
+                let output = String::from_utf8(output_data).unwrap();
+                assert_eq!(
+                    output.lines().collect::<Vec<_>>(),
+                    expected_output.lines().collect::<Vec<_>>()
+                );
+            }
+            _ => unreachable!(),
+        }
    }

    #[test]
--- a/src/main.rs
+++ b/src/main.rs
@ -1,4 +1,4 @@
-//! Copyright (C) 2022, Dmitriy Pleshevskiy <dmitriy@pleshevski.ru>
+//! Copyright (C) 2022, Dmitriy Pleshevskiy <dmitriy@ideascup.me>
 //!
 //! vnetod is free software: you can redistribute it and/or modify
 //! it under the terms of the GNU General Public License as published by