congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
org.eclipse.jgit.ignore.internal
Code IndexAdd Tabnine to your IDE (free)

How to use org.eclipse.jgit.ignore.internal

Best Java code snippets using org.eclipse.jgit.ignore.internal (Showing top 20 results out of 315)

origin: org.eclipse.jgit/org.eclipse.jgit

WildCardMatcher(String pattern, Character pathSeparator, boolean dirOnly)
    throws InvalidPatternException {
  super(pattern, pathSeparator, dirOnly, false);
  p = convertGlob(subPattern);
}
origin: org.eclipse.jgit/org.eclipse.jgit

/** {@inheritDoc} */
@Override
public final boolean matches(String path, boolean assumeDirectory,
    boolean pathMatch) {
  return !dirOnly || assumeDirectory
      || !pathMatch && isSubdirectory(path);
}
origin: org.eclipse.jgit/org.eclipse.jgit

private PathMatcher(String pattern, Character pathSeparator,
    boolean dirOnly)
    throws InvalidPatternException {
  super(pattern, dirOnly);
  slash = getPathSeparator(pathSeparator);
  beginning = pattern.indexOf(slash) == 0;
  if (isSimplePathWithSegments(pattern))
    matchers = null;
  else
    matchers = createMatchers(split(pattern, slash), pathSeparator,
        dirOnly);
}
origin: org.eclipse.jgit/org.eclipse.jgit

private static IMatcher createNameMatcher0(String segment,
    Character pathSeparator, boolean dirOnly, boolean lastSegment)
    throws InvalidPatternException {
  // check if we see /** or ** segments => double star pattern
  if (WildMatcher.WILDMATCH.equals(segment)
      || WildMatcher.WILDMATCH2.equals(segment))
    return dirOnly && lastSegment ? WILD_ONLY_DIRECTORY
        : WILD_NO_DIRECTORY;
  PatternState state = checkWildCards(segment);
  switch (state) {
  case LEADING_ASTERISK_ONLY:
    return new LeadingAsteriskMatcher(segment, pathSeparator, dirOnly);
  case TRAILING_ASTERISK_ONLY:
    return new TrailingAsteriskMatcher(segment, pathSeparator, dirOnly);
  case COMPLEX:
    return new WildCardMatcher(segment, pathSeparator, dirOnly);
  default:
    return new NameMatcher(segment, pathSeparator, dirOnly, true);
  }
}
origin: org.eclipse.jgit/org.eclipse.jgit

/**
 * Create path matcher
 *
 * @param pattern
 *            a pattern
 * @param pathSeparator
 *            if this parameter isn't null then this character will not
 *            match at wildcards(* and ? are wildcards).
 * @param dirOnly
 *            a boolean.
 * @return never null
 * @throws org.eclipse.jgit.errors.InvalidPatternException
 */
public static IMatcher createPathMatcher(String pattern,
    Character pathSeparator, boolean dirOnly)
    throws InvalidPatternException {
  pattern = trim(pattern);
  char slash = Strings.getPathSeparator(pathSeparator);
  // ignore possible leading and trailing slash
  int slashIdx = pattern.indexOf(slash, 1);
  if (slashIdx > 0 && slashIdx < pattern.length() - 1)
    return new PathMatcher(pattern, pathSeparator, dirOnly);
  return createNameMatcher0(pattern, pathSeparator, dirOnly, true);
}
origin: org.eclipse.jgit/org.eclipse.jgit

