rubydex 0.1.0.beta11 → 0.1.0.beta13

data/rust/rubydex/src/model/references.rs

@@ -1,111 +1,111 @@
-use crate::{
-    assert_mem_size,
-    model::ids::{NameId, ReferenceId, StringId, UriId},
-    offset::Offset,
-};
-
-/// A reference to a constant
-#[derive(Debug)]
-pub struct ConstantReference {
-    /// The name ID of this reference
-    name_id: NameId,
-    /// The document where we found the reference
-    uri_id: UriId,
-    /// The offsets inside of the document where we found the reference
-    offset: Offset,
-}
-assert_mem_size!(ConstantReference, 24);
-
-impl ConstantReference {
-    #[must_use]
-    pub fn new(name_id: NameId, uri_id: UriId, offset: Offset) -> Self {
-        Self {
-            name_id,
-            uri_id,
-            offset,
-        }
-    }
-
-    #[must_use]
-    pub fn name_id(&self) -> &NameId {
-        &self.name_id
-    }
-
-    #[must_use]
-    pub fn uri_id(&self) -> UriId {
-        self.uri_id
-    }
-
-    #[must_use]
-    pub fn offset(&self) -> &Offset {
-        &self.offset
-    }
-
-    #[must_use]
-    pub fn id(&self) -> ReferenceId {
-        ReferenceId::from(&format!(
-            "{}:{}:{}-{}",
-            self.name_id,
-            self.uri_id,
-            self.offset.start(),
-            self.offset.end()
-        ))
-    }
-}
-
-/// A reference to a method
-#[derive(Debug)]
-pub struct MethodRef {
-    /// The unqualified name of the method
-    str: StringId,
-    /// The document where we found the reference
-    uri_id: UriId,
-    /// The offsets inside of the document where we found the reference
-    offset: Offset,
-    /// The receiver of the method call if it's a constant
-    receiver: Option<NameId>,
-}
-assert_mem_size!(MethodRef, 32);
-
-impl MethodRef {
-    #[must_use]
-    pub fn new(str: StringId, uri_id: UriId, offset: Offset, receiver: Option<NameId>) -> Self {
-        Self {
-            str,
-            uri_id,
-            offset,
-            receiver,
-        }
-    }
-
-    #[must_use]
-    pub fn str(&self) -> &StringId {
-        &self.str
-    }
-
-    #[must_use]
-    pub fn uri_id(&self) -> UriId {
-        self.uri_id
-    }
-
-    #[must_use]
-    pub fn offset(&self) -> &Offset {
-        &self.offset
-    }
-
-    #[must_use]
-    pub fn receiver(&self) -> Option<NameId> {
-        self.receiver
-    }
-
-    #[must_use]
-    pub fn id(&self) -> ReferenceId {
-        ReferenceId::from(&format!(
-            "{}:{}:{}-{}",
-            self.str,
-            self.uri_id,
-            self.offset.start(),
-            self.offset.end()
-        ))
-    }
-}
+use crate::{
+    assert_mem_size,
+    model::ids::{ConstantReferenceId, MethodReferenceId, NameId, StringId, UriId},
+    offset::Offset,
+};
+
+/// A reference to a constant
+#[derive(Debug)]
+pub struct ConstantReference {
+    /// The name ID of this reference
+    name_id: NameId,
+    /// The document where we found the reference
+    uri_id: UriId,
+    /// The offsets inside of the document where we found the reference
+    offset: Offset,
+}
+assert_mem_size!(ConstantReference, 24);
+
+impl ConstantReference {
+    #[must_use]
+    pub fn new(name_id: NameId, uri_id: UriId, offset: Offset) -> Self {
+        Self {
+            name_id,
+            uri_id,
+            offset,
+        }
+    }
+
+    #[must_use]
+    pub fn name_id(&self) -> &NameId {
+        &self.name_id
+    }
+
+    #[must_use]
+    pub fn uri_id(&self) -> UriId {
+        self.uri_id
+    }
+
+    #[must_use]
+    pub fn offset(&self) -> &Offset {
+        &self.offset
+    }
+
+    #[must_use]
+    pub fn id(&self) -> ConstantReferenceId {
+        ConstantReferenceId::from(&format!(
+            "{}:{}:{}-{}",
+            self.name_id,
+            self.uri_id,
+            self.offset.start(),
+            self.offset.end()
+        ))
+    }
+}
+
+/// A reference to a method
+#[derive(Debug)]
+pub struct MethodRef {
+    /// The unqualified name of the method
+    str: StringId,
+    /// The document where we found the reference
+    uri_id: UriId,
+    /// The offsets inside of the document where we found the reference
+    offset: Offset,
+    /// The receiver of the method call if it's a constant
+    receiver: Option<NameId>,
+}
+assert_mem_size!(MethodRef, 32);
+
+impl MethodRef {
+    #[must_use]
+    pub fn new(str: StringId, uri_id: UriId, offset: Offset, receiver: Option<NameId>) -> Self {
+        Self {
+            str,
+            uri_id,
+            offset,
+            receiver,
+        }
+    }
+
+    #[must_use]
+    pub fn str(&self) -> &StringId {
+        &self.str
+    }
+
+    #[must_use]
+    pub fn uri_id(&self) -> UriId {
+        self.uri_id
+    }
+
+    #[must_use]
+    pub fn offset(&self) -> &Offset {
+        &self.offset
+    }
+
+    #[must_use]
+    pub fn receiver(&self) -> Option<NameId> {
+        self.receiver
+    }
+
+    #[must_use]
+    pub fn id(&self) -> MethodReferenceId {
+        MethodReferenceId::from(&format!(
+            "{}:{}:{}-{}",
+            self.str,
+            self.uri_id,
+            self.offset.start(),
+            self.offset.end()
+        ))
+    }
+}

