daxvena/elemeld - Change 2ZDRU4SSJJ4LJVQRQUZMD662TPJQTHQKDPZFMERPKTLNCHHDIUTQC

Use shorter matching syntax where possible

Created by daxvena on March 31, 2016

2ZDRU4SSJJ4LJVQRQUZMD662TPJQTHQKDPZFMERPKTLNCHHDIUTQC

Dependencies

In channels

main

Change contents

Replacement in Cargo.lock at line 81 [6.34]

B:BD[4.435] → [5.206:279]

 "regex 0.1.59 (registry+https://github.com/rust-lang/crates.io-index)",

[4.435]

[4.508]

 "regex 0.1.61 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 116 [6.34]

B:BD[7.566] → [5.280:353]

 "regex 0.1.59 (registry+https://github.com/rust-lang/crates.io-index)",

[7.566]

[6.1643]

 "regex 0.1.61 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 266 [6.34]
B:BD[7.874] → [5.909:928]
```
version = "0.1.59"
```
[7.874]
[7.893]
```
version = "0.1.61"
```

Replacement in src/cluster.rs at line 31 [9.13]

B:BD[8.272] → [8.272:410]

B:BD[8.410] → [10.0:68]

∅:D[7.1620] → [8.481:540]

∅:D[10.68] → [8.481:540]

B:BD[8.481] → [8.481:540]

            Ok(file) => match serde_json::from_reader(file) {
                Ok(screens) => Some(screens),
                Err(err) => {
                    warn!("Failed to parse screens.json: {}", err);
                    None
                },
            },

[8.272]

[7.1621]

            Ok(file) => serde_json::from_reader(file).map_err(|err| {
                warn!("Failed to parse screens.json: {}", err);
            }).ok(),

Replacement in src/elemeld.rs at line 32 [9.8294]
∅:D[11.838] → [12.1041:1071]
B:BD[9.8478] → [12.1041:1071]
```
#[derive(Clone, Copy, Debug)]
```
[11.838]
[9.8508]
```
#[derive(PartialEq, Clone, Copy, Debug)]
```

Replacement in src/elemeld.rs at line 88 [9.8294]

∅:D[11.1736] → [9.8993:9020]

∅:D[13.2074] → [9.8993:9020]

B:BD[9.8993] → [9.8993:9020]

B:BD[9.9020] → [11.1737:1910]

B:BD[11.1910] → [5.5645:5750]

∅:D[5.5750] → [13.2200:2477]

B:BD[13.2200] → [13.2200:2477]

∅:D[13.2477] → [11.2018:2192]

B:BD[11.2018] → [11.2018:2192]

B:BD[11.2192] → [5.5751:5814]

∅:D[5.5814] → [13.2540:2693]

B:BD[13.2540] → [13.2540:2693]

∅:D[13.2693] → [11.2250:2273]

