some renames
authorEugene.Petrenko <eugene.petrenko@gmail.com>
Thu, 25 Aug 2011 10:08:26 +0000 (12:08 +0200)
committerEugene.Petrenko <eugene.petrenko@gmail.com>
Thu, 25 Aug 2011 10:08:26 +0000 (12:08 +0200)
23 files changed:
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/MatchFilesBuildProcess.java
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/AntPatternState.java
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/AntPatternStateMatch.java [new file with mode: 0644]
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/AntPatternUtil.java
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/DirectoryEntry.java [moved from nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/IDirectoryEntry.java with 77% similarity]
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/DirectoryScanner.java
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/FileEntry.java [moved from nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/IFileEntry.java with 79% similarity]
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/FileSystem.java [moved from nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/IFileSystem.java with 81% similarity]
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/FileSystemPath.java
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/MatchResult.java [new file with mode: 0644]
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/RealDirectoryEntry.java
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/RealFileEntry.java
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/RealFileSystem.java
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/RealRootDirectory.java
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/Wildcard.java
nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/WildcardScanner2.java [deleted file]
nuget-tests/src/jetbrains/buildServer/nuget/tests/util/fsScanner/DirectoryFileFilesystemTest.java
nuget-tests/src/jetbrains/buildServer/nuget/tests/util/fsScanner/DirectoryScannerMockFSTest.java
nuget-tests/src/jetbrains/buildServer/nuget/tests/util/fsScanner/TestAntPatternState.java
nuget-tests/src/jetbrains/buildServer/nuget/tests/util/fsScanner/TestAntPatternUtil.java
nuget-tests/src/jetbrains/buildServer/nuget/tests/util/fsScanner/TestDirectoryScanner.java
nuget-tests/src/jetbrains/buildServer/nuget/tests/util/fsScanner/TestReadFileSystem.java
nuget-tests/src/jetbrains/buildServer/nuget/tests/util/fsScanner/TestWildcard.java

