1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
use std::borrow::Cow;
use std::collections::HashMap;
use spinoso_env::{ArgumentError as EnvArgumentError, Error as EnvError, InvalidError};
use crate::extn::prelude::*;
pub(in crate::extn) mod mruby;
pub(super) mod trampoline;
#[cfg(not(feature = "core-env-system"))]
type Backend = spinoso_env::Memory;
#[cfg(feature = "core-env-system")]
type Backend = spinoso_env::System;
#[derive(Default, Debug)]
#[allow(missing_copy_implementations)] pub struct Environ(Backend);
impl Environ {
#[must_use]
pub fn new() -> Self {
Self(Backend::new())
}
pub fn get(&self, name: &[u8]) -> Result<Option<Cow<'_, [u8]>>, Error> {
let value = self.0.get(name)?;
Ok(value)
}
pub fn put(&mut self, name: &[u8], value: Option<&[u8]>) -> Result<(), Error> {
self.0.put(name, value)?;
Ok(())
}
pub fn to_map(&self) -> Result<HashMap<Vec<u8>, Vec<u8>>, Error> {
let map = self.0.to_map()?;
Ok(map)
}
}
impl HeapAllocatedData for Environ {
const RUBY_TYPE: &'static str = "Artichoke::Environ";
}
impl From<EnvArgumentError> for Error {
fn from(err: EnvArgumentError) -> Self {
ArgumentError::from(err.message()).into()
}
}
impl From<InvalidError> for Error {
fn from(err: InvalidError) -> Self {
SystemCallError::from(err.into_message()).into()
}
}
impl From<EnvError> for Error {
fn from(err: EnvError) -> Self {
match err {
EnvError::Argument(err) => err.into(),
EnvError::Invalid(err) => err.into(),
}
}
}