Changeset 102

Timestamp:

Mar 26, 2007, 8:34:29 PM (18 years ago)

Author:

RBRi

Message:

improved StringUtilsUnit

Location:

trunk/NewView

Files:

• BookmarksFormUnit.pas (modified) (2 diffs)
• GlobalSearchForm.pas (modified) (3 diffs)
• StringUtilsUnit.pas (modified) (10 diffs)
• unittests/StringUtilsUnitTests.pas (modified) (4 diffs)

trunk/NewView/BookmarksFormUnit.pas

@@ -67 +67 @@
   ControlsUtility,
   ACLDialogs,
-  ACLStringUtility,
+  StringUtilsUnit,
   DebugUnit;
 
@@ -134 +134 @@
   if DoConfirmDlg( DeleteBookmarkTitle,
                    DeleteBookmarkA
-                   + StrDoubleQuote( Bookmark.Name )
+                   + StrInDoubleQuotes(Bookmark.Name)
                    + DeleteBookmarkB ) then
   begin

trunk/NewView/GlobalSearchForm.pas

@@ -145 +145 @@
   ControlsUtility,
   DriveInfoUnit,
-  ACLStringUtility,
   IPFFileFormatUnit,
   HelpTopic,
@@ -152 +151 @@
   SettingsUnit,
   InformationFormUnit,
+  StringUtilsUnit,
   FileUtilsUnit;
 
@@ -495 +495 @@
                                   ScanDirectoriesMsg );
     Dir := tmpSearchParameters.Directories[ i ];
-    if StrEnds( '...', Dir ) then
+    if StrEndsWith('...', Dir) then
     begin
       Dir := StrLeftWithout( Dir, 3 );

trunk/NewView/StringUtilsUnit.pas

@@ -16 +16 @@
   StrLF = chr(10);
   StrCRLF = StrCR + StrLF;
