Merge pull request #3 from thejpster/master

Added Pressure

Author: thejpster

.gitignore

@@ -1,2 +1,4 @@
 target
 Cargo.lock
+*.bk
+

Cargo.toml

@@ -1,9 +1,10 @@
 [package]
 name = "measurements"
-version = "0.2.1"
-authors = ["James O'Cull <[email protected]>"]
-documentation = "https://jocull.github.io/rust-measurements/"
+version = "0.3.0"
+authors = ["James O'Cull <[email protected]>", "Jonathan Pallant <[email protected]"]
+documentation = "https://docs.rs/crate/measurements"
 repository = "https://github.com/jocull/rust-measurements"
 keywords = ["measurements", "lengths", "weights", "temperatures", "volumes"]
-description = "Handle metric, imperial, and other measurements with ease! Types: Length, Temperature, Weight, Volume"
+description = "Handle metric, imperial, and other measurements with ease! Types: Length, Temperature, Weight, Volume, Pressure"
 license = "MIT"
+readme = "README.md"

README.md

@@ -22,44 +22,51 @@ Conversions to and from different units are simple, and operator overrides allow
 - Temperature
 - Weight
 - Volume
+- Pressure
 
 ### Examples
 
 In your Cargo.toml add the dependency...
 
-```
+```toml
 [dependencies]
-measurements = "^0.2.1"
+measurements = "^0.3.0"
 ```
 
 In your code...
 
 ```rust
 extern crate measurements;
 
-use measurements::{Length, Temperature, Weight, Volume};
-
-// Lengths!
-let football_field = Length::from_yards(100.0);
-let meters = football_field.as_meters();
-println!("There are {} meters in a football field.", meters);
-
-/// Temperatures!
-let boiling_water = Temperature::from_celsius(100.0);
-let fahrenheit = boiling_water.as_fahrenheit();
-println!("Boiling water measures at {} degrees fahrenheit.", fahrenheit);
-
-// Weights!
-let metric_ton = Weight::from_metric_tons(1.0);
-let united_states_tons = metric_ton.as_short_tons();
-let united_states_pounds = metric_ton.as_pounds();
-println!("One metric ton is {} U.S. tons - that's {} pounds!", united_states_tons, united_states_pounds);
-
-// Volumes!
-let gallon = Volume::from_gallons(1.0);
-let pint = Volume::from_pints(1.0);
-let beers = gallon / pint;
-println!("A gallon of beer will pour {} pints!", beers);
+use measurements::{Length, Pressure, Temperature, Volume, Weight};
+
+fn main() {
+    // Lengths!
+    let football_field = Length::from_yards(100.0);
+    let meters = football_field.as_meters();
+    println!("There are {} meters in a football field.", meters);
+
+    /// Temperatures!
+    let boiling_water = Temperature::from_celsius(100.0);
+    let fahrenheit = boiling_water.as_fahrenheit();
+    println!("Boiling water measures at {} degrees fahrenheit.", fahrenheit);
+
+    // Weights!
+    let metric_ton = Weight::from_metric_tons(1.0);
+    let united_states_tons = metric_ton.as_short_tons();
+    let united_states_pounds = metric_ton.as_pounds();
+    println!("One metric ton is {} U.S. tons - that's {} pounds!", united_states_tons, united_states_pounds);
+
+    // Volumes!
+    let gallon = Volume::from_gallons(1.0);
+    let pint = Volume::from_pints(1.0);
+    let beers = gallon / pint;
+    println!("A gallon of beer will pour {:.1} pints!", beers);
+
+    // Pressures!
+    let atmosphere = Pressure::from_atmospheres(1.0);
+    println!("Earth's atmosphere is usually {} psi", atmosphere.as_psi());
+}
 ```
 
 --------------------------------------

src/length.rs

@@ -18,126 +18,126 @@ const METER_MILE_FACTOR: f64 = 0.000621371192237;
 
 /// The `Length` struct can be used to deal with lengths in a common way.
 /// Common metric and imperial units are supported.
-/// 
+///
 /// # Example
-/// 
+///
 /// ```
 /// use measurements::Length;