dirOnly = isDirectoryPattern(pattern);
if (dirOnly) {
  pattern = stripTrailingWhitespace(pattern);
  pattern = stripTrailing(pattern, PATH_SEPARATOR);
  if (pattern.length() == 0) {
    this.matcher = NO_MATCH;
  m = PathMatcher.createPathMatcher(pattern,
      Character.valueOf(PATH_SEPARATOR), dirOnly);
} catch (InvalidPatternException e) {
origin: org.eclipse.jgit/org.eclipse.jgit

/**
 * Returns <code>true</code> if a match was made.
 *
 * @param relativeTarget
 *            Name pattern of the file, relative to the base directory of
 *            this rule
 * @param isDirectory
 *            Whether the target file is a directory or not
 * @return True if a match was made.
 */
public boolean isMatch(String relativeTarget, boolean isDirectory) {
  if (relativeTarget == null)
    return false;
  if (relativeTarget.length() == 0)
    return false;
  boolean match = matcher.matches(relativeTarget, isDirectory, true);
  return match;
}
origin: org.eclipse.jgit/org.eclipse.jgit

/** {@inheritDoc} */
@Override
public boolean matches(String path, boolean assumeDirectory,
    boolean pathMatch) {
  if (matchers == null) {
    return simpleMatch(path, assumeDirectory, pathMatch);
  }
  return iterate(path, 0, path.length(), assumeDirectory, pathMatch);
}
origin: org.eclipse.jgit/org.eclipse.jgit

private boolean isSimplePathWithSegments(String path) {
  return !isWildCard(path) && path.indexOf('\\') < 0
      && count(path, slash, true) > 0;
}
origin: org.eclipse.jgit/org.eclipse.jgit

NameMatcher(String pattern, Character pathSeparator, boolean dirOnly,
    boolean deleteBackslash) {
  super(pattern, dirOnly);
  slash = getPathSeparator(pathSeparator);
  if (deleteBackslash) {
    pattern = Strings.deleteBackslash(pattern);
  }
  beginning = pattern.length() == 0 ? false : pattern.charAt(0) == slash;
  if (!beginning) {
    this.subPattern = pattern;
  } else {
    this.subPattern = pattern.substring(1);
  }
}
origin: org.eclipse.jgit/org.eclipse.jgit

private static List<IMatcher> createMatchers(List<String> segments,
    Character pathSeparator, boolean dirOnly)
    throws InvalidPatternException {
  List<IMatcher> matchers = new ArrayList<>(segments.size());
  for (int i = 0; i < segments.size(); i++) {
    String segment = segments.get(i);
    IMatcher matcher = createNameMatcher0(segment, pathSeparator,
        dirOnly, i == segments.size() - 1);
    if (i > 0) {
      final IMatcher last = matchers.get(matchers.size() - 1);
      if (isWild(matcher) && isWild(last))
        // collapse wildmatchers **/** is same as **, but preserve
        // dirOnly flag (i.e. always use the last wildmatcher)
        matchers.remove(matchers.size() - 1);
    }
    matchers.add(matcher);
  }
  return matchers;
}
origin: org.eclipse.jgit/org.eclipse.jgit

/**
 * Sets one or more {@code glob(7)} patterns that tags must match to be
 * considered. If multiple patterns are provided, tags only need match one
 * of them.
 *
 * @param patterns
 *            the {@code glob(7)} pattern or patterns
 * @return {@code this}
 * @throws org.eclipse.jgit.errors.InvalidPatternException
 *             if the pattern passed in was invalid.
 * @see <a href=
 *      "https://www.kernel.org/pub/software/scm/git/docs/git-describe.html"
 *      >Git documentation about describe</a>
 * @since 4.9
 */
public DescribeCommand setMatch(String... patterns) throws InvalidPatternException {
  for (String p : patterns) {
    matchers.add(PathMatcher.createPathMatcher(p, null, false));
  }
  return this;
}
origin: org.eclipse.jgit/org.eclipse.jgit

static boolean isWildCard(String pattern) {
  return pattern.indexOf('*') != -1 || isComplexWildcard(pattern);
}
origin: org.eclipse.jgit/org.eclipse.jgit

private static boolean isComplexWildcard(String pattern) {
  int idx1 = pattern.indexOf('[');
  if (idx1 != -1) {
    return true;
  }
  if (pattern.indexOf('?') != -1) {
    return true;
  } else {
    // check if the backslash escapes one of the glob special characters
    // if not, backslash is not part of a regex and treated literally
    int backSlash = pattern.indexOf('\\');
    if (backSlash >= 0) {
      int nextIdx = backSlash + 1;
      if (pattern.length() == nextIdx) {
        return false;
      }
      char nextChar = pattern.charAt(nextIdx);
      if (escapedByBackslash(nextChar)) {
        return true;
      } else {
        return false;
      }
    }
  }
  return false;
}
origin: org.eclipse.jgit/org.eclipse.jgit

  match = matches(path, start, stop);
} else {
      && matches(path, lastSlash + 1, stop);
  end = stop;
if (end > start && matches(path, start, end)) {
origin: org.eclipse.jgit/org.eclipse.jgit

private boolean matches(int matcherIdx, String path, int startIncl,
    int endExcl, boolean assumeDirectory, boolean pathMatch) {
  IMatcher matcher = matchers.get(matcherIdx);
  final boolean matches = matcher.matches(path, startIncl, endExcl);
  if (!matches || !pathMatch || matcherIdx < matchers.size() - 1
      || !(matcher instanceof AbstractMatcher)) {
    return matches;
  }
  return assumeDirectory || !((AbstractMatcher) matcher).dirOnly;
}
origin: org.eclipse.jgit/org.eclipse.jgit

static PatternState checkWildCards(String pattern) {
  if (isComplexWildcard(pattern))
    return PatternState.COMPLEX;
  int startIdx = pattern.indexOf('*');
  if (startIdx < 0)
    return PatternState.NONE;
  if (startIdx == pattern.length() - 1)
    return PatternState.TRAILING_ASTERISK_ONLY;
  if (pattern.lastIndexOf('*') == 0)
    return PatternState.LEADING_ASTERISK_ONLY;
  return PatternState.COMPLEX;
}
origin: org.eclipse.jgit/org.eclipse.jgit

static String deleteBackslash(String s) {
  if (s.indexOf('\\') < 0) {
    return s;
  }
  StringBuilder sb = new StringBuilder(s.length());
  for (int i = 0; i < s.length(); i++) {
    char ch = s.charAt(i);
    if (ch == '\\') {
      if (i + 1 == s.length()) {
        continue;
      }
      char next = s.charAt(i + 1);
      if (next == '\\') {
        sb.append(ch);
        i++;
        continue;
      }
      if (!escapedByBackslash(next)) {
        continue;
      }
    }
    sb.append(ch);
  }
  return sb.toString();
}
origin: org.eclipse.jgit/org.eclipse.jgit

/**
 * Returns true if a match was made. <br>
 * This function does NOT return the actual ignore status of the target!
 * Please consult {@link #getResult()} for the negation status. The actual
 * ignore status may be true or false depending on whether this rule is an
 * ignore rule or a negation rule.
 *
 * @param path
 *            Name pattern of the file, relative to the base directory of
 *            this rule
 * @param directory
 *            Whether the target file is a directory or not
 * @param pathMatch
 *            {@code true} if the match is for the full path: see
 *            {@link IMatcher#matches(String, int, int)}
 * @return True if a match was made. This does not necessarily mean that the
 *         target is ignored. Call {@link #getResult() getResult()} for the
 *         result.
 * @since 4.11
 */
public boolean isMatch(String path, boolean directory, boolean pathMatch) {
  if (path == null)
    return false;
  if (path.length() == 0)
    return false;
  boolean match = matcher.matches(path, directory, pathMatch);
  return match;
}
origin: org.eclipse.jgit/org.eclipse.jgit

private Optional<Ref> getBestMatch(List<Ref> tags) {
  if (tags == null || tags.size() == 0) {
    return Optional.empty();
  } else if (matchers.size() == 0) {
    Collections.sort(tags, TAG_TIE_BREAKER);
    return Optional.of(tags.get(0));
  } else {
    // Find the first tag that matches in the stream of all tags
    // filtered by matchers ordered by tie break order
    Stream<Ref> matchingTags = Stream.empty();
    for (IMatcher matcher : matchers) {
      Stream<Ref> m = tags.stream().filter(
          tag -> matcher.matches(tag.getName(), false, false));
      matchingTags = Stream.of(matchingTags, m).flatMap(i -> i);
    }
    return matchingTags.sorted(TAG_TIE_BREAKER).findFirst();
  }
}
org.eclipse.jgit.ignore.internal

Most used classes

  • IMatcher
    Generic string matcher
  • PathMatcher
    Matcher built by patterns consists of multiple path segments. This class is immutable and thread saf
  • LeadingAsteriskMatcher
    Matcher for simple regex patterns starting with an asterisk, e.g. "*.tmp"
  • NameMatcher
    Matcher built from patterns for file names (single path segments). This class is immutable and threa
  • Strings
    Various String related utility methods, written mostly to avoid generation of new String objects (e.
  • WildCardMatcher,
  • WildMatcher
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now