Struct doomdooz_lib::source::File

source ·

pub struct File<'a> {
    pub parser_result: ParserResult,
    /* private fields */
}

Fields§

§parser_result: ParserResult

Implementations§

source §

pub fn is_enabled(&self, cop_name: &'static str) -> bool

Examples found in repository ?

src/source.rs (line 63)

    pub fn process(&self) {
        let ast = self.parser_result.ast.as_ref();

        if let Some(ast) = ast {
            self.iterate_nodes(&*ast);
            for (cop_name, handler) in TOKENS_HANLDERS.lock().unwrap().iter() {
                if self.is_enabled(cop_name) {
                    handler(&self.parser_result.tokens, self);
                }
            }
        }
    }

    fn iterate_nodes(&self, node: &types::Node) {
        let call_handlers = |node_type| {
            if let Some(handlers) = NODE_HANDLERS.lock().unwrap().get(node_type) {
                for (cop_name, handler) in handlers {
                    if self.is_enabled(cop_name) {
                        handler(node, self);
                    }
                }
            }
        };

        call_handlers(node.str_type());

        // TODO: implement all types
        match node {
            types::Node::Begin(n) => {
                for statement in &n.statements {
                    self.iterate_nodes(&statement);
                }
            }
            types::Node::Module(n) => {
                if let Some(body) = &n.body {
                    self.iterate_nodes(&body);
                }
            }
            types::Node::Class(n) => {
                if let Some(body) = &n.body {
                    self.iterate_nodes(&body);
                }
            }
            types::Node::Block(n) => {
                if let Some(body) = &n.body {
                    self.iterate_nodes(&body);
                }
            }
            types::Node::Lvasgn(n) => {
                if let Some(body) = &n.value {
                    self.iterate_nodes(&body);
                }
            }
            types::Node::Send(n) => {
                call_handlers(&("send_".to_owned() + &n.method_name));
            }
            _ => (),
        }
    }

source

pub fn process(&self)

source

pub fn add_offense<T: AsRef<str> + Display>(
 &self,
 cop_name: &'static str,
 range: Loc,
 message: T
)

Examples found in repository ?

src/cop/style/begin_block.rs (line 17)

pub fn on_preexe(node: &types::Node, file: &source::File) {
    if let types::Node::Preexe(node) = node {
        file.add_offense(COP_NAME, node.keyword_l, MSG);
    }
}

More examples

Hide additional examples

src/cop/style/end_block.rs (line 17)

pub fn on_postexe(node: &types::Node, file: &source::File) {
    if let types::Node::Postexe(node) = node {
        file.add_offense(COP_NAME, node.keyword_l, MSG);
    }
}

src/cop/style/send.rs (line 18)

pub fn on_def(node: &types::Node, file: &source::File) {
    if let types::Node::Send(node) = node {
        if node.method_name == "send" {
            file.add_offense(COP_NAME, node.selector_l.unwrap(), MSG)
        }
    }
}

src/cop/style/alias.rs (line 21)

pub fn on_alias(node: &types::Node, file: &source::File) {
    if CONFIG.get_string(COP_NAME, "EnforcedStyle") == "prefer_alias_method" {
        if let types::Node::Alias(node) = node {
            file.add_offense(COP_NAME, node.expression_l, MSG_ALIAS_METHOD);
        }
    }
}

pub fn on_alias_method(node: &types::Node, file: &source::File) {
    if CONFIG.get_string(COP_NAME, "EnforcedStyle") == "prefer_alias" {
        if let types::Node::Send(node) = node {
            file.add_offense(COP_NAME, node.expression_l, MSG_ALIAS);
        }
    }
}

src/cop/naming/ascii_identifiers.rs (line 21)

pub fn on_tokens(tokens: &Vec<types::Token>, file: &source::File) {
    for token in tokens {
        if should_scheck(&token) && !is_ascci(&token.token_value) {
            let offense = first_offense_range(&token);
            file.add_offense(COP_NAME, offense, IDENTIFIER_MSG);
        }
    }
}

src/cop/lint/empty_interpolation.rs (line 20)

pub fn on_dstr(node: &types::Node, file: &source::File) {
    if let types::Node::Dstr(node) = node {
        for part in &node.parts {
            if let types::Node::Begin(part) = part {
                if part.statements.is_empty() {
                    file.add_offense(COP_NAME, part.expression_l, MSG);
                }
            }
        }
    }
}

Additional examples can be found in:

source