Rework commands to be string based

This allows for significantly more flexibility and should make
implementing the bind command possible.

1 files changed, 0 insertions, 154 deletions

diff --git a/src/Command.zig b/src/Command.zig
deleted file mode 100644
index 0632e5c..0000000
--- a/src/Command.zig
+++ /dev/null
@@ -1,154 +0,0 @@
-// This file is part of river, a dynamic tiling wayland compositor.
-//
-// Copyright 2020 Isaac Freund
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program. If not, see <https://www.gnu.org/licenses/>.
-
-const Self = @This();
-
-const std = @import("std");
-
-const Seat = @import("Seat.zig");
-
-const command = struct {
-    const close = @import("command/close.zig").close;
-    const exit = @import("command/exit.zig").exit;
-    const focus = @import("command/focus.zig").focus;
-    const focusAllTags = @import("command/focus_all_tags.zig").focusAllTags;
-    const focusOutput = @import("command/focus_output.zig").focusOutput;
-    const focusTag = @import("command/focus_tag.zig").focusTag;
-    const layout = @import("command/layout.zig").layout;
-    const modMasterCount = @import("command/mod_master_count.zig").modMasterCount;
-    const modMasterFactor = @import("command/mod_master_factor.zig").modMasterFactor;
-    const mode = @import("command/mode.zig").mode;
-    const sendToOutput = @import("command/send_to_output.zig").sendToOutput;
-    const spawn = @import("command/spawn.zig").spawn;
-    const tagView = @import("command/tag_view.zig").tagView;
-    const tagViewAllTags = @import("command/tag_view_all_tags.zig").tagViewAllTags;
-    const toggleFloat = @import("command/toggle_float.zig").toggleFloat;
-    const toggleTagFocus = @import("command/toggle_tag_focus.zig").toggleTagFocus;
-    const toggleViewTag = @import("command/toggle_view_tag.zig").toggleViewTag;
-    const zoom = @import("command/zoom.zig").zoom;
-};
-
-const Direction = enum {
-    Next,
-    Prev,
-};
-
-pub const Arg = union(enum) {
-    int: i32,
-    uint: u32,
-    float: f64,
-    str: []const u8,
-    direction: Direction,
-    none: void,
-
-    fn parse(
-        arg_type: @TagType(Arg),
-        args: []const []const u8,
-        allocator: *std.mem.Allocator,
-    ) !Arg {
-        switch (arg_type) {
-            .int, .uint, .float, .direction => {
-                if (args.len == 0) return error.NotEnoughArguments;
-                if (args.len > 1) return error.TooManyArguments;
-                return switch (arg_type) {
-                    .int => .{ .int = try std.fmt.parseInt(i32, args[0], 10) },
-                    .uint => .{ .uint = try std.fmt.parseInt(u32, args[0], 10) },
-                    .float => .{ .float = try std.fmt.parseFloat(f64, args[0]) },
-                    .direction => if (std.mem.eql(u8, args[0], "next"))
-                        Arg{ .direction = .Next }
-                    else if (std.mem.eql(u8, args[0], "previous"))
-                        Arg{ .direction = .Prev }
-                    else
-                        error.InvalidDirection,
-                    else => unreachable,
-                };
-            },
-            .str => {
-                if (args.len == 0) return error.NotEnoughArguments;
-                return Arg{ .str = try std.mem.join(allocator, " ", args) };
-            },
-            .none => return if (args.len == 0) .{ .none = {} } else error.TooManyArguments,
-        }
-    }
-};
-
-const ImplFn = fn (seat: *Seat, arg: Arg) void;
-
-const Definition = struct {
-    name: []const u8,
-    arg_type: @TagType(Arg),
-    impl: ImplFn,
-};
-
-// zig fmt: off
-const str_to_read_fn = [_]Definition{
-    .{ .name = "close",             .arg_type = .none,      .impl = command.close },
-    .{ .name = "exit",              .arg_type = .none,      .impl = command.exit },
-    .{ .name = "focus",             .arg_type = .direction, .impl = command.focus },
-    .{ .name = "focus_all_tags",    .arg_type = .none,      .impl = command.focusAllTags },
-    .{ .name = "focus_output",      .arg_type = .direction, .impl = command.focusOutput },
-    .{ .name = "focus_tag",         .arg_type = .uint,      .impl = command.focusTag },
-    .{ .name = "layout",            .arg_type = .str,       .impl = command.layout},
-    .{ .name = "mod_master_count",  .arg_type = .int,       .impl = command.modMasterCount },
-    .{ .name = "mod_master_factor", .arg_type = .float,     .impl = command.modMasterFactor },
-    .{ .name = "mode",              .arg_type = .str,       .impl = command.mode },
-    .{ .name = "send_to_output",    .arg_type = .direction, .impl = command.sendToOutput },
-    .{ .name = "spawn",             .arg_type = .str,       .impl = command.spawn },
-    .{ .name = "tag_view",          .arg_type = .uint,      .impl = command.tagView },
-    .{ .name = "tag_view_all_tags", .arg_type = .none,      .impl = command.tagViewAllTags },
-    .{ .name = "toggle_float",      .arg_type = .none,      .impl = command.toggleFloat },
-    .{ .name = "toggle_tag_focus",  .arg_type = .uint,      .impl = command.toggleTagFocus },
-    .{ .name = "toggle_view_tag",   .arg_type = .uint,      .impl = command.toggleViewTag },
-    .{ .name = "zoom",              .arg_type = .none,      .impl = command.zoom },
-};
-// zig fmt: on
-
-pub const Error = error{
-    NoCommand,
-    UnknownCommand,
-    NotEnoughArguments,
-    TooManyArguments,
-    Overflow,
-    InvalidCharacter,
-    InvalidDirection,
-    OutOfMemory,
-};
-
-impl: ImplFn,
-arg: Arg,
-
-pub fn init(args: []const []const u8, allocator: *std.mem.Allocator) Error!Self {
-    if (args.len == 0) return error.NoCommand;
-    const name = args[0];
-
-    const definition = for (str_to_read_fn) |definition| {
-        if (std.mem.eql(u8, name, definition.name)) break definition;
-    } else return error.UnknownCommand;
-
-    return Self{
-        .impl = definition.impl,
-        .arg = try Arg.parse(definition.arg_type, args[1..], allocator),
-    };
-}
-
-pub fn deinit(self: Self, allocator: *std.mem.Allocator) void {
-    if (self.arg == .str) allocator.free(self.arg.str);
-}
-
-pub fn run(self: Self, seat: *Seat) void {
-    self.impl(seat, self.arg);
-}