mawsitsit 0.1.12 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13d6796c67206b0f552f9551fa5aefde1c3eb96a8e1aee3de6b777246e1d78e9
-  data.tar.gz: b7a8de632bc9006744e9f29ca1548051acf3743f0af53d1d062364c3e09af0b4
+  metadata.gz: e8822dfa37e369cfcf7ab3633b016e5cb8f2704798233aa32d546c2ef6a754e4
+  data.tar.gz: 6b9f99a27efba3b5ff94970b8e890cd5bfbae353d88b93bf9a8093c9e5d4ab5f
 SHA512:
-  metadata.gz: '080ed2ee076ebdd1a971bb44686b9e112aa860464331bc7dc1c7520094a05525ddc668b73774983a96d95cd2f2ae983de1526d31dc058c1c72fe14a894f91ad6'
-  data.tar.gz: f8e0194501ae5fb49075de6fce8a6c9cb9481da604094e931113b6c7f8d790658b3db425cca424efe85f10c2e3e2cbe97d7152af61e5a724db432c7aa0507f67
+  metadata.gz: 3a3c73aea5ae02a5321be9f9261af7b8d0d90a1442164c20870a65a886cb2cb4f808c2c6fd6667c4fdc5821a1076657a5bde7fba4c1d56c614a394cf89a33b8e
+  data.tar.gz: 99416b91be67f0c2933c0ea85de53b52e377d4835230b4a3c7a1c57c4041ae9682dce3be036a424257902ca0996da4326c15d48a045cc064b09a3315a0fcd378

data/Cargo.lock

@@ -26,6 +26,21 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "async-recursion"
 version = "1.1.1"
@@ -135,6 +150,20 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "chrono"
+version = "0.4.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-targets 0.52.5",
+]
+
 [[package]]
 name = "clang-sys"
 version = "1.8.1"
@@ -516,6 +545,29 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "iana-time-zone"
+version = "0.1.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "idna"
 version = "0.5.0"