index f2457fc7b9e88c88f75b85bc018a8c462b7e7336..b511ba55a41a97ca5982b50ecfecd125fd109ce1 100644 (file)
@@ -69,7 +69,7 @@ public class MatchFilesBuildProcess extends BuildProcessBase {
 \r
     final File root = myContext.getBuild().getCheckoutDirectory();\r
     try {\r
-      final Collection<File> result = DirectoryScanner.FindFiles(root, patterns, Collections.<String>emptyList());\r
+      final Collection<File> result = DirectoryScanner.findFiles(root, patterns, Collections.<String>emptyList());\r
       for (File file : result) {\r
         LOG.debug("Found nugkg to push: " + file);\r
         found = true;\r
index cc8fa2f68d2f8f11da3ea19cdaa573317a5039d2..2fa467cbfe6f31a4483cf4d0abf2f3028e1a507f 100644 (file)
@@ -15,6 +15,7 @@
  */\r
 package jetbrains.buildServer.nuget.agent.runner.publish.fsScanner;\r
 \r
+import org.jetbrains.annotations.NotNull;\r
 import org.jetbrains.annotations.Nullable;\r
 \r
 import java.util.ArrayList;\r
@@ -22,12 +23,6 @@ import java.util.Collection;
 import java.util.List;\r
 \r
 public class AntPatternState {\r
-  public enum MatchResult {\r
-    YES,\r
-    NO,\r
-    MAYBELATER\r
-  }\r
-\r
   private final List<Wildcard> myPatternParts;\r
   //NDA state of mathing of pattern. Every ** produces new state\r
   private final List<Integer> myPatternPositions;\r
@@ -47,28 +42,10 @@ public class AntPatternState {
     return list;\r
   }\r
 \r
-  public List<Integer> PatternPositions() {\r
+  public List<Integer> getPatternPositions() {\r
     return myPatternPositions;\r
   }\r
 \r
-  public static class AntPatternStateMatch {\r
-    private final MatchResult myResult;\r
-    private final AntPatternState myState;\r
-\r
-    public AntPatternStateMatch(MatchResult result, AntPatternState state) {\r
-      myResult = result;\r
-      myState = state;\r
-    }\r
-\r
-    public MatchResult getResult() {\r
-      return myResult;\r
-    }\r
-\r
-    public AntPatternState getState() {\r
-      return myState;\r
-    }\r
-  }\r
-\r
   /**\r
    * @return list of next tokends that are matching or null of there are at least one ** in pattern\r
    */\r
@@ -81,7 +58,7 @@ public class AntPatternState {
       if (wd == null) return null;\r
 \r
       if (wd.containsNoPatterns()) {\r
-        result.add(wd.Pattern());\r
+        result.add(wd.getPattern());\r
       } else {\r
         return null;\r
       }\r
@@ -100,7 +77,7 @@ public class AntPatternState {
   }\r
 \r
 \r
-  public AntPatternStateMatch Enter(String component) {\r
+  public AntPatternStateMatch enter(@NotNull final String component) {\r
     if (myPatternParts.size() == 0) {\r
       return new AntPatternStateMatch(MatchResult.NO, this);\r
     }\r
@@ -115,7 +92,7 @@ public class AntPatternState {
       final Wildcard wildcard = myPatternParts.get(pos);\r
 \r
       if (wildcard != null) {\r
-        if (wildcard.IsMatch(component)) {\r
+        if (wildcard.isMatch(component)) {\r
           if (pos == myPatternParts.size() - 1) {\r
             match = MatchResult.YES;\r
           } else if (pos == myPatternParts.size() - 2 && myPatternParts.get(pos + 1) == null) {\r
@@ -134,7 +111,7 @@ public class AntPatternState {
         if (pos == myPatternParts.size() - 1) {\r
           match = MatchResult.YES;\r
         } else {\r
-          if (myPatternParts.get(pos + 1).IsMatch(component)) {\r
+          if (myPatternParts.get(pos + 1).isMatch(component)) {\r
             if (pos == myPatternParts.size() - 2) {\r
               match = MatchResult.YES;\r
             } else {\r
diff --git a/nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/AntPatternStateMatch.java b/nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/AntPatternStateMatch.java
new file mode 100644 (file)
index 0000000..f54e578
--- /dev/null
@@ -0,0 +1,44 @@
+/*\r
+ * Copyright 2000-2011 JetBrains s.r.o.\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ */\r
+\r
+package jetbrains.buildServer.nuget.agent.runner.publish.fsScanner;\r
+\r
+import org.jetbrains.annotations.NotNull;\r
+\r
+/**\r
+* @author Eugene Petrenko (eugene.petrenko@gmail.com)\r
+*         Date: 25.08.11 11:56\r
+*/\r
+public class AntPatternStateMatch {\r
+  private final MatchResult myResult;\r
+  private final AntPatternState myState;\r
+\r
+  public AntPatternStateMatch(@NotNull final MatchResult result,\r
+                              @NotNull final AntPatternState state) {\r
+    myResult = result;\r
+    myState = state;\r
+  }\r
+\r
+  @NotNull\r
+  public MatchResult getResult() {\r
+    return myResult;\r
+  }\r
+\r
+  @NotNull\r
+  public AntPatternState getState() {\r
+    return myState;\r
+  }\r
+}\r
index 100d1fcc1a6d00c37e70061c0d954cc8dbf6c1ef..41fdde4a05d70251f51f07c658e1b093a0ef84fa 100644 (file)
 package jetbrains.buildServer.nuget.agent.runner.publish.fsScanner;\r
 \r
 import jetbrains.buildServer.util.StringUtil;\r
+import org.jetbrains.annotations.NotNull;\r
 \r
 import java.util.ArrayList;\r
 import java.util.Arrays;\r
 import java.util.Collections;\r
 import java.util.List;\r
 \r
-public class AntPatternUtil\r
-  {\r
-    private static String NormalizePatternString(String pattern)\r
-    {\r
-      pattern = pattern.trim();\r
-      pattern = pattern.replace('\\', '/');\r
-      pattern = pattern.replaceAll("[//]+", "/");\r
-      pattern = pattern.replaceAll("\\*\\*[\\*]+", "**");\r
-      pattern = pattern.replaceAll("\\*\\*/\\*\\*", "**");\r
-      if (pattern.startsWith("/")) pattern = pattern.substring(1);\r
-      return pattern;\r
-    }\r
+public class AntPatternUtil {\r
+  private static String normalizePatternString(@NotNull String pattern) {\r
+    pattern = pattern.trim();\r
+    pattern = pattern.replace('\\', '/');\r
+    pattern = pattern.replaceAll("[//]+", "/");\r
+    pattern = pattern.replaceAll("\\*\\*[\\*]+", "**");\r
+    pattern = pattern.replaceAll("\\*\\*/\\*\\*", "**");\r
+    if (pattern.startsWith("/")) pattern = pattern.substring(1);\r
+    return pattern;\r
+  }\r
 \r
-    public static boolean IsFileNameMatch(String pattern, String name)\r
-    {\r
-      name = name.trim();\r
-      name = name.replace('\\', '/');\r
-      name = name.replaceAll("[//]+", "/");\r
-\r
-      List<Wildcard> wildcards = ParsePattern(pattern, false);\r
-      AntPatternState state = new AntPatternState(wildcards);\r
-\r
-      List<String> splitted = new ArrayList<String>(Arrays.asList(name.split("/")));\r
-      List<String> nameComponents = new ArrayList<String>();\r
-      for (String s : splitted)\r
-      {\r
-        if (!StringUtil.isEmptyOrSpaces(s))\r
-        {\r
-          nameComponents.add(s);\r
-        }\r
-      }\r
+  public static boolean isFileNameMatch(@NotNull final String pattern, @NotNull String name) {\r
+    name = name.trim();\r
+    name = name.replace('\\', '/');\r
+    name = name.replaceAll("[//]+", "/");\r
 \r
-      AntPatternState.MatchResult matchResult = AntPatternState.MatchResult.NO;\r
+    List<Wildcard> wildcards = parsePattern(pattern, false);\r
+    AntPatternState state = new AntPatternState(wildcards);\r
 \r
-      for (int i = 0; i < nameComponents.size(); i++)\r
-      {\r
-        if (nameComponents.get(i).equals(".") && i < nameComponents.size() - 1)\r
-          continue;\r
+    List<String> splitted = new ArrayList<String>(Arrays.asList(name.split("/")));\r
+    List<String> nameComponents = new ArrayList<String>();\r
+    for (String s : splitted) {\r
+      if (!StringUtil.isEmptyOrSpaces(s)) nameComponents.add(s);\r
+    }\r
 \r
-        final AntPatternState.AntPatternStateMatch enter = state.Enter(nameComponents.get(i));\r
-        matchResult = enter.getResult();\r
-        state = enter.getState();\r
-      }\r
+    MatchResult matchResult = MatchResult.NO;\r
 \r
-      return matchResult == AntPatternState.MatchResult.YES;\r
+    for (int i = 0; i < nameComponents.size(); i++) {\r
+      if (nameComponents.get(i).equals(".") && i < nameComponents.size() - 1)\r
+        continue;\r
+\r
+      final AntPatternStateMatch enter = state.enter(nameComponents.get(i));\r
+      matchResult = enter.getResult();\r
+      state = enter.getState();\r
     }\r
 \r
-    public static List<Wildcard> ParsePattern(String pattern, boolean caseSensitive)\r
-    {\r
-      pattern = NormalizePatternString(pattern);\r
-      if (pattern.length() == 0)\r
-        return Collections.emptyList();\r
-\r
-      List<Wildcard> result = new ArrayList<Wildcard>();\r
-      for (String component : pattern.split("/"))\r
-      {\r
-        int astIndex = component.indexOf("**");\r
-        if (astIndex < 0)\r
-        {\r
-          result.add(new Wildcard(component, caseSensitive));\r
-          continue;\r
-        }\r
-\r
-        if (astIndex > 0)\r
-          result.add(new Wildcard(component.substring(0, astIndex) + "*", caseSensitive));\r
-\r
-        int cur = astIndex;\r
-        while (astIndex >= 0)\r
-        {\r
-          if (astIndex - cur > 0)\r
-            result.add(new Wildcard("*" + component.substring(cur, astIndex) + "*", caseSensitive));\r
-\r
-          result.add(null);\r
-\r
-          cur = astIndex + 2;\r
-          astIndex = component.indexOf("**", cur);\r
-        }\r
-\r
-        if (cur < component.length())\r
-          result.add(new Wildcard("*" + component.substring(cur), caseSensitive));\r
+    return matchResult == MatchResult.YES;\r
+  }\r
+\r
+  @NotNull\r
+  public static List<Wildcard> parsePattern(@NotNull String pattern, boolean caseSensitive) {\r
+    pattern = normalizePatternString(pattern);\r
+    if (pattern.length() == 0)\r
+      return Collections.emptyList();\r
+\r
+    List<Wildcard> result = new ArrayList<Wildcard>();\r
+    for (String component : pattern.split("/")) {\r
+      int astIndex = component.indexOf("**");\r
+      if (astIndex < 0) {\r
+        result.add(new Wildcard(component, caseSensitive));\r
+        continue;\r
+      }\r
+\r
+      if (astIndex > 0) {\r
+        result.add(new Wildcard(component.substring(0, astIndex) + "*", caseSensitive));\r
       }\r
 \r
-      RemoveTwoDots(result);\r
-      RemoveOneDot(result);\r
+      int cur = astIndex;\r
+      while (astIndex >= 0) {\r
+        if (astIndex - cur > 0)\r
+          result.add(new Wildcard("*" + component.substring(cur, astIndex) + "*", caseSensitive));\r
 \r
-      return result;\r
+        result.add(null);\r
+\r
+        cur = astIndex + 2;\r
+        astIndex = component.indexOf("**", cur);\r
+      }\r
+\r
+      if (cur < component.length()) {\r
+        result.add(new Wildcard("*" + component.substring(cur), caseSensitive));\r
+      }\r
     }\r
 \r
-    private static void RemoveOneDot(List<Wildcard> wildcards)\r
-    {\r
-      int i = 0;\r
-      while (i < wildcards.size() - 1)\r
-      {\r
-        if (wildcards.get(i) != null && wildcards.get(i).Pattern().equals("."))\r
-          wildcards.remove(i);\r
-        else\r
-          i++;\r
+    removeTwoDots(result);\r
+    removeOneDot(result);\r
+\r
+    return result;\r
+  }\r
+\r
+  private static void removeOneDot(@NotNull final List<Wildcard> wildcards) {\r
+    int i = 0;\r
+    while (i < wildcards.size() - 1) {\r
+      if (wildcards.get(i) != null && wildcards.get(i).getPattern().equals(".")) {\r
+        wildcards.remove(i);\r
+      } else {\r
+        i++;\r
       }\r
     }\r
+  }\r
 \r
-    private static void RemoveTwoDots(List<Wildcard> wildcards)\r
-    {\r
-      int i = 0;\r
-      while (i < wildcards.size() - 1)\r
-      {\r
-        if (wildcards.get(i + 1) != null && wildcards.get(i + 1).Pattern().equals(".."))\r
-        {\r
-          wildcards.remove(i);\r
-          wildcards.remove(i);\r
-\r
-          if (i > 0)\r
-            i--;\r
-        }\r
-        else\r
-          i++;\r
+  private static void removeTwoDots(List<Wildcard> wildcards) {\r
+    int i = 0;\r
+    while (i < wildcards.size() - 1) {\r
+      if (wildcards.get(i + 1) != null && wildcards.get(i + 1).getPattern().equals("..")) {\r
+        wildcards.remove(i);\r
+        wildcards.remove(i);\r
+\r
+        if (i > 0) i--;\r
+      } else {\r
+        i++;\r
       }\r
+    }\r
 \r
-      while (wildcards.size() > 0 && wildcards.get(0) != null && wildcards.get(0).Pattern().equals(".."))\r
-        wildcards.remove(0);\r
+    while (wildcards.size() > 0 && wildcards.get(0) != null && wildcards.get(0).getPattern().equals("..")) {\r
+      wildcards.remove(0);\r
     }\r
   }\r
+}\r
similarity index 77%
rename from nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/IDirectoryEntry.java
rename to nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/DirectoryEntry.java
index c873501f35db224f6f0071c6d145a7904794ab6a..3e72171a002ef60c6ee94f67555e99fbc6bcdf77 100644 (file)
@@ -20,30 +20,30 @@ import org.jetbrains.annotations.Nullable;
 \r
 import java.util.Collection;\r
 \r
-public interface IDirectoryEntry {\r
+public interface DirectoryEntry {\r
   @NotNull\r
-  String Name();\r
+  String getName();\r
 \r
   @Nullable\r
-  IDirectoryEntry Parent();\r
+  DirectoryEntry getParent();\r
 \r
   @NotNull\r
-  IDirectoryEntry[] Subdirectories();\r
+  DirectoryEntry[] getSubdirectories();\r
 \r
   /**\r
    * @param names names filter\r
    * @return redured list of items filtered (if possible) by given names\r
    */\r
   @NotNull\r
-  IDirectoryEntry[] Subdirectories(Collection<String> names);\r
+  DirectoryEntry[] getSubdirectories(Collection<String> names);\r
 \r
   @NotNull\r
-  IFileEntry[] Files();\r
+  FileEntry[] getFiles();\r
 \r
   /**\r
    * @param names names filter\r
    * @return returns list of existing file names, i.e. subset of given names\r
    */\r
   @NotNull\r
-  IFileEntry[] Files(Collection<String> names);\r
+  FileEntry[] getFiles(@NotNull Collection<String> names);\r
 }\r
index 51cc4a5a0ef34f5eea3314f68b4cf59d000a43e2..0e0dad03d0cfd6c1eaa75a2a3f72a63627dcd6c0 100644 (file)
@@ -27,40 +27,52 @@ import java.util.*;
 public class DirectoryScanner {\r
   private static final Logger LOG = Logger.getInstance(DirectoryScanner.class.getName());\r
 \r
-  public static Collection<File> FindFiles(@NotNull File root, Collection<String> includes, Collection<String> excludes) {\r
-    return FindFiles(new RealFileSystem(), new RealDirectoryEntry(new FileSystemPath(root)), includes, excludes);\r
+  public static Collection<File> findFiles(@NotNull File root,\r
+                                           @NotNull final Collection<String> includes,\r
+                                           @NotNull final Collection<String> excludes) {\r
+    return findFiles(new RealFileSystem(), new RealDirectoryEntry(new FileSystemPath(root)), includes, excludes);\r
   }\r
 \r
-  public static Collection<File> FindFiles(IFileSystem fs, IDirectoryEntry root, Collection<String> includes, Collection<String> excludes) {\r
-    List<Wildcard> basePath = BuildSearchPrefix(root, fs.CaseSensitive());\r
+  public static Collection<File> findFiles(@NotNull final FileSystem fs,\r
+                                           @NotNull final DirectoryEntry root,\r
+                                           @NotNull final Collection<String> includes,\r
+                                           @NotNull final Collection<String> excludes) {\r
+    List<Wildcard> basePath = buildSearchPrefix(root, fs.caseSensitive());\r
 \r
     List<FileSystemPath> result = new ArrayList<FileSystemPath>();\r
-    FindFilesRec(\r
-            fs.Root(),\r
+    findFilesRec(\r
+            fs.getRoot(),\r
             result,\r
-            ToAntPatternState(fs, basePath, fs.CaseSensitive(), includes),\r
-            ToAntPatternState(fs, basePath, fs.CaseSensitive(), excludes)\r
+            toAntPatternState(fs, basePath, fs.caseSensitive(), includes),\r
+            toAntPatternState(fs, basePath, fs.caseSensitive(), excludes)\r
     );\r
 \r
     Set<File> foundFiles = new TreeSet<File>();\r
     for (FileSystemPath path : result) {\r
-      foundFiles.add(path.FilePath());\r
+      foundFiles.add(path.getFilePath());\r
     }\r
     return foundFiles;\r
   }\r
 \r
-  private static List<Wildcard> BuildSearchPrefix(@NotNull IDirectoryEntry root, boolean caseSensitive) {\r
+  private static List<Wildcard> buildSearchPrefix(@NotNull DirectoryEntry root, boolean caseSensitive) {\r
     List<Wildcard> wildcardPrefix = new ArrayList<Wildcard>();\r
-    while (root.Parent() != null) {\r
-      wildcardPrefix.add(new Wildcard(root.Name(), caseSensitive));\r
-      root = root.Parent();\r
+    while (true) {\r
+      final DirectoryEntry parent = root.getParent();\r
+      if (parent == null) break;\r
+\r
+      wildcardPrefix.add(new Wildcard(root.getName(), caseSensitive));\r
+      root = parent;\r
     }\r
     Collections.reverse(wildcardPrefix);\r
 \r
     return wildcardPrefix;\r
   }\r
 \r
-  private static List<AntPatternState> ToAntPatternState(IFileSystem fs, List<Wildcard> wildcardPrefix, boolean caseSensitive, Collection<String> patterns) {\r
+  @NotNull\r
+  private static List<AntPatternState> toAntPatternState(@NotNull final FileSystem fs,\r
+                                                         @NotNull final List<Wildcard> wildcardPrefix,\r
+                                                         boolean caseSensitive,\r
+                                                         @NotNull final Collection<String> patterns) {\r
     List<AntPatternState> result = new ArrayList<AntPatternState>();\r
     for (String x : patterns) {\r
       result.add(new AntPatternState(ParsePattern(fs, wildcardPrefix, caseSensitive, x)));\r
@@ -68,10 +80,14 @@ public class DirectoryScanner {
     return result;\r
   }\r
 \r
-  private static List<Wildcard> ParsePattern(IFileSystem fs, List<Wildcard> rootPrefix, boolean caseSensitive, String pattern) {\r
-    List<Wildcard> wildcards = AntPatternUtil.ParsePattern(pattern, caseSensitive);\r
+  @NotNull\r
+  private static List<Wildcard> ParsePattern(@NotNull final FileSystem fs,\r
+                                             @NotNull final List<Wildcard> rootPrefix,\r
+                                             boolean caseSensitive,\r
+                                             @NotNull final String pattern) {\r
+    List<Wildcard> wildcards = AntPatternUtil.parsePattern(pattern, caseSensitive);\r
 \r
-    if (fs.IsPathAbsolute(pattern))\r
+    if (fs.isPathAbsolute(pattern))\r
       return wildcards;\r
 \r
     List<Wildcard> result = new ArrayList<Wildcard>();\r
@@ -80,17 +96,16 @@ public class DirectoryScanner {
     return result;\r
   }\r
 \r
-  private interface AnyPredicate {\r
-    boolean matches(AntPatternState.MatchResult r);\r
-  }\r
-\r
-  private static boolean Any(List<AntPatternState> state, String component, AnyPredicate predicate, List<AntPatternState> newState) {\r
+  private static boolean any(@NotNull final List<AntPatternState> state,\r
+                             @NotNull final String component,\r
+                             @NotNull final AnyPredicate predicate,\r
+                             @NotNull final List<AntPatternState> newState) {\r
     boolean any = false;\r
     newState.clear();\r
 \r
     for (AntPatternState aState : state) {\r
-      final AntPatternState.AntPatternStateMatch enter = aState.Enter(component);\r
-      AntPatternState.MatchResult match = enter.getResult();\r
+      final AntPatternStateMatch enter = aState.enter(component);\r
+      MatchResult match = enter.getResult();\r
       newState.add(enter.getState());\r
 \r
       if (predicate.matches(match))\r
@@ -100,8 +115,11 @@ public class DirectoryScanner {
     return any;\r
   }\r
 \r
-  private static void FindFilesRec(IDirectoryEntry directory, List<FileSystemPath> result, List<AntPatternState> includeState, List<AntPatternState> excludeState) {\r
-    LOG.debug("Scanning directory: " + directory.Name());\r
+  private static void findFilesRec(@NotNull final DirectoryEntry directory,\r
+                                   @NotNull final List<FileSystemPath> result,\r
+                                   @NotNull final List<AntPatternState> includeState,\r
+                                   @NotNull final List<AntPatternState> excludeState) {\r
+    LOG.debug("Scanning directory: " + directory.getName());\r
 \r
     boolean mayContainFiles = false;\r
     Collection<String> explicits = new ArrayList<String>();\r
@@ -119,46 +137,50 @@ public class DirectoryScanner {
     }\r
 \r
     if (mayContainFiles) {\r
-      for (IFileEntry file : explicits != null ? directory.Files(explicits) : directory.Files()) {\r
+      for (FileEntry file : explicits != null ? directory.getFiles(explicits) : directory.getFiles()) {\r
         List<AntPatternState> newState = new ArrayList<AntPatternState>();\r
 \r
-        if (!Any(includeState, file.Name(), equal(AntPatternState.MatchResult.YES), newState))\r
+        if (!any(includeState, file.getName(), equal(MatchResult.YES), newState))\r
           continue;\r
 \r
-        if (Any(excludeState, file.Name(), equal(AntPatternState.MatchResult.YES), newState))\r
+        if (any(excludeState, file.getName(), equal(MatchResult.YES), newState))\r
           continue;\r
 \r
-        result.add(file.Path());\r
+        result.add(file.getPath());\r
       }\r
     }\r
 \r
 \r
-    for (IDirectoryEntry subEntry : explicits != null ? directory.Subdirectories(explicits) : directory.Subdirectories()) {\r
-      String name = subEntry.Name();\r
+    for (DirectoryEntry subEntry : explicits != null ? directory.getSubdirectories(explicits) : directory.getSubdirectories()) {\r
+      String name = subEntry.getName();\r
 \r
       List<AntPatternState> newIncludeState = new ArrayList<AntPatternState>();\r
-      if (!Any(includeState, name, notEqual(AntPatternState.MatchResult.NO), newIncludeState))\r
+      if (!any(includeState, name, notEqual(MatchResult.NO), newIncludeState))\r
         continue;\r
 \r
       List<AntPatternState> newExcludeState = new ArrayList<AntPatternState>();\r
-      if (Any(excludeState, name, equal(AntPatternState.MatchResult.YES), newExcludeState))\r
+      if (any(excludeState, name, equal(MatchResult.YES), newExcludeState))\r
         continue;\r
 \r
-      FindFilesRec(subEntry, result, newIncludeState, newExcludeState);\r
+      findFilesRec(subEntry, result, newIncludeState, newExcludeState);\r
     }\r
   }\r
 \r
-  private static AnyPredicate notEqual(@NotNull final AntPatternState.MatchResult result) {\r
+  private interface AnyPredicate {\r
+    boolean matches(@NotNull MatchResult r);\r
+  }\r
+\r
+  private static AnyPredicate notEqual(@NotNull final MatchResult result) {\r
     return new AnyPredicate() {\r
-      public boolean matches(AntPatternState.MatchResult r) {\r
+      public boolean matches(@NotNull MatchResult r) {\r
         return result != r;\r
       }\r
     };\r
   }\r
 \r
-  private static AnyPredicate equal(@NotNull final AntPatternState.MatchResult result) {\r
+  private static AnyPredicate equal(@NotNull final MatchResult result) {\r
     return new AnyPredicate() {\r
-      public boolean matches(AntPatternState.MatchResult r) {\r
+      public boolean matches(@NotNull MatchResult r) {\r
         return result == r;\r
       }\r
     };\r
similarity index 79%
rename from nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/IFileEntry.java
rename to nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/FileEntry.java
index 564b567bb80c7fa94c95426a52348a0be21db534..8c9af07941aeeec237b438ba23b113c16683f686 100644 (file)
  */\r
 package jetbrains.buildServer.nuget.agent.runner.publish.fsScanner;\r
 \r
-public interface IFileEntry\r
-  {\r
-    String Name();\r
-    FileSystemPath Path();\r
-  }
\ No newline at end of file
+import org.jetbrains.annotations.NotNull;\r
+\r
+public interface FileEntry {\r
+  @NotNull\r
+  String getName();\r
+\r
+  @NotNull\r
+  FileSystemPath getPath();\r
+}
\ No newline at end of file
similarity index 81%
rename from nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/IFileSystem.java
rename to nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/FileSystem.java
index dd46ccbd206ca88f9108c28bc94bf664de2618ec..f7cf15121b1c8c99d08f42334af1e2ad101fad83 100644 (file)
@@ -17,11 +17,11 @@ package jetbrains.buildServer.nuget.agent.runner.publish.fsScanner;
 \r
 import org.jetbrains.annotations.NotNull;\r
 \r
-public interface IFileSystem {\r
-  boolean IsPathAbsolute(@NotNull String path);\r
+public interface FileSystem {\r
+  boolean isPathAbsolute(@NotNull String path);\r
 \r
   @NotNull\r
-  IDirectoryEntry Root();\r
+  DirectoryEntry getRoot();\r
 \r
-  boolean CaseSensitive();\r
+  boolean caseSensitive();\r
 }\r
index 885aacf1382151aaeb6a17d2af65bb1fe568c3d9..e0b2c9364548945d663fb0be3825414dfc78323e 100644 (file)
@@ -28,12 +28,12 @@ public class FileSystemPath {
     myPath = new File(path);\r
   }\r
 \r
-  public FileSystemPath(File path) {\r
+  public FileSystemPath(@NotNull final File path) {\r
     myPath = path;\r
   }\r
 \r
   @NotNull\r
-  public String Name() {\r
+  public String getName() {\r
 \r
     String name = myPath.getName();\r
     if (name == null || name.length() == 0) return myPath.getPath();\r
@@ -42,7 +42,7 @@ public class FileSystemPath {
   }\r
 \r
   @NotNull\r
-  public File FilePath() {\r
+  public File getFilePath() {\r
     return myPath;\r
   }\r
 }\r
diff --git a/nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/MatchResult.java b/nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/MatchResult.java
new file mode 100644 (file)
index 0000000..bd9fa26
--- /dev/null
@@ -0,0 +1,27 @@
+/*\r
+ * Copyright 2000-2011 JetBrains s.r.o.\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ */\r
+\r
+package jetbrains.buildServer.nuget.agent.runner.publish.fsScanner;\r
+\r
+/**\r
+* @author Eugene Petrenko (eugene.petrenko@gmail.com)\r
+*         Date: 25.08.11 11:56\r
+*/\r
+public enum MatchResult {\r
+  YES,\r
+  NO,\r
+  MAYBELATER\r
+}\r
index bb493fd7c737c5f16e7e3002ed56676df6c6d64d..9ecd929eae63f0dc07fb4332b37cdd17f3ac9e15 100644 (file)
@@ -26,7 +26,7 @@ import java.util.ArrayList;
 import java.util.Collection;\r
 import java.util.List;\r
 \r
-public class RealDirectoryEntry implements IDirectoryEntry {\r
+public class RealDirectoryEntry implements DirectoryEntry {\r
   private final FileSystemPath myPath;\r
 \r
   public RealDirectoryEntry(FileSystemPath path) {\r
@@ -34,61 +34,57 @@ public class RealDirectoryEntry implements IDirectoryEntry {
   }\r
 \r
   @NotNull\r
-  public String Name() {\r
-    {\r
-      String name = myPath.Name();\r
-      if (SystemInfo.isWindows) {\r
-        if (name.length() == 3 && name.charAt(1) == ':')\r
-          return name.charAt(0) + ":";\r
-      }\r
+  public String getName() {\r
 \r
-      return name;\r
+    String name = myPath.getName();\r
+    if (SystemInfo.isWindows) {\r
+      if (name.length() == 3 && name.charAt(1) == ':')\r
+        return name.charAt(0) + ":";\r
     }\r
+\r
+    return name;\r
+\r
   }\r
 \r
-  public IDirectoryEntry Parent() {\r
-    if (StringUtil.isEmptyOrSpaces(myPath.FilePath().getPath()))\r
+  public DirectoryEntry getParent() {\r
+    if (StringUtil.isEmptyOrSpaces(myPath.getFilePath().getPath()))\r
       return RealFileSystem.ROOT;\r
 \r
-    String parent = myPath.FilePath().getParent();\r
+    String parent = myPath.getFilePath().getParent();\r
     if (parent == null)\r
       return RealFileSystem.ROOT;\r
 \r
     FileSystemPath parentPath = new FileSystemPath(parent);\r
-    if (StringUtil.isEmptyOrSpaces(parentPath.FilePath().getPath()))\r
+    if (StringUtil.isEmptyOrSpaces(parentPath.getFilePath().getPath()))\r
       return RealFileSystem.ROOT;\r
 \r
     return new RealDirectoryEntry(parentPath);\r
   }\r
 \r
   @NotNull\r
-  public IDirectoryEntry[] Subdirectories() {\r
+  public DirectoryEntry[] getSubdirectories() {\r
     try {\r
-      List<IDirectoryEntry> list = new ArrayList<IDirectoryEntry>();\r
-      for (File dir : FilePath().listFiles(new FileFilter() {\r
-        public boolean accept(File pathname) {\r
-          return pathname.isDirectory();\r
-        }\r
-      })) {\r
+      List<DirectoryEntry> list = new ArrayList<DirectoryEntry>();\r
+      for (File dir : FilePath().listFiles(DIRECTORY_FILTER)) {\r
         list.add(new RealDirectoryEntry(new FileSystemPath(dir)));\r
       }\r
-      return list.toArray(new IDirectoryEntry[list.size()]);\r
+      return list.toArray(new DirectoryEntry[list.size()]);\r
     } catch (Exception e) {\r
-      return new IDirectoryEntry[0];\r
+      return new DirectoryEntry[0];\r
     }\r
   }\r
 \r
   @NotNull\r
-  public IDirectoryEntry[] Subdirectories(Collection<String> names) {\r
-    List<IDirectoryEntry> entries = new ArrayList<IDirectoryEntry>(names.size());\r
+  public DirectoryEntry[] getSubdirectories(Collection<String> names) {\r
+    List<DirectoryEntry> entries = new ArrayList<DirectoryEntry>(names.size());\r
     for (String name : names) {\r
       entries.add(new RealDirectoryEntry(new FileSystemPath(new File(FilePath(), name))));\r
     }\r
-    return entries.toArray(new IDirectoryEntry[entries.size()]);\r
+    return entries.toArray(new DirectoryEntry[entries.size()]);\r
   }\r
 \r
   private File FilePath() {\r
-    String filePath = myPath.FilePath().getPath();\r
+    String filePath = myPath.getFilePath().getPath();\r
 \r
     if (SystemInfo.isWindows && filePath.endsWith(":")) {\r
       return new File(filePath + "\\");\r
@@ -101,36 +97,45 @@ public class RealDirectoryEntry implements IDirectoryEntry {
   }\r
 \r
   @NotNull\r
-  public IFileEntry[] Files() {\r
+  public FileEntry[] getFiles() {\r
 \r
     try {\r
-      List<IFileEntry> list = new ArrayList<IFileEntry>();\r
-      for (File dir : FilePath().listFiles(new FileFilter() {\r
-        public boolean accept(File pathname) {\r
-          return pathname.isFile();\r
-        }\r
-      })) {\r
+      List<FileEntry> list = new ArrayList<FileEntry>();\r
+      for (File dir : FilePath().listFiles(FILE_FILTER)) {\r
         list.add(new RealFileEntry(new FileSystemPath(dir)));\r
       }\r
-      return list.toArray(new IFileEntry[list.size()]);\r
+      return list.toArray(new FileEntry[list.size()]);\r
     } catch (Exception e) {\r
-      return new IFileEntry[0];\r
+      return new FileEntry[0];\r
     }\r
   }\r
 \r
   @NotNull\r
-  public IFileEntry[] Files(Collection<String> names) {\r
-    List<IFileEntry> list = new ArrayList<IFileEntry>();\r
+  public FileEntry[] getFiles(@NotNull Collection<String> names) {\r
+    List<FileEntry> list = new ArrayList<FileEntry>();\r
     for (String name : names) {\r
       final File file = new File(FilePath(), name);\r
       if (!file.isFile()) continue;\r
       list.add(new RealFileEntry(new FileSystemPath(file)));\r
     }\r
-    return list.toArray(new IFileEntry[list.size()]);\r
+    return list.toArray(new FileEntry[list.size()]);\r
   }\r
 \r
   @Override\r
   public String toString() {\r
-    return "{d:" + myPath.FilePath() + "|" + Name() + "}";\r
+    return "{d:" + myPath.getFilePath() + "|" + getName() + "}";\r
   }\r
+\r
+  private final FileFilter DIRECTORY_FILTER = new FileFilter() {\r
+    public boolean accept(File pathname) {\r
+      return pathname.isDirectory();\r
+    }\r
+  };\r
+\r
+  private final FileFilter FILE_FILTER = new FileFilter() {\r
+    public boolean accept(File pathname) {\r
+      return pathname.isFile();\r
+    }\r
+  };\r
+\r
 }\r
index af010f52c172ba0c6d4c80725353975207188f92..05e02ca0b306cb14a862685b3bb195d6aa4701c0 100644 (file)
  */\r
 package jetbrains.buildServer.nuget.agent.runner.publish.fsScanner;\r
 \r
-public class RealFileEntry implements IFileEntry {\r
+import org.jetbrains.annotations.NotNull;\r
+\r
+public class RealFileEntry implements FileEntry {\r
   private final FileSystemPath myPath;\r
 \r
   public RealFileEntry(FileSystemPath path) {\r
     myPath = path;\r
   }\r
 \r
-  public String Name() {\r
-    return myPath.Name();\r
+  @NotNull\r
+  public String getName() {\r
+    return myPath.getName();\r
   }\r
 \r
-  public FileSystemPath Path() {\r
+  @NotNull\r
+  public FileSystemPath getPath() {\r
     return myPath;\r
   }\r
 \r
   @Override\r
   public String toString() {\r
-    return "{f:" + myPath.FilePath() + "|" + Name() + "}";\r
+    return "{f:" + myPath.getFilePath() + "|" + getName() + "}";\r
   }\r
 }
\ No newline at end of file
index a4a0e7ef9ebefe5505916c446d93d27086f4a1f0..2ecc6c9d3b9616a77310307a66ca9ace2acd05a0 100644 (file)
@@ -20,25 +20,23 @@ import org.jetbrains.annotations.NotNull;
 \r
 import java.io.File;\r
 \r
-public class RealFileSystem implements IFileSystem {\r
-  public static final IDirectoryEntry ROOT = new RealRootDirectory();\r
+public class RealFileSystem implements FileSystem {\r
+  public static final DirectoryEntry ROOT = new RealRootDirectory();\r
 \r
-  public boolean IsPathAbsolute(@NotNull String path) {\r
+  public boolean isPathAbsolute(@NotNull String path) {\r
     if (SystemInfo.isWindows) {\r
-      if ((path.startsWith("/") || path.startsWith("\\")))\r
-        return false;\r
-\r
+      if ((path.startsWith("/") || path.startsWith("\\"))) return false;\r
       return new File(path).isAbsolute();\r
     }\r
     return path.startsWith("/");\r
   }\r
 \r
   @NotNull\r
-  public IDirectoryEntry Root() {\r
+  public DirectoryEntry getRoot() {\r
     return ROOT;\r
   }\r
 \r
-  public boolean CaseSensitive() {\r
+  public boolean caseSensitive() {\r
     return SystemInfo.isFileSystemCaseSensitive;\r
   }\r
 }\r
index ab28545c9c6bee33b4c7da66ce1b6b265eaa3e9e..9a5de678dff5982105e8744a95a9bf87ba1e4aee 100644 (file)
@@ -24,19 +24,19 @@ import java.util.ArrayList;
 import java.util.Collection;\r
 import java.util.List;\r
 \r
-public class RealRootDirectory implements IDirectoryEntry {\r
+public class RealRootDirectory implements DirectoryEntry {\r
   @NotNull\r
-  public String Name() {\r
+  public String getName() {\r
     return "";\r
   }\r
 \r
-  public IDirectoryEntry Parent() {\r
+  public DirectoryEntry getParent() {\r
     return null;\r
   }\r
 \r
   @NotNull\r
-  public IDirectoryEntry[] Subdirectories() {\r
-    ArrayList<IDirectoryEntry> result = new ArrayList<IDirectoryEntry>();\r
+  public DirectoryEntry[] getSubdirectories() {\r
+    ArrayList<DirectoryEntry> result = new ArrayList<DirectoryEntry>();\r
     if (SystemInfo.isWindows) {\r
       for (File drive : File.listRoots()) {\r
         result.add(new RealDirectoryEntry(new FileSystemPath(drive)));\r
@@ -47,26 +47,26 @@ public class RealRootDirectory implements IDirectoryEntry {
       }\r
     }\r
 \r
-    return result.toArray(new IDirectoryEntry[result.size()]);\r
+    return result.toArray(new DirectoryEntry[result.size()]);\r
   }\r
 \r
   @NotNull\r
-  public IDirectoryEntry[] Subdirectories(Collection<String> names) {\r
-    List<IDirectoryEntry> entries = new ArrayList<IDirectoryEntry>(names.size());\r
+  public DirectoryEntry[] getSubdirectories(Collection<String> names) {\r
+    List<DirectoryEntry> entries = new ArrayList<DirectoryEntry>(names.size());\r
     for (String name : names) {\r
       entries.add(new RealDirectoryEntry(new FileSystemPath(new File(SystemInfo.isWindows ? name : "/" + name))));\r
     }\r
-    return entries.toArray(new IDirectoryEntry[entries.size()]);\r
+    return entries.toArray(new DirectoryEntry[entries.size()]);\r
   }\r
 \r
   @NotNull\r
-  public IFileEntry[] Files() {\r
-    return new IFileEntry[0];\r
+  public FileEntry[] getFiles() {\r
+    return new FileEntry[0];\r
   }\r
 \r
   @NotNull\r
-  public IFileEntry[] Files(Collection<String> names) {\r
-    return new IFileEntry[0];\r
+  public FileEntry[] getFiles(@NotNull Collection<String> names) {\r
+    return new FileEntry[0];\r
   }\r
 \r
   @Override\r
index 759e3031f10f757e7a20fe9fa598ff293d757c59..aacd10815488d91fae08527bad9d7d5f50dada70 100644 (file)
@@ -32,11 +32,11 @@ public class Wildcard {
     myPattern = !caseSensitive ? pattern.toLowerCase() : pattern;\r
   }\r
 \r
-  public String Pattern() {\r
+  public String getPattern() {\r
     return myPattern;\r
   }\r
 \r
-  public boolean IsMatch(@NotNull String str) {\r
+  public boolean isMatch(@NotNull String str) {\r
     String pattern = myPattern;\r
 \r
     if (StringUtil.isEmptyOrSpaces(pattern))\r
@@ -65,13 +65,13 @@ public class Wildcard {
           if (pat == patlen - 1)\r
             return true;\r
 \r
-          if (MatchChars(pattern.charAt(pat + 1), c)) {\r
+          if (matchChars(pattern.charAt(pat + 1), c)) {\r
             if (pat == patlen - 2 && j == str.length() - 1)\r
               return true;\r
             positions.add(pat + 2);\r
           }\r
         } else {\r
-          if (MatchChars(pattern.charAt(pat), c)) {\r
+          if (matchChars(pattern.charAt(pat), c)) {\r
             if (pat == patlen - 1 && j == str.length() - 1)\r
               return true;\r
 \r
@@ -91,7 +91,7 @@ public class Wildcard {
     return false;\r
   }\r
 \r
-  private static boolean MatchChars(char pat, char c) {\r
+  private static boolean matchChars(char pat, char c) {\r
     return pat == '?' || pat == c;\r
   }\r
 \r
diff --git a/nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/WildcardScanner2.java b/nuget-agent/src/jetbrains/buildServer/nuget/agent/runner/publish/fsScanner/WildcardScanner2.java
deleted file mode 100644 (file)
index fa3b715..0000000
+++ /dev/null
@@ -1,162 +0,0 @@
-/*\r
- * Copyright 2000-2011 JetBrains s.r.o.\r
- *\r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- */\r
-\r
-package jetbrains.buildServer.nuget.agent.runner.publish.fsScanner;\r
-\r
-/**\r
- * Created by Eugene Petrenko (eugene.petrenko@gmail.com)\r
- * Date: 24.08.11 22:21\r
- */\r
-public class WildcardScanner2 {\r
-/*\r
-  public Collection<File> matchWildcards(@NotNull final File root,\r
-                                         @NotNull final Collection<String> includes,\r
-                                         @NotNull final Collection<String> excludes) {\r
-\r
-  }\r
-\r
-\r
-  private static class MatchState {\r
-    private final List<Wildcard> myUnmatchedWildcards;\r
-    private final File myRoot;\r
-\r
-    private MatchState(@NotNull final File root, List<Wildcard> unmatchedWildcards) {\r
-      myUnmatchedWildcards = unmatchedWildcards;\r
-    }\r
-\r
-    @NotNull\r
-    public MatchResult match() {\r
-      assert myUnmatchedWildcards.size() > 0;\r
-      final Wildcard wd = myUnmatchedWildcards.iterator().next();\r
-\r
-      if (!wd.matches(name)) {\r
-        return new MatchResult(false, Collections.<MatchState>emptyList());\r
-      }\r
-\r
-      List<Wildcard> next = new ArrayList<Wildcard>(myUnmatchedWildcards);\r
-      List<MatchState> states = new ArrayList<MatchState>(2);\r
-\r
-      if (wd.isFork()) {\r
-        states.add(this);\r
-      }\r
-      next.remove(0);\r
-\r
-      if (next.isEmpty()) {\r
-        return new MatchResult(true, states);\r
-      } else {\r
-        states.add(new MatchState(next));\r
-        return new MatchResult(false, states);\r
-      }\r
-    }\r
-  }\r
-\r
-  private static class MatchResult {\r
-    private boolean myIsMatched;\r
-    private Collection<MatchState> myMatches;\r
-\r
-    private MatchResult(boolean isMatched, Collection<MatchState> matches) {\r
-      myIsMatched = isMatched;\r
-      myMatches = matches;\r
-    }\r
-\r
-    public boolean isIsMatched() {\r
-      return myIsMatched;\r
-    }\r
-\r
-    public Collection<MatchState> getMatches() {\r
-      return myMatches;\r
-    }\r
-  }\r
-\r
-  private abstract static class Wildcard {\r
-    protected final String myPattern;\r
-\r
-    protected Wildcard(@NotNull final String pattern) {\r
-      myPattern = pattern;\r
-    }\r
-\r
-    public abstract boolean matches(@NotNull final String name);\r
-    public abstract boolean isPattern();\r
-    public abstract boolean isFork();\r
-  }\r
-\r
-  private class NameWildcard extends Wildcard {\r
-    private NameWildcard(@NotNull String pattern) {\r
-      super(pattern);\r
-    }\r
-\r
-    @Override\r
-    public boolean matches(@NotNull String name) {\r
-      return myPattern.equals(name);\r
-    }\r
-\r
-    @Override\r
-    public boolean isPattern() {\r
-      return false;\r
-    }\r
-\r
-    @Override\r
-    public boolean isFork() {\r
-      return false;\r
-    }\r
-  }\r
-\r
-  private class PatternWildcard extends Wildcard {\r
-    private final Pattern myPattern;\r
-    private PatternWildcard(@NotNull String pattern) {\r
-      super(pattern);\r
-      myPattern = Pattern.compile("$" +\r
-              pattern.replaceAll("\\.", "\\.").replaceAll("\\*", ".*").replaceAll("\\?", ".?") + "^");\r
-    }\r
-\r
-    @Override\r
-    public boolean matches(@NotNull String name) {\r
-      return myPattern.matcher(name).matches();\r
-    }\r
-\r
-    @Override\r
-    public boolean isPattern() {\r
-      return true;\r
-    }\r
-\r
-    @Override\r
-    public boolean isFork() {\r
-      return false;\r
-    }\r
-  }\r
-\r
-  private class DoubleStarWildcard extends Wildcard {\r
-    private DoubleStarWildcard() {\r
-      super("**");\r
-    }\r
-\r
-    @Override\r
-    public boolean matches(@NotNull String name) {\r
-      return true;\r
-    }\r
-\r
-    @Override\r
-    public boolean isPattern() {\r
-      return true;\r
-    }\r
-\r
-    @Override\r
-    public boolean isFork() {\r
-      return true;\r
-    }\r
-  }\r
-*/\r
-}\r
index 0bc5074c70ffe92879182d42cdb645db42d332b8..d20456e16c6721c817326cea56add891b1c03b09 100644 (file)
@@ -47,6 +47,6 @@ public class DirectoryFileFilesystemTest extends BaseTestCase {
 \r
   private static void DoAbsTest(String path, boolean result) {\r
     RealFileSystem fs = new RealFileSystem();\r
-    Assert.assertEquals(result, fs.IsPathAbsolute(path));\r
+    Assert.assertEquals(result, fs.isPathAbsolute(path));\r
   }\r
 }\r
index c0daaf2db9aff1734f452d2c8289fa039485f229..a13aac89778802608d369514c0ff4e33e8525efd 100644 (file)
@@ -33,38 +33,38 @@ public class DirectoryScannerMockFSTest extends BaseTestCase {
   @Test\r
   public void test_should_not_list_folders_for_known_paths() {\r
     Mockery m = new Mockery();\r
-    final IFileSystem fs = m.mock(IFileSystem.class);\r
-    final IDirectoryEntry root = m.mock(IDirectoryEntry.class, "root");\r
-    final IDirectoryEntry a = m.mock(IDirectoryEntry.class, "a");\r
-    final IDirectoryEntry proot = m.mock(IDirectoryEntry.class, "proot");\r
-    final IDirectoryEntry fsRoot = m.mock(IDirectoryEntry.class, "fsRoot");\r
-    final IFileEntry c_txt = m.mock(IFileEntry.class, "c.txt");\r
+    final FileSystem fs = m.mock(FileSystem.class);\r
+    final DirectoryEntry root = m.mock(DirectoryEntry.class, "root");\r
+    final DirectoryEntry a = m.mock(DirectoryEntry.class, "a");\r
+    final DirectoryEntry proot = m.mock(DirectoryEntry.class, "proot");\r
+    final DirectoryEntry fsRoot = m.mock(DirectoryEntry.class, "fsRoot");\r
+    final FileEntry c_txt = m.mock(FileEntry.class, "c.txt");\r
 \r
     m.checking(new Expectations(){{\r
-      allowing(fs).CaseSensitive(); will(returnValue(true));\r
-      allowing(fs).Root(); will(returnValue(fsRoot));\r
-      oneOf(fs).IsPathAbsolute("a/c.txt"); will(returnValue(false));\r
+      allowing(fs).caseSensitive(); will(returnValue(true));\r
+      allowing(fs).getRoot(); will(returnValue(fsRoot));\r
+      oneOf(fs).isPathAbsolute("a/c.txt"); will(returnValue(false));\r
 \r
-      allowing(fsRoot).Name(); will(returnValue("fsRoot"));\r
-      allowing(fsRoot).Parent(); will(returnValue(null));\r
-      allowing(fsRoot).Subdirectories(Arrays.asList("root")); will(returnValue(new IDirectoryEntry[]{ root} ));\r
+      allowing(fsRoot).getName(); will(returnValue("fsRoot"));\r
+      allowing(fsRoot).getParent(); will(returnValue(null));\r
+      allowing(fsRoot).getSubdirectories(Arrays.asList("root")); will(returnValue(new DirectoryEntry[]{ root} ));\r
 \r
-      allowing(root).Parent(); will(returnValue(proot));\r
-      allowing(root).Name(); will(returnValue("root"));\r
-      allowing(root).Subdirectories(Arrays.asList("a")); will(returnValue(new IDirectoryEntry[] { a }));\r
-      allowing(root).Files(Arrays.asList("a")); will(returnValue(new IFileEntry[0]));\r
-      allowing(proot).Parent(); will(returnValue(null));\r
-      allowing(proot).Name(); will(returnValue("proot"));\r
+      allowing(root).getParent(); will(returnValue(proot));\r
+      allowing(root).getName(); will(returnValue("root"));\r
+      allowing(root).getSubdirectories(Arrays.asList("a")); will(returnValue(new DirectoryEntry[] { a }));\r
+      allowing(root).getFiles(Arrays.asList("a")); will(returnValue(new FileEntry[0]));\r
+      allowing(proot).getParent(); will(returnValue(null));\r
+      allowing(proot).getName(); will(returnValue("proot"));\r
 \r
-      allowing(a).Name(); will(returnValue("a"));\r
-      allowing(a).Files(Arrays.asList("c.txt")); will(returnValue(new IFileEntry[]{c_txt} ));\r
-      allowing(a).Subdirectories(Arrays.asList("c.txt")); will(returnValue(new IDirectoryEntry[0]));\r
+      allowing(a).getName(); will(returnValue("a"));\r
+      allowing(a).getFiles(Arrays.asList("c.txt")); will(returnValue(new FileEntry[]{c_txt} ));\r
+      allowing(a).getSubdirectories(Arrays.asList("c.txt")); will(returnValue(new DirectoryEntry[0]));\r
 \r
-      allowing(c_txt).Name(); will(returnValue("c.txt"));\r
-      allowing(c_txt).Path(); will(returnValue(new FileSystemPath("ccc")));\r
+      allowing(c_txt).getName(); will(returnValue("c.txt"));\r
+      allowing(c_txt).getPath(); will(returnValue(new FileSystemPath("ccc")));\r
     }});\r
 \r
-    DirectoryScanner.FindFiles(fs, root, Arrays.asList("a/c.txt"), Collections.<String>emptyList());\r
+    DirectoryScanner.findFiles(fs, root, Arrays.asList("a/c.txt"), Collections.<String>emptyList());\r
 \r
     m.assertIsSatisfied();\r
   }\r
index f99bdde1d87c99d079659252c18f6c80a8567289..d4bedd69e013acfc281c933f6015e893f624fac0 100644 (file)
@@ -16,9 +16,7 @@
 package jetbrains.buildServer.nuget.tests.util.fsScanner;\r
 \r
 import jetbrains.buildServer.BaseTestCase;\r
-import jetbrains.buildServer.nuget.agent.runner.publish.fsScanner.AntPatternState;\r
-import jetbrains.buildServer.nuget.agent.runner.publish.fsScanner.AntPatternUtil;\r
-import jetbrains.buildServer.nuget.agent.runner.publish.fsScanner.Wildcard;\r
+import jetbrains.buildServer.nuget.agent.runner.publish.fsScanner.*;\r
 import org.jetbrains.annotations.Nullable;\r
 import org.testng.Assert;\r
 import org.testng.annotations.Test;\r
@@ -28,20 +26,20 @@ import java.util.List;
 \r
 public class TestAntPatternState extends BaseTestCase {\r
   private static void AssertPatternState(String pattern, @Nullable List<Integer> pos, String enter, String expectedResult) {\r
-    List<Wildcard> wildcards = AntPatternUtil.ParsePattern(pattern, false);\r
+    List<Wildcard> wildcards = AntPatternUtil.parsePattern(pattern, false);\r
 \r
     AntPatternState state = pos == null\r
             ? new AntPatternState(wildcards)\r
             : new AntPatternState(wildcards, pos);\r
 \r
-    final AntPatternState.AntPatternStateMatch e = state.Enter(enter);\r
-    AntPatternState.MatchResult match = e.getResult();\r
+    final AntPatternStateMatch e = state.enter(enter);\r
+    MatchResult match = e.getResult();\r
     AntPatternState newState = e.getState();\r
 \r
     StringBuilder sb = new StringBuilder();\r
     sb.append(match);\r
     sb.append(" ");\r
-    for (int p : newState.PatternPositions()) {\r
+    for (int p : newState.getPatternPositions()) {\r
       sb.append(p);\r
       sb.append(":");\r
     }\r
index 64271df7275849c891a321645cd8709e7cb515c4..ce6cbcb5acc1a8537431afee656b9e2a02ed1fbb 100644 (file)
@@ -27,10 +27,10 @@ import java.util.List;
 \r
 public class TestAntPatternUtil extends BaseTestCase {\r
   private static void AssertParseResult(String pattern, String expectedResult) {\r
-    List<Wildcard> wildcards = AntPatternUtil.ParsePattern(pattern, false);\r
+    List<Wildcard> wildcards = AntPatternUtil.parsePattern(pattern, false);\r
     StringBuilder sb = new StringBuilder();\r
     for (Wildcard w : wildcards) {\r
-      sb.append(w == null ? "**" : w.Pattern());\r
+      sb.append(w == null ? "**" : w.getPattern());\r
       sb.append(":");\r
     }\r
     String result = StringUtil.trimEnd(sb.toString(), ":");\r
@@ -39,19 +39,19 @@ public class TestAntPatternUtil extends BaseTestCase {
 \r
   @Test\r
   public void IsFileNameMatch() {\r
-    Assert.assertTrue(AntPatternUtil.IsFileNameMatch("a*/**b**", "abc/ss/aa/vv/ggbbhh/qq"));\r
-    Assert.assertFalse(AntPatternUtil.IsFileNameMatch("a*/**b**", "abc/ss/aa/vv/gghh/qq"));\r
-    Assert.assertTrue(AntPatternUtil.IsFileNameMatch("**/bin/**.exe", "My/BiN/Debug/program.exe"));\r
-    Assert.assertFalse(AntPatternUtil.IsFileNameMatch("**/bin/**.exe", "My/BiN/Debug/program.dll"));\r
-    Assert.assertTrue(AntPatternUtil.IsFileNameMatch("**/bin/**.exe", "bin/program.exe"));\r
+    Assert.assertTrue(AntPatternUtil.isFileNameMatch("a*/**b**", "abc/ss/aa/vv/ggbbhh/qq"));\r
+    Assert.assertFalse(AntPatternUtil.isFileNameMatch("a*/**b**", "abc/ss/aa/vv/gghh/qq"));\r
+    Assert.assertTrue(AntPatternUtil.isFileNameMatch("**/bin/**.exe", "My/BiN/Debug/program.exe"));\r
+    Assert.assertFalse(AntPatternUtil.isFileNameMatch("**/bin/**.exe", "My/BiN/Debug/program.dll"));\r
+    Assert.assertTrue(AntPatternUtil.isFileNameMatch("**/bin/**.exe", "bin/program.exe"));\r
 \r
-    Assert.assertTrue(AntPatternUtil.IsFileNameMatch("**aaa**ddd***ccc**", "aaa/aaa/ddd/ddd/ccc/ccc"));\r
-    Assert.assertFalse(AntPatternUtil.IsFileNameMatch("**aaa**ddd***ccc**", "aaa/aaa/ccc/ccc"));\r
+    Assert.assertTrue(AntPatternUtil.isFileNameMatch("**aaa**ddd***ccc**", "aaa/aaa/ddd/ddd/ccc/ccc"));\r
+    Assert.assertFalse(AntPatternUtil.isFileNameMatch("**aaa**ddd***ccc**", "aaa/aaa/ccc/ccc"));\r
 \r
-    Assert.assertTrue(AntPatternUtil.IsFileNameMatch(".\\s.slN", "S.sln"));\r
-    Assert.assertTrue(AntPatternUtil.IsFileNameMatch("s.slN", ".\\S.sln"));\r
+    Assert.assertTrue(AntPatternUtil.isFileNameMatch(".\\s.slN", "S.sln"));\r
+    Assert.assertTrue(AntPatternUtil.isFileNameMatch("s.slN", ".\\S.sln"));\r
 \r
-    Assert.assertFalse(AntPatternUtil.IsFileNameMatch(".", ""));\r
+    Assert.assertFalse(AntPatternUtil.isFileNameMatch(".", ""));\r
   }\r
 \r
   @Test\r
index 2000561094171beff15fb5b1408199c7a9613d00..5d629a0585c6eebe2d2e5ebbb99a6e742e59b6a9 100644 (file)
@@ -32,7 +32,7 @@ public class TestDirectoryScanner extends BaseTestCase {
     File fsp = createTempDir();\r
 \r
     CreateDirectories(fsDescription, fsp);\r
-    Collection<File> findFiles = DirectoryScanner.FindFiles(fsp, Arrays.asList(includePatterns), Arrays.asList(excludePatterns));\r
+    Collection<File> findFiles = DirectoryScanner.findFiles(fsp, Arrays.asList(includePatterns), Arrays.asList(excludePatterns));\r
 \r
     Set<File> expected = new TreeSet<File>();\r
     for (String s : expectedResult) {\r
@@ -188,7 +188,7 @@ public class TestDirectoryScanner extends BaseTestCase {
     File atxtFsp = new File(fsp, "a.txt");\r
     FileUtil.writeFile(atxtFsp, "text");\r
 \r
-    Collection<File> files = DirectoryScanner.FindFiles(fsp, Arrays.asList(atxtFsp.getPath()), Collections.<String>emptyList());\r
+    Collection<File> files = DirectoryScanner.findFiles(fsp, Arrays.asList(atxtFsp.getPath()), Collections.<String>emptyList());\r
     Assert.assertEquals(1, files.size());\r
     Assert.assertEquals(PreparePath(atxtFsp), PreparePath(files.iterator().next()));\r
   }\r
index 52253a33faa1aa4c33902750d8d86acd1714572c..c0f4c6328eb0914d063e6355350f479063784cce 100644 (file)
@@ -36,7 +36,7 @@ public class TestReadFileSystem extends BaseTestCase {
 \r
   @Test\r
   public void TestCaseSensitive() {\r
-    Assert.assertEquals(!SystemInfo.isWindows, new RealFileSystem().CaseSensitive());\r
+    Assert.assertEquals(!SystemInfo.isWindows, new RealFileSystem().caseSensitive());\r
   }\r
 \r
   private void TestFSTest(FilesAction a) throws IOException {\r
@@ -63,9 +63,9 @@ public class TestReadFileSystem extends BaseTestCase {
   public void TestNames() throws IOException {\r
     TestFSTest(new FilesAction() {\r
       public void action(RealDirectoryEntry r1, RealDirectoryEntry r2, RealDirectoryEntry r3, RealDirectoryEntry r4) {\r
-        Assert.assertEquals("ccc", r4.Name());\r
-        Assert.assertEquals("bbb", r3.Name());\r
-        Assert.assertEquals("aaa", r2.Name());\r
+        Assert.assertEquals("ccc", r4.getName());\r
+        Assert.assertEquals("bbb", r3.getName());\r
+        Assert.assertEquals("aaa", r2.getName());\r
       }\r
     });\r
   }\r
@@ -75,14 +75,14 @@ public class TestReadFileSystem extends BaseTestCase {
     TestFSTest(\r
             new FilesAction() {\r
               public void action(RealDirectoryEntry r1, RealDirectoryEntry r2, RealDirectoryEntry r3, RealDirectoryEntry r4) {\r
-                AssertDirectoriesEqual(r4.Parent(), r3);\r
-                AssertDirectoriesEqual(r4.Parent().Parent(), r2);\r
-                AssertDirectoriesEqual(r4.Parent().Parent().Parent(), r1);\r
+                AssertDirectoriesEqual(r4.getParent(), r3);\r
+                AssertDirectoriesEqual(r4.getParent().getParent(), r2);\r
+                AssertDirectoriesEqual(r4.getParent().getParent().getParent(), r1);\r
 \r
-                AssertDirectoriesEqual(r3.Parent(), r2);\r
-                AssertDirectoriesEqual(r3.Parent().Parent(), r1);\r
+                AssertDirectoriesEqual(r3.getParent(), r2);\r
+                AssertDirectoriesEqual(r3.getParent().getParent(), r1);\r
 \r
-                AssertDirectoriesEqual(r2.Parent(), r1);\r
+                AssertDirectoriesEqual(r2.getParent(), r1);\r
 \r
 \r
               }\r
@@ -94,14 +94,14 @@ public class TestReadFileSystem extends BaseTestCase {
     TestFSTest(\r
             new FilesAction() {\r
               public void action(RealDirectoryEntry r1, RealDirectoryEntry r2, RealDirectoryEntry r3, RealDirectoryEntry r4) {\r
-                Assert.assertEquals(0, r4.Subdirectories().length);\r
-                Assert.assertEquals(1, r3.Subdirectories().length);\r
-                Assert.assertEquals(1, r2.Subdirectories().length);\r
-                Assert.assertEquals(1, r1.Subdirectories().length);\r
+                Assert.assertEquals(0, r4.getSubdirectories().length);\r
+                Assert.assertEquals(1, r3.getSubdirectories().length);\r
+                Assert.assertEquals(1, r2.getSubdirectories().length);\r
+                Assert.assertEquals(1, r1.getSubdirectories().length);\r
 \r
-                AssertDirectoriesEqual(r3.Subdirectories()[0], r4);\r
-                AssertDirectoriesEqual(r2.Subdirectories()[0], r3);\r
-                AssertDirectoriesEqual(r1.Subdirectories()[0], r2);\r
+                AssertDirectoriesEqual(r3.getSubdirectories()[0], r4);\r
+                AssertDirectoriesEqual(r2.getSubdirectories()[0], r3);\r
+                AssertDirectoriesEqual(r1.getSubdirectories()[0], r2);\r
 \r
               }\r
             });\r
@@ -110,19 +110,19 @@ public class TestReadFileSystem extends BaseTestCase {
   @Test\r
   public void TestRootSubdirectories() {\r
     RealRootDirectory root = new RealRootDirectory();\r
-    Assert.assertTrue(root.Subdirectories().length > 0);\r
+    Assert.assertTrue(root.getSubdirectories().length > 0);\r
   }\r
 \r
   @Test(enabled = false)\r
   public void TestRootSubdirectoriesWalk() {\r
     int k = 10;\r
-    for (IDirectoryEntry sub1 : new RealRootDirectory().Subdirectories()) {\r
+    for (DirectoryEntry sub1 : new RealRootDirectory().getSubdirectories()) {\r
       if (k-- < 0) break;\r
       int j = 10;\r
-      for (IDirectoryEntry sub2 : sub1.Subdirectories()) {\r
+      for (DirectoryEntry sub2 : sub1.getSubdirectories()) {\r
         if (j-- < 0) break;\r
         int i = 10;\r
-        for (IDirectoryEntry sub3 : sub2.Subdirectories()) {\r
+        for (DirectoryEntry sub3 : sub2.getSubdirectories()) {\r
           if (i-- < 0) break;\r
           System.out.println("sub3 = " + sub3);\r
         }\r
@@ -134,18 +134,18 @@ public class TestReadFileSystem extends BaseTestCase {
 \r
   @Test\r
   public void TestRealRoot() {\r
-    IDirectoryEntry root = RealFileSystem.ROOT;\r
+    DirectoryEntry root = RealFileSystem.ROOT;\r
     DumpItem(root);\r
-    Assert.assertTrue(root.Subdirectories().length > 0);\r
+    Assert.assertTrue(root.getSubdirectories().length > 0);\r
   }\r
 \r
-  private static void DumpItem(IDirectoryEntry e) {\r
+  private static void DumpItem(DirectoryEntry e) {\r
     Assert.assertNotNull(e);\r
     System.out.println("entry = " + e);\r
-    for (IDirectoryEntry sub : e.Subdirectories()) {\r
+    for (DirectoryEntry sub : e.getSubdirectories()) {\r
       System.out.println("entry->sub = " + sub);\r
     }\r
-    for (IFileEntry fileEntry : e.Files()) {\r
+    for (FileEntry fileEntry : e.getFiles()) {\r
       System.out.println("entry->file = " + fileEntry);\r
     }\r
   }\r
@@ -157,12 +157,12 @@ public class TestReadFileSystem extends BaseTestCase {
     path.mkdirs();\r
 \r
 \r
-    IDirectoryEntry e = cd(path);\r
-    IDirectoryEntry p = e.Parent();\r
+    DirectoryEntry e = cd(path);\r
+    DirectoryEntry p = e.getParent();\r
     Assert.assertNotNull(p);\r
 \r
-    for (IDirectoryEntry dir : p.Subdirectories()) {\r
-      if (dir.Name().equals(e.Name())) {\r
+    for (DirectoryEntry dir : p.getSubdirectories()) {\r
+      if (dir.getName().equals(e.getName())) {\r
         AssertDirectoriesEqual(dir, e);\r
         return;\r
       }\r
@@ -177,9 +177,9 @@ public class TestReadFileSystem extends BaseTestCase {
 \r
   @Test\r
   public void TestShouldFindRootFS() throws IOException {\r
-    IDirectoryEntry r = cd(createTempDir());\r
+    DirectoryEntry r = cd(createTempDir());\r
     while (true) {\r
-      IDirectoryEntry p = r.Parent();\r
+      DirectoryEntry p = r.getParent();\r
       if (p == null) break;\r
       r = p;\r
     }\r
@@ -197,27 +197,27 @@ public class TestReadFileSystem extends BaseTestCase {
       path.mkdirs();\r
     }\r
 \r
-    IDirectoryEntry test = new RealDirectoryEntry(new FileSystemPath(path));\r
+    DirectoryEntry test = new RealDirectoryEntry(new FileSystemPath(path));\r
 \r
     List<String> loop = new ArrayList<String>();\r
     while (true) {\r
       System.out.println("p = " + test);\r
-      loop.add(test.Name());\r
-      IDirectoryEntry p = test.Parent();\r
+      loop.add(test.getName());\r
+      DirectoryEntry p = test.getParent();\r
       if (p == null) break;\r
       test = p;\r
     }\r
     Collections.reverse(loop);\r
 \r
 \r
-    IDirectoryEntry root = new RealRootDirectory();\r
-    Assert.assertEquals(root.Name(), loop.get(0));\r
+    DirectoryEntry root = new RealRootDirectory();\r
+    Assert.assertEquals(root.getName(), loop.get(0));\r
     loop.remove(0);\r
 \r
     for (String name : loop) {\r
       boolean found = false;\r
-      for (IDirectoryEntry sub : root.Subdirectories()) {\r
-        if (sub.Name().equals(name)) {\r
+      for (DirectoryEntry sub : root.getSubdirectories()) {\r
+        if (sub.getName().equals(name)) {\r
           found = true;\r
           root = sub;\r
         }\r
@@ -233,7 +233,7 @@ public class TestReadFileSystem extends BaseTestCase {
 \r
   }\r
 \r
-  private static void AssertDirectoriesEqual(IDirectoryEntry e1, IDirectoryEntry e2) {\r
+  private static void AssertDirectoriesEqual(DirectoryEntry e1, DirectoryEntry e2) {\r
     Assert.assertEquals(e1.toString(), e2.toString());\r
   }\r
 \r
@@ -247,12 +247,12 @@ public class TestReadFileSystem extends BaseTestCase {
   public void TestParentDirectory() throws IOException {\r
     File path = createTempDir();\r
 \r
-    List<IDirectoryEntry> entries = new ArrayList<IDirectoryEntry>();\r
-    IDirectoryEntry e = new RealDirectoryEntry(new FileSystemPath(path));\r
-    while (e.Parent() != null) {\r
+    List<DirectoryEntry> entries = new ArrayList<DirectoryEntry>();\r
+    DirectoryEntry e = new RealDirectoryEntry(new FileSystemPath(path));\r
+    while (e.getParent() != null) {\r
       System.out.println("e = " + e);\r
       entries.add(e);\r
-      e = e.Parent();\r
+      e = e.getParent();\r
     }\r
   }\r
 }\r
index 63603f30411667b3cbf8e81e344adbac80a02e73..c5cc41a8621a642953998defa762226047c93387 100644 (file)
@@ -22,39 +22,39 @@ import org.testng.annotations.Test;
 public class TestWildcard {\r
   @Test\r
   public void test_01() {\r
-    Assert.assertFalse(new Wildcard("abcd", true).IsMatch("a"));\r
-    Assert.assertFalse(new Wildcard("*.cs", true).IsMatch("hello.csc"));\r
+    Assert.assertFalse(new Wildcard("abcd", true).isMatch("a"));\r
+    Assert.assertFalse(new Wildcard("*.cs", true).isMatch("hello.csc"));\r
 \r
-    Assert.assertTrue(new Wildcard("", true).IsMatch(""));\r
-    Assert.assertFalse(new Wildcard("", true).IsMatch("asdsad"));\r
+    Assert.assertTrue(new Wildcard("", true).isMatch(""));\r
+    Assert.assertFalse(new Wildcard("", true).isMatch("asdsad"));\r
 \r
-    Assert.assertTrue(new Wildcard("*.cs", true).IsMatch("hello.cs"));\r
-    Assert.assertTrue(new Wildcard("h*.cs", true).IsMatch("hello.cs"));\r
-    Assert.assertFalse(new Wildcard("a*.cs", true).IsMatch("hello.cs"));\r
-    Assert.assertTrue(new Wildcard("*.cs*", true).IsMatch("hello.cs"));\r
-    Assert.assertTrue(new Wildcard("*.cs", true).IsMatch(".cs"));\r
-    Assert.assertFalse(new Wildcard("*.cs", true).IsMatch("hello.s"));\r
+    Assert.assertTrue(new Wildcard("*.cs", true).isMatch("hello.cs"));\r
+    Assert.assertTrue(new Wildcard("h*.cs", true).isMatch("hello.cs"));\r
+    Assert.assertFalse(new Wildcard("a*.cs", true).isMatch("hello.cs"));\r
+    Assert.assertTrue(new Wildcard("*.cs*", true).isMatch("hello.cs"));\r
+    Assert.assertTrue(new Wildcard("*.cs", true).isMatch(".cs"));\r
+    Assert.assertFalse(new Wildcard("*.cs", true).isMatch("hello.s"));\r
 \r
-    Assert.assertTrue(new Wildcard("*a*c", true).IsMatch("1221abcccac"));\r
-    Assert.assertTrue(new Wildcard("a", true).IsMatch("a"));\r
-    Assert.assertTrue(new Wildcard("?", true).IsMatch("z"));\r
-    Assert.assertFalse(new Wildcard("*?*", true).IsMatch(""));\r
-    Assert.assertTrue(new Wildcard("*?*", true).IsMatch("k"));\r
+    Assert.assertTrue(new Wildcard("*a*c", true).isMatch("1221abcccac"));\r
+    Assert.assertTrue(new Wildcard("a", true).isMatch("a"));\r
+    Assert.assertTrue(new Wildcard("?", true).isMatch("z"));\r
+    Assert.assertFalse(new Wildcard("*?*", true).isMatch(""));\r
+    Assert.assertTrue(new Wildcard("*?*", true).isMatch("k"));\r
 \r
   }\r
 \r
   @Test\r
   public void test_02() {\r
-    Assert.assertTrue(new Wildcard("*?**", true).IsMatch("k"));\r
-    Assert.assertTrue(new Wildcard("*?*", true).IsMatch("111k"));\r
-    Assert.assertTrue(new Wildcard("*?*", true).IsMatch("11k22"));\r
-    Assert.assertTrue(new Wildcard("*?*m*", true).IsMatch("11mk22"));\r
-    Assert.assertFalse(new Wildcard("*??*m*", true).IsMatch("1mk22"));\r
+    Assert.assertTrue(new Wildcard("*?**", true).isMatch("k"));\r
+    Assert.assertTrue(new Wildcard("*?*", true).isMatch("111k"));\r
+    Assert.assertTrue(new Wildcard("*?*", true).isMatch("11k22"));\r
+    Assert.assertTrue(new Wildcard("*?*m*", true).isMatch("11mk22"));\r
+    Assert.assertFalse(new Wildcard("*??*m*", true).isMatch("1mk22"));\r
     Assert.assertTrue(\r
-            new Wildcard("*non-greedy character*matching", true).IsMatch(\r
+            new Wildcard("*non-greedy character*matching", true).isMatch(\r
                     "non-greedy character matching compared to greedy character matching"));\r
     Assert.assertFalse(\r
-            new Wildcard("*non-greedy character*matching2", true).IsMatch(\r
+            new Wildcard("*non-greedy character*matching2", true).isMatch(\r
                     "non-greedy character matching compared to greedy character matching"));\r
   }\r
 }\r