-/// 
+///
 /// let football_field = Length::from_yards(100.0);
 /// let meters = football_field.as_meters();
 /// println!("There are {} meters in a football field.", meters);
 /// ```
 #[derive(Copy, Clone, Debug)]
 pub struct Length {
-    meters: f64
+    meters: f64,
 }
 
 impl Length {
     // Inputs, metric
     pub fn from_meters(meters: f64) -> Self {
         Length { meters: meters }
     }
-    
+
     pub fn from_nanometers(nanometers: f64) -> Self {
         Self::from_meters(nanometers / METER_NANOMETER_FACTOR)
     }
-    
+
     pub fn from_micrometers(micrometers: f64) -> Self {
         Self::from_meters(micrometers / METER_MICROMETER_FACTOR)
     }
-    
+
     pub fn from_millimeters(millimeters: f64) -> Self {
         Self::from_meters(millimeters / METER_MILLIMETER_FACTOR)
     }
-    
+
     pub fn from_centimeters(centimeters: f64) -> Self {
         Self::from_meters(centimeters / METER_CENTIMETER_FACTOR)
     }
-    
+
     pub fn from_decameters(decameters: f64) -> Self {
         Self::from_meters(decameters / METER_DECAMETER_FACTOR)
     }
-    
+
     pub fn from_hectometers(hectometers: f64) -> Self {
         Self::from_meters(hectometers / METER_HECTOMETER_FACTOR)
     }
-    
+
     pub fn from_kilometers(kilometers: f64) -> Self {
         Self::from_meters(kilometers / METER_KILOMETER_FACTOR)
     }
-    
+
     // Inputs, imperial
     pub fn from_inches(inches: f64) -> Self {
         Self::from_meters(inches / METER_INCH_FACTOR)
     }
-    
+
     pub fn from_feet(feet: f64) -> Self {
         Self::from_meters(feet / METER_FEET_FACTOR)
     }
-    
+
     pub fn from_yards(yards: f64) -> Self {
         Self::from_meters(yards / METER_YARD_FACTOR)
     }
-    
+
     pub fn from_furlongs(furlongs: f64) -> Self {
         Self::from_meters(furlongs / METER_FURLONG_FACTOR)
     }
-    
+
     pub fn from_miles(miles: f64) -> Self {
         Self::from_meters(miles / METER_MILE_FACTOR)
     }
-    
+
     // Outputs, metric
     pub fn as_nanometers(&self) -> f64 {
         self.meters * METER_NANOMETER_FACTOR
     }
-    
+
     pub fn as_micrometers(&self) -> f64 {
         self.meters * METER_MICROMETER_FACTOR
     }
-    
+
     pub fn as_millimeters(&self) -> f64 {
         self.meters * METER_MILLIMETER_FACTOR
     }
-    
+
     pub fn as_centimeters(&self) -> f64 {
         self.meters * METER_CENTIMETER_FACTOR
     }
-    
+
     pub fn as_meters(&self) -> f64 {
         self.meters
     }
-    
+
     pub fn as_decameters(&self) -> f64 {
         self.meters * METER_DECAMETER_FACTOR
     }
-    
+
     pub fn as_hectometer(&self) -> f64 {
         self.meters * METER_HECTOMETER_FACTOR
     }
-    
+
     pub fn as_kilometers(&self) -> f64 {
         self.meters * METER_KILOMETER_FACTOR
     }
-    
+
     // Outputs, imperial
     pub fn as_inches(&self) -> f64 {
         self.meters * METER_INCH_FACTOR
     }
-    
+
     pub fn as_feet(&self) -> f64 {
         self.meters * METER_FEET_FACTOR
     }
-    
+
     pub fn as_yards(&self) -> f64 {
         self.meters * METER_YARD_FACTOR
     }
-    
+
     pub fn as_furlongs(&self) -> f64 {
         self.meters * METER_FURLONG_FACTOR
     }
-    
+
     pub fn as_miles(&self) -> f64 {
         self.meters * METER_MILE_FACTOR
     }
@@ -147,10 +147,16 @@ impl Measurement for Length {
     fn get_base_units(&self) -> f64 {
         self.meters
     }
-    
+
     fn from_base_units(units: f64) -> Self {
         Self::from_meters(units)
     }
 }
 
 implement_measurement! { Length }
+
+impl ::std::fmt::Display for Length {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "{:.1} m", self.as_meters())
+    }
+}

