private Collection<Selector> replaceFirstAppender(
      Selector selector, List<Selector> previousSelectors) {
    if (selector.getHead().isAppender()) {
      NestedSelectorAppender appender = (NestedSelectorAppender) selector.getHead();
      Selector reminder = chopOffHead(selector);
      return joinAll(
          previousSelectors,
          reminder,
          appender.getLeadingCombinator(),
          isDirectlyAfterPreviousPart(reminder));
    }

    // appender somewhere in the middle
    NestedSelectorAppender appender = selector.findFirstAppender();
    if (appender == null)
      throw new BugHappened("This is very weird error and should not happen.", selector);

    Selector afterAppender = splitOn(selector, appender);
    List<Selector> partialResults =
        joinAll(
            selector,
            previousSelectors,
            appender.getLeadingCombinator(),
            appender.isDirectlyAfter());
    // FIXME (now) last parameter should be nide and repats cold in 146
    return joinAll(partialResults, afterAppender, null, isDirectlyAfterPreviousPart(afterAppender));
  }
  public Selector indirectJoin(Selector firstI, SelectorCombinator combinator, Selector secondI) {
    // if both of them are null, something is very wrong
    if (secondI == null) return firstI.clone();

    if (firstI == null) return secondI.clone();

    Selector first = firstI.clone();
    Selector second = secondI.clone();

    return indirectJoinNoClone(first, combinator, second);
  }
Beispiel #3
0
  private boolean isEmptySelector(Selector selector) {
    if (selector.isCombined()) return false;

    SelectorPart head = selector.getHead();
    if (head.getType() != ASTCssNodeType.SIMPLE_SELECTOR) return false;

    SimpleSelector simpleHead = (SimpleSelector) head;
    if (!simpleHead.isEmptyForm() || !simpleHead.isStar()) {
      return false;
    }

    if (simpleHead.hasSubsequent()) return false;

    return true;
  }
 private Selector replaceMiddleAppendersByEmptiness(Selector selector) {
   Selector empty =
       new Selector(selector.getUnderlyingStructure(), createEmptySimpleSelector(selector));
   List<Selector> replaceAppenders = replaceAppenders(selector, Arrays.asList(empty));
   Selector replacement = replaceAppenders.get(0);
   return replacement;
 }
  public Selector removeAppenders(Selector selector) {
    selector = replaceLeadingAppendersByEmptiness(selector);
    if (!selector.containsAppender()) return selector;

    Selector replacement = replaceMiddleAppendersByEmptiness(selector);
    return replacement;
  }
  public Selector indirectJoinNoClone(
      Selector first,
      SelectorCombinator combinator,
      List<SelectorPart> second,
      List<Extend> extend) {
    first.addExtends(extend);

    if (second.isEmpty()) return first;

    if (combinator != null) {
      second.get(0).setLeadingCombinator(combinator);
    }
    first.addParts(second);
    first.configureParentToAllChilds();

    return first;
  }
  public Selector directJoin(Selector firstI, Selector secondI) {
    // if both of them are null, something is very wrong
    if (secondI == null) return firstI.clone();

    if (firstI == null) return secondI.clone();

    Selector first = firstI.clone();
    List<SelectorPart> secondParts = ArraysUtils.deeplyClonedList(secondI.getParts());
    List<Extend> secondExtends = ArraysUtils.deeplyClonedList(secondI.getExtend());
    SelectorPart secondHead = secondParts.get(0);

    if (secondHead.isAppender())
      return indirectJoinNoClone(
          first, secondHead.getLeadingCombinator(), secondParts, secondExtends);

    /*
     * FIXME: test on old whether survives if first is not simple selector. (say, if:
     * (~"escaped") {
     *   &:pseudo() {
     *   }
     * }
     *
     */
    SelectorPart attachToHead = first.getLastPart();
    directlyJoinParts(attachToHead, secondHead);

    secondParts.remove(0);
    SelectorCombinator leadingCombinator =
        secondParts.isEmpty() ? null : secondParts.get(0).getLeadingCombinator();
    return indirectJoinNoClone(first, leadingCombinator, secondParts, secondExtends);
  }
 private boolean isDirect(
     SelectorCombinator beforeAppenderCombinator,
     boolean appenderDirectlyPlaced,
     Selector afterAppender) {
   boolean result =
       beforeAppenderCombinator == null
           && appenderDirectlyPlaced
           && (afterAppender == null || !afterAppender.hasLeadingCombinator());
   return result;
 }
  private Selector splitOn(Selector selector, NestedSelectorAppender appender) {
    List<SelectorPart> parts = selector.getParts();
    int indexOfAppender = parts.indexOf(appender);
    List<SelectorPart> appenderAndAfter = parts.subList(indexOfAppender, parts.size());

    // remove appender
    appenderAndAfter.remove(0);
    appender.setParent(null);

    // create selector with after appender parts
    Selector result = null;
    if (!appenderAndAfter.isEmpty()) {
      result =
          new Selector(
              selector.getUnderlyingStructure(), new ArrayList<SelectorPart>(appenderAndAfter));
      result.configureParentToAllChilds();
    }

    // leave only before appender parts in original selector
    appenderAndAfter.clear();
    return result;
  }
  public List<Selector> replaceAppenders(Selector inSelector, List<Selector> replacements) {
    if (!inSelector.containsAppender()) {
      return indirectJoinAll(replacements, null, inSelector);
    }

    List<Selector> result = Arrays.asList(inSelector);
    while (result.get(0).containsAppender()) {
      List<Selector> nextRound = new ArrayList<Selector>();
      for (Selector tbch : result) {
        nextRound.addAll(replaceFirstAppender(tbch, replacements));
      }

      result = nextRound;
    }

    return result;
  }
  private Selector replaceLeadingAppendersByEmptiness(Selector selector) {
    while (!selector.isEmpty() && selector.getHead().isAppender()) {
      selector.getHead().setParent(null);
      selector.removeHead();
    }

    if (selector.isEmpty()) {
      SimpleSelector empty = createEmptySimpleSelector(selector);
      selector.addPart(empty);
    }
    return selector;
  }
 public Selector indirectJoinNoClone(
     Selector first, SelectorCombinator combinator, Selector second) {
   return indirectJoinNoClone(first, combinator, second.getParts(), second.getExtend());
 }
  private Selector chopOffHead(Selector selector) {
    if (!selector.isCombined()) return null;

    selector.removeHead();
    return selector;
  }
 private boolean isDirectlyAfterPreviousPart(Selector selector) {
   return selector == null ? false : !selector.hasLeadingCombinator();
 }
Beispiel #15
0
 public boolean appendSelector(Selector selector) {
   for (SelectorPart part : selector.getParts()) {
     append(part);
   }
   return true;
 }