Add StoreId interfacing code

imag-ruby/Cargo.toml

@@ -15,6 +15,8 @@ homepage      = "http://imag-pim.org"
 
 [dependencies]
 ruru = "0.9"
+lazy_static = "0.2"
+log = "0.3"
 
 [dependencies.libimagerror]
 path = "../libimagerror"

imag-ruby/src/lib.rs

@@ -18,9 +18,12 @@
 //
 
 #[macro_use] extern crate ruru;
+#[macro_use] extern crate lazy_static;
+#[macro_use] extern crate log;
 
 #[macro_use] extern crate libimagerror;
 extern crate libimagstore;
 extern crate libimagrt;
 #[macro_use] extern crate libimagutil;
 
+pub mod store;

imag-ruby/src/store.rs

@@ -0,0 +1,141 @@
+//
+// imag - the personal information management suite for the commandline
+// Copyright (C) 2015, 2016 Matthias Beyer <mail@beyermatthias.de> and contributors
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; version
+// 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+//
+
+pub mod storeid {
+    use std::path::PathBuf;
+
+    use ruru::{Class, Object, AnyObject, Boolean, RString, NilClass};
+
+    use libimagstore::storeid::StoreId;
+
+    wrappable_struct!(StoreId, StoreIdWrapper, STOREID_WRAPPER);
+    class!(RStoreId);
+
+    methods!(
+        RStoreId,
+        itself,
+
+        fn r_storeid_new(base: RString, id: RString) -> AnyObject {
+            let base = match base.map(|b| b.to_string()).map(PathBuf::from) {
+                Ok(base) => base,
+                Err(e) => {
+                    error!("Building StoreId object failed: {:?}", e);
+                    return AnyObject::from(NilClass::new().value());
+                },
+            };
+
+            let id = match id.map(|id| id.to_string()).map(PathBuf::from) {
+                Ok(id) => id,
+                Err(e) => {
+                    error!("Building StoreId object failed: {:?}", e);
+                    return AnyObject::from(NilClass::new().value());
+                },
+            };
+
+            match StoreId::new(Some(base), id) {
+                Ok(sid) => Class::from_existing("RStoreId").wrap_data(sid, &*STOREID_WRAPPER),
+                Err(e) => {
+                    error!("Building StoreId object failed: {:?}", e);
+                    return AnyObject::from(NilClass::new().value());
+                },
+            }
+        }
+
+        fn r_storeid_new_baseless(id: RString) -> AnyObject {
+            let id = match id.map(|id| id.to_string()).map(PathBuf::from) {
+                Ok(id) => id,
+                Err(e) => {
+                    error!("Building StoreId object failed: {:?}", e);
+                    return AnyObject::from(NilClass::new().value());
+                },
+            };
+
+            match StoreId::new(None, id) {
+                Ok(sid) => Class::from_existing("RStoreId").wrap_data(sid, &*STOREID_WRAPPER),
+                Err(e) => {
+                    error!("Building StoreId object failed: {:?}", e);
+                    return AnyObject::from(NilClass::new().value());
+                },
+            }
+        }
+
+        fn r_storeid_without_base() -> RStoreId {
+            let withoutbase : StoreId = itself.get_data(&*STOREID_WRAPPER).clone().without_base();
+            Class::from_existing("RStoreId").wrap_data(withoutbase, &*STOREID_WRAPPER)
+        }
+
+        fn r_storeid_with_base(base: RString) -> AnyObject {
+            let base : PathBuf = match base.map(|b| b.to_string()).map(PathBuf::from) {
+                Ok(pb) => pb,
+                Err(e) => {
+                    error!("Error: {:?}", e);
+                    return AnyObject::from(NilClass::new().value());
+                },
+            };
+            let withoutbase : StoreId = itself.get_data(&*STOREID_WRAPPER).clone().with_base(base);
+            Class::from_existing("RStoreId").wrap_data(withoutbase, &*STOREID_WRAPPER)
+        }
+
+        fn r_storeid_into_pathbuf() -> AnyObject {
+            itself.get_data(&*STOREID_WRAPPER)
+                .clone()
+                .into_pathbuf()
+                .map(|pb| pb.to_str().map(String::from).unwrap())
+                .as_ref()
+                .map(|s| AnyObject::from(RString::new(s).value()))
+                .unwrap_or(AnyObject::from(NilClass::new().value()))
+        }
+
+        fn r_storeid_exists() -> Boolean {
+            Boolean::new(itself.get_data(&*STOREID_WRAPPER).exists())
+        }
+
+        fn r_storeid_to_str() -> AnyObject {
+            itself.get_data(&*STOREID_WRAPPER)
+                .to_str()
+                .as_ref()
+                .map(|s| AnyObject::from(RString::new(s).value()))
+                .unwrap_or(AnyObject::from(NilClass::new().value()))
+        }
+
+        fn r_storeid_local() -> RString {
+            let local = itself.get_data(&*STOREID_WRAPPER).local();
+            let local = local.to_str().unwrap();
+            RString::new(local)
+        }
+
+    );
+
+    pub fn setup() -> Class {
+        let mut class = Class::new("RStoreId", None);
+        class.define(|itself| {
+                itself.def_self("new"          , r_storeid_new);
+                itself.def_self("new_baseless" , r_storeid_new_baseless);
+
+                itself.def("without_base"      , r_storeid_without_base);
+                itself.def("with_base"         , r_storeid_with_base);
+                itself.def("into_pathbuf"      , r_storeid_into_pathbuf);
+                itself.def("exists"            , r_storeid_exists);
+                itself.def("to_str"            , r_storeid_to_str);
+                itself.def("local"             , r_storeid_local);
+            });
+        class
+    }
+
+}