@@ -645,6 +697,7 @@ version = "0.1.0"
 dependencies = [
  "async-recursion",
  "base64",
+ "chrono",
  "exitfailure",
  "futures",
  "magnus",
@@ -722,6 +775,15 @@ dependencies = [
  "minimal-lexical",
 ]
 
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "num_cpus"
 version = "1.16.0"
@@ -1600,6 +1662,15 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets 0.52.5",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.48.0"

data/ext/mawsitsit/Cargo.toml

@@ -21,5 +21,5 @@ base64 = "0.22.1"
 futures = "0.3.30"
 async-recursion = "1.1.1"
 thiserror = "1.0.61"
-
+chrono = "0.4.38"
 

data/ext/mawsitsit/src/lib.rs

@@ -4,7 +4,6 @@ use crate::parser::parser::JsonToJson;
 use serde_magnus::deserialize;
 use magnus::{Value as RubyValue, RHash};
 
-
 fn hello(subject: String) -> String {
     format!("Hello from Rust, {subject}!")
 }
@@ -21,11 +20,10 @@ async fn parse(args: &[RubyValue]) -> Result<RubyValue, magnus::Error> {
     let origin = deserialize(origin).unwrap();
     let destination = deserialize(destination).unwrap();
     let mut parser = JsonToJson::new(origin, destination);
-    if let Some(no_null) = no_null {
-        parser.no_null = no_null;
-    }
-    
     parser.call().await;
+    if no_null.is_some() {
+        parser.destination.drop_nulls();
+    }
     Ok(parser.destination.to_ruby())	
 }
 

data/ext/mawsitsit/src/parser/manipulators.rs

@@ -1,18 +1,37 @@
 use crate::parser::utils::{application_option::ApplicationOption, helpers::{fetch, str_vec}};
-use magnus::Exception;
-use serde_json::{Map, Value};
+use serde_json::{Map, Value, json};
 use std::collections::HashMap;
 use serde_json::Value::Null;
 use crate::parser::parser::JsonValue;
-use super::utils::application_option::parse_ashby_type;
-pub fn like_enum(args: &str, enm: &str) -> Value {
+use super::utils::application_option::{parse_ashby_type, parse_lever_type};
+use chrono::{DateTime, NaiveDateTime, SecondsFormat, Utc};
+
+pub enum EnumValue {
+    Str(String),
+    Bool(bool),
+}
+
+pub fn like_enum(args: EnumValue, enm: &str) -> Value {
     let enm_list = str_vec(enm, ",");
     let mut enm_map: Map<String, Value> = serde_json::Map::new();
+    
     for enm_a in enm_list {
         let enm_args = enm_a.split(':').collect::<Vec<&str>>();
         enm_map.insert(enm_args[0].to_string(), serde_json::Value::String(enm_args[1].to_string()));
     }
-    return enm_map.get(args).unwrap().clone();
+    
+    match args {
+        EnumValue::Str(str_value) => {
+            enm_map.get(&str_value).unwrap_or_else(|| enm_map.get("else").unwrap_or(&serde_json::Value::Null)).clone()
+        },
+        EnumValue::Bool(bool_value) => {
+            if bool_value {
+                enm_map.get("true").unwrap_or_else(|| enm_map.get("else").unwrap_or(&serde_json::Value::Null)).clone()
+            } else {
+                enm_map.get("false").unwrap_or_else(|| enm_map.get("else").unwrap_or(&serde_json::Value::Null)).clone()
+            }
+        },
+    }
 }
 
 pub async fn like_fetch(args: &str, ftch: &str) -> Value {
@@ -106,3 +125,99 @@ pub fn like_ashby(_args: &Value) -> Value {
     
     return serde_json::Value::Array(new_appl);
 }
+
+pub fn like_lever(_args: &Value) -> Value {
+    let mut new_appl: Vec<serde_json::Value> = Vec::new();
+
+    if let Value::Object(map) = _args {
+        if let Some(Value::Array(arr)) = map.get("customQuestions") {
+            for value in arr {
+                if let Value::Object(map) = value {
+                    if let Some(Value::Array(fields)) = map.get("fields") {
+                        for field in fields {
+                            process_field(field, &mut new_appl);
+                        }
+                    }
+                }
+            }
+        }
+
+        if let Some(Value::Array(arr)) = map.get("personalInformation") {
+            for value in arr {
+                if let Value::Object(_) = value {
+                    process_field(value, &mut new_appl);
+                }
+            }
+        }
+
+        if let Some(Value::Array(arr)) = map.get("urls") {
+            for value in arr {
+                if let Value::Object(_) = value {
+                    process_field(value, &mut new_appl);
+                }
+            }
+        }
+
+        if let Some(Value::Object(map)) = map.get("eeoQuestions") {
+            for key in ["gender", "race", "veteran", "disability", "disabilitySignature", "disabilitySignatureDate"] {
+                if let Some(Value::Object(map)) = map.get(key) {
+                    process_eeo(map, key, &mut new_appl);
+                }
+            }
+        }
+    }
+
+    serde_json::Value::Array(new_appl)
+}
+
+fn process_field(value: &Value, new_appl: &mut Vec<serde_json::Value>) {
+    let question = value.get("text").and_then(Value::as_str).unwrap_or("Unknown question");
+    let question_type = value.get("type").and_then(Value::as_str).unwrap_or("Unknown type");
+    let ext_id = value.get("id").or_else(|| value.get("name"))
+        .and_then(Value::as_str)
+        .map(|s| format!("lever__{}", s))
+        .unwrap_or("Unknown question".to_string());
+    let required = value.get("required").and_then(Value::as_bool).unwrap_or(false);
+    let answer_options = value.get("options").and_then(Value::as_array).map(|array| {
+        array.iter().filter_map(|item| item.get("text").and_then(Value::as_str)).map(|s| s.to_string()).collect()
+    });
+
+    let app_option = ApplicationOption::new(
+        question.to_string(),
+        parse_lever_type(question_type).unwrap(),
+        Some(ext_id),
+        answer_options,
+        required,
+    );
+
+    new_appl.push(app_option.to_json());
+}
+
+fn process_eeo(map: &serde_json::Map<String, Value>, key: &str, new_appl: &mut Vec<serde_json::Value>) {
+    let question = map.get("text").and_then(Value::as_str).unwrap_or("Unknown question");
+    let question_type = map.get("type").and_then(Value::as_str).unwrap_or("Unknown type");
+    let ext_id = format!("lever__{}", key);
+    let required = map.get("required").and_then(Value::as_bool).unwrap_or(false);
+    let answer_options = map.get("options").and_then(Value::as_array).map(|array| {
+        array.iter().filter_map(|item| item.get("text").and_then(Value::as_str)).map(|s| s.to_string()).collect()
+    });
+
+    let app_option = ApplicationOption::new(
+        question.to_string(),
+        parse_lever_type(question_type).unwrap(),
+        Some(ext_id),
+        answer_options,
+        required,
+    );
+
+    new_appl.push(app_option.to_json());
+}
+
+pub fn int_to_dt(timestamp: i64) -> Value {
+    // Convert the timestamp (which is in seconds since Unix epoch) to a NaiveDateTime
+    let datetime = DateTime::from_timestamp(timestamp, 0);
+    println!("Datetime {:?}", datetime);
+    json!("none".to_string())
+    
+    
+}

data/ext/mawsitsit/src/parser/parser.rs

@@ -1,9 +1,10 @@
-use serde_json::Value;
+use serde_json::{Map, Value};
 use async_recursion::async_recursion;
 use serde::{Serialize, Deserialize};
 use serde_magnus::serialize;
 use magnus::Value as RubyValue;
-use crate::parser::manipulators::{like_enum, like_fetch, like_lambda, like_ashby};
+use crate::parser::manipulators::{like_enum, like_fetch, like_lambda, like_ashby, like_lever, int_to_dt};
+use super::{manipulators::EnumValue, utils::helpers::{remove_nulls, remove_nulls_in_place, vec_str}};
 
 
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -58,6 +59,15 @@ impl JsonValue {
         let ruby : RubyValue = serialize(&self.value).unwrap();
         return ruby;
     }
+    pub fn no_null(&self) -> JsonValue{
+        JsonValue {
+            value: remove_nulls(&self.value),
+        }
+    }
+    pub fn drop_nulls(&mut self) {
+        remove_nulls_in_place(&mut self.value);
+    }
+    
 
 }
 
@@ -117,23 +127,100 @@ impl JsonToJson {
                         let mut task_res = serde_json::Value::Null;
                         match task.get(0) {
                             Some(&"enum") => {
-                                task_res =
-                                    like_enum(&reference.get_by_path(bin[0]).expect("Path not found in reference").to_string(), task.get(1).unwrap());
+                                task_res = match reference.get_by_path(bin[0]) {
+                                    Some(value) => {
+                                        match task.get(1) {
+                                            Some(todo) => {
+                                                match value {
+                                                    serde_json::Value::String(value_str) => like_enum(EnumValue::Str(value_str.to_string()), todo),
+                                                    serde_json::Value::Bool(value_bool) => like_enum(EnumValue::Bool(*value_bool), todo),
+                                                    _ => serde_json::Value::Null,
+                                                }
+                                            }
+
+                                            None => serde_json::Value::Null
+                                        }
+                                    },
+                                    None => serde_json::Value::Null
+                                }                
                             }
                             Some(&"fetch") => {
-                                task_res = like_fetch(&reference.get_by_path(bin[0]).expect("Path not found in reference").to_string(), task.get(1).unwrap()).await;
+                                task_res = match reference.get_by_path(bin[0]) {
+                                    Some(value) => {
+                                        match task.get(1) {
+                                            Some(todo) => match value.as_str() {
+                                                Some(value) => like_fetch(value, todo).await,
+                                                None => serde_json::Value::Null
+                                            }
+                                            None => serde_json::Value::Null
+                                        }
+                                    },
+                                    None => serde_json::Value::Null
+                                }
                             }
                             Some(&"ashby") => {
-                                task_res = like_ashby(&reference.get_by_path(bin[0]).expect("Path not found in reference"));
+                                task_res = match reference.get_by_path(bin[0]) {
+                                    Some(value) => like_ashby(value),
+                                    None => serde_json::Value::Null
+                                }
+                            
+                            }
+                            Some(&"lever") => {
+                                task_res = match reference.get_by_path(bin[0]) {
+                                    Some(value) => like_lever(value),
+                                    None => serde_json::Value::Null
+                                }
                             }
                             Some(&"lambda") => {
-                                task_res = like_lambda(&reference.get_by_path(bin[0]).expect("Path not found in reference").to_string(), task.get(1).unwrap());
+                                task_res = match reference.get_by_path(bin[0]) {
+                                    Some(value) => {
+                                        match task.get(1) {
+                                            Some(todo) => match value.as_str() {
+                                                Some(value) => like_lambda(value, todo),
+                                                None => serde_json::Value::Null
+                                            }
+                                            None => serde_json::Value::Null
+                                        }
+                                    },
+                                    None => serde_json::Value::Null
+                                }
+                                
+                            }
+                            Some(&"int_to_datetime") => {
+                                task_res = match reference.get_by_path(bin[0]) {
+                                    Some(value) => {
+                                        match value.as_i64() {
+                                            Some(value) => int_to_dt(value),
+                                            None => serde_json::Value::Null
+                                        }
+                                    },
+                                    None => serde_json::Value::Null
+                                }
+                                
+                            }
+                            Some(&"flatten") => {
+                                task_res = reference.get_by_path(bin[0])
+                                    .and_then(|value| value.as_array())
+                                    .map_or(serde_json::Value::Null, |array| {
+                                        let strings: Vec<&str> = array.iter()
+                                            .filter_map(|v| v.as_str())
+                                            .collect();
+                                        serde_json::Value::String(vec_str(strings, ", "))
+                                    });
+                                
                             }
                             _ => (),
                         }
                         *value = task_res;
                     } else {
-                        *value = reference.get_by_path(value_str).unwrap().clone();
+                        let bin_spl:Vec<&str>= bin[0].split(".").collect(); 
+                        if bin_spl[0] == "ignore" {
+                            *value = bin[0].clone().into();
+                            return;
+                        }
+                        *value = reference
+                            .get_by_path(value_str)
+                            .map_or_else(|| serde_json::Value::Null, |v| v.clone().into());
                     }
                 }
             }