+  Quote = '''';
+  DoubleQuote = '"';
 
 
@@ -43 +45 @@
   // an optional escape character usable to escape field delimits.
   // Example:
-  //     StrExtractStrings('1x2x3\x4', "x", '\') ->
-  //     returns 4 strings: "1", "", "2" and "3x4"
+  //     StrExtractStrings('1x2x3\x4', 'x', '\') ->
+  //     returns 4 strings: '1', '', '2' and '3x4'
   Procedure StrExtractStrings(Var aResult : TStrings; Const aReceiver: String; const aSetOfChars: TSetOfChars; const anEscapeChar: char);
 
@@ -68 +70 @@
   Function StrLeft(const aString : String; const aCount : Integer) : String;
 
+  // Returns a copy of the string without aCount chars from right
+  Function StrLeftWithout(const aString : String; const aCount : Integer) : String;
+
+  // Returns a copy of the string including all characters until one from aSetOfChars found
+  Function StrLeftUntil(const aReceiver: String; const aSetOfChars: TSetOfChars) : String;
+
+  // returns true if the String starts with the provides one
+  // this is case SENSITIVE
+  Function StrStartsWith(const aReceiver: String; const aStartString: String): Boolean;
+
+  // returns true if the String starts with the provides one
+  // this is case INsensitive
+  Function StrStartsWithIgnoringCase(const aReceiver: String; const aStartString: String): Boolean;
+
   // returns true if the String ends with the provides one
   // this is case SENSITIVE
@@ -74 +90 @@
   // returns true if the String ends with the provides one
   // this is case INsensitive
-  Function StrEndsWithIgnoringCase(const aString: String; const anEndString: String): Boolean;
+  Function StrEndsWithIgnoringCase(const aReceiver: String; const anEndString: String): Boolean;
 
   // the IntToStr generates wrong results
@@ -82 +98 @@
 
   Function BoolToStr(const aBoolean : boolean ): string;
+
+  // Returns aString enclosed in double quotes
+  Function StrInDoubleQuotes(const aString : String) : String;
 
 
@@ -350 +369 @@
 
 
+  Function StrLeftWithout(const aString : String; const aCount : Integer) : String;
+  Begin
+    Result:= copy(aString, 1, length(aString) - aCount );
+  End;
+
+
+  Function StrLeftUntil(const aReceiver: String; const aSetOfChars: TSetOfChars) : String;
+  Var
+    i : integer;
+  Begin
+    Result := aReceiver;
+
+    for i := 1 To Length(aReceiver) do
+    begin
+      if aReceiver[i] in aSetOfChars then
+      begin
+        Result := Copy(aReceiver, 1, i-1 );
+        break;
+      end;
+    end;
+  end;
+
+
+  Function StrStartsWith(const aReceiver: String; const aStartString: String) : Boolean;
+  Var
+    tmpStringPos : integer;
+    tmpStartStringLength : integer;
+  Begin
+    tmpStartStringLength := Length(aStartString);
+
+    if Length(aReceiver) < tmpStartStringLength then
+    begin
+      result := false;
+      exit;
+    end;
+
+    for tmpStringPos := 1 to tmpStartStringLength do
+    begin
+      if aReceiver[tmpStringPos] <> aStartString[tmpStringPos] then
+      begin
+        result := false;
+        exit;
+      end;
+    end;
+
+    result := true;
+  end;
+
+
+  Function StrStartsWithIgnoringCase(const aReceiver: String; const aStartString: String) : Boolean;
+  Var
+    tmpStringPos : integer;
+    tmpStartStringLength : integer;
+  Begin
+    tmpStartStringLength := Length(aStartString);
+
+    if Length(aReceiver) < tmpStartStringLength then
+    begin
+      result := false;
+      exit;
+    end;
+
+    for tmpStringPos := 1 to tmpStartStringLength do
+    begin
+      if UpCase(aReceiver[tmpStringPos]) <> UpCase(aStartString[tmpStringPos]) then
+      begin
+        result := false;
+        exit;
+      end;
+    end;
+
+    result := true;
+  end;
+
+
   Function StrEndsWith(const aReceiver: String; const anEndString: String): Boolean;
   Var
@@ -384 +478 @@
     tmpMatchPos : Longint;
   Begin
-    tmpStringPos := length(aString);
+    tmpStringPos := length(aReceiver);
     tmpMatchPos := length(anEndString);
 
@@ -395 +489 @@
     while tmpMatchPos > 0 do
     begin
-      if upcase(aString[tmpStringPos]) <> upcase(anEndString[tmpMatchPos]) then
+      if upcase(aReceiver[tmpStringPos]) <> upcase(anEndString[tmpMatchPos]) then
       begin
         result := false;
@@ -406 +500 @@
     result := true;
   end;
+
 
   Function LongWordToStr(const aLongWord: LongWord) : String;
@@ -450 +545 @@
   end;
 
+  Function StrInDoubleQuotes(const aString : String) : String;
+  begin
+    Result := DoubleQuote + aString + DoubleQuote;
+  end;
+
+
 END.

trunk/NewView/unittests/StringUtilsUnitTests.pas

@@ -811 +811 @@
   END;
 
+
   // -------------------------------------------------------------------
 
 
+  PROCEDURE testStrLeftWithout_Empty;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeftWithout('', 4);
+
+    assertEqualsString('testStrLeftWithout_Empty', '', tmpResult);
+  END;
+
+
+  PROCEDURE testStrLeftWithout_ToBig;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeftWithout('ab', 4);
+
+    assertEqualsString('testStrLeftWithout_ToBig', '', tmpResult);
+  END;
+
+
+  PROCEDURE testStrLeftWithout_Negative;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeftWithout('ab', -1);
+
+    assertEqualsString('testStrLeftWithout_Negative', 'ab', tmpResult);
+  END;
+
+
+  PROCEDURE testStrLeftWithout_All;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeftWithout('abdefg', 6);
+
+    assertEqualsString('testStrLeftWithout_All', '', tmpResult);
+  END;
+
+
+  PROCEDURE testStrLeftWithout;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeftWithout('abdefg', 3);
+
+    assertEqualsString('testStrLeftWithout', 'abd', tmpResult);
+  END;
+
+
+  // -------------------------------------------------------------------
+
+
+  PROCEDURE testStrLeftUntil_Empty;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeftUntil('', ['b', 'x']);
+
+    assertEqualsString('testStrLeftUntil_Empty', '', tmpResult);
+  END;
+
+
+  PROCEDURE testStrLeftUntil_Empty_EmptyDelimiterSet;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeftUntil('', []);
+
+    assertEqualsString('testStrLeftUntil_Empty_EmptyDelimiterSet', '', tmpResult);
+  END;
+
+
+  PROCEDURE testStrLeftUntil_EmptyDelimiterSet;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeftUntil('abc', []);
+
+    assertEqualsString('testStrLeftUntil_EmptyDelimiterSet', 'abc', tmpResult);
+  END;
+
+
+  PROCEDURE testStrLeftUntil_FirstIsDelimiter;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeftUntil('abc', ['a']);
+
+    assertEqualsString('testStrLeftUntil_FirstIsDelimiter', '', tmpResult);
+  END;
+
+
+  PROCEDURE testStrLeftUntil_LastIsDelimiter;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeftUntil('abc', ['c']);
+
+    assertEqualsString('testStrLeftUntil_LastIsDelimiter', 'ab', tmpResult);
+  END;
+
+
+  PROCEDURE testStrLeftUntil_UnusedDelimiter;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeftUntil('abc', ['x']);
+
+    assertEqualsString('testStrLeftUntil_UnusedDelimiter', 'abc', tmpResult);
+  END;
+
+
+  PROCEDURE testStrLeftUntil;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeftUntil('abcx yz do', ['d', ' ']);
+
+    assertEqualsString('testStrLeftUntil', 'abcx', tmpResult);
+  END;
+
+
+  // -------------------------------------------------------------------
+
+
+  PROCEDURE testStrStartsWith_BothEmpty;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWith('', '');
+
+    assertTrue('testStrStartsWith_BothEmpty', tmpResult);
+  END;
+
+
+  PROCEDURE testStrStartsWith_StringEmpty;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWith('', 'end');
+
+    assertFalse('testStrStartsWith_StringEmpty', tmpResult);
+  END;
+
+
+  PROCEDURE testStrStartsWith_MatchEmpty;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWith('test', '');
+
+    assertTrue('testStrStartsWith_MatchEmpty', tmpResult);
+  END;
+
+
+  PROCEDURE testStrStartsWith_StringToShort;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWith('test', 'test1');
+
+    assertFalse('testStrStartsWith_StringToShort', tmpResult);
+  END;
+
+
+  PROCEDURE testStrStartsWith_StringEqualLength;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWith('test', 'best');
+
+    assertFalse('testStrStartsWith_StringEqualLength', tmpResult);
+  END;
+
+
+  PROCEDURE testStrStartsWith_StringEqualLengthMatch;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWith('test', 'test');
+
+    assertTrue('testStrStartsWith_StringEqualLengthMatch', tmpResult);
+  END;
+
+
+  PROCEDURE testStrStartsWith_StringMatch;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWith('this is a simple test', 'this');
+
+    assertTrue('testStrStartsWith_StringMatch', tmpResult);
+  END;
+
+
+  PROCEDURE testStrStartsWith_StringMatchCaseSensitive;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWith('This is a simple test', 'tHis');
+
+    assertFalse('testStrStartsWith_StringMatchCaseSensitive', tmpResult);
+  END;
+
+
+  // -------------------------------------------------------------------
+
+
+  PROCEDURE testStrStartsWithIgnoringCase_BothEmpty;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWithIgnoringCase('', '');
+
+    assertTrue('testStrStartsWithIgnoringCase_BothEmpty', tmpResult);
+  END;
+
+
+  PROCEDURE testStrStartsWithIgnoringCase_StringEmpty;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWithIgnoringCase('', 'end');
+
+    assertFalse('testStrStartsWithIgnoringCase_StringEmpty', tmpResult);
+  END;
+
+
+  PROCEDURE testStrStartsWithIgnoringCase_MatchEmpty;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWithIgnoringCase('test', '');
+
+    assertTrue('testStrStartsWithIgnoringCase_MatchEmpty', tmpResult);
+  END;
+
+
+  PROCEDURE testStrStartsWithIgnoringCase_StringToShort;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWithIgnoringCase('test', 'test1');
+
+    assertFalse('testStrStartsWithIgnoringCase_StringToShort', tmpResult);
+  END;
+
+
+  PROCEDURE testStrStartsWithIgnoringCase_StringEqualLength;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWithIgnoringCase('test', 'best');
+
+    assertFalse('testStrStartsWithIgnoringCase_StringEqualLength', tmpResult);
+  END;
+
+
+  PROCEDURE testStrStartsWithIgnoringCase_StringEqualLengthMatch;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWithIgnoringCase('test', 'test');
+
+    assertTrue('testStrStartsWithIgnoringCase_StringEqualLengthMatch', tmpResult);
+  END;
+
+
+  PROCEDURE testStrStartsWithIgnoringCase_StringMatch;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWithIgnoringCase('This is a simple test', 'This');
+
+    assertTrue('testStrStartsWithIgnoringCase_StringMatch', tmpResult);
+  END;
+
+
+  PROCEDURE testStrStartsWithIgnoringCase_StringMatchCaseInSensitive;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrStartsWithIgnoringCase('ThiS is a simple test', 'THis');
+
+    assertTrue('testStrStartsWithIgnoringCase_StringMatchCaseSensitive', tmpResult);
+  END;
+
+
+  // -------------------------------------------------------------------
+
+
   PROCEDURE testStrEndsWith_BothEmpty;
   VAR
@@ -1022 +1315 @@
     assertEqualsString('testBoolToStr_false', 'False', tmpResult);
   END;
+
+  // ----------------------------------------------------------
+
+
+  PROCEDURE testStrInDoubleQuotes_Empty;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrInDoubleQuotes('');
+
+    assertEqualsString('testStrInDoubleQuotes_Empty', '""', tmpResult);
+  END;
+
+
+  PROCEDURE testStrInDoubleQuotes;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrInDoubleQuotes('abc');
+
+    assertEqualsString('testStrInDoubleQuotes', '"abc"', tmpResult);
+  END;
+
 
   // ----------------------------------------------------------
@@ -1101 +1417 @@
     result.add(@testStrLeft_Part);
 
+    result.add(@testStrLeftWithout_Empty);
+    result.add(@testStrLeftWithout_ToBig);
+    result.add(@testStrLeftWithout_Negative);
+    result.add(@testStrLeftWithout_All);
+    result.add(@testStrLeftWithout);
+
+    result.add(@testStrLeftUntil_Empty);
+    result.add(@testStrLeftUntil_Empty_EmptyDelimiterSet);
+    result.add(@testStrLeftUntil_EmptyDelimiterSet);
+    result.add(@testStrLeftUntil_FirstIsDelimiter);
+    result.add(@testStrLeftUntil_LastIsDelimiter);
+    result.add(@testStrLeftUntil_UnusedDelimiter);
+    result.add(@testStrLeftUntil);
+
+    result.add(@testStrStartsWith_BothEmpty);
+    result.add(@testStrStartsWith_StringEmpty);
+    result.add(@testStrStartsWith_MatchEmpty);
+    result.add(@testStrStartsWith_StringToShort);
+    result.add(@testStrStartsWith_StringEqualLength);
+    result.add(@testStrStartsWith_StringEqualLengthMatch);
+    result.add(@testStrStartsWith_StringMatch);
+    result.add(@testStrStartsWith_StringMatchCaseSensitive);
+
+    result.add(@testStrStartsWithIgnoringCase_BothEmpty);
+    result.add(@testStrStartsWithIgnoringCase_StringEmpty);
+    result.add(@testStrStartsWithIgnoringCase_MatchEmpty);
+    result.add(@testStrStartsWithIgnoringCase_StringToShort);
+    result.add(@testStrStartsWithIgnoringCase_StringEqualLength);
+    result.add(@testStrStartsWithIgnoringCase_StringEqualLengthMatch);
+    result.add(@testStrStartsWithIgnoringCase_StringMatch);
+    result.add(@testStrStartsWithIgnoringCase_StringMatchCaseInSensitive);
+
     result.add(@testStrEndsWith_BothEmpty);
     result.add(@testStrEndsWith_StringEmpty);
@@ -1125 +1473 @@
     result.add(@testBoolToStr_true);
     result.add(@testBoolToStr_false);
+
+    result.add(@testStrInDoubleQuotes_Empty);
+    result.add(@testStrInDoubleQuotes);
   END;