feat: add simple get dep logic

scie-grammar/src/grammar_registry.rs

-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
+use crate::scope_dependency::{ScopeDependency, FullScopeDependency};
+use crate::scope_dependency::ScopeDependency::Full;
 
 pub struct IEmbeddedLanguagesMap {
     map: HashMap<String, i32>,
@@ -31,7 +33,33 @@ impl GrammarRegistry {
     ) {}
     // todo: modify logic to here for _collectDependenciesForDep
     pub fn _load_grammar(&self, initial_scope_name: String, _initial_language: i32, _token_type: Option<ITokenTypeMap>) {
+        let mut seen_full_scope_requests: HashSet<String> = HashSet::new();
+        let seen_partial_scope_requests: HashSet<String> = HashSet::new();
 
+        seen_full_scope_requests.insert(initial_scope_name.clone());
+
+        let dependency = FullScopeDependency::new(initial_scope_name);
+        let mut Q: Vec<ScopeDependency> = vec![ScopeDependency::Full(dependency)];
+
+        while Q.len() > 0 {
+            let q = Q.clone();
+            Q = vec![];
+
+            for x in q {
+                match x {
+                    Full(dep) => {
+                        self._loadSingleGrammar(dep.scope_name);
+                    },
+                    ScopeDependency::Partial(dep) => {
+                        self._loadSingleGrammar(dep.scope_name);
+                    },
+                }
+            }
+        }
+    }
+
+    pub fn _loadSingleGrammar(&self, scope_name: String) {
+        // todo: add cache supportr
     }
 
     pub fn load_grammar(&self, initial_scope_name: String) {

scie-grammar/src/scope_dependency.rs

@@ -18,10 +18,16 @@ pub struct FullScopeDependency {
     pub scope_name: String
 }
 
+impl FullScopeDependency {
+    pub fn new(scope_name: String) -> Self {
+        FullScopeDependency { scope_name }
+    }
+}
+
 #[derive(Clone, Debug, Serialize)]
 pub enum ScopeDependency {
-    FullScopeDependency(FullScopeDependency),
-    PartialScopeDependency(PartialScopeDependency)
+    Full(FullScopeDependency),
+    Partial(PartialScopeDependency)
 }
 
 #[derive(Clone, Debug, Serialize)]
@@ -46,14 +52,14 @@ impl ScopeDependencyCollector {
 
     pub fn add(&mut self, dep: ScopeDependency) {
         match dep {
-            ScopeDependency::FullScopeDependency(full_dep) => {
+            ScopeDependency::Full(full_dep) => {
                 let scope_name = &*full_dep.scope_name.clone();
                 if let None = self._seen_full.get(scope_name.clone()) {
                     self._seen_full.insert(String::from(scope_name));
                     self.full.push(full_dep);
                 }
             },
-            ScopeDependency::PartialScopeDependency(partial_dep) => {
+            ScopeDependency::Partial(partial_dep) => {
                 let key = &*partial_dep.to_key();
                 if let None = self._seen_partial.get(key) {
                     self._seen_partial.insert(String::from(key));