toss 2.1.1

A throw-catch style move and copy program.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

{
  description = "A throw-catch style move and copy program";

  inputs = {
    nixpkgs.url = "https://flakehub.com/f/NixOS/nixpkgs/0.1.*.tar.gz";
    rust-overlay = {
      url = "github:oxalica/rust-overlay";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    flake-utils.url = "github:numtide/flake-utils";
  };

  outputs = { self, nixpkgs, rust-overlay, flake-utils }:
    let
      supportedSystems = [ "x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin" ];
      forEachSupportedSystem = nixpkgs.lib.genAttrs supportedSystems;
      
      # Function to get the Toss package for a system
      packageFor = system:
        let
          pkgs = import nixpkgs {
            inherit system;
            overlays = [ (import rust-overlay) self.overlays.default ];
          };
        in pkgs.toss;
      
      # Read package version from Cargo.toml
      version = "1.1.1"; # Use static version for simplicity
    in
    {
      overlays.default = final: prev: {
        toss = final.rustPlatform.buildRustPackage {
          pname = "toss";
          inherit version;
          
          src = ./.;
          
          cargoLock = {
            lockFile = ./Cargo.lock;
          };
          
          nativeBuildInputs = with final; [
            pkg-config
          ];
          
          buildInputs = with final; [
            openssl
          ];
          
          meta = with final.lib; {
            description = "A throw-catch style move and copy program";
            homepage = "https://github.com/scientiac/toss";
            license = licenses.gpl3;
            maintainers = with maintainers; [ ];
          };
        };
      };
      
      # Packages for each supported system
      packages = forEachSupportedSystem (system: {
        default = packageFor system;
        toss = packageFor system;
      });
      
      # NixOS module
      nixosModules.default = { config, lib, pkgs, ... }:
        let
          cfg = config.programs.toss;
        in
        with lib; {
          options.programs.toss = {
            enable = mkEnableOption "toss program";
            package = mkOption {
              type = types.package;
              description = "The toss package to use.";
              default = self.packages.${pkgs.system}.toss;
            };
          };
          
          config = mkIf cfg.enable {
            environment.systemPackages = [ cfg.package ];
          };
        };
      
      # Home Manager module that doesn't depend on system-specific logic
      homeManagerModules.default = { config, lib, pkgs, ... }:
        let
          cfg = config.programs.toss;
        in
        with lib; {
          options.programs.toss = {
            enable = mkEnableOption "toss program";
            package = mkOption {
              type = types.package;
              description = "The toss package to use.";
              default = self.packages.${pkgs.system}.toss;
            };
          };
          
          config = mkIf cfg.enable {
            home.packages = [ cfg.package ];
          };
        };
      
      # Development shell
      devShells = forEachSupportedSystem (system:
        let
          pkgs = import nixpkgs {
            inherit system;
            overlays = [ (import rust-overlay) ];
          };
          
          rustToolchain =
            let
              rust = pkgs.rust-bin;
            in
            if builtins.pathExists ./rust-toolchain.toml then
              rust.fromRustupToolchainFile ./rust-toolchain.toml
            else if builtins.pathExists ./rust-toolchain then
              rust.fromRustupToolchainFile ./rust-toolchain
            else
              rust.stable.latest.default.override {
                extensions = [ "rust-src" "rustfmt" ];
              };
        in {
          default = pkgs.mkShell {
            packages = with pkgs; [
              rustToolchain
              openssl
              pkg-config
              cargo-deny
              cargo-edit
              cargo-watch
              rust-analyzer
            ];
            shellHook = ''
              echo "Developing Toss!"
            '';
            env = {
              # Required by rust-analyzer
              RUST_SRC_PATH = "${rustToolchain}/lib/rustlib/src/rust/library";
            };
          };
        }
      );
    };
}