osakit 0.1.1

OSAKit macOS Framework adapted for Rust
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

# osakit

`osakit` aims to provide direct access to `OSAKit Framework` of macOS. Is uses ObjC-bindings
to access OSAKit and run both `AppleScript` and `JavaScript`.

`osakit` is built using [`serde`](https://crates.io/crates/serde) for input-output
serialization/deserialization.
Allows passing data to `JavaScript`/`AppleScript` functions and returns back the results.
Input and output data are represented using `Value` from
[`serde_json`](https://crates.io/crates/serde_json).

Comes with `declare_script!` macro (unstable) to simplify working with `OSAKit Framework`.

## Installation

Add `osakit` to the dependencies. Specify `"full"` feature if you want to use `declare_script`
macro or `"stable"` feature to only include stable API.

```toml
[dependencies]
osakit = { version = "0.1.0", features = ["full"] }
```

## Example using `declare_script`

```rust
use serde::{Deserialize, Serialize};
use osakit::declare_script;
                                                                                                       
declare_script! {
    #[language(JavaScript)]
    #[source("
        function concat(x, y) {
            return x + y;
        }
                                                                                                       
        function multiply(a, b) {
            return a * b;
        }
                                                                                                       
        function current_user() {
            return {
                id: 21,
                name: \"root\"
            };
        }
    ")]
    MyJsScript {
        fn concat(x: &str, y: &str) -> String;
        fn multiply(a: i32, b: i32) -> i32;
        fn current_user() -> User;
    }
}
                                                                                                       
#[derive(Deserialize, Serialize, Debug, PartialEq, Eq)]
struct User {
    id: u16,
    name: String,
}
                                                                                                       
#[test]
fn it_runs_my_js_script() {
    let script = MyJsScript::new().unwrap();
    assert_eq!(
        script.multiply(3, 2).unwrap(),
        6
    );
    assert_eq!(
        script.concat("Hello, ", "World").unwrap(),
        "Hello, World"
    );
    assert_eq!(
        script.current_user().unwrap(),
        User {
            id: 21,
            name: "root".into()
        }
    );
}
```

## Example using `Script`

```rust
use osakit::{Language, Map, Script, Value, Number};
                                                                                                       
#[test]
fn it_constructs_and_executes_scripts() {
    let mut script = Script::new_from_source(
        Language::AppleScript, "
        on launch_terminal()
            tell application \"Terminal\" to launch
        end launch_terminal
                                                                                                       
        on concat(x, y)
            return x & y
        end concat
                                                                                                       
        return {id: 21, name: \"root\"}
    ");
                                                                                                       
    script.compile().unwrap();
                                                                                                       
    assert_eq!(
        script.execute().unwrap(),
        Value::Object(Map::from_iter(vec![
            ("id".into(), Value::Number(Number::from(21))),
            ("name".into(), Value::String("root".into()))
        ]))
    );
                                                                                                       
    assert_eq!(
        script.execute_function("concat", &vec![
            Value::String("Hello, ".into()),
            Value::String("World!".into())
        ]).unwrap(),
        Value::String("Hello, World!".into())
    );
                                                                                                       
    assert!(
        script.execute_function("launch_terminal", &vec![]).is_ok()
    );
}
```

## Usage

See [Full Documentation](https://docs.rs/osakit/).

## Supported platforms

Due to the fact that OSAKit is Mac-specific, only `macOS` is supported.

## License

Licensed under either of

* Apache License, Version 2.0
  ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
* MIT license
  ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)

at your option.

## Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.