B:BD[11.2250] → [11.2250:2273]

        match self.state {
            State::Connected => match self.cluster.process_host_event(&self.host, event) {
                Some(event) => match event {
                    // Global events
                    NetEvent::Focus(_) => {
                        match self.net.send_to_all(&event) {
                            Err(e) => {
                                error!("Failed to send event to cluster: {}", e);
                                self.state = State::Waiting;
                            }
                            _ => (),
                        };
                    },
                    // Focused events
                    event => {
                        let addr = self.cluster.focused_screen().default_route();
                        match self.net.send_to(&event, addr) {
                            Err(e) => error!("Failed to send event to {}: {}", addr, e),
                            _ => (),
                        };
                    },

[13.2074]

[14.671]

        if self.state != State::Connected { return }
        if let Some(event) = self.cluster.process_host_event(&self.host, event) {
            match event {
                // Global events
                NetEvent::Focus(_) => {
                    if let Err(err) = self.net.send_to_all(&event) {
                        error!("Failed to send event to cluster: {}", err);
                        self.state = State::Waiting;
                    }

Replacement in src/elemeld.rs at line 99 [9.8294]

∅:D[14.690] → [9.9171:9235]

B:BD[9.9171] → [9.9171:9235]

                None => (),
            },
            _ => (),

[14.690]

[9.9235]

                // Focused events
                event => {
                    let addr = self.cluster.focused_screen().default_route();
                    if let Err(err) = self.net.send_to(&event, addr) {
                        error!("Failed to send event to {}: {}", addr, err);
                    }
                },
            }

Replacement in src/elemeld.rs at line 128 [9.8294]

B:BD[5.6070] → [5.6070:6287]

                match self.net.send_to(&NetEvent::Cluster(self.cluster.clone()), addr) {
                    Err(err) => error!("Failed to passively connect: {}", err),
                    _ => (),
                };

[5.6070]

[11.2809]

                if let Err(err) = self.net.send_to(&NetEvent::Cluster(self.cluster.clone()), addr) {
                    error!("Failed to passively connect: {}", err);
                }

Replacement in src/elemeld.rs at line 140 [9.8294]

B:BD[11.2998] → [11.2998:3158]

            event => match self.cluster.process_net_event(event) {
                Some(event) => { self.host.send_event(event); },
                None => (),

[11.2998]

[11.3158]

            event => if let Some(event) = self.cluster.process_net_event(event) {
                self.host.send_event(event);

Replacement in src/elemeld.rs at line 154 [9.8294]

B:BD[5.6737] → [5.6737:6804]

            _ => unreachable!("Cannot broadcast without clients"),

[5.6737]

[11.3173]

            None => unreachable!("Cannot broadcast without clients"),

Replacement in src/elemeld.rs at line 173 [9.8294]

B:BD[2.219] → [2.219:437]

                    loop {
                        match self.host.recv_event() {
                            Some(event) => self.host_event(event),
                            None => break,
                        }

[2.219]

[11.3623]

                    while let Some(event) = self.host.recv_event() {
                        self.host_event(event);

Replacement in src/elemeld.rs at line 190 [9.8294]

B:BD[11.4123] → [3.257:356]

∅:D[5.7055] → [13.3563:3717]

∅:D[3.356] → [13.3563:3717]

B:BD[13.3563] → [13.3563:3717]

                            match self.net.send_to_all(&NetEvent::Connect(self.cluster.clone())) {
                                Err(err) => error!("Failed to connect: {}", err),
                                _ => (),
                            };

[11.4123]

[13.3717]

                            if let Err(err) = self.net.send_to_all(&NetEvent::Connect(self.cluster.clone())) {
                                error!("Failed to connect: {}", err);
                            }

Replacement in src/ip.rs at line 58 [9.11607]

B:BD[9.13451] → [13.5713:5761]

B:BD[13.5761] → [15.1315:1354]

        match self.socket.recv_from(&mut buf) {
            Ok(Some((len, addr))) => {

[9.13451]

[15.1354]

        self.socket.recv_from(&mut buf).map(|result| {
            result.map(|(len, addr)| {

Replacement in src/ip.rs at line 62 [9.11607]
B:BD[15.1515] → [15.1515:1555]
∅:D[13.6077] → [9.14179:14194]
∅:D[15.1555] → [9.14179:14194]
B:BD[9.14179] → [9.14179:14194]
B:BD[9.14194] → [13.6078:6146]
∅:D[13.6146] → [9.14220:14230]
B:BD[9.14220] → [9.14220:14230]
```
                Ok(Some((event, addr)))
            },
            Ok(None) => Ok(None),
            Err(err) => Err(err),
        }
```
[15.1515]
[9.14230]
```
                (event, addr)
            })
        })
```

Replacement in src/util.rs at line 13 [17.3673]

B:BD[16.758] → [16.758:1000]

    match gethostname(&mut buf) {
        Ok(_) => {
            let len = unsafe { strlen(mem::transmute(&buf as *const u8)) };
            Ok(String::from_utf8_lossy(&buf[..len]).into_owned())
        },
        Err(err) => Err(err),
    }

[16.758]

[16.1000]

    gethostname(&mut buf).map(|_| {
        let len = unsafe { strlen(mem::transmute(&buf as *const u8)) };
        String::from_utf8_lossy(&buf[..len]).into_owned()
    })

Replacement in src/util.rs at line 55 [17.3673]

B:BD[8.906] → [8.906:1023]

    match env::home_dir() {
        Some(base) => Some(base.join(".config").join(name)),
        None => None,
    }

[8.906]

[8.1023]

    env::home_dir().map(|base| {
        base.join(".config").join(name)
    })