Ejemplo n.º 1
0
    def parse(self, parse_context, graph, node):
        klass = URIRef(MAIN_NAMESPACE + "Command")
        check_node_class(self.subclasses, parse_context, graph, node, klass,
                         ErrorMode.IGNORE)

        base = BaseScriptInfoParser(self.transformer, self.script_kind).parse(
            parse_context, graph, node)
        more = CommandScriptInfo()

        str1_parser = ZeroOnePredicate(URIRef(MAIN_NAMESPACE + "scriptURL"),
                                       IRILiteral(ErrorMode.WARNING),
                                       ErrorMode.WARNING)
        str1 = str1_parser.parse(parse_context, graph, node)
        str2_parser = ZeroOnePredicate(
            URIRef(MAIN_NAMESPACE + "commandString"),
            StringLiteral(ErrorMode.WARNING), ErrorMode.WARNING)
        str2 = str2_parser.parse(parse_context, graph, node)
        # if str1 is None and str2 is None:
        #     msg = parse_context.translate("Both :scriptURL and :commandString can't be missing in node {node}.").format(node=node)
        #     parse_context.throw(ErrorMode.WARNING, msg)
        if str1 is not None and str2 is not None:
            msg = parse_context.translate(
                "Both :scriptURL and :commandString can't be present in node {node}."
            ).format(node=node)
            parse_context.throw(ErrorMode.WARNING, msg)
        more.script_url = str1
        more.command_string = str2

        if not more.script_url and len(more.params) != 0:

            def s():
                return parse_context.translate("Cannot provide params for commandString script {node}.").\
                    format(node=node)

            parse_context.throw(ErrorMode.FATAL, s)

        min_parser = ZeroOnePredicate(URIRef(MAIN_NAMESPACE + "minVersion"),
                                      StringLiteral(ErrorMode.WARNING),
                                      ErrorMode.WARNING)
        more.min_version = min_parser.parse(parse_context, graph, node)
        max_parser = ZeroOnePredicate(URIRef(MAIN_NAMESPACE + "maxVersion"),
                                      StringLiteral(ErrorMode.WARNING),
                                      ErrorMode.WARNING)
        more.max_version = max_parser.parse(parse_context, graph, node)

        language_parser = OnePredicate(URIRef(MAIN_NAMESPACE + "language"),
                                       IRILiteral(ErrorMode.WARNING),
                                       ErrorMode.WARNING)
        more.language = language_parser.parse(parse_context, graph, node)

        params_parser = ZeroOnePredicate(URIRef(MAIN_NAMESPACE + "params"),
                                         ListParser(_ParamParser(),
                                                    ErrorMode.FATAL),
                                         ErrorMode.WARNING,
                                         default_value=[])
        more.params = params_parser.parse(parse_context, graph, node)

        return ScriptInfo(base=base, more=more)
Ejemplo n.º 2
0
    def parse(self, parse_context, graph, node):
        klass = URIRef(MAIN_NAMESPACE + "Namespace")
        check_node_class(self.subclasses, parse_context, graph, node, klass, ErrorHandler.IGNORE)

        result = Namespace(resource=node)

        script_node_parser = ScriptInfoParser(result, self.subclasses, ScriptKindEnum.VALIDATOR)
        script_parser = OneOrMorePredicate(URIRef(MAIN_NAMESPACE + "validator"), script_node_parser, ErrorHandler.WARNING)
        result.validators = script_parser.parse(parse_context, graph, node)

        return result
Ejemplo n.º 3
0
    def parse(self, parse_context, graph, node):
        klass = URIRef(MAIN_NAMESPACE + "Transformer")
        check_node_class(self.subclasses, parse_context, graph, node, klass,
                         ErrorHandler.IGNORE)

        result = Transformer()

        source_namespaces_parser = OneOrMorePredicate(
            URIRef(MAIN_NAMESPACE + "sourceNamespace"),
            IRILiteral(ErrorHandler.WARNING), ErrorHandler.WARNING)
        result.source_namespaces = source_namespaces_parser.parse(
            parse_context, graph, node)
        target_namespaces_parser = ZeroOrMorePredicate(
            URIRef(MAIN_NAMESPACE + "targetNamespace"),
            IRILiteral(ErrorHandler.WARNING))
        result.target_namespaces = target_namespaces_parser.parse(
            parse_context, graph, node)

        precedence_parser = ZeroOnePredicate(
            URIRef(MAIN_NAMESPACE + "precedence"),
            IRILiteral(ErrorHandler.WARNING), ErrorHandler.WARNING)
        result.precedence = precedence_parser.parse(parse_context, graph, node)
        inwardness_parser = ZeroOnePredicate(
            URIRef(MAIN_NAMESPACE + "inward"),
            BooleanLiteral(ErrorHandler.WARNING), ErrorHandler.WARNING, True)
        result.inwardness = inwardness_parser.parse(parse_context, graph, node)
        ignore_target_parser = ZeroOnePredicate(
            URIRef(MAIN_NAMESPACE + "ignoreTarget"),
            BooleanLiteral(ErrorHandler.WARNING), ErrorHandler.WARNING)
        result.ignore_target = ignore_target_parser.parse(
            parse_context, graph, node)
        universal_parser = ZeroOnePredicate(
            URIRef(MAIN_NAMESPACE + "universal"),
            BooleanLiteral(ErrorHandler.WARNING), ErrorHandler.WARNING)
        result.universal = universal_parser.parse(parse_context, graph, node)

        script_node_parser = ScriptInfoParser(result, self.subclasses,
                                              ScriptKindEnum.TRANSFORMER)
        script_parser = OneOrMorePredicate(URIRef(
            (MAIN_NAMESPACE + "script")), script_node_parser,
                                           ErrorHandler.WARNING)
        result.scripts = script_parser.parse(parse_context, graph, node)

        return result
Ejemplo n.º 4
0
    def parse(self, parse_context, graph, node):
        klass = URIRef(MAIN_NAMESPACE + "WebService")
        check_node_class(self.subclasses, parse_context, graph, node, klass,
                         ErrorMode.IGNORE)

        base = BaseScriptInfoParser(self.transformer, self.script_kind).parse(
            parse_context, graph, node)
        more = CommandScriptInfo()

        action_parser = OnePredicate(URIRef(MAIN_NAMESPACE + "action"),
                                     IRILiteral(ErrorMode.WARNING))
        more.action = action_parser.parse(parse_context, graph, node)
        method_parser = OnePredicate(URIRef(MAIN_NAMESPACE + "method"),
                                     IRILiteral(ErrorMode.WARNING))
        more.method = method_parser.parse(parse_context, graph, node)
        xml_field_parser = OnePredicate(URIRef(MAIN_NAMESPACE + "xmlField"),
                                        IRILiteral(ErrorMode.WARNING))
        more.xml_field = xml_field_parser.parse(parse_context, graph, node)

        return ScriptInfo(base=base, more=more)