tracklib 0.1.4 → 0.3.0

data/src/rwtfile.rs

@@ -0,0 +1,429 @@
+use lazy_static::lazy_static;
+use rutie::{
+    class, methods, wrappable_struct, AnyObject, Array, Boolean, Class, Encoding, Float, Hash,
+    Integer, Module, Object, RString, VM,
+};
+use rutie_serde::{ruby_class, rutie_serde_methods};
+use std::collections::HashMap;
+use std::convert::TryFrom;
+use std::io::BufWriter;
+use tracklib::{parse_rwtf, DataField, RWTFMetadata, RWTFile, TrackType};
+use super::polyline;
+use super::surface;
+
+fn any_to_float(o: AnyObject) -> f64 {
+    match o.try_convert_to::<Float>() {
+        Ok(f) => f.to_f64(),
+        Err(float_e) => o
+            .try_convert_to::<Integer>()
+            .map_err(|_| VM::raise_ex(float_e))
+            .unwrap()
+            .to_i64() as f64,
+    }
+}
+
+fn any_to_int(o: AnyObject) -> i64 {
+    match o.try_convert_to::<Integer>() {
+        Ok(i) => i.to_i64(),
+        Err(int_e) => o
+            .try_convert_to::<Float>()
+            .map_err(|_| VM::raise_ex(int_e))
+            .unwrap()
+            .to_f64() as i64,
+    }
+}
+
+fn any_to_str(o: AnyObject) -> String {
+    o.try_convert_to::<RString>()
+        .map_err(|e| VM::raise_ex(e))
+        .unwrap()
+        .to_string()
+}
+
+fn any_to_bool(o: AnyObject) -> bool {
+    o.try_convert_to::<Boolean>()
+        .map_err(|e| VM::raise_ex(e))
+        .unwrap()
+        .to_bool()
+}
+
+fn any_to_ids(o: AnyObject) -> Vec<u64> {
+    o.try_convert_to::<Array>()
+        .map_err(|e| VM::raise_ex(e))
+        .unwrap()
+        .into_iter()
+        .map(|ele| {
+            ele.try_convert_to::<Integer>()
+                .map_err(|e| VM::raise_ex(e))
+                .unwrap()
+                .to_u64()
+        })
+        .collect()
+}
+
+#[derive(Debug, Copy, Clone)]
+enum ColumnType {
+    Numbers,
+    LongFloat,
+    ShortFloat,
+    Base64,
+    String,
+    Bool,
+    IDs,
+}
+
+impl ColumnType {
+    fn from_str(name: &str) -> Option<Self> {
+        match name {
+            "Number" => Some(ColumnType::Numbers),
+            "LongFloat" => Some(ColumnType::LongFloat),
+            "ShortFloat" => Some(ColumnType::ShortFloat),
+            "Base64" => Some(ColumnType::Base64),
+            "String" => Some(ColumnType::String),
+            "Bool" => Some(ColumnType::Bool),
+            "IDs" => Some(ColumnType::IDs),
+            _ => None,
+        }
+    }
+
+    fn exponent(&self) -> u8 {
+        match self {
+            ColumnType::Numbers => 48,
+            ColumnType::LongFloat => 24,
+            ColumnType::ShortFloat => 38,
+            _ => {
+                VM::raise(
+                    Class::from_existing("Exception"),
+                    &format!("can't handle numeric value for non-numeric field"),
+                );
+                unreachable!();
+            }
+        }
+    }
+
+    fn max_integer(&self) -> i64 {
+        2i64.pow(u32::from(self.exponent()))
+    }
+
+    fn max_float(&self) -> f64 {
+        2f64.powi(i32::from(self.exponent()))
+    }
+}
+
+fn convert_config(config: Hash) -> HashMap<String, ColumnType> {
+    let mut hm = HashMap::new();
+
+    config.each(|rwtf_type_name, array_of_field_names| {
+        let type_name_obj = rwtf_type_name
+            .try_convert_to::<RString>()
+            .map_err(|e| VM::raise_ex(e))
+            .unwrap();
+        let type_name_str = type_name_obj.to_str();
+
+        if let Some(column_type) = ColumnType::from_str(type_name_str) {
+            let array_obj = array_of_field_names
+                .try_convert_to::<Array>()
+                .map_err(|e| VM::raise_ex(e))
+                .unwrap();
+
+            for field_name in array_obj.into_iter() {
+                let field_name_obj = field_name
+                    .try_convert_to::<RString>()
+                    .map_err(|e| VM::raise_ex(e))
+                    .unwrap();
+
+                hm.insert(field_name_obj.to_string(), column_type);
+            }
+        } else {
+            VM::raise(
+                Class::from_existing("Exception"),
+                &format!("unknown rwtf_field_config type: {}", type_name_str),
+            );
+            unreachable!();
+        }
+    });
+
+    hm
+}
+
+fn is_empty_string(v: &AnyObject) -> bool {
+    match v.try_convert_to::<RString>() {
+        Ok(s) => s.to_str().is_empty(),
+        Err(_) => false,
+    }
+}
+
+fn is_empty_array(v: &AnyObject) -> bool {
+    match v.try_convert_to::<Array>() {
+        Ok(a) => a.length() == 0,
+        Err(_) => false,
+    }
+}
+
+fn is_number_and_too_large(v: &AnyObject, field_type: ColumnType) -> bool {
+    // First we have to try to cast `v` to a numeric type (Integer or Float)
+    // and then call to_i64/f64(). This will raise an exception if the number
+    // is too large to turn into a primitive.
+    let is_number_result = VM::protect(|| {
+        match v.try_convert_to::<Integer>() {
+            Ok(i) => {
+                let _ = i.to_i64(); // force a conversion
+                Boolean::new(true)
+            }
+            Err(_) => match v.try_convert_to::<Float>() {
+                Ok(f) => {
+                    let _ = f.to_f64(); // force a conversion
+                    Boolean::new(true)
+                }
+                Err(_) => Boolean::new(false),
+            },
+        }
+        .to_any_object()
+    });
+
+    match is_number_result {
+        Ok(is_number) => {
+            // Here we know that no exception was raised during the attempted primitive conversion.
+            // We also know that `is_number` is a Boolean, so this unsafe cast is fine.
+            if unsafe { is_number.to::<Boolean>().to_bool() } {
+                match v.try_convert_to::<Integer>() {
+                    Ok(i) => i.to_i64().abs() > field_type.max_integer(),
+                    Err(_) => match v.try_convert_to::<Float>() {
+                        Ok(f) => f.to_f64().abs() > field_type.max_float(),
+                        Err(_) => false,
+                    },
+                }
+            } else {
+                false
+            }
+        }
+        Err(_) => {
+            VM::clear_error_info(); // clear ruby VM error register
+            true // this IS a number and it IS too large
+        }
+    }
+}
+
+fn add_points(
+    source: &Hash,
+    section_points_config: &HashMap<String, ColumnType>,
+    section_type: &str,
+    mut callback: impl FnMut(usize, &str, DataField),
+) {
+    let maybe_section_points = source
+        .at(&RString::new_utf8(section_type))
+        .try_convert_to::<Array>();
+
+    if let Ok(section_points) = maybe_section_points {
+        for (i, maybe_point) in section_points.into_iter().enumerate() {
+            let point = maybe_point
+                .try_convert_to::<Hash>()
+                .map_err(|e| VM::raise_ex(e))
+                .unwrap();
+
+            point.each(|k: AnyObject, v: AnyObject| {
+                let field_name_obj = k
+                    .try_convert_to::<RString>()
+                    .map_err(|e| VM::raise_ex(e))
+                    .unwrap();
+                let name = field_name_obj.to_str();
+
+                if !name.is_empty() {
+                    if let Some(field_type) = section_points_config.get(name) {
+                        if !v.is_nil()
+                            && !is_empty_string(&v)
+                            && !is_empty_array(&v)
+                            && !is_number_and_too_large(&v, *field_type)
+                        {
+                            let data = match field_type {
+                                ColumnType::LongFloat => DataField::LongFloat(any_to_float(v)),
+                                ColumnType::ShortFloat => DataField::ShortFloat(any_to_float(v)),
+                                ColumnType::Numbers => DataField::Number(any_to_int(v)),
+                                ColumnType::Base64 => {
+                                    DataField::Base64(any_to_str(v).replace("\n", ""))
+                                }
+                                ColumnType::String => DataField::String(any_to_str(v)),
+                                ColumnType::Bool => DataField::Bool(any_to_bool(v)),
+                                ColumnType::IDs => DataField::IDs(any_to_ids(v)),
+                            };
+
+                            callback(i, name, data);
+                        }
+                    } else {
+                        VM::raise(
+                            Module::from_existing("Tracklib").get_nested_class("UnknownFieldError"),
+                            &format!("unknown {} field: {}", section_type, name),
+                        );
+                        unreachable!();
+                    }
+                }
+            });
+        }
+    }
+}
+
+pub struct Inner {
+    inner: RWTFile,
+}
+
+wrappable_struct!(Inner, InnerWrapper, INNER_WRAPPER);
+
+class!(RubyRWTFile);
+
+methods!(
+    RubyRWTFile,
+    itself,
+    fn rwtf_from_bytes(bytes: RString) -> AnyObject {
+        let source = bytes.map_err(|e| VM::raise_ex(e)).unwrap();
+        let (_, rwtf) = parse_rwtf(source.to_bytes_unchecked())
+            .map_err(|e| VM::raise(Class::from_existing("Exception"), &format!("{}", e)))
+            .unwrap();
+        let inner = Inner { inner: rwtf };
+
+        Class::from_existing("RWTFile").wrap_data(inner, &*INNER_WRAPPER)
+    }
+
+    fn rwtf_to_bytes() -> RString {
+        let mut writer = BufWriter::new(Vec::new());
+        itself
+            .get_data(&*INNER_WRAPPER)
+            .inner
+            .write(&mut writer)
+            .map_err(|e| VM::raise(Class::from_existing("Exception"), &format!("{}", e)))
+            .unwrap();
+
+        let encoding = Encoding::find("ASCII-8BIT")
+            .map_err(|e| VM::raise_ex(e))
+            .unwrap();
+
+        let buf = writer
+            .into_inner()
+            .map_err(|e| VM::raise(Class::from_existing("Exception"), &format!("{}", e)))
+            .unwrap();
+
+        RString::from_bytes(&buf, &encoding)
+    }
+
+    fn rwtf_from_hash(input: Hash, config_input: Hash, metadata: Hash) -> AnyObject {
+        let source = input.map_err(|e| VM::raise_ex(e)).unwrap();
+        let config = config_input.map_err(|e| VM::raise_ex(e)).unwrap();
+        let track_points_config = convert_config(
+            config
+                .at(&RString::new_utf8("track_points"))
+                .try_convert_to::<Hash>()
+                .map_err(|e| VM::raise_ex(e))
+                .unwrap(),
+        );
+        let course_points_config = convert_config(
+            config
+                .at(&RString::new_utf8("course_points"))
+                .try_convert_to::<Hash>()
+                .map_err(|e| VM::raise_ex(e))
+                .unwrap(),
+        );
+
+        let mut rwtf = if let Some(md) = metadata.ok() {
+            let tt_metadata = md
+                .at(&RString::new_utf8("track_type"))
+                .try_convert_to::<Hash>()
+                .map_err(|e| VM::raise_ex(e))
+                .unwrap();
+
+            let track_type = tt_metadata
+                .at(&RString::new_utf8("type"))
+                .try_convert_to::<RString>()
+                .map_err(|e| VM::raise_ex(e))
+                .unwrap();
+
+            let id = u32::try_from(
+                tt_metadata
+                    .at(&RString::new_utf8("id"))
+                    .try_convert_to::<Integer>()
+                    .map_err(|e| VM::raise_ex(e))
+                    .unwrap()
+                    .to_u64(),
+            )
+            .map_err(|e| VM::raise(Class::from_existing("Exception"), &format!("{}", e)))
+            .unwrap();
+
+            let tt = match track_type.to_str() {
+                "trip" => TrackType::Trip(id),
+                "route" => TrackType::Route(id),
+                "segment" => TrackType::Segment(id),
+                _ => {
+                    VM::raise(
+                        Class::from_existing("Exception"),
+                        &format!("unknown track_type metadata: {}", track_type.to_str()),
+                    );
+                    unreachable!();
+                }
+            };
+
+            RWTFile::with_track_type(tt)
+        } else {
+            RWTFile::new()
+        };
+
+        add_points(
+            &source,
+            &track_points_config,
+            "track_points",
+            |i, name, data| {
+                rwtf.add_track_point(i, name, data)
+                    .map_err(|e| VM::raise(Class::from_existing("Exception"), &format!("{}", e)))
+                    .unwrap();
+            },
+        );
+
+        add_points(
+            &source,
+            &course_points_config,
+            "course_points",
+            |i, name, data| {
+                rwtf.add_course_point(i, name, data)
+                    .map_err(|e| VM::raise(Class::from_existing("Exception"), &format!("{}", e)))
+                    .unwrap();
+            },
+        );
+
+        let inner = Inner { inner: rwtf };
+        Class::from_existing("RWTFile").wrap_data(inner, &*INNER_WRAPPER)
+    }
+
+    fn rwtf_simplify_track_points(surface_mapping: surface::RubySurfaceMapping,
+                                  tolerance: Float,
+                                  encode_options: polyline::RubyFieldEncodeOptionsVec) -> RString {
+        let track_points = &itself.get_data(&*INNER_WRAPPER).inner.track_points;
+        let surface_mapping_container = surface_mapping.map_err(|e| VM::raise_ex(e)).unwrap();
+        let mapping = surface_mapping_container.inner();
+        let tol = tolerance.map_err(|e| VM::raise_ex(e)).unwrap().to_f64();
+        let encode_options_container = encode_options.map_err(|e| VM::raise_ex(e)).unwrap();
+        let enc_opts = encode_options_container.inner();
+
+        RString::new_utf8(&track_points.simplify_and_encode(mapping, tol, enc_opts))
+    }
+
+    fn rwtf_inspect() -> RString {
+        let rwtf = &itself.get_data(&*INNER_WRAPPER).inner;
+
+        RString::new_utf8(&format!(
+            "RWTFile<track_points: {}, course_points: {}>",
+            rwtf.track_points.len(),
+            rwtf.course_points.len()
+        ))
+    }
+);
+
+rutie_serde_methods!(
+    RubyRWTFile,
+    itself,
+    ruby_class!(Exception),
+
+    fn rwtf_to_hash() -> &RWTFile {
+        &itself.get_data(&*INNER_WRAPPER).inner
+    }
+
+    fn rwtf_metadata() -> &RWTFMetadata {
+        &itself.get_data(&*INNER_WRAPPER).inner.metadata()
+    }
+);