data/rust/rubydex/src/model/string_ref.rs

@@ -1,50 +1,50 @@
-use std::ops::Deref;
-
-/// A reference-counted string used in the graph.
-///
-/// This struct wraps a `String` with a reference count to track how many times
-/// the string is used across the graph. When a document is removed, we decrement
-/// the reference count for each string it uses, and remove the string from the
-/// graph when its count reaches zero.
-#[derive(Debug)]
-pub struct StringRef {
-    value: String,
-    ref_count: u32,
-}
-
-impl StringRef {
-    #[must_use]
-    pub fn new(value: String) -> Self {
-        Self { value, ref_count: 1 }
-    }
-
-    #[must_use]
-    pub fn ref_count(&self) -> u32 {
-        self.ref_count
-    }
-
-    /// # Panics
-    ///
-    /// This function will panic if the reference count would exceed `u32::MAX`
-    pub fn increment_ref_count(&mut self, count: u32) {
-        self.ref_count = self
-            .ref_count
-            .checked_add(count)
-            .expect("Should not exceed maximum string ref count");
-    }
-
-    #[must_use]
-    pub fn decrement_ref_count(&mut self) -> bool {
-        debug_assert!(self.ref_count > 0);
-        self.ref_count -= 1;
-        self.ref_count > 0
-    }
-}
-
-impl Deref for StringRef {
-    type Target = String;
-
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
+use std::ops::Deref;
+
+/// A reference-counted string used in the graph.
+///
+/// This struct wraps a `String` with a reference count to track how many times
+/// the string is used across the graph. When a document is removed, we decrement
+/// the reference count for each string it uses, and remove the string from the
+/// graph when its count reaches zero.
+#[derive(Debug)]
+pub struct StringRef {
+    value: String,
+    ref_count: u32,
+}
+
+impl StringRef {
+    #[must_use]
+    pub fn new(value: String) -> Self {
+        Self { value, ref_count: 1 }
+    }
+
+    #[must_use]
+    pub fn ref_count(&self) -> u32 {
+        self.ref_count
+    }
+
+    /// # Panics
+    ///
+    /// This function will panic if the reference count would exceed `u32::MAX`
+    pub fn increment_ref_count(&mut self, count: u32) {
+        self.ref_count = self
+            .ref_count
+            .checked_add(count)
+            .expect("Should not exceed maximum string ref count");
+    }
+
+    #[must_use]
+    pub fn decrement_ref_count(&mut self) -> bool {
+        debug_assert!(self.ref_count > 0);
+        self.ref_count -= 1;
+        self.ref_count > 0
+    }
+}
+
+impl Deref for StringRef {
+    type Target = String;
+
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}

data/rust/rubydex/src/model/visibility.rs

@@ -1,41 +1,41 @@
-use core::fmt;
-use std::fmt::Display;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Visibility {
-    Public,
-    Protected,
-    Private,
-    ModuleFunction,
-}
-
-impl Visibility {
-    /// Parse a visibility from a string.
-    ///
-    /// Valid values are `public`, `protected`, and `private`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the string is not a valid visibility
-    #[must_use]
-    pub fn from_string(str: &str) -> Self {
-        match str {
-            "public" => Self::Public,
-            "protected" => Self::Protected,
-            "private" => Self::Private,
-            "module_function" => Self::ModuleFunction,
-            _ => panic!("Invalid visibility: {str}"),
-        }
-    }
-}
-
-impl Display for Visibility {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Public => write!(f, "public"),
-            Self::Protected => write!(f, "protected"),
-            Self::Private => write!(f, "private"),
-            Self::ModuleFunction => write!(f, "module_function"),
-        }
-    }
-}
+use core::fmt;
+use std::fmt::Display;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Visibility {
+    Public,
+    Protected,
+    Private,
+    ModuleFunction,
+}
+
+impl Visibility {
+    /// Parse a visibility from a string.
+    ///
+    /// Valid values are `public`, `protected`, and `private`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the string is not a valid visibility
+    #[must_use]
+    pub fn from_string(str: &str) -> Self {
+        match str {
+            "public" => Self::Public,
+            "protected" => Self::Protected,
+            "private" => Self::Private,
+            "module_function" => Self::ModuleFunction,
+            _ => panic!("Invalid visibility: {str}"),
+        }
+    }
+}
+
+impl Display for Visibility {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Public => write!(f, "public"),
+            Self::Protected => write!(f, "protected"),
+            Self::Private => write!(f, "private"),
+            Self::ModuleFunction => write!(f, "module_function"),
+        }
+    }
+}

data/rust/rubydex/src/model.rs

@@ -1,14 +1,15 @@
-pub mod comment;
-pub mod declaration;
-pub mod definitions;
-pub mod document;
-pub mod encoding;
-pub mod graph;
-pub mod id;
-pub mod identity_maps;
-pub mod ids;
-pub mod keywords;
-pub mod name;
-pub mod references;
-pub mod string_ref;
-pub mod visibility;
+pub mod built_in;
+pub mod comment;
+pub mod declaration;
+pub mod definitions;
+pub mod document;
+pub mod encoding;
+pub mod graph;
+pub mod id;
+pub mod identity_maps;
+pub mod ids;
+pub mod keywords;
+pub mod name;
+pub mod references;
+pub mod string_ref;
+pub mod visibility;