Thread local fallback

[divergentdave]

This PR provides a failing test to reproduce the issue described in #145, and fixes the issue as described by handling the AccessError.

[KodrAus]

Thanks for the PR @divergentdave!

It looks like we're accumulating a bit of logic in this method so maybe it's time to refactor it a bit into something more manageable. I was thinking we could just inline the write call into the places where we have a Formatter. So something like (probably doesn't actually compile):

let print = |formatter, record| {
    let _ = (self.format)(&mut formatter, record)
        .and_then(|_| formatter.print(&self.writer));
    formatter.clear();
}

let printed = FORMATTER.try_with(|tl_buf| {
    match tl_buf.try_borrow_mut() {
        // There are no active borrows of the buffer
        Ok(ref mut tl_buf) => match tl_buf {
            // We have a previously set formatter
            Some(ref mut formatter) => {
                if formatter.write_style() != self.writer.write_style() {
                    *formatter = Formatter::new(&self.writer)
                }

                print(formatter, record);
            },
            // We don't have a previously set formatter
            None => {
                let mut formatter = Formatter::new(&self.writer);
                print(formatter, record);

                *tl_buf = Some(formatter);
            }
        }
        // There's already an active borrow of the buffer
        Err(_) => {
            print(&mut Formatter::new(&self.writer), record);
        }
    }
}).is_ok();

if !printed {
    print(&mut Formatter::new(&self.writer), record);
}

What do you think?

[divergentdave]

Sounds good, I'll split that out

[KodrAus]

Thanks @divergentdave! This looks good to me