docs: fix example in readme and clean things up a bit

Signed-off-by: Paul Osborne <[email protected]>

Author: posborne

Cargo.toml

@@ -18,11 +18,11 @@ https://www.kernel.org/doc/Documentation/i2c/dev-interface
 libc = "^0.2.7"
 bitflags = "^0.5.0"
 byteorder = "^0.4.2"
-nix = "^0.5.0"
+nix = "^0.6.0"
 
 [dev-dependencies]
 docopt = "^0.6.78"
-skeptic = "0.4"
+skeptic = "^0.5"
 
 [build-dependencies]
-skeptic = "0.4"
+skeptic = "^0.5"

README.md

@@ -20,56 +20,44 @@ The source includes an example of using the library to talk to a Wii
 Nunchuck (which has an i2c interface).
 [Go View the Example](https://github.com/rust-embedded/rust-i2cdev/blob/master/examples/nunchuck.rs).
 
-Here's a real quick example showing the guts of how you create a
+Here's a real quick example showing the guts of how you create
 device and start talking to it...  This device only requires basic
 functions (read/write) which are done via the Read/Write traits (if
 you actually want to use the Wii Nunchuck you should use
 [`i2cdev::sensors::nunchuck::Nunchuck`][nunchuck]:
 
-```rust
+```rust,no_run
 extern crate i2cdev;
-use i2cdev::*;
+
 use std::thread;
+use std::time::Duration;
+
+use i2cdev::core::*;
+use i2cdev::linux::{LinuxI2CDevice, LinuxI2CError};
 
 const NUNCHUCK_SLAVE_ADDR: u16 = 0x52;
 
 // real code should probably not use unwrap()
-fn i2cfun() -> Result<(), I2CError> {
-    let mut dev = try!(I2CDevice::new("/dev/i2c-1", NUNCHUCK_SLAVE_ADDR));
+fn i2cfun() -> Result<(), LinuxI2CError> {
+    let mut dev = try!(LinuxI2CDevice::new("/dev/i2c-1", NUNCHUCK_SLAVE_ADDR));
 
     // init sequence
-    try!(self.i2cdev.smbus_write_byte_data(0xF0, 0x55));
-    try!(self.i2cdev.smbus_write_byte_data(0xFB, 0x00));
-    thread::sleep_ms(100);
+    try!(dev.smbus_write_byte_data(0xF0, 0x55));
+    try!(dev.smbus_write_byte_data(0xFB, 0x00));
+    thread::sleep(Duration::from_millis(100));
 
     loop {
-        let mut buf: [u8: 6] = [0: 6];
-        self.i2cdev.smbus_write_byte(0x00).unwrap();
-        thread::sleep_ms(10);
-        self.i2cdev.read(&mut buf).unwrap();
+        let mut buf: [u8; 6] = [0; 6];
+        dev.smbus_write_byte(0x00).unwrap();
+        thread::sleep(Duration::from_millis(10));
+        dev.read(&mut buf).unwrap();
         println!("Reading: {:?}", buf);
     }
 }
 ```
 
 In addition to the Read/Write traits, the following methods are
-available via the I2CSMBus trait:
-
-```rust
-pub trait I2CSMBus {
-    fn smbus_write_quick(&self, bit: bool) -> Result<(), Error>;
-    fn smbus_read_byte(&self) -> Result<u8, Error>;
-    fn smbus_write_byte(&self, value: u8) -> Result<(), Error>;
-    fn smbus_read_byte_data(&self, register: u8) -> Result<u8, Error>;
-    fn smbus_write_byte_data(&self, register: u8, value: u8) -> Result<(), Error>;
-    fn smbus_read_word_data(&self, register: u8) -> Result<u16, Error>;
-    fn smbus_write_word_data(&self, register: u8, value: u16) -> Result<(), Error>;
-    fn smbus_process_word(&self, register: u8, value: u16) -> Result<u16, Error>;
-    fn smbus_read_block_data(&self, register: u8) -> Result<Vec<u8>, Error>;
-    fn smbus_write_block_data(&self, register: u8, values: &[u8]) -> Result<(), Error>;
-    fn smbus_process_block(&self, register: u8, values: &[u8]) -> Result<(), Error>;
-}
-```
+available via the [I2CDevice trait](https://rust-embedded.github.io/rust-i2cdev/i2cdev/core/trait.I2CDevice.html).
 
 [nunchuck]: http://rust-embedded.github.io/rust-i2cdev/i2cdev/sensors/nunchuck/struct.Nunchuck.html
 
@@ -82,7 +70,7 @@ The following features are implemented and planned for the library:
 - [x] Implement the Write trait
 - [x] Implement SMBus Methods
 - [x] Add Tests/Example for SMBus Methods
-- [/] Add sensor library for handy sensors (and examples)
+- [x] Add sensor library for handy sensors (and examples)
 - [ ] Add higher-level APIs/Macros for simplifying access to devices
       with large register sets
 - [ ] Add Support for Non-SMBus ioctl methods
@@ -94,37 +82,17 @@ Cross Compiling
 
 Most likely, the machine you are running on is not your development
 machine (although it could be).  In those cases, you will need to
-cross-compile.  The following basic instructions should work for the
-raspberry pi or beaglebone black:
-
-1. Install rust and cargo
-2. Install an appropriate cross compiler.  On an Ubuntu system, this
-   can be done by doing `sudo apt-get install g++-arm-linux-gnueabihf`.
-3. Build or install rust for your target.  This is necessary in order
-   to have libstd available for your target.  For arm-linux-gnueabihf,
-   you can find binaries at https://github.com/japaric/ruststrap.
-   With this approach or building it yourself, you will need to copy
-   the ${rust}/lib/rustlib/arm-unknown-linux-gnueabihf to your system
-   rust library folder (it is namespaced by triple, so it shouldn't
-   break anything).
-4. Tell cargo how to link by adding the lines below to your
-   ~/.cargo/config file.
-5. Run your build `cargo build --target=arm-unknown-linux-gnueabi`.
-
-The following snippet added to my ~/.cargo/config worked for me:
-
-```
-[target.arm-unknown-linux-gnueabihf]
-linker = "arm-linux-gnueabihf-gcc"
-```
+cross-compile.  See https://github.com/japaric/rust-cross for pointers.
 
 License
 -------
 
+```
 Copyright (c) 2015, Paul Osborne <[email protected]>
 
 Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
 http://www.apache.org/license/LICENSE-2.0> or the MIT license
 <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 option.  This file may not be copied, modified, or distributed
 except according to those terms.
+```

build.rs

@@ -0,0 +1,14 @@
+// Copyright 2016, Paul Osborne <[email protected]>
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/license/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option.  This file may not be copied, modified, or distributed
+// except according to those terms.
+
+extern crate skeptic;
+
+fn main() {
+    // generate tests for README.md using skeptic
+    skeptic::generate_doc_tests(&["README.md"]);
+}

tests/skeptic.rs

@@ -0,0 +1,9 @@
+// Copyright 2016, Paul Osborne <[email protected]>
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/license/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option.  This file may not be copied, modified, or distributed
+// except according to those terms.
+
+include!(concat!(env!("OUT_DIR"), "/skeptic-tests.rs"));