data/ext/mawsitsit/src/parser/utils/application_option.rs

@@ -1,5 +1,5 @@
 use std::fmt;
-use serde_json::{json, Value};
+use serde_json::Value;
 
 
 #[derive(Debug)]
@@ -9,7 +9,7 @@ pub enum ParseError {
 
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Ashby Application Option Type is not represented in QuestionType")
+        write!(f, "Application Option Type is not represented in QuestionType")
     }
 }
 impl std::error::Error for ParseError {}
@@ -86,6 +86,19 @@ pub fn parse_ashby_type(input: &str) -> Result<QuestionType, ParseError> {
     }
 }
 
+pub fn parse_lever_type(input: &str) -> Result<QuestionType, ParseError> {
+    match input {
+        "text" => Ok(QuestionType::ShortText),
+        "file-upload" => Ok(QuestionType::File),
+        "textarea" => Ok(QuestionType::LongText),
+        "dropdown" => Ok(QuestionType::SingleChoice),
+        "multiple-choice" => Ok(QuestionType::SingleChoice),
+        "university" => Ok(QuestionType::SingleChoice),
+        "multiple-select" => Ok(QuestionType::MultipleChoice),
+        _ => Err(ParseError::InvalidType),
+    }
+}
+
 #[derive(Debug)]
 pub struct ApplicationOption {
     pub question: String,

data/ext/mawsitsit/src/parser/utils/helpers.rs

@@ -2,10 +2,16 @@ use reqwest::{Client, Method};
 use std::collections::HashMap;
 use base64::encode;
 use magnus::Value as RubyValue;
+use serde_json::{Map, Value as SerdeValue};
+
+
 
 
 pub fn str_vec<'a>(args: &'a str, param: &str) -> Vec<&'a str> {
