dbml-rs 1.0.1

A DBML parser for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use alloc::vec::Vec;

use super::*;

/// Represents the entire structure of a parsed DBML file.
#[derive(Debug, Clone, Default)]
pub struct SchemaBlock<'a> {
  /// The span range of the entire parsed DBML structure in the source text.
  pub span_range: SpanRange,
  /// The input source content.
  pub input: &'a str,
  /// A vector of top-level blocks comprising the parsed DBML structure.
  pub blocks: Vec<TopLevelBlock>,
}

/// An enum representing various top-level blocks in a parsed DBML file.
#[derive(Debug, Clone)]
pub enum TopLevelBlock {
  /// Represents a project block in the DBML file.
  Project(ProjectBlock),
  /// Represents a table block in the DBML file.
  Table(TableBlock),
  /// Represents a table group block in the DBML file.
  TableGroup(TableGroupBlock),
  /// Represents a note block in the DBML file.
  Note(NoteBlock),
  /// Represents a reference block in the DBML file.
  Ref(RefBlock),
  /// Represents an enum block in the DBML file.
  Enum(EnumBlock),
}

impl<'a> SchemaBlock<'a> {
  pub fn projects(&self) -> Vec<&ProjectBlock> {
    self
      .blocks
      .iter()
      .filter_map(|block| {
        if let TopLevelBlock::Project(project) = block {
          Some(project)
        } else {
          None
        }
      })
      .collect()
  }

  pub fn tables(&self) -> Vec<&TableBlock> {
    self
      .blocks
      .iter()
      .filter_map(|block| {
        if let TopLevelBlock::Table(table) = block {
          Some(table)
        } else {
          None
        }
      })
      .collect()
  }

  pub fn table_groups(&self) -> Vec<&TableGroupBlock> {
    self
      .blocks
      .iter()
      .filter_map(|block| {
        if let TopLevelBlock::TableGroup(table_group) = block {
          Some(table_group)
        } else {
          None
        }
      })
      .collect()
  }

  pub fn notes(&self) -> Vec<&NoteBlock> {
    self
      .blocks
      .iter()
      .filter_map(|block| {
        if let TopLevelBlock::Note(note_block) = block {
          Some(note_block)
        } else {
          None
        }
      })
      .collect()
  }

  pub fn refs(&self) -> Vec<&RefBlock> {
    self
      .blocks
      .iter()
      .filter_map(|block| {
        if let TopLevelBlock::Ref(reference) = block {
          Some(reference)
        } else {
          None
        }
      })
      .collect()
  }

  pub fn enums(&self) -> Vec<&EnumBlock> {
    self
      .blocks
      .iter()
      .filter_map(|block| {
        if let TopLevelBlock::Enum(enum_block) = block {
          Some(enum_block)
        } else {
          None
        }
      })
      .collect()
  }
}