data/src/surface.rs

@@ -0,0 +1,143 @@
+use lazy_static::lazy_static;
+use rutie::{
+    class, methods, wrappable_struct, AnyObject, Array, Class, Float, Integer, NilClass, Object,
+    RString, VerifiedObject, VM,
+};
+use tracklib::{RoadClassMapping, SurfaceMapping};
+
+pub struct RoadClassInner {
+    inner: RoadClassMapping,
+}
+
+wrappable_struct!(
+    RoadClassInner,
+    RoadClassInnerWrapper,
+    ROAD_CLASS_INNER_WRAPPER
+);
+
+class!(RubyRoadClassMapping);
+
+methods!(
+    RubyRoadClassMapping,
+    itself,
+
+    fn road_class_mapping_new(bbox_array: Array) -> AnyObject {
+        let bbox_vec: Vec<f64> = bbox_array
+            .map_err(|e| VM::raise_ex(e))
+            .unwrap()
+            .into_iter()
+            .map(|ele| match ele.try_convert_to::<Float>() {
+                Ok(f) => f.to_f64(),
+                Err(float_e) => ele
+                    .try_convert_to::<Integer>()
+                    .map_err(|_| VM::raise_ex(float_e))
+                    .unwrap()
+                    .to_i32()
+                    .into(),
+            })
+            .collect();
+        if bbox_vec.len() != 4 {
+            VM::raise(
+                Class::from_existing("Exception"),
+                "BBOX Array len must be 4",
+            );
+        }
+        let bbox = [bbox_vec[0], bbox_vec[1], bbox_vec[2], bbox_vec[3]];
+
+        let inner = RoadClassInner {
+            inner: tracklib::RoadClassMapping::new(bbox),
+        };
+
+        Class::from_existing("TracklibRoadClassMapping").wrap_data(inner, &*ROAD_CLASS_INNER_WRAPPER)
+    }
+
+    fn road_class_mapping_add_road_class(road_class_id: Integer, surface_id: Integer) -> NilClass {
+        let rc_id = road_class_id.map_err(|e| VM::raise_ex(e)).unwrap().to_i64();
+        let s_id = surface_id.map_err(|e| VM::raise_ex(e)).unwrap().to_i64();
+        let mapping = &mut itself.get_data_mut(&*ROAD_CLASS_INNER_WRAPPER).inner;
+        mapping.add_road_class(rc_id, s_id);
+
+        NilClass::new()
+    }
+
+    fn road_class_mapping_to_s() -> RString {
+        let mapping = &itself.get_data(&*ROAD_CLASS_INNER_WRAPPER).inner;
+
+        RString::new_utf8(&format!("{:?}", mapping))
+    }
+);
+
+impl VerifiedObject for RubyRoadClassMapping {
+    fn is_correct_type<T: Object>(object: &T) -> bool {
+        Class::from_existing("TracklibRoadClassMapping").case_equals(object)
+    }
+
+    fn error_message() -> &'static str {
+        "Error converting to RoadClassMapping"
+    }
+}
+
+pub struct SurfaceInner {
+    inner: SurfaceMapping,
+}
+
+wrappable_struct!(SurfaceInner, SurfaceInnerWrapper, SURFACE_INNER_WRAPPER);
+
+class!(RubySurfaceMapping);
+
+methods!(
+    RubySurfaceMapping,
+    itself,
+
+    fn surface_mapping_new(unknown_surface_id: Integer) -> AnyObject {
+        let id = unknown_surface_id
+            .map_err(|e| VM::raise_ex(e))
+            .unwrap()
+            .to_i64();
+        let inner = SurfaceInner {
+            inner: tracklib::SurfaceMapping::new(id),
+        };
+
+        Class::from_existing("TracklibSurfaceMapping").wrap_data(inner, &*SURFACE_INNER_WRAPPER)
+    }
+
+    fn surface_mapping_add_surface(surface_id: Integer, group: RString) -> NilClass {
+        let id = surface_id.map_err(|e| VM::raise_ex(e)).unwrap().to_i64();
+        let group_name = group.map_err(|e| VM::raise_ex(e)).unwrap().to_string();
+        let mapping = &mut itself.get_data_mut(&*SURFACE_INNER_WRAPPER).inner;
+        mapping.add_surface(id, group_name);
+
+        NilClass::new()
+    }
+
+    fn surface_mapping_add_road_class_mapping(road_class_mapping: RubyRoadClassMapping) -> NilClass {
+        let rcm = road_class_mapping.map_err(|e| VM::raise_ex(e)).unwrap();
+        let mapping = &mut itself.get_data_mut(&*SURFACE_INNER_WRAPPER).inner;
+        let road_class = &rcm.get_data(&*ROAD_CLASS_INNER_WRAPPER).inner;
+        mapping.add_road_class_mapping(road_class.clone());
+
+        NilClass::new()
+    }
+
+    fn surface_mapping_to_s() -> RString {
+        let mapping = &itself.get_data(&*SURFACE_INNER_WRAPPER).inner;
+
+        RString::new_utf8(&format!("{:?}", mapping))
+    }
+);
+
+impl RubySurfaceMapping {
+    pub fn inner(&self) -> &SurfaceMapping {
+        &self.get_data(&*SURFACE_INNER_WRAPPER).inner
+    }
+}
+
+impl VerifiedObject for RubySurfaceMapping {
+    fn is_correct_type<T: Object>(object: &T) -> bool {
+        Class::from_existing("TracklibSurfaceMapping").case_equals(object)
+    }
+
+    fn error_message() -> &'static str {
+        "Error converting to SurfaceMapping"
+    }
+}

