├── .github
├── FUNDING.yml
├── dependabot.yml
└── workflows
│ ├── ci.yml
│ └── release.yml
├── .gitignore
├── CHANGELOG.md
├── Cargo.lock
├── Cargo.toml
├── LICENSE.md
├── README.md
├── assets
└── templates
│ ├── empty
│ ├── .gitignore
│ ├── project.json
│ ├── selene.toml
│ └── wally.toml
│ ├── model
│ ├── .gitignore
│ ├── LICENSE.md
│ ├── README.md
│ ├── project.json
│ ├── selene.toml
│ ├── src
│ │ └── .src.luau
│ └── wally.toml
│ ├── package
│ ├── .gitignore
│ ├── CHANGELOG.md
│ ├── LICENSE.md
│ ├── README.md
│ ├── project.json
│ ├── selene.toml
│ ├── src
│ │ └── init.luau
│ └── wally.toml
│ ├── place
│ ├── .gitignore
│ ├── README.md
│ ├── project.json
│ ├── selene.toml
│ ├── src
│ │ ├── Client
│ │ │ └── Main.client.luau
│ │ ├── Server
│ │ │ └── Main.server.luau
│ │ └── Shared
│ │ │ └── Hello.luau
│ └── wally.toml
│ ├── plugin
│ ├── .gitignore
│ ├── CHANGELOG.md
│ ├── LICENSE.md
│ ├── README.md
│ ├── project.json
│ ├── selene.toml
│ ├── src
│ │ └── .src.server.luau
│ └── wally.toml
│ └── quick
│ ├── .gitignore
│ ├── project.json
│ ├── selene.toml
│ ├── src
│ ├── ReplicatedFirst
│ │ └── .gitkeep
│ ├── ReplicatedStorage
│ │ └── .gitkeep
│ ├── ServerScriptService
│ │ └── .gitkeep
│ ├── ServerStorage
│ │ └── .gitkeep
│ ├── StarterGui
│ │ └── .gitkeep
│ ├── StarterPack
│ │ └── .gitkeep
│ ├── StarterPlayer
│ │ ├── StarterCharacterScripts
│ │ │ └── .gitkeep
│ │ └── StarterPlayerScripts
│ │ │ └── .gitkeep
│ └── Workspace
│ │ └── .gitkeep
│ └── wally.toml
├── build.rs
├── crates
├── config-derive
│ ├── .gitignore
│ ├── Cargo.lock
│ ├── Cargo.toml
│ ├── LICENSE
│ ├── rustfmt.toml
│ ├── src
│ │ ├── lib.rs
│ │ └── util.rs
│ └── tests
│ │ └── mod.rs
├── json-formatter
│ ├── .gitignore
│ ├── Cargo.lock
│ ├── Cargo.toml
│ ├── LICENSE
│ ├── rustfmt.toml
│ └── src
│ │ └── lib.rs
├── notify-debouncer-full
│ ├── .gitignore
│ ├── Cargo.lock
│ ├── Cargo.toml
│ ├── LICENSE-APACHE
│ ├── LICENSE-MIT
│ ├── rustfmt.toml
│ └── src
│ │ ├── cache.rs
│ │ ├── debounced_event.rs
│ │ ├── lib.rs
│ │ └── testing.rs
├── profiling
│ ├── .gitignore
│ ├── Cargo.lock
│ ├── Cargo.toml
│ ├── profiling-procmacros
│ │ ├── Cargo.toml
│ │ └── src
│ │ │ └── lib.rs
│ ├── profiling
│ │ ├── Cargo.toml
│ │ ├── src
│ │ │ └── lib.rs
│ │ └── tests
│ │ │ └── mod.rs
│ └── rustfmt.toml
└── self_update
│ ├── .gitignore
│ ├── Cargo.lock
│ ├── Cargo.toml
│ ├── LICENSE
│ ├── build.rs
│ ├── rustfmt.toml
│ └── src
│ ├── backends
│ ├── github.rs
│ └── mod.rs
│ ├── errors.rs
│ ├── lib.rs
│ ├── macros.rs
│ ├── update.rs
│ └── version.rs
├── rustfmt.toml
├── scripts
└── release
├── src
├── cli
│ ├── build.rs
│ ├── config.rs
│ ├── debug.rs
│ ├── doc.rs
│ ├── exec.rs
│ ├── init.rs
│ ├── mod.rs
│ ├── plugin.rs
│ ├── serve.rs
│ ├── sourcemap.rs
│ ├── stop.rs
│ ├── studio.rs
│ └── update.rs
├── config.rs
├── constants.rs
├── core
│ ├── changes.rs
│ ├── helpers
│ │ ├── migrations.rs
│ │ ├── mod.rs
│ │ └── syncback.rs
│ ├── meta.rs
│ ├── mod.rs
│ ├── processor
│ │ ├── mod.rs
│ │ ├── read.rs
│ │ └── write.rs
│ ├── queue.rs
│ ├── snapshot.rs
│ └── tree.rs
├── crash_handler.rs
├── ext.rs
├── glob.rs
├── installer.rs
├── integration.rs
├── lib.rs
├── logger.rs
├── main.rs
├── middleware
│ ├── csv.rs
│ ├── data.rs
│ ├── dir.rs
│ ├── helpers
│ │ ├── markdown.rs
│ │ ├── mesh_part.rs
│ │ ├── mod.rs
│ │ └── snapshot.rs
│ ├── json.rs
│ ├── json_model.rs
│ ├── luau.rs
│ ├── md.rs
│ ├── mod.rs
│ ├── msgpack.rs
│ ├── project.rs
│ ├── rbxm.rs
│ ├── rbxmx.rs
│ ├── toml.rs
│ ├── txt.rs
│ └── yaml.rs
├── program.rs
├── project.rs
├── resolution.rs
├── server
│ ├── details.rs
│ ├── exec.rs
│ ├── home.rs
│ ├── mod.rs
│ ├── open.rs
│ ├── read.rs
│ ├── snapshot.rs
│ ├── stop.rs
│ ├── subscribe.rs
│ ├── unsubscribe.rs
│ └── write.rs
├── sessions.rs
├── stats.rs
├── studio.rs
├── updater.rs
├── util.rs
├── vfs
│ ├── debouncer.rs
│ ├── mem_backend.rs
│ ├── mod.rs
│ └── std_backend.rs
└── workspace.rs
└── tests
└── resolution.rs
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: DervexDev
2 | ko_fi: Dervex
3 |
--------------------------------------------------------------------------------
/.github/dependabot.yml:
--------------------------------------------------------------------------------
1 | version: 2
2 | updates:
3 | - package-ecosystem: "cargo"
4 | directory: "/"
5 | schedule:
6 | interval: "monthly"
7 | time: "06:00"
8 | open-pull-requests-limit: 40
9 | ignore:
10 | - dependency-name: "*"
11 | update-types:
12 | - "version-update:semver-major"
13 |
--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
1 | name: CI
2 |
3 | on:
4 | push:
5 | branches:
6 | - main
7 |
8 | pull_request:
9 | branches:
10 | - main
11 |
12 | env:
13 | RUSTFLAGS: "-D warnings"
14 |
15 | jobs:
16 | build-test:
17 | name: Build and Test
18 | runs-on: ${{ matrix.os }}
19 |
20 | strategy:
21 | matrix:
22 | os: [ubuntu-latest, macos-latest, windows-latest]
23 |
24 | steps:
25 | - uses: actions/checkout@v4
26 |
27 | - name: Cache
28 | uses: Swatinem/rust-cache@v2
29 |
30 | - name: Build
31 | run: cargo build --verbose
32 |
33 | - name: Test
34 | run: cargo test --verbose
35 |
36 | lint-format:
37 | name: Lint and Format
38 | runs-on: ubuntu-latest
39 |
40 | steps:
41 | - uses: actions/checkout@v4
42 |
43 | - name: Cache
44 | uses: Swatinem/rust-cache@v2
45 |
46 | - name: Lint
47 | run: cargo clippy
48 |
49 | - name: Format
50 | run: cargo fmt -- --check
51 |
--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
1 | name: Release
2 |
3 | on:
4 | push:
5 | tags: ["*"]
6 |
7 | jobs:
8 | bump:
9 | name: Bump Version
10 | runs-on: ubuntu-latest
11 |
12 | steps:
13 | - uses: actions/checkout@v4
14 | with:
15 | ref: main
16 |
17 | - name: Update Changelog
18 | uses: thomaseizinger/keep-a-changelog-new-release@v3
19 | with:
20 | tag: ${{ github.ref_name }}
21 |
22 | - name: Bump Cargo version
23 | id: version-bump
24 | uses: DervexDev/file-version-bumper@v1
25 | with:
26 | path: ./Cargo.toml
27 |
28 | - name: Update Cargo lock
29 | run: cargo update --workspace
30 |
31 | - name: Commit and Push
32 | uses: EndBug/add-and-commit@v9
33 | if: ${{ github.ref_name != steps.version-bump.outputs.old_version }}
34 | with:
35 | message: Bump version to ${{ github.ref_name }}
36 | default_author: github_actions
37 |
38 | - name: Update tag
39 | if: ${{ github.ref_name != steps.version-bump.outputs.old_version }}
40 | run: |
41 | git tag -fa ${{ github.ref_name }} -m "Release ${{ github.ref_name }}"
42 | git push -f --tags
43 |
44 | draft-release:
45 | name: Draft Release
46 | runs-on: ubuntu-latest
47 | needs: bump
48 |
49 | outputs:
50 | upload_url: ${{ steps.create-release.outputs.upload_url }}
51 | release_id: ${{ steps.create-release.outputs.id }}
52 |
53 | steps:
54 | - uses: actions/checkout@v4
55 | with:
56 | ref: main
57 |
58 | - name: Read Changelog
59 | id: read-changes
60 | uses: mindsers/changelog-reader-action@v2
61 | with:
62 | version: ${{ github.ref_name }}
63 |
64 | - name: Get previous Tag
65 | id: previous-tag
66 | uses: WyriHaximus/github-action-get-previous-tag@v1
67 |
68 | - name: Create Release
69 | id: create-release
70 | uses: shogo82148/actions-create-release@v1
71 | with:
72 | release_name: ${{ github.ref_name }}
73 | body: |
74 | ## Changelog
75 | ${{ steps.read-changes.outputs.changes }}
76 | prerelease: ${{ contains(github.ref_name, 'pre') }}
77 | notes_start_tag: ${{ steps.previous-tag.outputs.tag }}
78 | generate_release_notes: true
79 | commitish: main
80 | draft: true
81 |
82 | build:
83 | name: Build (${{ matrix.label }})
84 | runs-on: ${{ matrix.os }}
85 | needs: draft-release
86 |
87 | strategy:
88 | matrix:
89 | include:
90 | # x86_64
91 | - host: linux
92 | os: ubuntu-22.04
93 | target: x86_64-unknown-linux-gnu
94 | label: linux-x86_64
95 |
96 | - host: macos
97 | os: macos-latest
98 | target: x86_64-apple-darwin
99 | label: macos-x86_64
100 |
101 | - host: windows
102 | os: windows-latest
103 | target: x86_64-pc-windows-msvc
104 | label: windows-x86_64
105 |
106 | # aarch64
107 | - host: macos
108 | os: macos-latest
109 | target: aarch64-apple-darwin
110 | label: macos-aarch64
111 |
112 | steps:
113 | - uses: actions/checkout@v4
114 | with:
115 | ref: main
116 |
117 | - name: Setup Rust
118 | uses: hecrj/setup-rust-action@v2
119 | with:
120 | targets: ${{ matrix.target }}
121 |
122 | - name: Build
123 | run: cargo build --all-features --release --verbose --target ${{ matrix.target }}
124 | env:
125 | ARGON_TOKEN: ${{ secrets.ARGON_TOKEN }}
126 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
127 |
128 | - name: Archive
129 | shell: bash
130 | run: |
131 | mkdir release
132 |
133 | if [ "${{ matrix.host }}" = "windows" ]; then
134 | cp "target/${{ matrix.target }}/release/argon.exe" release/
135 | cd release
136 | 7z a ../release.zip *
137 | else
138 | cp "target/${{ matrix.target }}/release/argon" release/
139 | cd release
140 | zip ../release.zip *
141 | fi
142 |
143 | - name: Upload to Artifacts
144 | uses: actions/upload-artifact@v4
145 | with:
146 | name: argon-${{ github.ref_name }}-${{ matrix.label }}.zip
147 | path: release.zip
148 |
149 | - name: Upload to Release
150 | uses: shogo82148/actions-upload-release-asset@v1
151 | with:
152 | upload_url: ${{ needs.draft-release.outputs.upload_url }}
153 | asset_name: argon-${{ github.ref_name }}-${{ matrix.label }}.zip
154 | asset_path: release.zip
155 |
156 | publish-release:
157 | name: Publish Release
158 | runs-on: ubuntu-latest
159 | needs: [build, draft-release]
160 |
161 | steps:
162 | - name: Publish on GitHub
163 | uses: eregon/publish-release@v1
164 | env:
165 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
166 | with:
167 | release_id: ${{ needs.draft-release.outputs.release_id }}
168 |
169 | # - name: Publish on crates.io
170 | # run: cargo publish
171 | # env:
172 | # CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
173 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | /target
3 | /sourcemap.json
4 | *.rbxm
5 | *.rbxmx
6 | *.rbxl
7 | *.rbxlx
8 |
--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "argon-rbx"
3 | authors = ["Dervex"]
4 | description = "Full featured tool for Roblox development"
5 | repository = "https://github.com/argon-rbx/argon"
6 | documentation = "https://argon.wiki/docs"
7 | homepage = "https://argon.wiki"
8 | license = "Apache-2.0"
9 | version = "2.0.24"
10 | edition = "2021"
11 | build = "build.rs"
12 |
13 | [[bin]]
14 | name = "argon"
15 | path = "src/main.rs"
16 |
17 | [lib]
18 | name = "argon"
19 | path = "src/lib.rs"
20 |
21 | [features]
22 | plugin = []
23 |
24 | [dependencies]
25 | rbx_xml = "1.0.0"
26 | rbx_binary = "1.0.0"
27 | rbx_dom_weak = "3.0.0"
28 | rbx_reflection = "5.0.0"
29 | rbx_reflection_database = "1.0.3"
30 |
31 | config-derive = { version = "*", path = "crates/config-derive" }
32 | json-formatter = { version = "*", path = "crates/json-formatter" }
33 | profiling = { version = "*", path = "crates/profiling/profiling" }
34 |
35 | uuid = { version = "1.17.0", features = ["v4", "fast-rng"] }
36 | serde = { version = "1.0.219", features = ["derive"] }
37 | rmpv = { version = "1.3.0", features = ["with-serde"] }
38 | clap = { version = "4.5.40", features = ["derive", "cargo"] }
39 | reqwest = { version = "0.12.18", default-features = false, features = [
40 | "blocking",
41 | "rustls-tls",
42 | "json",
43 | ] }
44 | self_update = { version = "0.39.0", default-features = false, features = [
45 | "compression-zip-deflate",
46 | "rustls",
47 | ] }
48 |
49 | notify-debouncer-full = "0.3.1"
50 | clap-verbosity-flag = "2.2.3"
51 | crossbeam-channel = "0.5.15"
52 | derive-from-one = "0.1.0"
53 | roblox_install = "1.0.0"
54 | panic-message = "0.3.0"
55 | actix-msgpack = "0.1.4"
56 | puffin_http = "0.16.0"
57 | serde_json = "1.0.140"
58 | env_logger = "0.11.6"
59 | include_dir = "0.7.4"
60 | directories = "5.0.1"
61 | lazy_static = "1.5.0"
62 | backtrace = "0.3.75"
63 | documented = "0.9.1"
64 | dialoguer = "0.11.0"
65 | path-clean = "1.0.1"
66 | rmp-serde = "1.3.0"
67 | actix-web = "4.11.0"
68 | multimap = "0.10.1"
69 | optfield = "0.4.0"
70 | markdown = "0.3.0"
71 |
72 | json2lua = "0.1.3"
73 | toml2lua = "0.1.0"
74 | yaml2lua = "0.1.1"
75 | globenv = "0.2.1"
76 |
77 | puffin = "0.19.0"
78 | colored = "2.2.0"
79 | anyhow = "1.0.98"
80 | chrono = "0.4.41"
81 | notify = "6.1.1"
82 | whoami = "1.6.0"
83 | trash = "5.2.2"
84 | ctrlc = "3.4.7"
85 | toml = "0.8.22"
86 | glob = "0.3.2"
87 | open = "5.3.2"
88 | log = "0.4.27"
89 | csv = "1.3.1"
90 |
91 | [target.'cfg(not(target_os = "linux"))'.dependencies]
92 | keybd_event = "0.1.2"
93 |
94 | [target.'cfg(target_os = "windows")'.dependencies]
95 | winsafe = { version = "0.0.23", features = ["user"] }
96 |
97 | [build-dependencies]
98 | anyhow = "1.0.98"
99 | self_update = { version = "0.39.0", default-features = false, features = [
100 | "rustls",
101 | ] }
102 |
103 | [dev-dependencies]
104 | approx = "0.5.1"
105 |
106 | [patch.crates-io]
107 | notify-debouncer-full = { path = "crates/notify-debouncer-full" }
108 | self_update = { path = "crates/self_update" }
109 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
Full featured tool for Roblox development
4 |
[,
11 | }
12 |
13 | impl Changes {
14 | pub fn new() -> Self {
15 | Self {
16 | additions: Vec::new(),
17 | updates: Vec::new(),
18 | removals: Vec::new(),
19 | }
20 | }
21 |
22 | pub fn add(&mut self, snapshot: Snapshot, parent: Ref) {
23 | self.additions.push(AddedSnapshot {
24 | id: snapshot.id,
25 | parent,
26 | name: snapshot.name,
27 | class: snapshot.class,
28 | properties: snapshot.properties,
29 | children: snapshot.children,
30 | meta: snapshot.meta,
31 | });
32 | }
33 |
34 | pub fn update(&mut self, modified_snapshot: UpdatedSnapshot) {
35 | self.updates.push(modified_snapshot);
36 | }
37 |
38 | pub fn remove(&mut self, id: Ref) {
39 | self.removals.push(id);
40 | }
41 |
42 | pub fn extend(&mut self, changes: Self) {
43 | self.additions.extend(changes.additions);
44 | self.updates.extend(changes.updates);
45 | self.removals.extend(changes.removals);
46 | }
47 |
48 | pub fn is_empty(&self) -> bool {
49 | self.additions.is_empty() && self.updates.is_empty() && self.removals.is_empty()
50 | }
51 |
52 | pub fn total(&self) -> usize {
53 | self.additions.len() + self.updates.len() + self.removals.len()
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/src/core/helpers/migrations.rs:
--------------------------------------------------------------------------------
1 | // Temporary module for ContentId to Content migration of selected properties
2 |
3 | use rbx_dom_weak::{
4 | types::{Content, Variant},
5 | Ustr,
6 | };
7 | use std::{collections::HashMap, sync::OnceLock};
8 |
9 | use crate::Properties;
10 |
11 | pub type Migrations = HashMap<&'static str, HashMap<&'static str, &'static str>>;
12 |
13 | fn get_migrations() -> &'static Migrations {
14 | static MIGRATIONS: OnceLock = OnceLock::new();
15 |
16 | MIGRATIONS.get_or_init(|| {
17 | HashMap::from([
18 | ("ImageLabel", HashMap::from([("Image", "ImageContent")])),
19 | ("ImageButton", HashMap::from([("Image", "ImageContent")])),
20 | (
21 | "MeshPart",
22 | HashMap::from([("MeshId", "MeshContent"), ("TextureID", "TextureContent")]),
23 | ),
24 | ("BaseWrap", HashMap::from([("CageMeshId", "CageMeshContent")])),
25 | (
26 | "WrapLayer",
27 | HashMap::from([("ReferenceMeshId", "ReferenceMeshContent")]),
28 | ),
29 | ])
30 | })
31 | }
32 |
33 | pub fn apply<'a>(class: &str, properties: &'a mut Properties) -> Option<&'a mut Properties> {
34 | let migration = get_migrations().get(class)?;
35 |
36 | for (old, new) in migration {
37 | let new = Ustr::from(new);
38 |
39 | if properties.contains_key(&new) {
40 | continue;
41 | }
42 |
43 | if let Some(Variant::ContentId(value)) = properties.remove(&Ustr::from(old)) {
44 | properties.insert(new, Content::from(value.as_str()).into());
45 | }
46 | }
47 |
48 | Some(properties)
49 | }
50 |
--------------------------------------------------------------------------------
/src/core/helpers/mod.rs:
--------------------------------------------------------------------------------
1 | use crate::Properties;
2 |
3 | mod migrations;
4 |
5 | pub mod syncback;
6 |
7 | #[inline]
8 | pub fn apply_migrations(class: &str, properties: &mut Properties) {
9 | migrations::apply(class, properties);
10 | }
11 |
--------------------------------------------------------------------------------
/src/core/processor/read.rs:
--------------------------------------------------------------------------------
1 | use std::path::Path;
2 |
3 | use log::{error, trace};
4 | use rbx_dom_weak::types::Ref;
5 |
6 | use crate::{
7 | core::{
8 | changes::Changes,
9 | meta::SourceKind,
10 | snapshot::{Snapshot, UpdatedSnapshot},
11 | tree::Tree,
12 | },
13 | middleware::{new_snapshot, project::new_snapshot_node},
14 | stats, util,
15 | vfs::Vfs,
16 | };
17 |
18 | pub fn process_changes(id: Ref, tree: &mut Tree, vfs: &Vfs) -> Option {
19 | trace!("Processing changes for instance: {:?}", id);
20 |
21 | let mut changes = Changes::new();
22 |
23 | let meta = tree.get_meta(id)?;
24 | let source = meta.source.get();
25 |
26 | let process_path = |path: &Path| -> Option> {
27 | match new_snapshot(path, &meta.context, vfs) {
28 | Ok(snapshot) => Some(snapshot),
29 | Err(err) => {
30 | error!("Failed to process changes: {}, source: {:?}", err, source);
31 | None
32 | }
33 | }
34 | };
35 |
36 | let snapshot = match source {
37 | SourceKind::Project(name, path, node, node_path) => {
38 | if node_path.is_root() {
39 | process_path(path)?
40 | } else {
41 | match new_snapshot_node(name, path, *node.clone(), node_path.clone(), &meta.context, vfs) {
42 | Ok(snapshot) => Some(snapshot),
43 | Err(err) => {
44 | error!("Failed to process changes: {}, source: {:?}", err, source);
45 | return Some(changes);
46 | }
47 | }
48 | }
49 | }
50 | SourceKind::Path(path) => process_path(path)?,
51 | SourceKind::None => panic!(
52 | "Fatal processing error: `SourceKind::None` should not be present in the tree! Id: {:?}, meta: {:#?}",
53 | id, meta
54 | ),
55 | };
56 |
57 | // Handle additions, modifications and child removals
58 | if let Some(snapshot) = snapshot {
59 | process_child_changes(id, snapshot, &mut changes, tree);
60 | // Handle regular removals
61 | } else {
62 | tree.remove_instance(id);
63 | changes.remove(id);
64 | }
65 |
66 | Some(changes)
67 | }
68 |
69 | fn process_child_changes(id: Ref, mut snapshot: Snapshot, changes: &mut Changes, tree: &mut Tree) {
70 | // Process instance changes
71 | let mut updated_snapshot = UpdatedSnapshot::new(id);
72 |
73 | updated_snapshot.meta = if snapshot.meta != *tree.get_meta(id).expect("Instance meta not found") {
74 | tree.update_meta(id, snapshot.meta.clone());
75 | Some(snapshot.meta)
76 | } else {
77 | None
78 | };
79 |
80 | let instance = tree.get_instance_mut(id).unwrap();
81 |
82 | updated_snapshot.name = if snapshot.name != instance.name {
83 | instance.name.clone_from(&snapshot.name);
84 | Some(snapshot.name)
85 | } else {
86 | None
87 | };
88 |
89 | updated_snapshot.class = if snapshot.class != instance.class {
90 | instance.class.clone_from(&snapshot.class);
91 | Some(snapshot.class)
92 | } else {
93 | None
94 | };
95 |
96 | updated_snapshot.properties = if snapshot.properties != instance.properties {
97 | instance.properties.clone_from(&snapshot.properties);
98 | Some(snapshot.properties)
99 | } else {
100 | None
101 | };
102 |
103 | if !updated_snapshot.is_empty() {
104 | // Track `lines_synced` stat
105 | if let Some(properties) = &updated_snapshot.properties {
106 | let loc = util::count_loc_from_properties(properties);
107 | stats::lines_synced(loc as u32);
108 | }
109 |
110 | changes.update(updated_snapshot);
111 | }
112 |
113 | let mut hydrated = vec![false; snapshot.children.len()];
114 |
115 | // Pair instances and find removed children
116 | #[allow(clippy::unnecessary_to_owned)]
117 | for child_id in instance.children().to_owned() {
118 | let instance = tree.get_instance(child_id).unwrap();
119 |
120 | let snapshot = snapshot.children.iter_mut().enumerate().find(|(index, child)| {
121 | if hydrated[*index] {
122 | return false;
123 | }
124 |
125 | if child.name == instance.name && child.class == instance.class {
126 | hydrated[*index] = true;
127 | return true;
128 | }
129 |
130 | false
131 | });
132 |
133 | if let Some((_, child)) = snapshot {
134 | child.set_id(child_id);
135 | } else {
136 | tree.remove_instance(child_id);
137 | changes.remove(child_id);
138 | }
139 | }
140 |
141 | // Process child changes and find new children
142 | for child in snapshot.children {
143 | if child.id.is_some() {
144 | process_child_changes(child.id, child, changes, tree);
145 | } else {
146 | let mut child = child;
147 |
148 | insert_children(&mut child, id, tree);
149 |
150 | // Track `lines_synced` stat
151 | let loc = util::count_loc_from_properties(&child.properties);
152 | stats::lines_synced(loc as u32);
153 |
154 | changes.add(child, id);
155 | }
156 | }
157 | }
158 |
159 | fn insert_children(snapshot: &mut Snapshot, parent: Ref, tree: &mut Tree) {
160 | let id = tree.insert_instance(snapshot.clone(), parent);
161 |
162 | snapshot.set_id(id);
163 |
164 | for child in snapshot.children.iter_mut() {
165 | insert_children(child, id, tree);
166 | }
167 | }
168 |
--------------------------------------------------------------------------------
/src/core/queue.rs:
--------------------------------------------------------------------------------
1 | use anyhow::{bail, Result};
2 | use colored::Colorize;
3 | use crossbeam_channel::{Receiver, Sender};
4 | use std::{collections::HashMap, sync::RwLock};
5 |
6 | use crate::{
7 | argon_warn,
8 | config::Config,
9 | constants::QUEUE_TIMEOUT,
10 | server::{self, Message},
11 | };
12 |
13 | macro_rules! read {
14 | ($rwlock:expr) => {
15 | $rwlock.write().unwrap()
16 | };
17 | }
18 |
19 | macro_rules! write {
20 | ($rwlock:expr) => {
21 | $rwlock.write().unwrap()
22 | };
23 | }
24 |
25 | #[derive(Debug, Clone)]
26 | struct Listener {
27 | pub id: u32,
28 | pub name: String,
29 | pub is_internal: bool,
30 | }
31 |
32 | #[derive(Debug)]
33 | struct Channel {
34 | sender: Sender,
35 | receiver: Receiver,
36 | }
37 |
38 | #[derive(Debug)]
39 | pub struct Queue {
40 | queues: RwLock>,
41 | listeners: RwLock>,
42 | unsynced_changes: RwLock,
43 | }
44 |
45 | impl Queue {
46 | pub fn new() -> Self {
47 | Self {
48 | queues: RwLock::new(HashMap::new()),
49 | listeners: RwLock::new(Vec::new()),
50 | unsynced_changes: RwLock::new(0),
51 | }
52 | }
53 |
54 | pub fn push(&self, message: M, id: Option) -> Result<()>
55 | where
56 | M: Into,
57 | {
58 | if let Some(id) = id {
59 | if !self.is_subscribed(id) {
60 | bail!("Not subscribed")
61 | }
62 |
63 | let queues = read!(self.queues);
64 | let sender = queues.get(&id).unwrap().sender.clone();
65 |
66 | sender.send(message.into())?;
67 |
68 | return Ok(());
69 | }
70 |
71 | let message: Message = message.into();
72 | let mut did_push = false;
73 |
74 | for listener in read!(self.listeners).iter() {
75 | let queues = read!(self.queues);
76 | let sender = queues.get(&listener.id).unwrap().sender.clone();
77 |
78 | sender.send(message.clone())?;
79 |
80 | did_push = true;
81 | }
82 |
83 | if !did_push {
84 | let max_unsynced_changes = Config::new().max_unsynced_changes;
85 | let mut unsynced_changes = write!(self.unsynced_changes);
86 |
87 | *unsynced_changes += 1;
88 |
89 | if max_unsynced_changes > 0 && *unsynced_changes >= max_unsynced_changes {
90 | argon_warn!(
91 | "There are {} unsynced changes. Connect at least one client to this server or increase max_unsynced_changes setting to suppress this warning",
92 | unsynced_changes.to_string().bold()
93 | );
94 | }
95 | }
96 |
97 | Ok(())
98 | }
99 |
100 | pub fn get(&self, id: u32) -> Result> {
101 | if !self.is_subscribed(id) {
102 | bail!("Not subscribed")
103 | }
104 |
105 | let queues = read!(self.queues);
106 | let receiver = queues.get(&id).unwrap().receiver.clone();
107 |
108 | drop(queues);
109 |
110 | Ok(receiver.recv().ok())
111 | }
112 |
113 | pub fn get_timeout(&self, id: u32) -> Result> {
114 | if !self.is_subscribed(id) {
115 | bail!("Not subscribed")
116 | }
117 |
118 | let queues = read!(self.queues);
119 | let receiver = queues.get(&id).unwrap().receiver.clone();
120 |
121 | drop(queues);
122 |
123 | Ok(receiver.recv_timeout(QUEUE_TIMEOUT).ok())
124 | }
125 |
126 | pub fn get_change(&self, id: u32) -> Result {
127 | if !self.is_subscribed(id) {
128 | bail!("Not subscribed")
129 | }
130 |
131 | let queues = read!(self.queues);
132 | let receiver = queues.get(&id).unwrap().receiver.clone();
133 |
134 | drop(queues);
135 |
136 | Ok(loop {
137 | if let Ok(message) = receiver.recv() {
138 | if message.is_change() {
139 | break message;
140 | }
141 | }
142 | })
143 | }
144 |
145 | pub fn subscribe(&self, id: u32, name: &str) -> Result<()> {
146 | if self.is_subscribed(id) {
147 | bail!("Already subscribed")
148 | }
149 |
150 | let (sender, receiver) = crossbeam_channel::unbounded();
151 | let channel = Channel { sender, receiver };
152 |
153 | let listener = Listener {
154 | id,
155 | name: name.to_owned(),
156 | is_internal: false,
157 | };
158 |
159 | write!(self.listeners).push(listener);
160 | write!(self.queues).insert(id.to_owned(), channel);
161 |
162 | Ok(())
163 | }
164 |
165 | pub fn subscribe_internal(&self) -> Result<()> {
166 | let mut id = 0;
167 |
168 | loop {
169 | if !self.is_subscribed(id) {
170 | break;
171 | }
172 |
173 | id += 1;
174 | }
175 |
176 | let (sender, receiver) = crossbeam_channel::unbounded();
177 | let channel = Channel { sender, receiver };
178 |
179 | let listener = Listener {
180 | id,
181 | name: format!("Internal listener #{}", id),
182 | is_internal: true,
183 | };
184 |
185 | write!(self.listeners).push(listener);
186 | write!(self.queues).insert(id.to_owned(), channel);
187 |
188 | Ok(())
189 | }
190 |
191 | pub fn unsubscribe(&self, id: u32) -> Result<()> {
192 | if !self.is_subscribed(id) {
193 | bail!("Not subscribed")
194 | }
195 |
196 | write!(self.listeners).retain(|listener| listener.id != id);
197 | write!(self.queues).remove(&id);
198 |
199 | Ok(())
200 | }
201 |
202 | pub fn disconnect(&self, message: &str, id: u32) -> Result<()> {
203 | if !self.is_subscribed(id) {
204 | bail!("Not subscribed")
205 | }
206 |
207 | self.push(
208 | server::Disconnect {
209 | message: message.to_owned(),
210 | },
211 | Some(id),
212 | )?;
213 |
214 | Ok(())
215 | }
216 |
217 | pub fn is_subscribed(&self, id: u32) -> bool {
218 | read!(self.listeners).iter().any(|listener| listener.id == id)
219 | }
220 |
221 | pub fn get_first_non_internal_listener_name(&self) -> Option {
222 | read!(self.listeners)
223 | .iter()
224 | .find(|listener| !listener.is_internal)
225 | .map(|listener| listener.name.to_owned())
226 | }
227 | }
228 |
--------------------------------------------------------------------------------
/src/core/tree.rs:
--------------------------------------------------------------------------------
1 | use multimap::MultiMap;
2 | use rbx_dom_weak::{types::Ref, Instance, InstanceBuilder, WeakDom};
3 | use std::{
4 | collections::HashMap,
5 | path::{Path, PathBuf},
6 | };
7 |
8 | use super::{meta::Meta, snapshot::Snapshot};
9 |
10 | #[derive(Debug)]
11 | pub struct Tree {
12 | dom: WeakDom,
13 | path_to_ids: MultiMap,
14 | id_to_meta: HashMap,
15 | }
16 |
17 | impl Tree {
18 | pub fn new(snapshot: Snapshot) -> Self {
19 | let builder = InstanceBuilder::new(snapshot.class)
20 | .with_name(snapshot.name)
21 | .with_properties(snapshot.properties);
22 |
23 | let mut tree = Self {
24 | dom: WeakDom::new(builder),
25 | id_to_meta: HashMap::new(),
26 | path_to_ids: MultiMap::new(),
27 | };
28 |
29 | let root_ref = tree.dom.root_ref();
30 |
31 | tree.insert_meta(root_ref, snapshot.meta);
32 |
33 | for child in snapshot.children {
34 | tree.insert_instance_recursive(child, root_ref);
35 | }
36 |
37 | tree
38 | }
39 |
40 | pub fn insert_instance(&mut self, snapshot: Snapshot, parent: Ref) -> Ref {
41 | let builder = InstanceBuilder::new(snapshot.class)
42 | .with_name(snapshot.meta.original_name.as_ref().unwrap_or(&snapshot.name))
43 | .with_properties(snapshot.properties);
44 |
45 | let id = self.dom.insert(parent, builder);
46 |
47 | self.insert_meta(id, snapshot.meta);
48 |
49 | id
50 | }
51 |
52 | pub fn insert_instance_recursive(&mut self, snapshot: Snapshot, parent: Ref) -> Ref {
53 | let builder = InstanceBuilder::new(snapshot.class)
54 | .with_name(snapshot.meta.original_name.as_ref().unwrap_or(&snapshot.name))
55 | .with_properties(snapshot.properties);
56 |
57 | let id = self.dom.insert(parent, builder);
58 |
59 | self.insert_meta(id, snapshot.meta);
60 |
61 | for child in snapshot.children {
62 | self.insert_instance_recursive(child, id);
63 | }
64 |
65 | id
66 | }
67 |
68 | pub fn insert_instance_with_ref(&mut self, snapshot: Snapshot, parent: Ref) {
69 | let builder = InstanceBuilder::new(snapshot.class)
70 | .with_name(snapshot.meta.original_name.as_ref().unwrap_or(&snapshot.name))
71 | .with_referent(snapshot.id)
72 | .with_properties(snapshot.properties);
73 |
74 | let id = self.dom.insert(parent, builder);
75 |
76 | self.insert_meta(id, snapshot.meta);
77 | }
78 |
79 | pub fn remove_instance(&mut self, id: Ref) {
80 | let mut to_remove = vec![id];
81 |
82 | fn walk(id: Ref, dom: &WeakDom, to_remove: &mut Vec][) {
83 | let instance = dom.get_by_ref(id).unwrap();
84 |
85 | for child in instance.children() {
86 | to_remove.push(*child);
87 | walk(*child, dom, to_remove);
88 | }
89 | }
90 |
91 | walk(id, &self.dom, &mut to_remove);
92 |
93 | for id in to_remove {
94 | self.remove_meta(id);
95 | }
96 |
97 | self.dom.destroy(id);
98 | }
99 |
100 | pub fn get_instance(&self, id: Ref) -> Option<&Instance> {
101 | self.dom.get_by_ref(id)
102 | }
103 |
104 | pub fn get_instance_mut(&mut self, id: Ref) -> Option<&mut Instance> {
105 | self.dom.get_by_ref_mut(id)
106 | }
107 |
108 | pub fn insert_meta(&mut self, id: Ref, meta: Meta) -> Option {
109 | for path in meta.source.paths() {
110 | self.path_to_ids.insert(path.to_owned(), id);
111 | }
112 |
113 | self.id_to_meta.insert(id, meta)
114 | }
115 |
116 | pub fn update_meta(&mut self, id: Ref, meta: Meta) -> Option {
117 | let old_meta = self.id_to_meta.remove(&id);
118 |
119 | if let Some(old_meta) = &old_meta {
120 | let removed: Vec<&Path> = old_meta
121 | .source
122 | .paths()
123 | .into_iter()
124 | .filter(|&path| !meta.source.paths().contains(&path))
125 | .collect();
126 |
127 | let added: Vec<&Path> = meta
128 | .source
129 | .paths()
130 | .into_iter()
131 | .filter(|&path| !old_meta.source.paths().contains(&path))
132 | .collect();
133 |
134 | for path in removed {
135 | self.path_to_ids.remove(path);
136 | }
137 |
138 | for path in added {
139 | self.path_to_ids.insert(path.to_owned(), id);
140 | }
141 | }
142 |
143 | self.id_to_meta.insert(id, meta);
144 |
145 | old_meta
146 | }
147 |
148 | pub fn remove_meta(&mut self, id: Ref) -> Option {
149 | let meta = self.id_to_meta.remove(&id);
150 |
151 | if let Some(meta) = &meta {
152 | for path in meta.source.paths() {
153 | self.path_to_ids.remove(path);
154 | }
155 | }
156 |
157 | meta
158 | }
159 |
160 | pub fn get_meta(&self, id: Ref) -> Option<&Meta> {
161 | self.id_to_meta.get(&id)
162 | }
163 |
164 | pub fn get_meta_mut(&mut self, id: Ref) -> Option<&mut Meta> {
165 | self.id_to_meta.get_mut(&id)
166 | }
167 |
168 | pub fn get_ids(&self, path: &Path) -> Option<&Vec][> {
169 | self.path_to_ids.get_vec(path)
170 | }
171 |
172 | pub fn exists(&self, id: Ref) -> bool {
173 | self.dom.get_by_ref(id).is_some()
174 | }
175 |
176 | pub fn inner(&self) -> &WeakDom {
177 | &self.dom
178 | }
179 |
180 | pub fn meta_map(&self) -> &HashMap {
181 | &self.id_to_meta
182 | }
183 |
184 | pub fn id_map(&self) -> &MultiMap {
185 | &self.path_to_ids
186 | }
187 |
188 | pub fn root(&self) -> &Instance {
189 | self.dom.root()
190 | }
191 |
192 | pub fn root_ref(&self) -> Ref {
193 | self.dom.root_ref()
194 | }
195 |
196 | pub fn place_root_refs(&self) -> &[Ref] {
197 | self.dom.root().children()
198 | }
199 | }
200 |
--------------------------------------------------------------------------------
/src/crash_handler.rs:
--------------------------------------------------------------------------------
1 | use backtrace::Backtrace;
2 | use colored::Colorize;
3 | use log::{error, trace, LevelFilter};
4 | use open;
5 | use panic_message::get_panic_info_message;
6 | use std::{env, panic, process};
7 |
8 | use crate::{argon_error, logger, util};
9 |
10 | const MAX_BACKTRACE_LEN: usize = 6500;
11 |
12 | pub fn hook() {
13 | panic::set_hook(Box::new(|panic_info| {
14 | let message = get_panic_info_message(panic_info).unwrap_or("Failed to get panic info message");
15 | let backtrace_enabled = util::env_backtrace();
16 | let verbosity = util::env_verbosity();
17 |
18 | let mut report = String::from("> This crash report was automatically generated by Argon");
19 | report.push_str("\n\nDetails:\n--------\n");
20 | report.push_str("*Provide extra details about your problem or what happened here*");
21 |
22 | argon_error!("{}", "Argon has crashed!".bold());
23 |
24 | report.push_str("\n\nMessage:\n----------\n");
25 | report.push_str(message);
26 |
27 | argon_error!("{}: {}", "Message".bold(), message);
28 |
29 | report.push_str("\n\nLocation:\n----------\n");
30 |
31 | if let Some(location) = panic_info.location() {
32 | report.push_str(location.file());
33 | report.push_str(": ");
34 | report.push_str(&location.line().to_string());
35 |
36 | argon_error!("{}: {}: {}", "Location".bold(), location.file(), location.line());
37 | } else {
38 | report.push_str("Failed to get panic info location");
39 | }
40 |
41 | report.push_str("\n\nVerbose output:\n----------------\n");
42 |
43 | if verbosity != LevelFilter::Trace {
44 | report.push_str("Verbose output disabled, run Argon with `-vvvv` flag to enable");
45 |
46 | argon_error!(
47 | "{}: Run Argon with {} flag to show detailed tracing",
48 | "Verbosity".bold(),
49 | "-vvvv".bold()
50 | );
51 | } else {
52 | report.push_str("```\nPast your verbose output here\n```");
53 | }
54 |
55 | report.push_str("\n\nBacktrace:\n-----------\n");
56 |
57 | if backtrace_enabled {
58 | let backtrace = Backtrace::new();
59 |
60 | argon_error!("{}:\n{:?}", "Backtrace".bold(), backtrace);
61 |
62 | // Temporary solution for broken OsString parser
63 | let mut backtrace = format!("{:?}", backtrace);
64 | backtrace = backtrace.replace(" ", "\t\t");
65 | backtrace = backtrace.replace(" ", "\t");
66 | backtrace = backtrace.replace(" ", "");
67 | backtrace = backtrace.replace(" ", "");
68 | backtrace = backtrace.replace('&', "ptr");
69 |
70 | if backtrace.len() > MAX_BACKTRACE_LEN {
71 | backtrace.drain(..MAX_BACKTRACE_LEN);
72 | backtrace.push_str("\n...\n");
73 | }
74 |
75 | report.push_str("```\n");
76 | report.push_str(&backtrace);
77 | report.push_str("```");
78 | } else {
79 | report.push_str("Backtrace disabled, run Argon with `--backtrace` flag to enable");
80 |
81 | argon_error!(
82 | "{}: Run Argon with {} flag to show full backtrace\n",
83 | "Backtrace".bold(),
84 | "--backtrace".bold()
85 | );
86 | }
87 |
88 | let report_issue = logger::prompt(
89 | "Would you like to create new issue on GitHub with current report?",
90 | false,
91 | );
92 |
93 | if report_issue {
94 | let mut url = env!("CARGO_PKG_REPOSITORY").to_owned();
95 | url.push_str(&format!("/issues/new?title=Argon crashed: {}&body=", message));
96 |
97 | #[cfg(not(target_os = "windows"))]
98 | url.push_str(&report);
99 |
100 | #[cfg(target_os = "windows")]
101 | url.push_str(&report.replace('\n', "%0A").replace('\t', "%09"));
102 |
103 | match open::that(url) {
104 | Err(err) => error!("Failed to launch system browser: {}", err),
105 | Ok(()) => trace!("Browser launched successfully"),
106 | }
107 | }
108 |
109 | process::exit(1)
110 | }));
111 | }
112 |
--------------------------------------------------------------------------------
/src/ext.rs:
--------------------------------------------------------------------------------
1 | use anyhow::{bail, Result};
2 | use env_logger::WriteStyle;
3 | use path_clean::PathClean;
4 | use rbx_reflection::{PropertyDescriptor, PropertyKind, PropertySerialization};
5 | use std::{
6 | env,
7 | fmt::Display,
8 | path::{Path, PathBuf},
9 | };
10 |
11 | /// Collection of extension methods for `Path`
12 | pub trait PathExt {
13 | fn resolve(&self) -> Result;
14 | fn to_string(&self) -> String;
15 | fn get_name(&self) -> &str;
16 | fn get_stem(&self) -> &str;
17 | fn get_ext(&self) -> &str;
18 | fn get_parent(&self) -> &Path;
19 | fn len(&self) -> usize;
20 | fn is_empty(&self) -> bool;
21 | fn contains(&self, pat: &[&str]) -> bool;
22 | }
23 |
24 | impl PathExt for Path {
25 | fn resolve(&self) -> Result {
26 | if self.is_absolute() {
27 | return Ok(self.to_owned());
28 | }
29 |
30 | let current_dir = env::current_dir()?;
31 | let absolute = current_dir.join(self);
32 |
33 | Ok(absolute.clean())
34 | }
35 |
36 | fn to_string(&self) -> String {
37 | self.to_str().unwrap_or_default().to_owned()
38 | }
39 |
40 | fn get_name(&self) -> &str {
41 | self.file_name().unwrap_or_default().to_str().unwrap_or_default()
42 | }
43 |
44 | fn get_stem(&self) -> &str {
45 | if !self.is_dir() {
46 | self.file_stem().unwrap_or_default().to_str().unwrap_or_default()
47 | } else {
48 | self.get_name()
49 | }
50 | }
51 |
52 | fn get_ext(&self) -> &str {
53 | if !self.is_dir() {
54 | self.extension().unwrap_or_default().to_str().unwrap_or_default()
55 | } else {
56 | ""
57 | }
58 | }
59 |
60 | fn get_parent(&self) -> &Path {
61 | self.parent().unwrap_or(self)
62 | }
63 |
64 | fn len(&self) -> usize {
65 | self.components().count()
66 | }
67 |
68 | fn is_empty(&self) -> bool {
69 | self.len() == 0
70 | }
71 |
72 | fn contains(&self, pattern: &[&str]) -> bool {
73 | let mut index = 0;
74 |
75 | for comp in self.components() {
76 | if pattern[index] == comp.as_os_str() {
77 | index += 1;
78 |
79 | if index == pattern.len() {
80 | return true;
81 | }
82 | } else if index > 0 {
83 | return false;
84 | }
85 | }
86 |
87 | false
88 | }
89 | }
90 |
91 | /// Additional methods for `anyhow::Error`, similar to `context` and `with_context`
92 | pub trait ResultExt {
93 | fn desc(self, desc: D) -> Result
94 | where
95 | D: Display + Send + Sync + 'static;
96 |
97 | fn with_desc(self, f: F) -> Result
98 | where
99 | C: Display + Send + Sync + 'static,
100 | F: FnOnce() -> C;
101 | }
102 |
103 | impl ResultExt for Result
104 | where
105 | E: Display + Send + Sync + 'static,
106 | {
107 | fn desc(self, desc: D) -> Result
108 | where
109 | D: Display + Send + Sync + 'static,
110 | {
111 | match self {
112 | Ok(ok) => Ok(ok),
113 | Err(err) => {
114 | bail!("{}: {}", desc, err);
115 | }
116 | }
117 | }
118 |
119 | fn with_desc(self, desc: F) -> Result
120 | where
121 | C: Display + Send + Sync + 'static,
122 | F: FnOnce() -> C,
123 | {
124 | match self {
125 | Ok(ok) => Ok(ok),
126 | Err(err) => {
127 | bail!("{}: {}", desc(), err);
128 | }
129 | }
130 | }
131 | }
132 |
133 | /// `to_string` implementation for `WriteStyle`
134 | pub trait WriteStyleExt {
135 | fn to_string(&self) -> String;
136 | }
137 |
138 | impl WriteStyleExt for WriteStyle {
139 | fn to_string(&self) -> String {
140 | let write_style = match self {
141 | WriteStyle::Always => "always",
142 | WriteStyle::Auto => "auto",
143 | WriteStyle::Never => "never",
144 | };
145 |
146 | String::from(write_style)
147 | }
148 | }
149 |
150 | /// Additional methods for `rbx_reflection::PropertyDescriptor`
151 | pub trait PropertyDescriptorExt {
152 | fn get_custom_serialization(&self) -> Option;
153 | }
154 |
155 | impl PropertyDescriptorExt for PropertyDescriptor<'_> {
156 | fn get_custom_serialization(&self) -> Option {
157 | match &self.kind {
158 | PropertyKind::Canonical {
159 | serialization: PropertySerialization::SerializesAs(data_type),
160 | } => Some(data_type.to_string()),
161 | _ => None,
162 | }
163 | }
164 | }
165 |
--------------------------------------------------------------------------------
/src/glob.rs:
--------------------------------------------------------------------------------
1 | use glob::{glob, Paths, Pattern, PatternError};
2 | use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer};
3 | use std::{
4 | fmt::{self, Debug, Formatter},
5 | path::{Path, PathBuf},
6 | };
7 |
8 | #[derive(Clone, PartialEq)]
9 | pub struct Glob {
10 | pattern: Pattern,
11 | }
12 |
13 | impl Glob {
14 | pub fn new(pattern: &str) -> Result {
15 | #[cfg(not(target_os = "windows"))]
16 | let pattern = pattern.replace('\\', "/");
17 |
18 | #[cfg(target_os = "windows")]
19 | let pattern = pattern.replace('/', "\\");
20 |
21 | Ok(Self {
22 | pattern: Pattern::new(&pattern)?,
23 | })
24 | }
25 |
26 | pub fn from_path(path: &Path) -> Result {
27 | Self::new(path.to_str().unwrap_or_default())
28 | }
29 |
30 | pub fn matches(&self, str: &str) -> bool {
31 | self.pattern.matches(str)
32 | }
33 |
34 | pub fn matches_path(&self, path: &Path) -> bool {
35 | self.pattern.matches_path(path)
36 | }
37 |
38 | pub fn matches_path_with_dir(&self, path: &Path) -> bool {
39 | let matches = self.pattern.matches_path(path);
40 |
41 | if !matches && self.pattern.as_str().ends_with("/**") {
42 | if let Ok(pattern) = Pattern::new(self.pattern.as_str().strip_suffix("/**").unwrap()) {
43 | return pattern.matches_path(path);
44 | } else {
45 | return false;
46 | }
47 | }
48 |
49 | matches
50 | }
51 |
52 | pub fn first(&self) -> Option {
53 | let path = glob(self.pattern.as_str()).unwrap().next();
54 |
55 | if let Some(path) = path {
56 | return Some(path.unwrap_or_default());
57 | }
58 |
59 | None
60 | }
61 |
62 | pub fn iter(&self) -> Paths {
63 | glob(self.pattern.as_str()).unwrap()
64 | }
65 |
66 | pub fn as_str(&self) -> &str {
67 | self.pattern.as_str()
68 | }
69 | }
70 |
71 | impl Serialize for Glob {
72 | fn serialize(&self, serializer: S) -> Result {
73 | serializer.serialize_str(self.pattern.as_str())
74 | }
75 | }
76 |
77 | impl<'de> Deserialize<'de> for Glob {
78 | fn deserialize>(deserializer: D) -> Result {
79 | let pattern = String::deserialize(deserializer)?;
80 | Self::new(&pattern).map_err(Error::custom)
81 | }
82 | }
83 |
84 | impl Debug for Glob {
85 | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
86 | write!(f, "{}", self.pattern.as_str())
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/src/integration.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use colored::Colorize;
3 | use log::{debug, warn};
4 | use serde::Deserialize;
5 | use std::{collections::HashMap, fs, path::Path};
6 |
7 | use crate::{
8 | glob::Glob,
9 | logger,
10 | program::{Program, ProgramName},
11 | };
12 |
13 | type Deps = HashMap;
14 |
15 | #[derive(Debug, Deserialize)]
16 | #[serde(rename_all = "kebab-case")]
17 | struct WallyManifest {
18 | dependencies: Option,
19 | server_dependencies: Option,
20 | dev_dependencies: Option,
21 | }
22 |
23 | impl WallyManifest {
24 | fn get_directories(&self) -> HashMap {
25 | let mut directories = HashMap::new();
26 |
27 | let mut join = |dependencies: &Option, path: &str| {
28 | if let Some(dependency) = dependencies {
29 | if !dependency.is_empty() {
30 | directories.insert(path.to_owned(), dependency.clone());
31 | }
32 | }
33 | };
34 |
35 | join(&self.dependencies, "Packages");
36 | join(&self.server_dependencies, "ServerPackages");
37 | join(&self.dev_dependencies, "DevPackages");
38 |
39 | directories
40 | }
41 | }
42 |
43 | fn install_wally_packages(workspace_path: &Path) -> Result<()> {
44 | let install = logger::prompt(
45 | &format!("Looks like your project uses Wally but one of the directories is missing or one of the dependencies is not installed. Would you like to run {} now?",
46 | "wally install".bold()
47 | ),
48 | true
49 | );
50 |
51 | if !install {
52 | return Ok(());
53 | }
54 |
55 | Program::new(ProgramName::Wally)
56 | .message("Failed to install dependencies")
57 | .arg("install")
58 | .current_dir(workspace_path)
59 | .output()?;
60 |
61 | Ok(())
62 | }
63 |
64 | pub fn check_wally_packages(workspace_path: &Path) {
65 | let manifest_path = workspace_path.join("wally.toml");
66 |
67 | if !manifest_path.exists() {
68 | debug!("Aborted package verification: wally.toml does not exist");
69 | return;
70 | }
71 |
72 | let verify_wally_manifest = || -> Result<()> {
73 | let manifest: WallyManifest = toml::from_str(&fs::read_to_string(manifest_path)?)?;
74 |
75 | for (path, dependencies) in manifest.get_directories() {
76 | let path = workspace_path.join(path);
77 | let index_path = path.join("_Index");
78 |
79 | if !path.exists() || !index_path.exists() {
80 | return install_wally_packages(workspace_path);
81 | }
82 |
83 | for (short, long) in dependencies {
84 | let short = Glob::from_path(&path.join(short + ".lua*"))?;
85 |
86 | let long = long.replace('/', "_");
87 | let long = long.rsplit_once("@").unwrap_or_default().0.to_owned();
88 | let long = Glob::from_path(&index_path.join(long + "*"))?;
89 |
90 | if short.first().is_none() || long.first().is_none() {
91 | return install_wally_packages(workspace_path);
92 | }
93 | }
94 | }
95 |
96 | Ok(())
97 | };
98 |
99 | match verify_wally_manifest() {
100 | Ok(()) => (),
101 | Err(err) => {
102 | warn!("Failed to verify or install missing Wally packages: {}", err);
103 | }
104 | }
105 | }
106 |
--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
1 | #![allow(clippy::new_without_default)]
2 |
3 | use rbx_dom_weak::{types::Variant, UstrMap};
4 |
5 | pub mod cli;
6 | pub mod config;
7 | pub mod constants;
8 | pub mod core;
9 | pub mod crash_handler;
10 | pub mod ext;
11 | pub mod glob;
12 | pub mod installer;
13 | pub mod integration;
14 | pub mod logger;
15 | pub mod middleware;
16 | pub mod program;
17 | pub mod project;
18 | pub mod resolution;
19 | pub mod server;
20 | pub mod sessions;
21 | pub mod stats;
22 | pub mod studio;
23 | pub mod updater;
24 | pub mod util;
25 | pub mod vfs;
26 | pub mod workspace;
27 |
28 | /// Global type for snapshot and instance properties
29 | pub type Properties = UstrMap;
30 |
31 | /// A shorter way to lock the Mutex
32 | #[macro_export]
33 | macro_rules! lock {
34 | ($mutex:expr) => {
35 | $mutex.lock().expect("Tried to lock Mutex that panicked!")
36 | };
37 | }
38 |
--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
1 | use env_logger::WriteStyle;
2 | use log::{debug, error, info, warn};
3 | use puffin_http::Server;
4 | use std::{
5 | env,
6 | io::{self, IsTerminal},
7 | mem::ManuallyDrop,
8 | process::ExitCode,
9 | thread,
10 | };
11 |
12 | use argon::{argon_error, cli::Cli, config::Config, crash_handler, installer, logger, stats, updater};
13 |
14 | const PROFILER_ADDRESS: &str = "localhost:8888";
15 |
16 | fn main() -> ExitCode {
17 | crash_handler::hook();
18 |
19 | let config_kind = Config::load();
20 | let config = Config::new().clone();
21 |
22 | let is_managed = installer::is_managed();
23 | let installation = installer::verify(is_managed, config.install_plugin);
24 |
25 | let cli = Cli::new();
26 |
27 | let yes = cli.yes();
28 | let backtrace = cli.backtrace();
29 | let verbosity = cli.verbosity();
30 | let log_style = cli.log_style();
31 |
32 | if log_style == WriteStyle::Auto && io::stdin().is_terminal() {
33 | env::set_var("RUST_LOG_STYLE", "always");
34 | } else {
35 | env::set_var(
36 | "RUST_LOG_STYLE",
37 | match log_style {
38 | WriteStyle::Always => "always",
39 | _ => "never",
40 | },
41 | )
42 | }
43 |
44 | env::set_var("RUST_VERBOSE", verbosity.as_str());
45 | env::set_var("RUST_YES", if yes { "1" } else { "0" });
46 | env::set_var("RUST_BACKTRACE", if backtrace { "1" } else { "0" });
47 |
48 | logger::init(verbosity, log_style);
49 |
50 | match config_kind {
51 | Ok(kind) => info!("{:?} config loaded", kind),
52 | Err(err) => error!("Failed to load config file: {}", err),
53 | }
54 |
55 | match installation {
56 | Ok(()) => info!("Argon installation verified successfully!"),
57 | Err(err) => warn!("Failed to verify Argon installation: {}", err),
58 | }
59 |
60 | let handle = thread::spawn(move || {
61 | if !is_managed && config.check_updates {
62 | match updater::check_for_updates(config.install_plugin, config.update_templates, !config.auto_update) {
63 | Ok(()) => info!("Update check completed successfully!"),
64 | Err(err) => warn!("Update check failed: {}", err),
65 | }
66 | }
67 |
68 | if config.share_stats {
69 | match stats::track() {
70 | Ok(()) => info!("Stat tracker initialized successfully!"),
71 | Err(err) => warn!("Failed to initialize stat tracker: {}", err),
72 | }
73 | }
74 | });
75 |
76 | if cfg!(debug_assertions) && cli.profile() {
77 | match Server::new(PROFILER_ADDRESS) {
78 | Ok(server) => {
79 | let _ = ManuallyDrop::new(server);
80 |
81 | info!("Profiler started at {}", PROFILER_ADDRESS);
82 | }
83 | Err(err) => {
84 | error!("Failed to start profiler: {}", err);
85 | }
86 | }
87 |
88 | puffin::set_scopes_on(true);
89 | }
90 |
91 | let exit_code = match cli.main() {
92 | Ok(()) => {
93 | debug!("Successfully executed command!");
94 | ExitCode::SUCCESS
95 | }
96 | Err(err) => {
97 | argon_error!("{}", err);
98 | ExitCode::FAILURE
99 | }
100 | };
101 |
102 | handle.join().ok();
103 | stats::save().ok();
104 |
105 | exit_code
106 | }
107 |
--------------------------------------------------------------------------------
/src/middleware/csv.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use csv::{ReaderBuilder, WriterBuilder};
3 | use rbx_dom_weak::{types::Variant, ustr, HashMapExt, UstrMap};
4 | use serde::{Deserialize, Serialize};
5 | use std::{collections::HashMap, path::Path};
6 |
7 | use crate::{core::snapshot::Snapshot, vfs::Vfs, Properties};
8 |
9 | #[derive(Debug, Default, Serialize, Deserialize)]
10 | struct LocalizationEntry {
11 | key: Option,
12 | context: Option,
13 | example: Option,
14 | source: Option,
15 | values: HashMap,
16 | }
17 |
18 | #[profiling::function]
19 | pub fn read_csv(path: &Path, vfs: &Vfs) -> Result {
20 | let contents = vfs.read(path)?;
21 |
22 | if contents.is_empty() {
23 | return Ok(Snapshot::new().with_class("LocalizationTable"));
24 | }
25 |
26 | let mut reader = ReaderBuilder::new()
27 | .has_headers(true)
28 | .flexible(true)
29 | .from_reader(contents.as_slice());
30 |
31 | let headers = reader.headers()?.clone();
32 | let mut entries = Vec::new();
33 |
34 | for record in reader.records() {
35 | let mut entry = LocalizationEntry::default();
36 |
37 | for (index, field) in record?.iter().enumerate() {
38 | if field.is_empty() {
39 | continue;
40 | }
41 |
42 | let header = headers.get(index);
43 |
44 | if let Some(header) = header {
45 | match header {
46 | "Key" => entry.key = Some(field.to_owned()),
47 | "Source" => entry.source = Some(field.to_owned()),
48 | "Context" => entry.context = Some(field.to_owned()),
49 | "Example" => entry.example = Some(field.to_owned()),
50 | _ => {
51 | entry.values.insert(header.to_owned(), field.to_owned());
52 | }
53 | }
54 | }
55 | }
56 |
57 | if entry.key.is_some() || entry.source.is_some() {
58 | entries.push(entry);
59 | }
60 | }
61 |
62 | let contents = serde_json::to_string(&entries)?;
63 |
64 | let mut properties = UstrMap::new();
65 | properties.insert(ustr("Contents"), Variant::String(contents));
66 |
67 | Ok(Snapshot::new()
68 | .with_class("LocalizationTable")
69 | .with_properties(properties))
70 | }
71 |
72 | #[profiling::function]
73 | pub fn write_csv(mut properties: Properties, path: &Path, vfs: &Vfs) -> Result {
74 | if let Some(Variant::String(contents)) = properties.remove(&ustr("Contents")) {
75 | let entries: Vec = serde_json::from_str(&contents)?;
76 | let mut contents = Vec::new();
77 |
78 | let mut writer = WriterBuilder::new()
79 | .has_headers(true)
80 | .flexible(true)
81 | .from_writer(&mut contents);
82 |
83 | writer.write_record(["Key", "Source", "Context", "Example"])?;
84 |
85 | for entry in entries {
86 | let mut record = vec![
87 | entry.key.unwrap_or_default(),
88 | entry.source.unwrap_or_default(),
89 | entry.context.unwrap_or_default(),
90 | entry.example.unwrap_or_default(),
91 | ];
92 |
93 | for value in entry.values.values() {
94 | record.push(value.to_owned());
95 | }
96 |
97 | writer.write_record(&record)?;
98 | }
99 |
100 | writer.flush()?;
101 | drop(writer);
102 |
103 | vfs.write(path, &contents)?;
104 | }
105 |
106 | Ok(properties)
107 | }
108 |
--------------------------------------------------------------------------------
/src/middleware/dir.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use std::path::Path;
3 |
4 | use super::new_snapshot;
5 | use crate::{
6 | core::{
7 | meta::{Context, Meta, Source},
8 | snapshot::Snapshot,
9 | },
10 | ext::PathExt,
11 | vfs::Vfs,
12 | };
13 |
14 | #[profiling::function]
15 | pub fn read_dir(path: &Path, context: &Context, vfs: &Vfs) -> Result {
16 | let name = path.get_name();
17 |
18 | let mut snapshot = Snapshot::new()
19 | .with_name(name)
20 | .with_meta(Meta::new().with_context(context).with_source(Source::directory(path)));
21 |
22 | for path in vfs.read_dir(path)? {
23 | if let Some(child_snapshot) = new_snapshot(&path, context, vfs)? {
24 | snapshot.add_child(child_snapshot);
25 | }
26 | }
27 |
28 | Ok(snapshot)
29 | }
30 |
31 | #[profiling::function]
32 | pub fn write_dir(path: &Path, vfs: &Vfs) -> Result<()> {
33 | vfs.create_dir(path)?;
34 |
35 | Ok(())
36 | }
37 |
--------------------------------------------------------------------------------
/src/middleware/helpers/markdown.rs:
--------------------------------------------------------------------------------
1 | use markdown::{
2 | Block::{self, Blockquote, CodeBlock, Header, Hr, OrderedList, Paragraph, Raw, UnorderedList},
3 | ListItem,
4 | Span::{self, Break, Code, Emphasis, Image, Link, Strong, Text},
5 | };
6 |
7 | const LIST_ELEMENT_PREFIX: &str = "•";
8 |
9 | fn escape(text: &str) -> String {
10 | text.replace("&", "&")
11 | .replace("<", "<")
12 | .replace("\"", """)
13 | .replace("'", "’")
14 | .replace(">", ">")
15 | }
16 |
17 | fn format_spans(elements: &[Span]) -> String {
18 | let mut string = String::new();
19 |
20 | for element in elements.iter() {
21 | string.push_str(&match *element {
22 | Text(ref text) => escape(text),
23 | Strong(ref content) => format!("{}", format_spans(content)),
24 | Emphasis(ref content) => format!("{}", format_spans(content)),
25 | Code(ref text) => format!(
26 | "{}",
27 | &escape(text)
28 | ),
29 | Link(ref text, _, _) => escape(text),
30 | Image(_, _, _) => String::new(),
31 | Break => String::from("\n"),
32 | })
33 | }
34 |
35 | string
36 | }
37 |
38 | fn format_list(elements: &[ListItem], ordered: bool) -> String {
39 | let mut string = String::new();
40 |
41 | for (index, item) in elements.iter().enumerate() {
42 | let prefix = if ordered {
43 | format!("{}.", index + 1)
44 | } else {
45 | String::from(LIST_ELEMENT_PREFIX)
46 | };
47 |
48 | string.push_str(&format!(
49 | "{prefix} {}\n",
50 | match *item {
51 | ListItem::Simple(ref elements) => format_spans(elements),
52 | ListItem::Paragraph(ref elements) => walk(elements),
53 | }
54 | ))
55 | }
56 |
57 | format!("{}\n", string)
58 | }
59 |
60 | fn format_header(elements: &[Span], _level: usize) -> String {
61 | format!("{}\n\n", format_spans(elements),)
62 | }
63 |
64 | fn format_paragraph(elements: &[Span]) -> String {
65 | format!("{}\n\n", format_spans(elements))
66 | }
67 |
68 | fn format_blockquote(elements: &[Block]) -> String {
69 | format!("{}\n\n", walk(elements))
70 | }
71 |
72 | fn format_codeblock(_lang: &Option, elements: &str) -> String {
73 | format!(
74 | "{}\n\n",
75 | &escape(elements)
76 | )
77 | }
78 |
79 | fn format_unordered_list(elements: &[ListItem]) -> String {
80 | format_list(elements, false)
81 | }
82 |
83 | fn format_ordered_list(elements: &[ListItem]) -> String {
84 | format_list(elements, true)
85 | }
86 |
87 | fn walk(blocks: &[Block]) -> String {
88 | let mut string = String::new();
89 |
90 | for block in blocks.iter() {
91 | string.push_str(&match *block {
92 | Header(ref elements, level) => format_header(elements, level),
93 | Paragraph(ref elements) => format_paragraph(elements),
94 | Blockquote(ref elements) => format_blockquote(elements),
95 | CodeBlock(ref lang, ref elements) => format_codeblock(lang, elements),
96 | UnorderedList(ref elements) => format_unordered_list(elements),
97 | OrderedList(ref elements, _) => format_ordered_list(elements),
98 | Raw(ref elements) => elements.to_owned(),
99 | Hr => String::from("\n\n"),
100 | })
101 | }
102 |
103 | string.trim().to_owned()
104 | }
105 |
106 | pub fn parse(text: &str) -> String {
107 | walk(&markdown::tokenize(text))
108 | }
109 |
--------------------------------------------------------------------------------
/src/middleware/helpers/mesh_part.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use log::{debug, error, trace};
3 | use rbx_dom_weak::{types::Variant, ustr, InstanceBuilder, WeakDom};
4 | use roblox_install::RobloxStudio;
5 | use std::{
6 | collections::HashMap,
7 | fs::{self, File},
8 | io::BufWriter,
9 | path::Path,
10 | process,
11 | sync::RwLock,
12 | thread,
13 | };
14 |
15 | use crate::{ext::PathExt, util, Properties};
16 |
17 | const CUSTOM_MESH_PART_PROPERTIES: [&str; 2] = ["MeshContent", "InitialSize"];
18 |
19 | static INDEX: RwLock = RwLock::new(0);
20 |
21 | pub fn save_mesh(properties: &Properties) -> Option {
22 | let mut mesh_properties: HashMap<&str, Variant> = HashMap::new();
23 |
24 | for property in CUSTOM_MESH_PART_PROPERTIES {
25 | if let Some(value) = properties.get(&ustr(property)) {
26 | mesh_properties.insert(property, value.clone());
27 | }
28 | }
29 |
30 | if mesh_properties.is_empty() {
31 | return None;
32 | }
33 |
34 | let dom = WeakDom::new(InstanceBuilder::new("MeshPart").with_properties(mesh_properties));
35 |
36 | trace!("Writing MeshPart temporary binary model");
37 |
38 | let result = || -> Result {
39 | let pid = process::id().to_string();
40 | let path = RobloxStudio::locate()?.content_path().join("argon").join(&pid);
41 |
42 | let index = *INDEX.read().unwrap();
43 |
44 | if index == 0 {
45 | let path = path.clone();
46 |
47 | thread::spawn(move || match clear(&path) {
48 | Ok(_) => debug!("Cleared temporary mesh models"),
49 | Err(err) => error!("Failed to clear temporary mesh models: {}", err),
50 | });
51 | }
52 |
53 | if !path.exists() {
54 | fs::create_dir_all(&path)?;
55 | }
56 |
57 | let name = index.to_string();
58 | let writer = BufWriter::new(File::create(path.join(&name))?);
59 |
60 | rbx_binary::to_writer(writer, &dom, &[dom.root_ref()])?;
61 |
62 | Ok(pid + "/" + &name)
63 | }();
64 |
65 | match result {
66 | Ok(name) => {
67 | let mut index = INDEX.write().unwrap();
68 | *index += 1;
69 |
70 | Some(name)
71 | }
72 | Err(err) => {
73 | error!("Failed to write MeshPart temporary model: {}", err);
74 | None
75 | }
76 | }
77 | }
78 |
79 | fn clear(path: &Path) -> Result<()> {
80 | let ignore_name = path.get_name();
81 | let parent = path.get_parent();
82 |
83 | if !parent.exists() {
84 | return Ok(());
85 | }
86 |
87 | for entry in fs::read_dir(parent)? {
88 | let path = entry?.path();
89 | let name = path.get_name();
90 |
91 | if name == ignore_name {
92 | continue;
93 | }
94 |
95 | if path.is_dir() && !name.parse().is_ok_and(util::process_exists) {
96 | fs::remove_dir_all(&path)?;
97 | }
98 | }
99 |
100 | Ok(())
101 | }
102 |
--------------------------------------------------------------------------------
/src/middleware/helpers/mod.rs:
--------------------------------------------------------------------------------
1 | use rbx_dom_weak::{types::Ref, WeakDom};
2 |
3 | use crate::{
4 | core::{helpers::apply_migrations, snapshot::Snapshot},
5 | Properties,
6 | };
7 |
8 | mod markdown;
9 | mod mesh_part;
10 | mod snapshot;
11 |
12 | #[inline]
13 | pub fn save_mesh(properties: &Properties) -> Option {
14 | let mut properties = properties.clone();
15 | apply_migrations("MeshPart", &mut properties);
16 |
17 | mesh_part::save_mesh(&properties)
18 | }
19 |
20 | #[inline]
21 | pub fn snapshot_from_dom(dom: WeakDom, id: Ref) -> Snapshot {
22 | snapshot::snapshot_from_dom(dom, id)
23 | }
24 |
25 | #[inline]
26 | pub fn markdown_to_rich_text(text: &str) -> String {
27 | markdown::parse(text)
28 | }
29 |
--------------------------------------------------------------------------------
/src/middleware/helpers/snapshot.rs:
--------------------------------------------------------------------------------
1 | use rbx_dom_weak::{types::Ref, AHashMap, Instance, WeakDom};
2 |
3 | use crate::core::{meta::Meta, snapshot::Snapshot};
4 |
5 | // Based on Rojo's InstanceSnapshot::from_tree (https://github.com/rojo-rbx/rojo/blob/master/src/snapshot/instance_snapshot.rs#L105)
6 | pub fn snapshot_from_dom(dom: WeakDom, id: Ref) -> Snapshot {
7 | let (_, mut raw_dom) = dom.into_raw();
8 |
9 | fn walk(id: Ref, raw_dom: &mut AHashMap) -> Snapshot {
10 | let instance = raw_dom
11 | .remove(&id)
12 | .expect("Provided ID does not exist in the current DOM");
13 |
14 | let children = instance
15 | .children()
16 | .iter()
17 | .map(|&child_id| walk(child_id, raw_dom))
18 | .collect();
19 |
20 | let mut meta = Meta::new();
21 |
22 | if instance.class == "MeshPart" {
23 | meta.set_mesh_source(super::save_mesh(&instance.properties));
24 | }
25 |
26 | Snapshot::new()
27 | .with_meta(meta)
28 | .with_name(&instance.name)
29 | .with_class(&instance.class)
30 | .with_properties(instance.properties)
31 | .with_children(children)
32 | }
33 |
34 | walk(id, &mut raw_dom)
35 | }
36 |
--------------------------------------------------------------------------------
/src/middleware/json.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use rbx_dom_weak::{types::Variant, ustr, HashMapExt, UstrMap};
3 | use std::path::Path;
4 |
5 | use crate::{core::snapshot::Snapshot, vfs::Vfs};
6 |
7 | #[profiling::function]
8 | pub fn read_json(path: &Path, vfs: &Vfs) -> Result {
9 | let json = vfs.read_to_string(path)?;
10 |
11 | if json.is_empty() {
12 | return Ok(Snapshot::new().with_class("ModuleScript"));
13 | }
14 |
15 | let lua = json2lua::parse(&json)?;
16 |
17 | let source = format!("return {}", lua);
18 |
19 | let mut properties = UstrMap::new();
20 | properties.insert(ustr("Source"), Variant::String(source));
21 |
22 | Ok(Snapshot::new().with_class("ModuleScript").with_properties(properties))
23 | }
24 |
--------------------------------------------------------------------------------
/src/middleware/json_model.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use log::error;
3 | use rbx_dom_weak::{types::Tags, ustr, HashMapExt, Ustr, UstrMap};
4 | use serde::Deserialize;
5 | use std::path::Path;
6 |
7 | use super::helpers;
8 | use crate::{core::snapshot::Snapshot, resolution::UnresolvedValue, vfs::Vfs};
9 |
10 | #[derive(Debug, Deserialize)]
11 | #[serde(rename_all = "camelCase")]
12 | struct JsonModel {
13 | #[serde(alias = "Name")]
14 | name: Option,
15 | #[serde(alias = "ClassName")]
16 | class_name: Option,
17 |
18 | #[serde(alias = "Properties")]
19 | properties: Option>,
20 | #[serde(alias = "Attributes")]
21 | attributes: Option,
22 | #[serde(alias = "Tags")]
23 | tags: Option>,
24 |
25 | #[serde(alias = "Children")]
26 | children: Option>,
27 | }
28 |
29 | #[profiling::function]
30 | pub fn read_json_model(path: &Path, vfs: &Vfs) -> Result {
31 | let contents = vfs.read_to_string(path)?;
32 |
33 | if contents.is_empty() {
34 | return Ok(Snapshot::new().with_class("Folder"));
35 | }
36 |
37 | let model = serde_json::from_str(&contents)?;
38 | let snapshot = walk(model, path)?;
39 |
40 | Ok(snapshot)
41 | }
42 |
43 | fn walk(model: JsonModel, path: &Path) -> Result {
44 | let mut snapshot = Snapshot::new();
45 | let mut properties = UstrMap::new();
46 |
47 | // Apply class
48 | let class = model.class_name.unwrap_or(snapshot.class);
49 | snapshot.set_class(&class);
50 |
51 | // Apply name
52 | if let Some(name) = model.name {
53 | snapshot.set_name(&name);
54 | }
55 |
56 | // Resolve properties
57 | if let Some(model_properties) = model.properties {
58 | for (property, value) in model_properties {
59 | match value.resolve(&class, &property) {
60 | Ok(value) => {
61 | properties.insert(property, value);
62 | }
63 | Err(err) => {
64 | error!("Failed to parse property: {} at {}", err, path.display());
65 | }
66 | }
67 | }
68 | }
69 |
70 | // Resolve attributes
71 | if let Some(attributes) = model.attributes {
72 | match attributes.resolve(&class, "Attributes") {
73 | Ok(value) => {
74 | properties.insert(ustr("Attributes"), value);
75 | }
76 | Err(err) => {
77 | error!("Failed to parse attributes: {} at {}", err, path.display());
78 | }
79 | }
80 | }
81 |
82 | // Resolve tags
83 | if let Some(tags) = model.tags {
84 | properties.insert(ustr("Tags"), Tags::from(tags).into());
85 | }
86 |
87 | if class == "MeshPart" {
88 | snapshot.meta.set_mesh_source(helpers::save_mesh(&properties));
89 | }
90 |
91 | snapshot.set_properties(properties);
92 |
93 | // Append children
94 | for child in model.children.unwrap_or_default() {
95 | snapshot.add_child(walk(child, path)?);
96 | }
97 |
98 | Ok(snapshot)
99 | }
100 |
--------------------------------------------------------------------------------
/src/middleware/luau.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use rbx_dom_weak::{
3 | types::{Enum, Variant},
4 | ustr, HashMapExt, UstrMap,
5 | };
6 | use std::path::Path;
7 |
8 | use super::Middleware;
9 | use crate::{
10 | core::{meta::Context, snapshot::Snapshot},
11 | vfs::Vfs,
12 | Properties,
13 | };
14 |
15 | #[derive(Debug, Clone, PartialEq)]
16 | pub enum ScriptType {
17 | Server,
18 | Client,
19 | Module,
20 | }
21 |
22 | impl From for ScriptType {
23 | fn from(middleware: Middleware) -> Self {
24 | match middleware {
25 | Middleware::ServerScript => ScriptType::Server,
26 | Middleware::ClientScript => ScriptType::Client,
27 | Middleware::ModuleScript => ScriptType::Module,
28 | _ => panic!("Cannot convert {:?} to ScriptType", middleware),
29 | }
30 | }
31 | }
32 |
33 | #[profiling::function]
34 | pub fn read_luau(path: &Path, context: &Context, vfs: &Vfs, script_type: ScriptType) -> Result {
35 | let (class_name, run_context) = match (context.use_legacy_scripts(), &script_type) {
36 | (false, ScriptType::Server) => ("Script", Some(Variant::Enum(Enum::from_u32(1)))),
37 | (false, ScriptType::Client) => ("Script", Some(Variant::Enum(Enum::from_u32(2)))),
38 | (true, ScriptType::Server) => ("Script", Some(Variant::Enum(Enum::from_u32(0)))),
39 | (true, ScriptType::Client) => ("LocalScript", None),
40 | (_, ScriptType::Module) => ("ModuleScript", None),
41 | };
42 |
43 | let mut snapshot = Snapshot::new().with_class(class_name);
44 | let mut properties = UstrMap::new();
45 |
46 | let source = vfs.read_to_string(path)?;
47 |
48 | if script_type != ScriptType::Module {
49 | if let Some(run_context) = run_context {
50 | properties.insert(ustr("RunContext"), run_context);
51 | }
52 | }
53 |
54 | properties.insert(ustr("Source"), Variant::String(source));
55 | snapshot.set_properties(properties);
56 |
57 | Ok(snapshot)
58 | }
59 |
60 | #[profiling::function]
61 | pub fn write_luau(mut properties: Properties, path: &Path, vfs: &Vfs) -> Result {
62 | let source = if let Some(Variant::String(source)) = properties.remove(&ustr("Source")) {
63 | source
64 | } else {
65 | String::new()
66 | };
67 |
68 | vfs.write(path, source.as_bytes())?;
69 |
70 | Ok(properties)
71 | }
72 |
--------------------------------------------------------------------------------
/src/middleware/md.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use rbx_dom_weak::{types::Variant, ustr, HashMapExt, UstrMap};
3 | use std::path::Path;
4 |
5 | use crate::{core::snapshot::Snapshot, middleware::helpers::markdown_to_rich_text, vfs::Vfs};
6 |
7 | #[profiling::function]
8 | pub fn read_md(path: &Path, vfs: &Vfs) -> Result {
9 | let markdown = vfs.read_to_string(path)?;
10 | let rich_text = markdown_to_rich_text(&markdown);
11 |
12 | let mut properties = UstrMap::new();
13 | properties.insert(ustr("Value"), Variant::String(rich_text));
14 |
15 | Ok(Snapshot::new().with_class("StringValue").with_properties(properties))
16 | }
17 |
--------------------------------------------------------------------------------
/src/middleware/msgpack.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use rbx_dom_weak::{types::Variant, ustr, HashMapExt, UstrMap};
3 | use rmp_serde::Deserializer;
4 | use rmpv::Value;
5 | use std::path::Path;
6 |
7 | use crate::{core::snapshot::Snapshot, vfs::Vfs};
8 |
9 | #[profiling::function]
10 | pub fn read_msgpack(path: &Path, vfs: &Vfs) -> Result {
11 | let msgpack = vfs.read(path)?;
12 |
13 | if msgpack.is_empty() {
14 | return Ok(Snapshot::new().with_class("ModuleScript"));
15 | }
16 |
17 | let mut deserializer = Deserializer::from_read_ref(&msgpack).with_human_readable();
18 | let msgpack: Value = serde::Deserialize::deserialize(&mut deserializer)?;
19 |
20 | let lua = format!("return {}", msgpack_to_lua(&msgpack));
21 |
22 | let mut properties = UstrMap::new();
23 | properties.insert(ustr("Source"), Variant::String(lua));
24 |
25 | Ok(Snapshot::new().with_class("ModuleScript").with_properties(properties))
26 | }
27 |
28 | fn msgpack_to_lua(value: &Value) -> String {
29 | let mut lua = String::new();
30 |
31 | match value {
32 | Value::Nil => lua.push_str("nil"),
33 | Value::Boolean(b) => lua.push_str(&b.to_string()),
34 | Value::Integer(i) => lua.push_str(&i.to_string()),
35 | Value::F32(f) => {
36 | if f.is_infinite() {
37 | lua.push_str("math.huge")
38 | } else {
39 | lua.push_str(&f.to_string())
40 | }
41 | }
42 | Value::F64(f) => {
43 | if f.is_infinite() {
44 | lua.push_str("math.huge")
45 | } else {
46 | lua.push_str(&f.to_string())
47 | }
48 | }
49 | Value::String(s) => lua.push_str(&format!("\"{}\"", &escape_chars(s.as_str().unwrap_or_default()))),
50 | Value::Binary(b) => lua.push_str(&String::from_utf8_lossy(b)),
51 | Value::Array(a) => {
52 | lua.push('{');
53 |
54 | for v in a {
55 | lua.push_str(&msgpack_to_lua(v));
56 | lua.push(',');
57 | }
58 |
59 | lua.push('}');
60 | }
61 | Value::Map(t) => {
62 | lua.push('{');
63 |
64 | for (k, v) in t {
65 | lua.push_str(&format!("[{}] = ", &msgpack_to_lua(k)));
66 | lua.push_str(&msgpack_to_lua(v));
67 | lua.push(',');
68 | }
69 |
70 | lua.push('}');
71 | }
72 | Value::Ext(_, _) => {}
73 | }
74 |
75 | lua
76 | }
77 |
78 | fn escape_chars(string: &str) -> String {
79 | let mut validated = String::new();
80 |
81 | for char in string.chars() {
82 | match char {
83 | '\n' => validated.push_str("\\n"),
84 | '\t' => validated.push_str("\\t"),
85 | '\r' => validated.push_str("\\r"),
86 | '\\' => validated.push_str("\\\\"),
87 | '"' => validated.push_str("\\\""),
88 | _ => validated.push(char),
89 | }
90 | }
91 |
92 | validated
93 | }
94 |
--------------------------------------------------------------------------------
/src/middleware/project.rs:
--------------------------------------------------------------------------------
1 | use anyhow::{bail, Result};
2 | use colored::Colorize;
3 | use log::error;
4 | use path_clean::PathClean;
5 | use rbx_dom_weak::{types::Tags, ustr, HashMapExt, UstrMap};
6 | use std::path::Path;
7 |
8 | use super::new_snapshot;
9 | use crate::{
10 | argon_warn,
11 | core::{
12 | meta::{Context, Meta, NodePath, Source},
13 | snapshot::Snapshot,
14 | },
15 | ext::PathExt,
16 | middleware::helpers,
17 | project::{Project, ProjectNode, ProjectPath},
18 | util,
19 | vfs::Vfs,
20 | };
21 |
22 | #[profiling::function]
23 | pub fn read_project(path: &Path, vfs: &Vfs) -> Result {
24 | let project: Project = Project::load(path)?;
25 |
26 | vfs.watch(path, false)?;
27 |
28 | let meta = Meta::from_project(&project);
29 | let mut snapshot = new_snapshot_node(&project.name, path, project.node, NodePath::new(), &meta.context, vfs)?;
30 |
31 | snapshot.meta.source.add_project(path);
32 |
33 | Ok(snapshot)
34 | }
35 |
36 | #[profiling::function]
37 | pub fn new_snapshot_node(
38 | name: &str,
39 | path: &Path,
40 | node: ProjectNode,
41 | node_path: NodePath,
42 | context: &Context,
43 | vfs: &Vfs,
44 | ) -> Result {
45 | if node.class_name.is_some() && node.path.is_some() {
46 | bail!("Failed to load project: $className and $path cannot be set at the same time");
47 | }
48 |
49 | let class = if let Some(class_name) = &node.class_name {
50 | class_name.to_owned()
51 | } else if util::is_service(name) {
52 | name.to_owned()
53 | } else {
54 | String::from("Folder")
55 | };
56 |
57 | let properties = {
58 | let mut properties = UstrMap::new();
59 |
60 | for (property, value) in &node.properties {
61 | match value.clone().resolve(&class, property) {
62 | Ok(value) => {
63 | properties.insert(*property, value);
64 | }
65 | Err(err) => {
66 | error!(
67 | "Failed to parse property: {} at {}, JSON path: {}",
68 | err,
69 | path.display(),
70 | node_path
71 | );
72 | }
73 | }
74 | }
75 |
76 | if let Some(attributes) = &node.attributes {
77 | match attributes.clone().resolve(&class, "Attributes") {
78 | Ok(value) => {
79 | properties.insert(ustr("Attributes"), value);
80 | }
81 | Err(err) => {
82 | error!(
83 | "Failed to parse attributes: {} at {}, JSON path: {}",
84 | err,
85 | path.display(),
86 | node_path
87 | );
88 | }
89 | }
90 | }
91 |
92 | if !node.tags.is_empty() {
93 | properties.insert(ustr("Tags"), Tags::from(node.tags.clone()).into());
94 | }
95 |
96 | properties
97 | };
98 |
99 | let mut meta = Meta::new()
100 | .with_source(Source::project(name, path, node.clone(), node_path.clone()))
101 | .with_context(context)
102 | .with_keep_unknowns(node.keep_unknowns.unwrap_or_else(|| util::is_service(&class)));
103 |
104 | if class == "MeshPart" {
105 | meta.set_mesh_source(helpers::save_mesh(&properties));
106 | }
107 |
108 | let mut snapshot = Snapshot::new()
109 | .with_name(name)
110 | .with_class(&class)
111 | .with_properties(properties)
112 | .with_meta(meta);
113 |
114 | if let Some(path_node) = node.path {
115 | let path = path.with_file_name(path_node.path()).clean();
116 |
117 | if vfs.exists(&path) {
118 | vfs.watch(&path, vfs.is_dir(&path))?;
119 |
120 | if let Some(mut path_snapshot) = new_snapshot(&path, context, vfs)? {
121 | path_snapshot.extend_properties(snapshot.properties);
122 | path_snapshot.set_name(&snapshot.name);
123 |
124 | if path_snapshot.class == "Folder" {
125 | path_snapshot.set_class(&snapshot.class);
126 | }
127 |
128 | // We want to keep the original inner source
129 | // but with addition of new relevant paths
130 | snapshot
131 | .meta
132 | .source
133 | .extend_relevant(path_snapshot.meta.source.relevant().to_owned());
134 |
135 | path_snapshot.meta.set_source(snapshot.meta.source);
136 | path_snapshot
137 | .meta
138 | .set_keep_unknowns(path_snapshot.meta.keep_unknowns || snapshot.meta.keep_unknowns);
139 |
140 | snapshot = path_snapshot;
141 | }
142 | } else if let ProjectPath::Required(_) = path_node {
143 | argon_warn!(
144 | "Path specified in the project does not exist: {}. Please create this path and restart Argon \
145 | to watch for file changes in this path or remove it from the project to suppress this warning",
146 | path.to_string().bold()
147 | );
148 | }
149 | }
150 |
151 | for (node_name, node) in node.tree {
152 | let node_path = node_path.join(&node_name);
153 | let child = new_snapshot_node(&node_name, path, node, node_path, context, vfs)?;
154 |
155 | snapshot.add_child(child);
156 | }
157 |
158 | Ok(snapshot)
159 | }
160 |
--------------------------------------------------------------------------------
/src/middleware/rbxm.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use std::path::Path;
3 |
4 | use super::helpers;
5 | use crate::{core::snapshot::Snapshot, vfs::Vfs};
6 |
7 | #[profiling::function]
8 | pub fn read_rbxm(path: &Path, vfs: &Vfs) -> Result {
9 | let dom = rbx_binary::from_reader(vfs.read(path)?.as_slice())?;
10 |
11 | let snapshot = if dom.root().children().len() == 1 {
12 | let id = dom.root().children()[0];
13 | helpers::snapshot_from_dom(dom, id)
14 | } else {
15 | let id = dom.root_ref();
16 | helpers::snapshot_from_dom(dom, id).with_class("Folder")
17 | };
18 |
19 | Ok(snapshot)
20 | }
21 |
--------------------------------------------------------------------------------
/src/middleware/rbxmx.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use std::path::Path;
3 |
4 | use super::helpers;
5 | use crate::{core::snapshot::Snapshot, vfs::Vfs};
6 |
7 | #[profiling::function]
8 | pub fn read_rbxmx(path: &Path, vfs: &Vfs) -> Result {
9 | let dom = rbx_xml::from_reader_default(vfs.read(path)?.as_slice())?;
10 |
11 | let snapshot = if dom.root().children().len() == 1 {
12 | let id = dom.root().children()[0];
13 | helpers::snapshot_from_dom(dom, id)
14 | } else {
15 | let id = dom.root_ref();
16 | helpers::snapshot_from_dom(dom, id).with_class("Folder")
17 | };
18 |
19 | Ok(snapshot)
20 | }
21 |
--------------------------------------------------------------------------------
/src/middleware/toml.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use rbx_dom_weak::{types::Variant, ustr, HashMapExt, UstrMap};
3 | use std::path::Path;
4 |
5 | use crate::{core::snapshot::Snapshot, vfs::Vfs};
6 |
7 | #[profiling::function]
8 | pub fn read_toml(path: &Path, vfs: &Vfs) -> Result {
9 | let toml = vfs.read_to_string(path)?;
10 | let lua = toml2lua::parse(&toml)?;
11 |
12 | let source = format!("return {}", lua);
13 |
14 | let mut properties = UstrMap::new();
15 | properties.insert(ustr("Source"), Variant::String(source));
16 |
17 | Ok(Snapshot::new().with_class("ModuleScript").with_properties(properties))
18 | }
19 |
--------------------------------------------------------------------------------
/src/middleware/txt.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use rbx_dom_weak::{types::Variant, ustr, HashMapExt, UstrMap};
3 | use std::path::Path;
4 |
5 | use crate::{core::snapshot::Snapshot, vfs::Vfs, Properties};
6 |
7 | #[profiling::function]
8 | pub fn read_txt(path: &Path, vfs: &Vfs) -> Result {
9 | let value = vfs.read_to_string(path)?;
10 |
11 | let mut properties = UstrMap::new();
12 | properties.insert(ustr("Value"), Variant::String(value));
13 |
14 | Ok(Snapshot::new().with_class("StringValue").with_properties(properties))
15 | }
16 |
17 | #[profiling::function]
18 | pub fn write_txt(mut properties: Properties, path: &Path, vfs: &Vfs) -> Result {
19 | let value = if let Some(Variant::String(value)) = properties.remove(&ustr("Value")) {
20 | value
21 | } else {
22 | String::new()
23 | };
24 |
25 | vfs.write(path, value.as_bytes())?;
26 |
27 | Ok(properties)
28 | }
29 |
--------------------------------------------------------------------------------
/src/middleware/yaml.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use rbx_dom_weak::{types::Variant, ustr, HashMapExt, UstrMap};
3 | use std::path::Path;
4 |
5 | use crate::{core::snapshot::Snapshot, vfs::Vfs};
6 |
7 | #[profiling::function]
8 | pub fn read_yaml(path: &Path, vfs: &Vfs) -> Result {
9 | let yaml = vfs.read_to_string(path)?;
10 | let lua = yaml2lua::parse(&yaml)?;
11 |
12 | let source = format!("return {}", lua);
13 |
14 | let mut properties = UstrMap::new();
15 | properties.insert(ustr("Source"), Variant::String(source));
16 |
17 | Ok(Snapshot::new().with_class("ModuleScript").with_properties(properties))
18 | }
19 |
--------------------------------------------------------------------------------
/src/server/details.rs:
--------------------------------------------------------------------------------
1 | use actix_msgpack::MsgPackResponseBuilder;
2 | use actix_web::{get, web::Data, HttpResponse, Responder};
3 | use log::trace;
4 | use std::sync::Arc;
5 |
6 | use crate::{core::Core, project::ProjectDetails};
7 |
8 | #[get("/details")]
9 | async fn main(core: Data>) -> impl Responder {
10 | trace!("Received request: details");
11 | HttpResponse::Ok().msgpack(ProjectDetails::from_project(&core.project(), &core.tree()))
12 | }
13 |
--------------------------------------------------------------------------------
/src/server/exec.rs:
--------------------------------------------------------------------------------
1 | use actix_msgpack::MsgPack;
2 | use actix_web::{post, web::Data, HttpResponse, Responder};
3 | use log::{error, trace};
4 | use serde::Deserialize;
5 | use std::sync::Arc;
6 |
7 | use crate::{core::Core, server, studio};
8 |
9 | #[derive(Deserialize, Debug)]
10 | #[serde(rename_all = "camelCase")]
11 | struct Request {
12 | code: String,
13 | focus: bool,
14 | }
15 |
16 | #[post("/exec")]
17 | async fn main(request: MsgPack, core: Data>) -> impl Responder {
18 | trace!("Received request: exec");
19 |
20 | let queue = core.queue();
21 |
22 | let pushed = queue.push(
23 | server::ExecuteCode {
24 | code: request.code.clone(),
25 | },
26 | None,
27 | );
28 |
29 | if request.focus {
30 | if let Some(name) = queue.get_first_non_internal_listener_name() {
31 | match studio::focus(Some(name)) {
32 | Ok(()) => (),
33 | Err(err) => error!("Failed to focus Roblox Studio: {}", err),
34 | }
35 | }
36 | }
37 |
38 | match pushed {
39 | Ok(()) => HttpResponse::Ok().body("Code executed successfully"),
40 | Err(err) => HttpResponse::InternalServerError().body(err.to_string()),
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/src/server/home.rs:
--------------------------------------------------------------------------------
1 | use actix_web::{get, HttpResponse, Responder};
2 | use log::trace;
3 |
4 | #[get("/")]
5 | async fn main() -> impl Responder {
6 | trace!("Received request: home");
7 | HttpResponse::Ok().body("Home Page")
8 | }
9 |
--------------------------------------------------------------------------------
/src/server/mod.rs:
--------------------------------------------------------------------------------
1 | use actix_msgpack::MsgPackConfig;
2 | use actix_web::{
3 | web::{self, Data},
4 | App, HttpServer, Responder,
5 | };
6 | use derive_from_one::FromOne;
7 | use serde::{Deserialize, Serialize};
8 | use std::{io::Result, net::TcpListener, sync::Arc};
9 |
10 | use crate::{
11 | constants::MAX_PAYLOAD_SIZE,
12 | core::{changes::Changes, Core},
13 | project::ProjectDetails,
14 | };
15 |
16 | mod details;
17 | mod exec;
18 | mod home;
19 | mod open;
20 | mod read;
21 | mod snapshot;
22 | mod stop;
23 | mod subscribe;
24 | mod unsubscribe;
25 | mod write;
26 |
27 | #[derive(Debug, Clone, Serialize, FromOne)]
28 | pub enum Message {
29 | SyncChanges(SyncChanges),
30 | SyncbackChanges(SyncbackChanges),
31 | SyncDetails(SyncDetails),
32 | ExecuteCode(ExecuteCode),
33 | Disconnect(Disconnect),
34 | }
35 |
36 | impl Message {
37 | pub fn is_change(&self) -> bool {
38 | matches!(self, Message::SyncChanges(_) | Message::SyncbackChanges(_))
39 | }
40 | }
41 |
42 | #[derive(Debug, Clone, Serialize)]
43 | pub struct SyncChanges(pub Changes);
44 |
45 | #[derive(Debug, Clone, Serialize)]
46 | pub struct SyncbackChanges();
47 |
48 | #[derive(Debug, Clone, Serialize)]
49 | pub struct SyncDetails(pub ProjectDetails);
50 |
51 | #[derive(Debug, Clone, Serialize)]
52 | pub struct ExecuteCode {
53 | pub code: String,
54 | }
55 |
56 | #[derive(Debug, Clone, Serialize)]
57 | pub struct Disconnect {
58 | pub message: String,
59 | }
60 |
61 | #[derive(Deserialize, Debug)]
62 | #[serde(rename_all = "camelCase")]
63 | pub struct AuthRequest {
64 | client_id: u32,
65 | }
66 |
67 | pub struct Server {
68 | core: Arc,
69 | host: String,
70 | port: u16,
71 | }
72 |
73 | impl Server {
74 | pub fn new(core: Arc, host: &str, port: u16) -> Self {
75 | Self {
76 | core,
77 | host: host.to_owned(),
78 | port,
79 | }
80 | }
81 |
82 | #[actix_web::main]
83 | pub async fn start(&self) -> Result<()> {
84 | let core = self.core.clone();
85 |
86 | HttpServer::new(move || {
87 | let mut msgpack_config = MsgPackConfig::default();
88 | msgpack_config.limit(MAX_PAYLOAD_SIZE);
89 |
90 | App::new()
91 | .app_data(Data::new(core.clone()))
92 | .app_data(msgpack_config)
93 | .service(details::main)
94 | .service(subscribe::main)
95 | .service(unsubscribe::main)
96 | .service(snapshot::main)
97 | .service(read::main)
98 | .service(write::main)
99 | .service(exec::main)
100 | .service(open::main)
101 | .service(stop::main)
102 | .service(home::main)
103 | .default_service(web::to(Self::default_redirect))
104 | })
105 | .backlog(0)
106 | .disable_signals()
107 | .bind((self.host.clone(), self.port))?
108 | .run()
109 | .await
110 | }
111 |
112 | async fn default_redirect() -> impl Responder {
113 | web::Redirect::to("/")
114 | }
115 | }
116 |
117 | pub fn is_port_free(host: &str, port: u16) -> bool {
118 | TcpListener::bind((host, port)).is_ok()
119 | }
120 |
121 | pub fn get_free_port(host: &str, port: u16) -> u16 {
122 | let mut port = port;
123 |
124 | while !is_port_free(host, port) {
125 | port += 1;
126 |
127 | // This should never happen, but just in case
128 | if port == 65535 {
129 | break;
130 | }
131 | }
132 |
133 | port
134 | }
135 |
136 | pub fn format_address(host: &str, port: u16) -> String {
137 | format!("http://{}:{}", host, port)
138 | }
139 |
--------------------------------------------------------------------------------
/src/server/open.rs:
--------------------------------------------------------------------------------
1 | use actix_msgpack::MsgPack;
2 | use actix_web::{post, web::Data, HttpResponse, Responder};
3 | use log::trace;
4 | use rbx_dom_weak::types::Ref;
5 | use serde::Deserialize;
6 | use std::sync::Arc;
7 |
8 | use crate::core::Core;
9 |
10 | #[derive(Deserialize, Debug)]
11 | #[serde(rename_all = "camelCase")]
12 | struct Request {
13 | instance: Ref,
14 | _line: u32,
15 | }
16 |
17 | #[post("/open")]
18 | async fn main(request: MsgPack, core: Data>) -> impl Responder {
19 | trace!("Received request: open");
20 |
21 | match core.open(request.instance) {
22 | Ok(_) => HttpResponse::Ok().body("Opened file successfully"),
23 | Err(err) => HttpResponse::InternalServerError().body(err.to_string()),
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/src/server/read.rs:
--------------------------------------------------------------------------------
1 | use actix_msgpack::{MsgPack, MsgPackResponseBuilder};
2 | use actix_web::{post, web::Data, HttpResponse, Responder};
3 | use log::trace;
4 | use std::sync::Arc;
5 |
6 | use crate::{core::Core, server::AuthRequest};
7 |
8 | #[post("/read")]
9 | async fn main(request: MsgPack, core: Data>) -> impl Responder {
10 | trace!("Received request: read");
11 |
12 | let id = request.client_id;
13 | let queue = core.queue();
14 |
15 | if !queue.is_subscribed(id) {
16 | return HttpResponse::Unauthorized().body("Not subscribed");
17 | }
18 |
19 | match queue.get_timeout(id) {
20 | Ok(message) => HttpResponse::Ok().msgpack(message),
21 | Err(err) => HttpResponse::InternalServerError().body(err.to_string()),
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/src/server/snapshot.rs:
--------------------------------------------------------------------------------
1 | use actix_msgpack::{MsgPack, MsgPackResponseBuilder};
2 | use actix_web::{post, web::Data, HttpResponse, Responder};
3 | use log::trace;
4 | use rbx_dom_weak::types::Ref;
5 | use serde::Deserialize;
6 | use std::sync::Arc;
7 |
8 | use crate::core::Core;
9 |
10 | #[derive(Deserialize, Debug)]
11 | #[serde(rename_all = "camelCase")]
12 | struct Request {
13 | instance: Ref,
14 | }
15 |
16 | #[post("/snapshot")]
17 | async fn main(request: MsgPack, core: Data>) -> impl Responder {
18 | trace!("Received request: snapshot");
19 | HttpResponse::Ok().msgpack(core.snapshot(request.instance))
20 | }
21 |
--------------------------------------------------------------------------------
/src/server/stop.rs:
--------------------------------------------------------------------------------
1 | use actix_web::{post, HttpResponse, Responder};
2 | use log::{info, trace};
3 | use std::process;
4 |
5 | use crate::util;
6 |
7 | #[post("/stop")]
8 | async fn main() -> impl Responder {
9 | trace!("Received request: stop");
10 | info!("Stopping Argon!");
11 |
12 | util::kill_process(process::id());
13 |
14 | HttpResponse::Ok().body("Argon stopped successfully")
15 | }
16 |
--------------------------------------------------------------------------------
/src/server/subscribe.rs:
--------------------------------------------------------------------------------
1 | use actix_msgpack::MsgPack;
2 | use actix_web::{post, web::Data, HttpResponse, Responder};
3 | use log::trace;
4 | use serde::Deserialize;
5 | use std::sync::Arc;
6 |
7 | use crate::core::Core;
8 |
9 | #[derive(Deserialize, Debug)]
10 | #[serde(rename_all = "camelCase")]
11 | struct Request {
12 | client_id: u32,
13 | name: String,
14 | }
15 |
16 | #[post("/subscribe")]
17 | async fn main(request: MsgPack, core: Data>) -> impl Responder {
18 | trace!("Received request: subscribe");
19 |
20 | let subscribed = core.queue().subscribe(request.client_id, &request.name);
21 |
22 | if subscribed.is_ok() {
23 | HttpResponse::Ok().body("Subscribed successfully")
24 | } else {
25 | HttpResponse::BadRequest().body("Already subscribed")
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/src/server/unsubscribe.rs:
--------------------------------------------------------------------------------
1 | use actix_msgpack::MsgPack;
2 | use actix_web::{post, web::Data, HttpResponse, Responder};
3 | use log::trace;
4 | use std::sync::Arc;
5 |
6 | use crate::{core::Core, server::AuthRequest};
7 |
8 | #[post("/unsubscribe")]
9 | async fn main(request: MsgPack, core: Data>) -> impl Responder {
10 | trace!("Received request: unsubscribe");
11 |
12 | let unsubscribed = core.queue().unsubscribe(request.client_id);
13 |
14 | if unsubscribed.is_ok() {
15 | HttpResponse::Ok().body("Unsubscribed successfully")
16 | } else {
17 | HttpResponse::BadRequest().body("Not subscribed")
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/src/server/write.rs:
--------------------------------------------------------------------------------
1 | use actix_msgpack::MsgPack;
2 | use actix_web::{post, web::Data, HttpResponse, Responder};
3 | use log::trace;
4 | use std::sync::Arc;
5 |
6 | use crate::core::{processor::WriteRequest, Core};
7 |
8 | #[post("/write")]
9 | async fn main(request: MsgPack, core: Data>) -> impl Responder {
10 | trace!("Received request: write");
11 |
12 | let request = request.0;
13 |
14 | if !core.queue().is_subscribed(request.client_id) {
15 | return HttpResponse::Unauthorized().body("Not subscribed");
16 | }
17 |
18 | core.processor().write(request);
19 |
20 | HttpResponse::Ok().body("Written changes successfully")
21 | }
22 |
--------------------------------------------------------------------------------
/src/sessions.rs:
--------------------------------------------------------------------------------
1 | use anyhow::{Context, Result};
2 | use log::{debug, trace, warn};
3 | use serde::{Deserialize, Serialize};
4 | use std::{collections::HashMap, fs, process, thread};
5 |
6 | use crate::util;
7 |
8 | #[derive(Serialize, Deserialize, Clone, PartialEq, Debug)]
9 | pub struct Session {
10 | pub pid: u32,
11 | pub host: Option,
12 | pub port: Option,
13 | }
14 |
15 | impl Session {
16 | pub fn get_address(&self) -> Option {
17 | if let Some(host) = &self.host {
18 | if let Some(port) = self.port {
19 | return Some(format!("http://{}:{}", host, port));
20 | }
21 | }
22 |
23 | None
24 | }
25 | }
26 |
27 | #[derive(Serialize, Deserialize, Debug)]
28 | struct Sessions {
29 | last_session: String,
30 | active_sessions: HashMap,
31 | }
32 |
33 | fn get_sessions() -> Result {
34 | let path = util::get_argon_dir()?.join("sessions.toml");
35 |
36 | if path.exists() {
37 | match toml::from_str(&fs::read_to_string(&path)?) {
38 | Ok(sessions) => return Ok(sessions),
39 | Err(_) => warn!("Session data file is corrupted! Creating new one.."),
40 | }
41 | }
42 |
43 | let sessions = Sessions {
44 | last_session: String::new(),
45 | active_sessions: HashMap::new(),
46 | };
47 |
48 | fs::write(path, toml::to_string(&sessions)?)?;
49 |
50 | Ok(sessions)
51 | }
52 |
53 | fn set_sessions(sessions: &Sessions) -> Result<()> {
54 | let path = util::get_argon_dir()?.join("sessions.toml");
55 |
56 | fs::write(path, toml::to_string(sessions)?)?;
57 |
58 | Ok(())
59 | }
60 |
61 | pub fn add(id: Option, host: Option, port: Option, pid: u32, run_async: bool) -> Result<()> {
62 | let mut sessions = get_sessions()?;
63 |
64 | let session = Session { host, port, pid };
65 | let id = id.unwrap_or(generate_id(&sessions));
66 |
67 | sessions.last_session.clone_from(&id);
68 | sessions.active_sessions.insert(id, session.clone());
69 |
70 | set_sessions(&sessions)?;
71 |
72 | if !run_async {
73 | ctrlc::set_handler(move || {
74 | match remove(&session) {
75 | Ok(()) => trace!("Session entry removed"),
76 | Err(err) => warn!("Failed to remove session entry: {}", err),
77 | }
78 |
79 | process::exit(0);
80 | })?;
81 | }
82 |
83 | // Schedule manual cleanup of old sessions
84 | // as ctrlc handler does not work on Windows,
85 | // on UNIX cleanup will remove crashed sessions
86 | thread::spawn(move || match cleanup(sessions) {
87 | Ok(()) => debug!("Session cleanup completed"),
88 | Err(err) => warn!("Failed to cleanup sessions: {}", err),
89 | });
90 |
91 | Ok(())
92 | }
93 |
94 | pub fn get(id: Option, host: Option, port: Option) -> Result> {
95 | let sessions = get_sessions()?;
96 |
97 | if id.is_none() && host.is_none() && port.is_none() {
98 | return Ok(sessions.active_sessions.get(&sessions.last_session).cloned());
99 | } else if let Some(id) = id {
100 | return Ok(sessions.active_sessions.get(&id).cloned());
101 | }
102 |
103 | for (_, session) in sessions.active_sessions {
104 | if session.host == host || session.port == port {
105 | return Ok(Some(session));
106 | }
107 | }
108 |
109 | Ok(None)
110 | }
111 |
112 | pub fn get_multiple(ids: &Vec) -> Result> {
113 | let sessions = get_sessions()?;
114 |
115 | let mut result = HashMap::new();
116 |
117 | for id in ids {
118 | if let Some(session) = sessions.active_sessions.get(id) {
119 | result.insert(id.to_owned(), session.to_owned());
120 | }
121 | }
122 |
123 | Ok(result)
124 | }
125 |
126 | pub fn get_all() -> Result> {
127 | Ok(get_sessions()?.active_sessions)
128 | }
129 |
130 | pub fn remove(session: &Session) -> Result<()> {
131 | let mut sessions = get_sessions()?;
132 |
133 | let id = sessions
134 | .active_sessions
135 | .iter()
136 | .find_map(|(i, s)| if s == session { Some(i.clone()) } else { None })
137 | .context("Session not found")?;
138 |
139 | sessions.active_sessions.remove(&id);
140 |
141 | if sessions.last_session == id {
142 | if let Some((session_id, _)) = sessions.active_sessions.iter().next() {
143 | sessions.last_session.clone_from(session_id);
144 | } else {
145 | sessions.last_session = String::new();
146 | }
147 | }
148 |
149 | set_sessions(&sessions)?;
150 |
151 | Ok(())
152 | }
153 |
154 | pub fn remove_multiple(ids: &Vec) -> Result<()> {
155 | let mut sessions = get_sessions()?;
156 |
157 | for id in ids {
158 | sessions.active_sessions.remove(id);
159 | }
160 |
161 | sessions.last_session = sessions.active_sessions.keys().next().cloned().unwrap_or_default();
162 |
163 | set_sessions(&sessions)?;
164 |
165 | Ok(())
166 | }
167 |
168 | pub fn remove_all() -> Result<()> {
169 | let sessions = Sessions {
170 | last_session: String::new(),
171 | active_sessions: HashMap::new(),
172 | };
173 |
174 | set_sessions(&sessions)?;
175 |
176 | Ok(())
177 | }
178 |
179 | fn cleanup(mut sessions: Sessions) -> Result<()> {
180 | let mut did_remove = false;
181 |
182 | for (id, session) in sessions.active_sessions.clone() {
183 | if !util::process_exists(session.pid) {
184 | sessions.active_sessions.remove(&id);
185 | did_remove = true;
186 | }
187 | }
188 |
189 | if did_remove {
190 | set_sessions(&sessions)?;
191 | }
192 |
193 | Ok(())
194 | }
195 |
196 | fn generate_id(sessions: &Sessions) -> String {
197 | let mut index = 0;
198 |
199 | loop {
200 | let id = index.to_string();
201 |
202 | if !sessions.active_sessions.contains_key(&id) {
203 | return id;
204 | }
205 |
206 | index += 1;
207 | }
208 | }
209 |
--------------------------------------------------------------------------------
/src/stats.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use lazy_static::lazy_static;
3 | use log::{debug, warn};
4 | use reqwest::blocking::Client;
5 | use serde::{Deserialize, Serialize};
6 | use serde_json::json;
7 | use std::{
8 | fs,
9 | sync::RwLock,
10 | thread,
11 | time::{Duration, SystemTime},
12 | };
13 |
14 | use crate::util;
15 |
16 | lazy_static! {
17 | static ref TRACKER: RwLock = RwLock::new(StatTracker::default());
18 | }
19 |
20 | macro_rules! stat_fn {
21 | ($name:ident) => {
22 | pub fn $name($name: u32) {
23 | TRACKER.write().unwrap().stats.$name += $name;
24 | }
25 | };
26 | }
27 |
28 | #[derive(Clone, Debug, Default, Serialize, Deserialize)]
29 | struct ArgonStats {
30 | minutes_used: u32,
31 | files_synced: u32,
32 | lines_synced: u32,
33 | projects_created: u32,
34 | projects_built: u32,
35 | sessions_started: u32,
36 | }
37 |
38 | impl ArgonStats {
39 | fn total(&self) -> u32 {
40 | self.minutes_used / 60
41 | + self.files_synced
42 | + self.lines_synced
43 | + self.projects_created
44 | + self.projects_built
45 | + self.sessions_started
46 | }
47 |
48 | fn extend(&mut self, other: &ArgonStats) {
49 | self.minutes_used += other.minutes_used;
50 | self.files_synced += other.files_synced;
51 | self.lines_synced += other.lines_synced;
52 | self.projects_created += other.projects_created;
53 | self.projects_built += other.projects_built;
54 | self.sessions_started += other.sessions_started;
55 | }
56 | }
57 |
58 | #[derive(Debug, Serialize, Deserialize)]
59 | struct StatTracker {
60 | last_synced: SystemTime,
61 | stats: ArgonStats,
62 | }
63 |
64 | impl StatTracker {
65 | fn reset(&mut self) {
66 | self.stats = ArgonStats::default();
67 | }
68 |
69 | fn merge(&mut self, other: Self) {
70 | if other.last_synced > self.last_synced {
71 | self.last_synced = other.last_synced;
72 | }
73 |
74 | self.stats.extend(&other.stats);
75 | }
76 | }
77 |
78 | impl Default for StatTracker {
79 | fn default() -> Self {
80 | Self {
81 | last_synced: SystemTime::UNIX_EPOCH,
82 | stats: ArgonStats::default(),
83 | }
84 | }
85 | }
86 |
87 | fn get_tracker() -> Result {
88 | let path = util::get_argon_dir()?.join("stats.toml");
89 |
90 | if path.exists() {
91 | match toml::from_str(&fs::read_to_string(&path)?) {
92 | Ok(tracker) => return Ok(tracker),
93 | Err(_) => warn!("Stat tracker file is corrupted! Creating new one.."),
94 | }
95 | }
96 |
97 | let tracker = StatTracker::default();
98 |
99 | fs::write(path, toml::to_string(&tracker)?)?;
100 |
101 | Ok(tracker)
102 | }
103 |
104 | fn set_tracker(tracker: &StatTracker) -> Result<()> {
105 | let path = util::get_argon_dir()?.join("stats.toml");
106 |
107 | fs::write(path, toml::to_string(tracker)?)?;
108 |
109 | Ok(())
110 | }
111 |
112 | pub fn track() -> Result<()> {
113 | let mut tracker = get_tracker()?;
114 |
115 | if tracker.last_synced.elapsed()?.as_secs() > 3600 && tracker.stats.total() > 10 {
116 | if let Some(token) = option_env!("ARGON_TOKEN") {
117 | let stats = tracker.stats;
118 | let remainder = stats.minutes_used % 60;
119 |
120 | let stats = json!({
121 | "hours_used": stats.minutes_used / 60,
122 | "files_synced": stats.files_synced,
123 | "lines_synced": stats.lines_synced,
124 | "projects_created": stats.projects_created,
125 | "projects_built": stats.projects_built,
126 | "sessions_started": stats.sessions_started,
127 | });
128 |
129 | Client::new()
130 | .post(format!("https://api.argon.wiki/push?auth={}", token))
131 | .json(&stats)
132 | .send()?;
133 |
134 | tracker.last_synced = SystemTime::now();
135 | tracker.stats = ArgonStats::default();
136 |
137 | tracker.stats.minutes_used = remainder;
138 |
139 | set_tracker(&tracker)?;
140 | } else {
141 | warn!("This Argon build has no `ARGON_TOKEN` set, stats will not be uploaded")
142 | }
143 | } else {
144 | debug!("Stats already synced within the last hour or too few stats to sync");
145 | }
146 |
147 | thread::spawn(|| loop {
148 | thread::sleep(Duration::from_secs(300));
149 | minutes_used(5);
150 |
151 | match save() {
152 | Ok(_) => debug!("Stats saved successfully"),
153 | Err(err) => warn!("Failed to save stats: {}", err),
154 | }
155 | });
156 |
157 | sessions_started(1);
158 |
159 | Ok(())
160 | }
161 |
162 | pub fn save() -> Result<()> {
163 | let mut tracker = TRACKER.write().unwrap();
164 |
165 | if let Ok(old) = get_tracker() {
166 | tracker.merge(old);
167 | }
168 |
169 | set_tracker(&tracker)?;
170 | tracker.reset();
171 |
172 | Ok(())
173 | }
174 |
175 | stat_fn!(minutes_used);
176 | stat_fn!(files_synced);
177 | stat_fn!(lines_synced);
178 | stat_fn!(projects_created);
179 | stat_fn!(projects_built);
180 | stat_fn!(sessions_started);
181 |
--------------------------------------------------------------------------------
/src/studio.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 | use roblox_install::RobloxStudio;
3 | use std::{
4 | path::PathBuf,
5 | process::{Command, Stdio},
6 | };
7 |
8 | #[cfg(target_os = "windows")]
9 | use winsafe::{co::SW, prelude::user_Hwnd, EnumWindows};
10 |
11 | pub fn launch(path: Option) -> Result<()> {
12 | let studio_path = RobloxStudio::locate()?.application_path().to_owned();
13 |
14 | Command::new(studio_path)
15 | .arg(path.unwrap_or_default())
16 | .stdin(Stdio::null())
17 | .stdout(Stdio::null())
18 | .stderr(Stdio::null())
19 | .spawn()?;
20 |
21 | Ok(())
22 | }
23 |
24 | #[allow(unused_variables)]
25 | pub fn is_running(title: Option) -> Result {
26 | #[cfg(target_os = "macos")]
27 | {
28 | let output = Command::new("osascript")
29 | .args([
30 | "-e",
31 | "tell app \"System Events\" to get the title of every window of (processes whose background only is false)",
32 | ])
33 | .output()?;
34 |
35 | let windows = String::from_utf8(output.stdout)?;
36 |
37 | if let Some(title) = title {
38 | Ok(windows.contains(&format!("{} - Roblox Studio", title)))
39 | } else {
40 | Ok(windows.contains("Roblox Studio"))
41 | }
42 | }
43 |
44 | #[cfg(target_os = "windows")]
45 | {
46 | let is_studio_running = EnumWindows(|hwnd| -> bool {
47 | if !hwnd.IsWindowVisible() {
48 | return true;
49 | }
50 |
51 | if let Ok(text) = hwnd.GetWindowText() {
52 | if let Some(title) = &title {
53 | if text == format!("{} - Roblox Studio", title) {
54 | return false;
55 | }
56 | } else if text.contains("Roblox Studio") {
57 | return false;
58 | }
59 | }
60 |
61 | true
62 | })
63 | .is_err();
64 |
65 | Ok(is_studio_running)
66 | }
67 |
68 | #[cfg(target_os = "linux")]
69 | {
70 | anyhow::bail!("This feature is not yet supported on Linux!");
71 | }
72 | }
73 |
74 | #[allow(unused_variables)]
75 | pub fn focus(title: Option) -> Result<()> {
76 | #[cfg(target_os = "macos")]
77 | {
78 | if let Some(title) = title {
79 | Command::new("osascript")
80 | .args([
81 | "-e",
82 | r#"tell application "System Events"
83 | repeat with theProcess in processes whose name is "RobloxStudio"
84 | tell theProcess
85 | set windowList to windows whose name contains "Argon - Roblox Studio"
86 |
87 | if (count of windowList) > 0 then
88 | set frontmost to true
89 | perform action "AXRaise" of window 1
90 | end if
91 | end tell
92 | end repeat
93 | end tell"#,
94 | ])
95 | .output()?;
96 | } else {
97 | Command::new("osascript")
98 | .args([
99 | "-e",
100 | r#"tell application "System Events"
101 | tell process "RobloxStudio"
102 | set frontmost to true
103 | perform action "AXRaise" of window 1
104 | end tell
105 | end tell"#,
106 | ])
107 | .output()?;
108 | }
109 |
110 | Ok(())
111 | }
112 |
113 | #[cfg(target_os = "windows")]
114 | {
115 | let result = EnumWindows(|hwnd| -> bool {
116 | if !hwnd.IsWindowVisible() {
117 | return true;
118 | }
119 |
120 | if let Ok(text) = hwnd.GetWindowText() {
121 | if let Some(title) = &title {
122 | if text == format!("{} - Roblox Studio", title) {
123 | hwnd.SetForegroundWindow();
124 | hwnd.ShowWindow(SW::RESTORE);
125 |
126 | return false;
127 | }
128 | } else if text.contains("Roblox Studio") {
129 | hwnd.SetForegroundWindow();
130 | hwnd.ShowWindow(SW::RESTORE);
131 |
132 | return false;
133 | }
134 | }
135 |
136 | true
137 | });
138 |
139 | match result {
140 | Ok(()) => (),
141 | Err(err) => {
142 | if err.raw() != 0 {
143 | anyhow::bail!("Failed to focus Roblox Studio: {}", err)
144 | }
145 | }
146 | }
147 |
148 | Ok(())
149 | }
150 |
151 | #[cfg(target_os = "linux")]
152 | {
153 | anyhow::bail!("This feature is not yet supported on Linux!");
154 | }
155 | }
156 |
--------------------------------------------------------------------------------
/src/util.rs:
--------------------------------------------------------------------------------
1 | use anyhow::{Context, Result};
2 | use colored::Colorize;
3 | use directories::UserDirs;
4 | use env_logger::WriteStyle;
5 | use json_formatter::JsonFormatter;
6 | use log::LevelFilter;
7 | use rbx_dom_weak::types::Variant;
8 | use rbx_reflection::ClassTag;
9 | use roblox_install::RobloxStudio;
10 | use std::{env, path::PathBuf, process::Command};
11 |
12 | use crate::Properties;
13 |
14 | /// Returns the `.argon` directory
15 | pub fn get_argon_dir() -> Result {
16 | let user_dirs = UserDirs::new().context("Failed to get user directory")?;
17 |
18 | Ok(user_dirs.home_dir().join(".argon"))
19 | }
20 |
21 | /// Returns the Git or local username of the current user
22 | pub fn get_username() -> String {
23 | if let Ok(output) = Command::new("git").arg("config").arg("user.name").output() {
24 | let username = String::from_utf8_lossy(&output.stdout).trim().to_owned();
25 |
26 | if !username.is_empty() {
27 | return username;
28 | }
29 | }
30 |
31 | whoami::username()
32 | }
33 |
34 | pub fn get_plugin_path() -> Result {
35 | Ok(RobloxStudio::locate()?.plugins_path().join("Argon.rbxm"))
36 | }
37 |
38 | /// Checks if the given `class` is a service
39 | pub fn is_service(class: &str) -> bool {
40 | let descriptor = rbx_reflection_database::get().classes.get(class);
41 |
42 | let has_tag = if let Some(descriptor) = descriptor {
43 | descriptor.tags.contains(&ClassTag::Service)
44 | } else {
45 | false
46 | };
47 |
48 | has_tag || class == "StarterPlayerScripts" || class == "StarterCharacterScripts"
49 | }
50 |
51 | /// Checks if the given `class` is a script
52 | pub fn is_script(class: &str) -> bool {
53 | class == "Script" || class == "LocalScript" || class == "ModuleScript"
54 | }
55 |
56 | /// Kills the process with the given `pid`
57 | pub fn kill_process(pid: u32) {
58 | #[cfg(not(target_os = "windows"))]
59 | {
60 | // Kill main process
61 | Command::new("kill").arg(pid.to_string()).output().ok();
62 |
63 | // Kill child processes
64 | Command::new("pkill").arg("-P").arg(pid.to_string()).output().ok();
65 | }
66 |
67 | // Kill both main and child processes
68 | #[cfg(target_os = "windows")]
69 | Command::new("TASKKILL")
70 | .arg("/F")
71 | .arg("/T")
72 | .args(["/PID", &pid.to_string()])
73 | .output()
74 | .ok();
75 | }
76 |
77 | pub fn process_exists(pid: u32) -> bool {
78 | #[cfg(not(target_os = "windows"))]
79 | {
80 | if let Ok(output) = Command::new("kill").arg("-0").arg(pid.to_string()).output() {
81 | output.status.success()
82 | } else {
83 | false
84 | }
85 | }
86 |
87 | #[cfg(target_os = "windows")]
88 | {
89 | let output = Command::new("TASKLIST")
90 | .arg("/NH")
91 | .args(["/FI", &format!("PID eq {}", pid)])
92 | .output();
93 |
94 | if let Ok(output) = output {
95 | String::from_utf8_lossy(&output.stdout).contains("argon.exe")
96 | } else {
97 | false
98 | }
99 | }
100 | }
101 |
102 | /// Returns progress bar styling
103 | pub fn get_progress_style() -> (String, String) {
104 | let mut template = match env_log_style() {
105 | WriteStyle::Always => "PROGRESS: ".magenta().bold().to_string(),
106 | _ => "PROGRESS: ".into(),
107 | };
108 | template.push_str("[{bar:40}] ({bytes}/{total_bytes})");
109 |
110 | (template, String::from("=>-"))
111 | }
112 |
113 | /// Returns the `RUST_VERBOSE` environment variable
114 | pub fn env_verbosity() -> LevelFilter {
115 | let verbosity = env::var("RUST_VERBOSE").unwrap_or("ERROR".into());
116 |
117 | match verbosity.as_str() {
118 | "OFF" => LevelFilter::Off,
119 | "ERROR" => LevelFilter::Error,
120 | "WARN" => LevelFilter::Warn,
121 | "INFO" => LevelFilter::Info,
122 | "DEBUG" => LevelFilter::Debug,
123 | "TRACE" => LevelFilter::Trace,
124 | _ => LevelFilter::Error,
125 | }
126 | }
127 |
128 | /// Returns the `RUST_LOG_STYLE` environment variable
129 | pub fn env_log_style() -> WriteStyle {
130 | let log_style = env::var("RUST_LOG_STYLE").unwrap_or("auto".into());
131 |
132 | match log_style.as_str() {
133 | "always" => WriteStyle::Always,
134 | "never" => WriteStyle::Never,
135 | _ => WriteStyle::Auto,
136 | }
137 | }
138 |
139 | /// Returns the `RUST_BACKTRACE` environment variable
140 | pub fn env_backtrace() -> bool {
141 | let backtrace = env::var("RUST_BACKTRACE").unwrap_or("0".into());
142 | backtrace == "1"
143 | }
144 |
145 | /// Returns the `RUST_YES` environment variable
146 | pub fn env_yes() -> bool {
147 | let yes = env::var("RUST_YES").unwrap_or("0".into());
148 | yes == "1"
149 | }
150 |
151 | /// Returns line of code count from snapshot's properties
152 | pub fn count_loc_from_properties(properties: &Properties) -> usize {
153 | let mut loc = 0;
154 |
155 | for value in properties.values() {
156 | if let Variant::String(value) = value {
157 | loc += value.lines().count();
158 | }
159 | }
160 |
161 | loc
162 | }
163 |
164 | /// Returns a custom serde_json formatter
165 | pub fn get_json_formatter() -> JsonFormatter<'static> {
166 | JsonFormatter::new()
167 | .with_array_breaks(false)
168 | .with_extra_newline(true)
169 | .with_max_decimals(4)
170 | }
171 |
--------------------------------------------------------------------------------
/src/vfs/mem_backend.rs:
--------------------------------------------------------------------------------
1 | use crossbeam_channel::Receiver;
2 | use std::{
3 | collections::HashMap,
4 | io::{Error, ErrorKind, Result},
5 | path::{Path, PathBuf},
6 | };
7 |
8 | use super::{VfsBackend, VfsEvent};
9 |
10 | #[derive(Debug)]
11 | pub enum VfsEntry {
12 | Directory(Vec),
13 | File(Vec),
14 | }
15 |
16 | pub struct MemBackend {
17 | inner: HashMap,
18 | receiver: Receiver,
19 | }
20 |
21 | impl MemBackend {
22 | pub fn new() -> Self {
23 | let (_sender, receiver) = crossbeam_channel::unbounded();
24 |
25 | Self {
26 | inner: HashMap::new(),
27 | receiver,
28 | }
29 | }
30 |
31 | pub fn get_entry(&self, path: &Path) -> Result<&VfsEntry> {
32 | match self.inner.get(path) {
33 | Some(entry) => Ok(entry),
34 | None => not_found(path),
35 | }
36 | }
37 | }
38 |
39 | impl VfsBackend for MemBackend {
40 | fn read(&self, path: &Path) -> Result> {
41 | match self.get_entry(path)? {
42 | VfsEntry::File(contents) => Ok(contents.clone()),
43 | VfsEntry::Directory(_) => not_file(path),
44 | }
45 | }
46 |
47 | fn read_to_string(&self, path: &Path) -> Result {
48 | match self.get_entry(path)? {
49 | VfsEntry::File(contents) => {
50 | Ok(String::from_utf8(contents.clone()).map_err(|err| Error::new(ErrorKind::InvalidData, err))?)
51 | }
52 | VfsEntry::Directory(_) => not_file(path),
53 | }
54 | }
55 |
56 | fn read_dir(&self, path: &Path) -> Result> {
57 | match self.get_entry(path)? {
58 | VfsEntry::File(_) => not_dir(path),
59 | VfsEntry::Directory(children) => Ok(children.clone()),
60 | }
61 | }
62 |
63 | fn write(&mut self, path: &Path, contents: &[u8]) -> Result<()> {
64 | let entry = self.inner.entry(path.to_owned()).or_insert(VfsEntry::File(Vec::new()));
65 |
66 | match entry {
67 | VfsEntry::File(old) => contents.clone_into(old),
68 | VfsEntry::Directory(_) => return not_file(path),
69 | }
70 |
71 | Ok(())
72 | }
73 |
74 | fn create_dir(&mut self, path: &Path) -> Result<()> {
75 | let mut cur_path = PathBuf::new();
76 | let mut last_path = PathBuf::new();
77 |
78 | for comp in path.components() {
79 | cur_path.push(comp);
80 |
81 | match self.inner.get(&cur_path) {
82 | Some(VfsEntry::File(_)) => return not_dir(&cur_path),
83 | Some(VfsEntry::Directory(_)) => (),
84 | None => {
85 | self.inner.insert(cur_path.clone(), VfsEntry::Directory(Vec::new()));
86 |
87 | if let Some(VfsEntry::Directory(children)) = self.inner.get_mut(&last_path) {
88 | children.push(cur_path.clone());
89 | }
90 | }
91 | }
92 |
93 | last_path.push(comp);
94 | }
95 |
96 | Ok(())
97 | }
98 |
99 | fn rename(&mut self, from: &Path, to: &Path) -> Result<()> {
100 | let entry = self.inner.remove(from);
101 |
102 | match entry {
103 | Some(entry) => {
104 | self.inner.insert(to.to_owned(), entry);
105 |
106 | if let Some(VfsEntry::Directory(children)) = self.inner.get_mut(from.parent().unwrap()) {
107 | children.retain(|p| p != from);
108 | children.push(to.to_owned());
109 | }
110 | }
111 | None => return not_found(from),
112 | }
113 |
114 | Ok(())
115 | }
116 |
117 | fn remove(&mut self, path: &Path) -> Result<()> {
118 | let entry = self.inner.remove(path);
119 |
120 | match entry {
121 | Some(VfsEntry::Directory(_)) => {
122 | self.inner.retain(|p, _| !p.starts_with(path));
123 | }
124 | None => return not_found(path),
125 | _ => {}
126 | }
127 |
128 | Ok(())
129 | }
130 |
131 | fn exists(&self, path: &Path) -> bool {
132 | self.inner.contains_key(path)
133 | }
134 |
135 | fn is_dir(&self, path: &Path) -> bool {
136 | matches!(self.inner.get(path), Some(VfsEntry::Directory(_)))
137 | }
138 |
139 | fn is_file(&self, path: &Path) -> bool {
140 | matches!(self.inner.get(path), Some(VfsEntry::File(_)))
141 | }
142 |
143 | fn watch(&mut self, _path: &Path, _recursive: bool) -> Result<()> {
144 | Ok(())
145 | }
146 |
147 | fn unwatch(&mut self, _path: &Path) -> Result<()> {
148 | Ok(())
149 | }
150 |
151 | fn pause(&mut self) {}
152 |
153 | fn resume(&mut self) {}
154 |
155 | fn receiver(&self) -> Receiver {
156 | self.receiver.clone()
157 | }
158 | }
159 |
160 | // Based on Rojo's in_memory_fs::not_found (https://github.com/rojo-rbx/rojo/blob/master/crates/memofs/src/in_memory_fs.rs)
161 | fn not_found(path: &Path) -> Result {
162 | Err(Error::new(
163 | ErrorKind::NotFound,
164 | format!("path {} not found", path.display()),
165 | ))
166 | }
167 |
168 | fn not_file(path: &Path) -> Result {
169 | Err(Error::other(format!(
170 | "path {} was a directory, but must be a file",
171 | path.display()
172 | )))
173 | }
174 |
175 | fn not_dir(path: &Path) -> Result {
176 | Err(Error::other(format!(
177 | "path {} was a file, but must be a directory",
178 | path.display()
179 | )))
180 | }
181 |
--------------------------------------------------------------------------------
/src/vfs/mod.rs:
--------------------------------------------------------------------------------
1 | use crossbeam_channel::Receiver;
2 | use std::{
3 | io::Result,
4 | path::{Path, PathBuf},
5 | sync::Mutex,
6 | };
7 |
8 | use self::{mem_backend::MemBackend, std_backend::StdBackend};
9 | use crate::lock;
10 |
11 | pub mod debouncer;
12 | pub mod mem_backend;
13 | pub mod std_backend;
14 |
15 | #[derive(Debug, Clone)]
16 | pub enum VfsEvent {
17 | Create(PathBuf),
18 | Delete(PathBuf),
19 | Write(PathBuf),
20 | }
21 |
22 | pub trait VfsBackend: Send {
23 | fn read(&self, path: &Path) -> Result>;
24 | fn read_to_string(&self, path: &Path) -> Result;
25 | fn read_dir(&self, path: &Path) -> Result>;
26 |
27 | fn write(&mut self, path: &Path, contents: &[u8]) -> Result<()>;
28 | fn create_dir(&mut self, path: &Path) -> Result<()>;
29 | fn rename(&mut self, from: &Path, to: &Path) -> Result<()>;
30 | fn remove(&mut self, path: &Path) -> Result<()>;
31 |
32 | fn exists(&self, path: &Path) -> bool;
33 | fn is_dir(&self, path: &Path) -> bool;
34 | fn is_file(&self, path: &Path) -> bool;
35 |
36 | fn watch(&mut self, path: &Path, recursive: bool) -> Result<()>;
37 | fn unwatch(&mut self, path: &Path) -> Result<()>;
38 | fn pause(&mut self);
39 | fn resume(&mut self);
40 |
41 | fn receiver(&self) -> Receiver;
42 | }
43 |
44 | impl VfsEvent {
45 | pub fn path(&self) -> &Path {
46 | match self {
47 | VfsEvent::Create(path) | VfsEvent::Delete(path) | VfsEvent::Write(path) => path.as_ref(),
48 | }
49 | }
50 | }
51 |
52 | pub struct Vfs {
53 | inner: Mutex>,
54 | }
55 |
56 | impl Vfs {
57 | pub fn new(watch: bool) -> Self {
58 | Self {
59 | inner: Mutex::new(Box::new(StdBackend::new(watch))),
60 | }
61 | }
62 |
63 | pub fn new_virtual() -> Self {
64 | Self {
65 | inner: Mutex::new(Box::new(MemBackend::new())),
66 | }
67 | }
68 |
69 | pub fn read(&self, path: &Path) -> Result> {
70 | lock!(self.inner).read(path)
71 | }
72 |
73 | pub fn read_to_string(&self, path: &Path) -> Result {
74 | lock!(self.inner).read_to_string(path)
75 | }
76 |
77 | pub fn read_dir(&self, path: &Path) -> Result> {
78 | lock!(self.inner).read_dir(path)
79 | }
80 |
81 | pub fn write(&self, path: &Path, contents: &[u8]) -> Result<()> {
82 | lock!(self.inner).write(path, contents)
83 | }
84 |
85 | pub fn create_dir(&self, path: &Path) -> Result<()> {
86 | lock!(self.inner).create_dir(path)
87 | }
88 |
89 | pub fn rename(&self, from: &Path, to: &Path) -> Result<()> {
90 | lock!(self.inner).rename(from, to)
91 | }
92 |
93 | pub fn remove(&self, path: &Path) -> Result<()> {
94 | lock!(self.inner).remove(path)
95 | }
96 |
97 | pub fn exists(&self, path: &Path) -> bool {
98 | lock!(self.inner).exists(path)
99 | }
100 |
101 | pub fn is_dir(&self, path: &Path) -> bool {
102 | lock!(self.inner).is_dir(path)
103 | }
104 |
105 | pub fn is_file(&self, path: &Path) -> bool {
106 | lock!(self.inner).is_file(path)
107 | }
108 |
109 | pub fn watch(&self, path: &Path, recursive: bool) -> Result<()> {
110 | lock!(self.inner).watch(path, recursive)
111 | }
112 |
113 | pub fn unwatch(&self, path: &Path) -> Result<()> {
114 | lock!(self.inner).unwatch(path)
115 | }
116 |
117 | pub fn pause(&self) {
118 | lock!(self.inner).pause()
119 | }
120 |
121 | pub fn resume(&self) {
122 | lock!(self.inner).resume()
123 | }
124 |
125 | pub fn receiver(&self) -> Receiver {
126 | lock!(self.inner).receiver()
127 | }
128 | }
129 |
--------------------------------------------------------------------------------
/src/vfs/std_backend.rs:
--------------------------------------------------------------------------------
1 | use crossbeam_channel::Receiver;
2 | use std::{
3 | fs,
4 | io::{Error, Result},
5 | path::{Path, PathBuf},
6 | };
7 |
8 | use super::{debouncer::VfsDebouncer, VfsBackend, VfsEvent};
9 | use crate::config::Config;
10 |
11 | pub struct StdBackend {
12 | watching: bool,
13 | debouncer: VfsDebouncer,
14 | watched_paths: Vec,
15 | }
16 |
17 | impl StdBackend {
18 | pub fn new(watch: bool) -> Self {
19 | Self {
20 | watching: watch,
21 | debouncer: VfsDebouncer::new(),
22 | watched_paths: Vec::new(),
23 | }
24 | }
25 | }
26 |
27 | impl VfsBackend for StdBackend {
28 | fn read(&self, path: &Path) -> Result> {
29 | fs::read(path)
30 | }
31 |
32 | fn read_to_string(&self, path: &Path) -> Result {
33 | let contents = fs::read_to_string(path)?;
34 |
35 | if Config::new().ignore_line_endings && contents.contains('\r') {
36 | return Ok(contents.replace("\r\n", "\n").replace("\r", "\n"));
37 | }
38 |
39 | Ok(contents)
40 | }
41 |
42 | fn read_dir(&self, path: &Path) -> Result> {
43 | let mut paths = Vec::new();
44 |
45 | for entry in fs::read_dir(path)? {
46 | paths.push(entry?.path());
47 | }
48 |
49 | Ok(paths)
50 | }
51 |
52 | fn write(&mut self, path: &Path, contents: &[u8]) -> Result<()> {
53 | fs::write(path, contents)
54 | }
55 |
56 | fn create_dir(&mut self, path: &Path) -> Result<()> {
57 | fs::create_dir_all(path)
58 | }
59 |
60 | fn rename(&mut self, from: &Path, to: &Path) -> Result<()> {
61 | fs::rename(from, to)
62 | }
63 |
64 | fn remove(&mut self, path: &Path) -> Result<()> {
65 | self.unwatch(path)?;
66 |
67 | if Config::new().move_to_bin {
68 | trash::delete(path).map_err(Error::other)
69 | } else if path.is_dir() {
70 | fs::remove_dir_all(path)
71 | } else {
72 | fs::remove_file(path)
73 | }
74 | }
75 |
76 | fn exists(&self, path: &Path) -> bool {
77 | path.exists()
78 | }
79 |
80 | fn is_dir(&self, path: &Path) -> bool {
81 | path.is_dir()
82 | }
83 |
84 | fn is_file(&self, path: &Path) -> bool {
85 | path.is_file()
86 | }
87 |
88 | fn watch(&mut self, path: &Path, recursive: bool) -> Result<()> {
89 | let path = path.to_owned();
90 |
91 | if !self.watching || self.watched_paths.iter().any(|p| path.starts_with(p)) {
92 | return Ok(());
93 | }
94 |
95 | self.debouncer.watch(&path, recursive)?;
96 | self.watched_paths.push(path);
97 |
98 | Ok(())
99 | }
100 |
101 | fn unwatch(&mut self, path: &Path) -> Result<()> {
102 | if !self.watching {
103 | return Ok(());
104 | }
105 |
106 | let path = path.to_owned();
107 |
108 | self.watched_paths.retain(|p| {
109 | let unwatch = p.starts_with(&path);
110 |
111 | if unwatch {
112 | self.debouncer.unwatch(p).ok();
113 | }
114 |
115 | !unwatch
116 | });
117 |
118 | Ok(())
119 | }
120 |
121 | fn pause(&mut self) {
122 | self.debouncer.pause()
123 | }
124 |
125 | fn resume(&mut self) {
126 | self.debouncer.resume()
127 | }
128 |
129 | fn receiver(&self) -> Receiver {
130 | self.debouncer.receiver()
131 | }
132 | }
133 |
--------------------------------------------------------------------------------
]