-    return args.split(param).collect();
+    args.split(param).collect()
+}
+pub fn vec_str(args: Vec<&str>, separator: &str) -> String {
+    args.join(separator)
 }
 
 pub async fn fetch(
@@ -34,8 +40,57 @@ pub trait IO {
     fn to_ruby(&self) -> RubyValue;
 }
 
+pub fn remove_nulls(value: &SerdeValue) -> SerdeValue {
+    match value {
+        SerdeValue::Object(map) => {
+            let filtered_map: Map<_, _> = map.iter()
+                .filter_map(|(k, v)| {
+                    let cleaned_value = remove_nulls(v);
+                    if !cleaned_value.is_null() {
+                        Some((k.clone(), cleaned_value))
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+            SerdeValue::Object(filtered_map)
+        }
+        SerdeValue::Array(arr) => {
+            let filtered_array: Vec<_> = arr.iter()
+                .map(|v| remove_nulls(v))
+                .filter(|v| !v.is_null())
+                .collect();
+            SerdeValue::Array(filtered_array)
+        }
+        _ => value.clone(),
+    }
+}
 
-
-
-
-
+pub fn remove_nulls_in_place(value: &mut serde_json::Value) {
+    match value {
+        serde_json::Value::Array(arr) => {
+            let mut i = 0;
+            while i < arr.len() {
+                if arr[i].is_null() {
+                    arr.remove(i);
+                } else {
+                    remove_nulls_in_place(&mut arr[i]);
+                    i += 1;
+                }
+            }
+        }
+        serde_json::Value::Object(obj) => {
+            let keys: Vec<_> = obj.keys().cloned().collect();
+            for key in keys {
+                if let Some(v) = obj.get_mut(&key) {
+                    if v.is_null() {
+                        obj.remove(&key);
+                    } else {
+                        remove_nulls_in_place(v);
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+}

data/lib/mawsitsit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mawsitsit
-  VERSION = "0.1.12"
+  VERSION = "0.1.13"
 end

data/var/data_lever_test_1.identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

data/var/data_lever_test_1.json

@@ -0,0 +1,333 @@
+
+{
+    "data": {
+        "id": "54d15a33-c024-4ba4-bc62-6f9588978758",
+        "text": "test",
+        "customQuestions": [
+            {
+                "id": "911f7ca4-e7a2-4081-9472-0c1f94d9df25",
+                "text": "Custom Questions",
+                "fields": [
+                    {
+                        "description": "",
+                        "required": true,
+                        "text": "Short text",
+                        "type": "text",
+                        "id": "e7ac71d9-78e2-403a-a541-6c1802ee21e6",
+                        "value": null
+                    },
+                    {
+                        "description": "",
+                        "required": true,
+                        "text": "Long text",
+                        "type": "textarea",
+                        "id": "5844afad-6f34-47a1-bf69-b099e48db9c7",
+                        "value": null
+                    },
+                    {
+                        "description": "",
+                        "required": true,
+                        "text": "Dropdown",
+                        "type": "dropdown",
+                        "id": "5c89bddd-7aa7-430f-9db7-98ba78a524a9",
+                        "prompt": "Choose one",
+                        "options": [
+                            {
+                                "text": "Choice 1",
+                                "optionId": "b0e17be1-c39f-4899-8fc5-a0b74b230371"
+                            },
+                            {
+                                "text": "Choice 2",
+                                "optionId": "d36aec06-c439-4832-8982-11e9c29bcb54"
+                            },
+                            {
+                                "text": "Choice 3",
+                                "optionId": "c1a6f7e3-bfeb-436d-8c78-08f08d7353f1"
+                            },
+                            {
+                                "text": "Choice 4",
+                                "optionId": "0a5fc73b-d775-4d31-8b7f-fb19a852c59d"
+                            }
+                        ],
+                        "value": null
+                    },
+                    {
+                        "description": "",
+                        "required": true,
+                        "text": "File upload",
+                        "type": "file-upload",
+                        "id": "4d1e49c2-1619-4216-9245-7f69c63b400d",
+                        "value": null
+                    },
+                    {
+                        "description": "",
+                        "required": true,
+                        "text": "Single Choice",
+                        "type": "multiple-select",
+                        "id": "4b3898d9-6dfa-4602-874a-dbe31fc8945c",
+                        "options": [
+                            {
+                                "text": "Option1",
+                                "optionId": "ff2e4a8a-0736-444f-b950-c4ab2c749973"
+                            },
+                            {
+                                "text": "Option2",
+                                "optionId": "f6f58997-2fa2-485f-85fd-fdb840913120"
+                            }
+                        ],
+                        "value": []
+                    },
+                    {
+                        "description": "",
+                        "required": true,
+                        "text": "Multiple Choice",
+                        "type": "multiple-choice",
+                        "id": "d9cf6785-2452-44bf-9eba-6854b68863c2",
+                        "options": [
+                            {
+                                "text": "MC1",
+                                "optionId": "0dab75d4-b915-4838-b764-c546a30f50e8"
+                            },
+                            {
+                                "text": "MC2",
+                                "optionId": "b4d057f0-5b4f-4182-b060-8147e670b4f9"
+                            },
+                            {
+                                "text": "MC3",
+                                "optionId": "7be4a1c6-ea29-41c6-b5c7-57b687341885"
+                            }
+                        ],
+                        "value": null
+                    }
+                ],
+                "distribution": [
+                    "external"
+                ]
+            }
+        ],
+        "personalInformation": [
+            {
+                "text": "Full name",
+                "name": "fullName",
+                "type": "text",
+                "required": true,
+                "value": null
+            },
+            {
+                "text": "Email",
+                "name": "email",
+                "type": "text",
+                "required": true,
+                "value": null
+            },
+            {
+                "text": "Current company",
+                "name": "currentCompany",
+                "type": "text",
+                "required": false,
+                "value": null
+            },
+            {
+                "text": "Current location",
+                "name": "currentLocation",
+                "type": "text",
+                "required": true,
+                "value": null
+            },
+            {
+                "text": "Phone",
+                "name": "phone",
+                "type": "text",
+                "required": false,
+                "value": null
+            },
+            {
+                "text": "Resume",
+                "name": "resume",
+                "type": "file-upload",
+                "required": false,
+                "value": null
+            },
+            {
+                "text": "Additional information",
+                "name": "additionalInformation",
+                "type": "textarea",
+                "required": false,
+                "value": null
+            }
+        ],
+        "urls": [
+            {
+                "text": "LinkedIn",
+                "name": "LinkedIn",
+                "type": "text",
+                "required": false,
+                "value": null
+            },
+            {
+                "text": "Twitter",
+                "name": "Twitter",
+                "type": "text",
+                "required": false,
+                "value": null
+            },
+            {
+                "text": "GitHub",
+                "name": "GitHub",
+                "type": "text",
+                "required": false,
+                "value": null
+            },
+            {
+                "text": "Portfolio",
+                "name": "Portfolio",
+                "type": "text",
+                "required": false,
+                "value": null
+            },
+            {
+                "text": "Other",
+                "name": "Other",
+                "type": "text",
+                "required": false,
+                "value": null
+            }
+        ],
+        "consentDisclosures": null,
+        "eeoQuestions": {
+            "gender": {
+                "description": null,
+                "required": false,
+                "text": "Gender",
+                "type": "dropdown",
+                "options": [
+                {
+                    "text": "Female",
+                    "optionId": "Female"
+                },
+                {
+                    "text": "Male",
+                    "optionId": "Male"
+                },
+                {
+                    "text": "Decline to self-identify",
+                    "optionId": "Decline to self-identify"
+                }
+                ],
+                "prompt": "Gender",
+                "value": null
+            },
+            "race": {
+                "description": null,
+                "required": false,
+                "text": "Race",
+                "type": "dropdown",
+                "options": [
+                {
+                    "text": "Hispanic or Latino",
+                    "optionId": "Hispanic or Latino",
+                    "description": "A person of Cuban, Mexican, Puerto Rican, South or Central American, or other Spanish culture or origin regardless of race."
+                },
+                {
+                    "text": "White (Not Hispanic or Latino)",
+                    "optionId": "White (Not Hispanic or Latino)",
+                    "description": "A person having origins in any of the original peoples of Europe, the Middle East, or North Africa."
+                },
+                {
+                    "text": "Black or African American (Not Hispanic or Latino)",
+                    "optionId": "Black or African American (Not Hispanic or Latino)",
+                    "description": "A person having origins in any of the black racial groups of Africa."
+                },
+                {
+                    "text": "Native Hawaiian or Other Pacific Islander (Not Hispanic or Latino)",
+                    "optionId": "Native Hawaiian or Other Pacific Islander (Not Hispanic or Latino)",
+                    "description": "A person having origins in any of the peoples of Hawaii, Guam, Samoa, or other Pacific Islands."
+                },
+                {
+                    "text": "Asian (Not Hispanic or Latino)",
+                    "optionId": "Asian (Not Hispanic or Latino)",
+                    "description": "A person having origins in any of the original peoples of the Far East, Southeast Asia, or the Indian Subcontinent, including, for example, Cambodia, China, India, Japan, Korea, Malaysia, Pakistan, the Philippine Islands, Thailand, and Vietnam."
+                },
+                {
+                    "text": "American Indian or Alaska Native (Not Hispanic or Latino)",
+                    "optionId": "American Indian or Alaska Native (Not Hispanic or Latino)",
+                    "description": "A person having origins in any of the original peoples of North and South America (including Central America), and who maintain tribal affiliation or community attachment."
+                },
+                {
+                    "text": "Two or More Races (Not Hispanic or Latino)",
+                    "optionId": "Two or More Races (Not Hispanic or Latino)",
+                    "description": "All persons who identify with more than one of the above five races."
+                },
+                {
+                    "text": "Decline to self-identify",
+                    "optionId": "Decline to self-identify"
+                }
+                ],
+                "prompt": "Race",
+                "value": null
+            },
+            "veteran": {
+                "description": "We are a Government contractor subject to the Section 4212 of the Vietnam Era Veterans’ Readjustment Assistance Act of 1974, as amended by the Jobs for Veterans Act of 2002, which requires Government contractors to take affirmative action to employ and advance in employment: (1) Disabled veterans – A veteran who served on active duty in the U.S. military and is entitled to disability compensation (or who but for the receipt of military retired pay would be entitled to disability compensation) under laws administered by the Secretary of Veterans Affairs, or was discharged or released from active duty because of a service-connected disability; (2) Recently separated veteran – A veteran separated during the three-year period beginning on the date of the veteran's discharge or release from active duty in the U.S military, ground, naval, or air service; (3) Active duty wartime or campaign badge veteran – A veteran who served on active duty in the U.S. military during a war, or in a campaign or expedition for which a campaign badge was authorized under the laws administered by the Department of Defense; (4) Armed forces service medal veteran – A veteran who, while serving on active duty in the U.S. military ground, naval, or air service, participated in a United States military operation for which an Armed Forces service medal was awarded pursuant to Executive Order 12985 (61 Fed. Reg. 1209).  If you believe that you belong to any of the categories of protected veterans, please indicate by making the appropriate selection.",
+                "required": false,
+                "text": "Veteran status",
+                "type": "dropdown",
+                "options": [
+                {
+                    "text": "I am a Protected Veteran",
+                    "optionId": "I am a Protected Veteran",
+                    "description": "I identify as one or more of the classifications of protected veteran"
+                },
+                {
+                    "text": "I am not a Protected Veteran",
+                    "optionId": "I am not a Protected Veteran",
+                    "description": "I do not identify as one or more of the classifications of protected veteran"
+                },
+                {
+                    "text": "Decline to self-identify",
+                    "optionId": "Decline to self-identify",
+                    "description": "I decline to self-identify for protected veteran status"
+                }
+                ],
+                "prompt": "Veteran status",
+                "value": null
+            },
+            "disability": {
+                "description": null,
+                "required": false,
+                "text": "Voluntary self-identification of disability",
+                "type": "dropdown",
+                "options": [
+                {
+                    "text": "Yes, I have a disability, or have a history/record of having a disability",
+                    "optionId": "Yes, I have a disability, or have a history/record of having a disability"
+                },
+                {
+                    "text": "No, I don't have a disability, or a history/record of having a disability",
+                    "optionId": "No, I don't have a disability, or a history/record of having a disability"
+                },
+                {
+                    "text": "I don't wish to answer",
+                    "optionId": "I don't wish to answer"
+                }
+                ],
+                "prompt": "Voluntary self-identification of disability",
+                "value": null
+            },
+            "disabilitySignature": {
+                "type": "text",
+                "text": "Disability signature",
+                "description": "Captured user signature string. eg. \"First Last\"",
+                "required": false,
+                "value": null
+            },
+            "disabilitySignatureDate": {
+                "type": "text",
+                "text": "Disability signature date",
+                "description": "Please enter the date when the disabilitySignature was filled out eg. \"11/21/2022\"",
+                "required": false,
+                "value": null
+            }
+        }
+    }
+    
+}

data/var/data_lever_test_2.identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

data/var/data_lever_test_2.json

@@ -0,0 +1,52 @@
+{
+    "data": {
+        "id": "54d15a33-c024-4ba4-bc62-6f9588978758",
+        "text": "test",
+        "state": "published",
+        "distributionChannels": [
+            "public"
+        ],
+        "user": "715f7dbc-7e66-4bf6-949e-2d8bf368f9f5",
+        "owner": "715f7dbc-7e66-4bf6-949e-2d8bf368f9f5",
+        "hiringManager": null,
+        "categories": {
+            "commitment": "worktype1",
+            "department": null,
+            "level": null,
+            "location": "STUTTGART",
+            "team": "team1",
+            "allLocations": [
+                "STUTTGART"
+            ]
+        },
+        "tags": [],
+        "content": {
+            "description": "Hello World\n",
+            "descriptionHtml": "<div>Hello World</div>",
+            "lists": [],
+            "closing": "",
+            "closingHtml": ""
+        },
+        "country": "AS",
+        "followers": [
+            "715f7dbc-7e66-4bf6-949e-2d8bf368f9f5"
+        ],
+        "reqCode": "",
+        "requisitionCodes": [],
+        "urls": {
+            "list": "https://jobs.sandbox.lever.co/de",
+            "show": "https://jobs.sandbox.lever.co/de/54d15a33-c024-4ba4-bc62-6f9588978758",
+            "apply": "https://jobs.sandbox.lever.co/de/54d15a33-c024-4ba4-bc62-6f9588978758/apply"
+        },
+        "confidentiality": "non-confidential",
+        "createdAt": 1716466155252,
+        "updatedAt": 1719617791866,
+        "workplaceType": "onsite",
+        "salaryRange": {
+            "min": 1,
+            "max": 123,
+            "currency": "EUR",
+            "interval": "per-year-salary"
+        }
+    }
+}

data/var/expected_test_1.identifier

@@ -1,3 +1,2 @@
-
 [ZoneTransfer]
 ZoneId=3

data/var/lever_test_1.identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

data/var/lever_test_1.json

@@ -0,0 +1,41 @@
+{
+    "job_id": null,
+    "job_type": null,
+    "job_slug": null,
+    "job_type_value": null,
+    "activity_status": null,
+    "job_status": null,
+    "user_id": null,
+    "referrer_url": null,
+    "duration": null,
+    "code_lang": null,
+    "title": null,
+    "position": null,
+    "description": null,
+    "key_skills": null,
+    "salary": null,
+    "euro_salary": null,
+    "relevance_score": null,
+    "currency": null,
+    "start_slot": null,
+    "longitude": null,
+    "latitude": null,
+    "country_code": null,
+    "postal_code": null,
+    "city": null,
+    "address": null,
+    "view_count": null,
+    "created_at": null,
+    "updated_at": null,
+    "applications_count": null,
+    "employer_rating": null,
+    "job_notifications": null,
+    "boost": null,
+    "cv_required": null,
+    "allowed_cv_formats": null,
+    "deleted_at": null,
+    "job_value": null,
+    "allowed_cv_format": null,
+    "application_options_attributes": "data-<lever>",
+    "image_url": null
+  }

data/var/lever_test_2.identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

data/var/lever_test_2.json

@@ -0,0 +1,41 @@
+{
+    "job_id": null,
+    "job_type": null,
+    "job_slug": "data.id",
+    "job_type_value": null,
+    "activity_status": null,
+    "job_status": "data.state-<enum|published:listed,else:unlisted>",
+    "user_id": null,
+    "referrer_url": "data.urls.show",
+    "duration": null,
+    "code_lang": null,
+    "title": "data.text",
+    "position": "data.text",
+    "description": "data.content.descriptionHtml",
+    "key_skills": null,
+    "salary": null,
+    "euro_salary": null,
+    "relevance_score": null,
+    "currency": null,
+    "start_slot": null,
+    "longitude": null,
+    "latitude": null,
+    "country_code": "data.country",
+    "postal_code": null,
+    "city": "data.categories.allLocations-<flatten>",
+    "address": null,
+    "view_count": null,
+    "created_at": null, 
+    "updated_at": null, 
+    "applications_count": null,
+    "employer_rating": null,
+    "job_notifications": null,
+    "boost": null,
+    "cv_required": null,
+    "allowed_cv_formats": null,
+    "deleted_at": null,
+    "job_value": null,
+    "allowed_cv_format": null,
+    "application_options_attributes": null,
+    "image_url": null
+  }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mawsitsit
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors:
 - Jan Hummel
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-23 00:00:00.000000000 Z
+date: 2024-06-29 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -38,6 +38,10 @@ files:
 - lib/mawsitsit.rb
 - lib/mawsitsit/version.rb
 - sig/mawsitsit.rbs
+- var/data_lever_test_1.identifier
+- var/data_lever_test_1.json
+- var/data_lever_test_2.identifier
+- var/data_lever_test_2.json
 - var/destination.Identifier
 - var/destination.json
 - var/expected.identifier
@@ -46,6 +50,10 @@ files:
 - var/expected_test_1.json
 - var/expected_test_2.identifier
 - var/expected_test_2.json
+- var/lever_test_1.identifier
+- var/lever_test_1.json
+- var/lever_test_2.identifier
+- var/lever_test_2.json
 - var/origin.Identifier
 - var/origin.json
 - var/test_1.identifier