yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/Utils.java

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
   9
  10 import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
  11 import com.google.common.base.CharMatcher;
  12 import com.google.common.base.Preconditions;
  13 import com.google.common.base.Splitter;
  14 import com.google.common.base.Strings;
  15 import com.google.common.collect.Iterables;
  16 import java.util.ArrayList;
  17 import java.util.Arrays;
  18 import java.util.Collection;
  19 import java.util.Date;
  20 import java.util.HashSet;
  21 import java.util.List;
  22 import java.util.Objects;
  23 import java.util.Set;
  24 import java.util.regex.Pattern;
  25 import javax.annotation.Nullable;
  26 import javax.xml.xpath.XPath;
  27 import javax.xml.xpath.XPathExpressionException;
  28 import javax.xml.xpath.XPathFactory;
  29 import org.antlr.v4.runtime.tree.TerminalNode;
  30 import org.opendaylight.yangtools.antlrv4.code.gen.YangStatementParser;
  31 import org.opendaylight.yangtools.yang.common.QName;
  32 import org.opendaylight.yangtools.yang.common.QNameModule;
  33 import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
  34 import org.opendaylight.yangtools.yang.model.api.Deviation;
  35 import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
  36 import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
  37 import org.opendaylight.yangtools.yang.model.api.Status;
  38 import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
  39 import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
  40 import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
  41 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
  42 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Relative;
  43 import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
  44 import org.opendaylight.yangtools.yang.model.util.RevisionAwareXPathImpl;
  45 import org.opendaylight.yangtools.yang.parser.spi.meta.QNameCacheNamespace;
  46 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  47 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
  48 import org.opendaylight.yangtools.yang.parser.spi.source.BelongsToPrefixToModuleName;
  49 import org.opendaylight.yangtools.yang.parser.spi.source.ImpPrefixToModuleIdentifier;
  50 import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
  51 import org.opendaylight.yangtools.yang.parser.spi.source.ModuleIdentifierToModuleQName;
  52 import org.opendaylight.yangtools.yang.parser.spi.source.ModuleNameToModuleQName;
  53 import org.opendaylight.yangtools.yang.parser.spi.source.PrefixToModule;
  54 import org.opendaylight.yangtools.yang.parser.spi.source.QNameToStatementDefinition;
  55 import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
  56 import org.slf4j.Logger;
  57 import org.slf4j.LoggerFactory;
  58
  59 public final class Utils {
  60     private static final Logger LOG = LoggerFactory.getLogger(Utils.class);
  61     private static final CharMatcher DOUBLE_QUOTE_MATCHER = CharMatcher.is('"');
  62     private static final CharMatcher SINGLE_QUOTE_MATCHER = CharMatcher.is('\'');
  63     private static final Splitter SLASH_SPLITTER = Splitter.on('/').omitEmptyStrings().trimResults();
  64     private static final Splitter SPACE_SPLITTER = Splitter.on(' ').omitEmptyStrings().trimResults();
  65     private static final Pattern PATH_ABS = Pattern.compile("/[^/].*");
  66
  67     private static final ThreadLocal<XPathFactory> XPATH_FACTORY = new ThreadLocal<XPathFactory>() {
  68         @Override
  69         protected XPathFactory initialValue() {
  70             return XPathFactory.newInstance();
  71         }
  72     };
  73
  74     private Utils() {
  75         throw new UnsupportedOperationException();
  76     }
  77
  78     /**
  79      * Cleanup any resources attached to the current thread. Threads interacting with this class can cause thread-local
  80      * caches to them. Invoke this method if you want to detach those resources.
  81      */
  82     public static void detachFromCurrentThread() {
  83         XPATH_FACTORY.remove();
  84     }
  85
  86     public static Collection<SchemaNodeIdentifier.Relative> transformKeysStringToKeyNodes(final StmtContext<?, ?, ?> ctx,
  87             final String value) {
  88         List<String> keyTokens = SPACE_SPLITTER.splitToList(value);
  89
  90         // to detect if key contains duplicates
  91         if ((new HashSet<>(keyTokens)).size() < keyTokens.size()) {
  92             // FIXME: report all duplicate keys
  93             throw new IllegalArgumentException();
  94         }
  95
  96         Set<SchemaNodeIdentifier.Relative> keyNodes = new HashSet<>();
  97
  98         for (String keyToken : keyTokens) {
  99
 100             SchemaNodeIdentifier.Relative keyNode = (Relative) SchemaNodeIdentifier.Relative.create(false,
 101                     Utils.qNameFromArgument(ctx, keyToken));
 102             keyNodes.add(keyNode);
 103         }
 104
 105         return keyNodes;
 106     }
 107
 108     private static String trimSingleLastSlashFromXPath(final String path) {
 109         return path.endsWith("/") ? path.substring(0, path.length() - 1) : path;
 110     }
 111
 112     static RevisionAwareXPath parseXPath(final StmtContext<?, ?, ?> ctx, final String path) {
 113         final XPath xPath = XPATH_FACTORY.get().newXPath();
 114         xPath.setNamespaceContext(StmtNamespaceContext.create(ctx));
 115
 116         final String trimmed = trimSingleLastSlashFromXPath(path);
 117         try {
 118             // TODO: we could capture the result and expose its 'evaluate' method
 119             xPath.compile(trimmed);
 120         } catch (XPathExpressionException e) {
 121             LOG.warn("Argument \"{}\" is not valid XPath string at \"{}\"", path, ctx.getStatementSourceReference(), e);
 122         }
 123
 124         return new RevisionAwareXPathImpl(path, PATH_ABS.matcher(path).matches());
 125     }
 126
 127     public static QName trimPrefix(final QName identifier) {
 128         String prefixedLocalName = identifier.getLocalName();
 129         String[] namesParts = prefixedLocalName.split(":");
 130
 131         if (namesParts.length == 2) {
 132             String localName = namesParts[1];
 133             return QName.create(identifier.getModule(), localName);
 134         }
 135
 136         return identifier;
 137     }
 138
 139     /**
 140      *
 141      * Based on identifier read from source and collections of relevant prefixes and statement definitions mappings
 142      * provided for actual phase, method resolves and returns valid QName for declared statement to be written.
 143      * This applies to any declared statement, including unknown statements.
 144      *
 145      * @param prefixes - collection of all relevant prefix mappings supplied for actual parsing phase
 146      * @param stmtDef - collection of all relevant statement definition mappings provided for actual parsing phase
 147      * @param identifier - statement to parse from source
 148      * @return valid QName for declared statement to be written
 149      *
 150      */
 151     public static QName getValidStatementDefinition(final PrefixToModule prefixes, final QNameToStatementDefinition
 152             stmtDef, final QName identifier) {
 153         if (stmtDef.get(identifier) != null) {
 154             return stmtDef.get(identifier).getStatementName();
 155         } else {
 156             String prefixedLocalName = identifier.getLocalName();
 157             String[] namesParts = prefixedLocalName.split(":");
 158
 159             if (namesParts.length == 2) {
 160                 String prefix = namesParts[0];
 161                 String localName = namesParts[1];
 162                 if (prefixes != null && prefixes.get(prefix) != null
 163                         && stmtDef.get(QName.create(prefixes.get(prefix), localName)) != null) {
 164                     return QName.create(prefixes.get(prefix), localName);
 165                 }
 166             }
 167         }
 168         return null;
 169     }
 170
 171     static SchemaNodeIdentifier nodeIdentifierFromPath(final StmtContext<?, ?, ?> ctx, final String path) {
 172         // FIXME: is the path trimming really necessary??
 173         final List<QName> qNames = new ArrayList<>();
 174         for (String nodeName : SLASH_SPLITTER.split(trimSingleLastSlashFromXPath(path))) {
 175             try {
 176                 final QName qName = Utils.qNameFromArgument(ctx, nodeName);
 177                 qNames.add(qName);
 178             } catch (Exception e) {
 179                 throw new IllegalArgumentException(
 180                     String.format("Failed to parse node '%s' in path '%s'", nodeName, path), e);
 181             }
 182         }
 183
 184         return SchemaNodeIdentifier.create(qNames, PATH_ABS.matcher(path).matches());
 185     }
 186
 187     public static String stringFromStringContext(final YangStatementParser.ArgumentContext context) {
 188         StringBuilder sb = new StringBuilder();
 189         List<TerminalNode> strings = context.STRING();
 190         if (strings.isEmpty()) {
 191             strings = Arrays.asList(context.IDENTIFIER());
 192         }
 193         for (TerminalNode stringNode : strings) {
 194             final String str = stringNode.getText();
 195             char firstChar = str.charAt(0);
 196             final CharMatcher quoteMatcher;
 197             if (SINGLE_QUOTE_MATCHER.matches(firstChar)) {
 198                 quoteMatcher = SINGLE_QUOTE_MATCHER;
 199             } else if (DOUBLE_QUOTE_MATCHER.matches(firstChar)) {
 200                 quoteMatcher = DOUBLE_QUOTE_MATCHER;
 201             } else {
 202                 sb.append(str);
 203                 continue;
 204             }
 205             sb.append(quoteMatcher.removeFrom(str.substring(1, str.length() - 1)));
 206         }
 207         return sb.toString();
 208     }
 209
 210     public static QName qNameFromArgument(StmtContext<?, ?, ?> ctx, final String value) {
 211         if (Strings.isNullOrEmpty(value)) {
 212             return ctx.getPublicDefinition().getStatementName();
 213         }
 214
 215         String prefix;
 216         QNameModule qNameModule = null;
 217         String localName = null;
 218
 219         String[] namesParts = value.split(":");
 220         switch (namesParts.length) {
 221         case 1:
 222             localName = namesParts[0];
 223             qNameModule = getRootModuleQName(ctx);
 224             break;
 225         default:
 226             prefix = namesParts[0];
 227             localName = namesParts[1];
 228             qNameModule = getModuleQNameByPrefix(ctx, prefix);
 229             // in case of unknown statement argument, we're not going to parse it
 230             if (qNameModule == null
 231                     && ctx.getPublicDefinition().getDeclaredRepresentationClass()
 232                     .isAssignableFrom(UnknownStatementImpl.class)) {
 233                 localName = value;
 234                 qNameModule = getRootModuleQName(ctx);
 235             }
 236             if (qNameModule == null
 237                     && Iterables.getLast(ctx.getCopyHistory()) == StmtContext.TypeOfCopy.ADDED_BY_AUGMENTATION) {
 238                 ctx = ctx.getOriginalCtx();
 239                 qNameModule = getModuleQNameByPrefix(ctx, prefix);
 240             }
 241             break;
 242         }
 243
 244         Preconditions.checkArgument(qNameModule != null, "Error in module '%s': can not resolve QNameModule for '%s'.",
 245                 ctx.getRoot().rawStatementArgument(), value);
 246         final QNameModule resultQNameModule;
 247         if (qNameModule.getRevision() == null) {
 248             resultQNameModule = QNameModule.create(qNameModule.getNamespace(), SimpleDateFormatUtil.DEFAULT_DATE_REV)
 249                 .intern();
 250         } else {
 251             resultQNameModule = qNameModule;
 252         }
 253
 254         return ctx.getFromNamespace(QNameCacheNamespace.class, QName.create(resultQNameModule, localName));
 255     }
 256
 257     public static QNameModule getModuleQNameByPrefix(final StmtContext<?, ?, ?> ctx, final String prefix) {
 258         final ModuleIdentifier modId = ctx.getRoot().getFromNamespace(ImpPrefixToModuleIdentifier.class, prefix);
 259         final QNameModule qNameModule = ctx.getFromNamespace(ModuleIdentifierToModuleQName.class, modId);
 260
 261         if (qNameModule == null && StmtContextUtils.producesDeclared(ctx.getRoot(), SubmoduleStatement.class)) {
 262             String moduleName = ctx.getRoot().getFromNamespace(BelongsToPrefixToModuleName.class, prefix);
 263             return ctx.getFromNamespace(ModuleNameToModuleQName.class, moduleName);
 264         }
 265         return qNameModule;
 266     }
 267
 268     public static QNameModule getRootModuleQName(final StmtContext<?, ?, ?> ctx) {
 269         if (ctx == null) {
 270             return null;
 271         }
 272
 273         final StmtContext<?, ?, ?> rootCtx = ctx.getRoot();
 274         final QNameModule qNameModule;
 275
 276         if (StmtContextUtils.producesDeclared(rootCtx, ModuleStatement.class)) {
 277             qNameModule = rootCtx.getFromNamespace(ModuleCtxToModuleQName.class, rootCtx);
 278         } else if (StmtContextUtils.producesDeclared(rootCtx, SubmoduleStatement.class)) {
 279             final String belongsToModuleName = firstAttributeOf(rootCtx.substatements(), BelongsToStatement.class);
 280             qNameModule = rootCtx.getFromNamespace(ModuleNameToModuleQName.class, belongsToModuleName);
 281         } else {
 282             qNameModule = null;
 283         }
 284
 285         Preconditions.checkArgument(qNameModule != null, "Failed to look up root QNameModule for %s", ctx);
 286         if (qNameModule.getRevision() != null) {
 287             return qNameModule;
 288         }
 289
 290         return QNameModule.create(qNameModule.getNamespace(), SimpleDateFormatUtil.DEFAULT_DATE_REV).intern();
 291     }
 292
 293     @Nullable
 294     public static StatementContextBase<?, ?, ?> findNode(final StmtContext<?, ?, ?> rootStmtCtx,
 295             final SchemaNodeIdentifier node) {
 296         return (StatementContextBase<?, ?, ?>) rootStmtCtx.getFromNamespace(SchemaNodeIdentifierBuildNamespace.class, node);
 297     }
 298
 299     public static boolean isUnknownNode(final StmtContext<?, ?, ?> stmtCtx) {
 300         return stmtCtx.getPublicDefinition().getDeclaredRepresentationClass()
 301                 .isAssignableFrom(UnknownStatementImpl.class);
 302     }
 303
 304     public static Deviation.Deviate parseDeviateFromString(final String deviate) {
 305
 306         // Yang constants should be lowercase so we have throw if value does not
 307         // suit this
 308         String deviateUpper = deviate.toUpperCase();
 309         Preconditions.checkArgument(!Objects.equals(deviate, deviateUpper),
 310             "String %s is not valid deviate argument", deviate);
 311
 312         // but Java enum is uppercase so we cannot use lowercase here
 313         try {
 314             return Deviation.Deviate.valueOf(deviateUpper);
 315         } catch (IllegalArgumentException e) {
 316             throw new IllegalArgumentException(String.format("String %s is not valid deviate argument", deviate), e);
 317         }
 318     }
 319
 320     public static Status parseStatus(final String value) {
 321         switch (value) {
 322         case "current":
 323             return Status.CURRENT;
 324         case "deprecated":
 325             return Status.DEPRECATED;
 326         case "obsolete":
 327             return Status.OBSOLETE;
 328         default:
 329             LOG.warn("Invalid 'status' statement: {}", value);
 330             return null;
 331         }
 332     }
 333
 334     public static Date getLatestRevision(final Iterable<? extends StmtContext<?, ?, ?>> subStmts) {
 335         Date revision = null;
 336         for (StmtContext<?, ?, ?> subStmt : subStmts) {
 337             if (subStmt.getPublicDefinition().getDeclaredRepresentationClass().isAssignableFrom(RevisionStatement
 338                     .class)) {
 339                 if (revision == null && subStmt.getStatementArgument() != null) {
 340                     revision = (Date) subStmt.getStatementArgument();
 341                 } else if (subStmt.getStatementArgument() != null && ((Date) subStmt.getStatementArgument()).compareTo
 342                         (revision) > 0) {
 343                     revision = (Date) subStmt.getStatementArgument();
 344                 }
 345             }
 346         }
 347         return revision;
 348     }
 349
 350     public static boolean isModuleIdentifierWithoutSpecifiedRevision(final Object o) {
 351         return (o instanceof ModuleIdentifier)
 352                 && (((ModuleIdentifier) o).getRevision() == SimpleDateFormatUtil.DEFAULT_DATE_IMP ||
 353                         ((ModuleIdentifier) o).getRevision() == SimpleDateFormatUtil.DEFAULT_BELONGS_TO_DATE);
 354     }
 355 }