data/tracklib.gemspec

@@ -20,12 +20,15 @@ Gem::Specification.new do |spec|
                         "lib/tracklib/version.rb",
                         "Cargo.toml",
                         "Cargo.lock",
-                        "src/lib.rs"]
+                        "src/lib.rs",
+                        "src/polyline.rs",
+                        "src/rwtfile.rs",
+                        "src/surface.rs"]
 
   spec.require_paths = ["lib"]
   spec.extensions    = ["ext/Rakefile"]
 
-  spec.add_development_dependency "minitest", "~> 5.11"
+  spec.add_development_dependency "rspec"
 
   spec.add_runtime_dependency "rake", "~> 12.3"
   spec.add_runtime_dependency 'thermite', '~> 0.13'

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: tracklib
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Dan Larkin
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-08-01 00:00:00.000000000 Z
+date: 1980-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.11'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.11'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -82,13 +82,16 @@ files:
 - lib/tracklib.rb
 - lib/tracklib/version.rb
 - src/lib.rs
+- src/polyline.rs
+- src/rwtfile.rs
+- src/surface.rs
 - tracklib.gemspec
 homepage: https://ridewithgps.com
 licenses:
 - Apache-2.0
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -103,9 +106,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14.3
-signing_key: 
+rubygems_version: 3.2.16
+signing_key:
 specification_version: 4
 summary: tracklib
 test_files: []