src/lib.rs

@@ -18,6 +18,10 @@ pub use weight::Weight;
 mod volume;
 pub use volume::Volume;
 
+#[allow(dead_code)]
+mod pressure;
+pub use pressure::Pressure;
+
 // Include when running tests, but don't export them
 #[cfg(test)]
 #[allow(dead_code)]

src/measurement.rs

@@ -1,23 +1,23 @@
 /// The `Measurement` trait and the `implement_measurement!` macro
 /// provides a common way for various measurements to be implemented.
-/// 
+///
 /// # Example
 /// ```
 /// // Importing the `implement_measurement` macro from the external crate is important
 /// #[macro_use]
 /// extern crate measurements;
-/// 
+///
 /// use measurements::Measurement;
-/// 
+///
 /// struct Cubits {
 ///     forearms: f64
 /// }
-/// 
+///
 /// impl Measurement for Cubits {
 ///     fn get_base_units(&self) -> f64 {
 ///         self.forearms
 ///     }
-///     
+///
 ///     fn from_base_units(units: f64) -> Self {
 ///         Cubits { forearms: units }
 ///     }
@@ -42,59 +42,55 @@ macro_rules! implement_measurement {
     ($($t:ty)*) => ($(
         impl ::std::ops::Add for $t {
             type Output = Self;
-            
+
             fn add(self, rhs: Self) -> Self {
                 Self::from_base_units(self.get_base_units() + rhs.get_base_units())
             }
         }
 
         impl ::std::ops::Sub for $t {
             type Output = Self;
-            
+
             fn sub(self, rhs: Self) -> Self {
                 Self::from_base_units(self.get_base_units() - rhs.get_base_units())
             }
         }
 
-        /// 
-        /// Dividing a `$t` by another `$` returns a ratio.
-        /// 
+        // Dividing a `$t` by another `$` returns a ratio.
+        //
         impl ::std::ops::Div<$t> for $t {
             type Output = f64;
-            
+
             fn div(self, rhs: Self) -> f64 {
                 self.get_base_units() / rhs.get_base_units()
             }
         }
 
-        /// 
-        /// Dividing a `$` by a factor returns a new portion of the measurement.
-        /// 
+        // Dividing a `$` by a factor returns a new portion of the measurement.
+        //
         impl ::std::ops::Div<f64> for $t {
             type Output = Self;
-            
+
             fn div(self, rhs: f64) -> Self {
                 Self::from_base_units(self.get_base_units() / rhs)
             }
         }
 
-        /// 
-        /// Multiplying a `$t` by another `$t` returns the product of those measurements.
-        /// 
+        // Multiplying a `$t` by another `$t` returns the product of those measurements.
+        //
         impl ::std::ops::Mul<$t> for $t {
             type Output = Self;
-            
+
             fn mul(self, rhs: Self) -> Self {
                 Self::from_base_units(self.get_base_units() * rhs.get_base_units())
             }
         }
 
-        /// 
-        /// Multiplying a `$t` by a factor increases (or decreases) that measurement a number of times.
-        /// 
+        // Multiplying a `$t` by a factor increases (or decreases) that measurement a number of times.
+        //
         impl ::std::ops::Mul<f64> for $t {
             type Output = Self;
-            
+
             fn mul(self, rhs: f64) -> Self {
                 Self::from_base_units(self.get_base_units() * rhs)
             }