pax_global_header00006660000000000000000000000064131416617440014521gustar00rootroot0000000000000052 comment=43d8699de8106ebb8e0124a32bc4c9e0732191d9 purescript-strings-3.3.1/000077500000000000000000000000001314166174400154145ustar00rootroot00000000000000purescript-strings-3.3.1/.eslintrc.json000066400000000000000000000011111314166174400202020ustar00rootroot00000000000000{ "parserOptions": { "ecmaVersion": 5 }, "extends": "eslint:recommended", "env": { "commonjs": true }, "rules": { "strict": [2, "global"], "block-scoped-var": 2, "consistent-return": 2, "eqeqeq": [2, "smart"], "guard-for-in": 2, "no-caller": 2, "no-extend-native": 2, "no-loop-func": 2, "no-new": 2, "no-param-reassign": 2, "no-return-assign": 2, "no-unused-expressions": 2, "no-use-before-define": 2, "radix": [2, "always"], "indent": [2, 2], "quotes": [2, "double"], "semi": [2, "always"] } } purescript-strings-3.3.1/.gitignore000066400000000000000000000001331314166174400174010ustar00rootroot00000000000000/.* !/.gitignore !/.eslintrc.json !/.travis.yml /bower_components/ /node_modules/ /output/ purescript-strings-3.3.1/.travis.yml000066400000000000000000000013041314166174400175230ustar00rootroot00000000000000language: node_js dist: trusty sudo: required node_js: stable env: - PATH=$HOME/purescript:$PATH install: - TAG=$(wget -q -O - https://github.com/purescript/purescript/releases/latest --server-response --max-redirect 0 2>&1 | sed -n -e 's/.*Location:.*tag\///p') - wget -O $HOME/purescript.tar.gz https://github.com/purescript/purescript/releases/download/$TAG/linux64.tar.gz - tar -xvf $HOME/purescript.tar.gz -C $HOME/ - chmod a+x $HOME/purescript - npm install -g bower - npm install script: - bower install --production - npm run -s build - bower install - npm -s test after_success: - >- test $TRAVIS_TAG && echo $GITHUB_TOKEN | pulp login && echo y | pulp publish --no-push purescript-strings-3.3.1/LICENSE000066400000000000000000000020651314166174400164240ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2014 PureScript Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. purescript-strings-3.3.1/README.md000066400000000000000000000010551314166174400166740ustar00rootroot00000000000000# purescript-strings [![Latest release](http://img.shields.io/github/release/purescript/purescript-strings.svg)](https://github.com/purescript/purescript-strings/releases) [![Build status](https://travis-ci.org/purescript/purescript-strings.svg?branch=master)](https://travis-ci.org/purescript/purescript-strings) String and char utility functions, regular expressions. ## Installation ``` bower install purescript-strings ``` ## Documentation Module documentation is [published on Pursuit](http://pursuit.purescript.org/packages/purescript-strings). purescript-strings-3.3.1/bower.json000066400000000000000000000014071314166174400174270ustar00rootroot00000000000000{ "name": "purescript-strings", "homepage": "https://github.com/purescript/purescript-strings", "description": "String and char utility functions, regular expressions.", "license": "MIT", "repository": { "type": "git", "url": "git://github.com/purescript/purescript-strings.git" }, "ignore": [ "**/.*", "bower_components", "node_modules", "output", "test", "bower.json", "package.json" ], "dependencies": { "purescript-either": "^3.0.0", "purescript-gen": "^1.1.0", "purescript-maybe": "^3.0.0", "purescript-partial": "^1.2.0", "purescript-unfoldable": "^3.0.0", "purescript-arrays": "^4.0.1" }, "devDependencies": { "purescript-assert": "^3.0.0", "purescript-console": "^3.0.0" } } purescript-strings-3.3.1/package.json000066400000000000000000000005001314166174400176750ustar00rootroot00000000000000{ "private": true, "scripts": { "clean": "rimraf output && rimraf .pulp-cache", "build": "eslint src && pulp build -- --censor-lib --strict", "test": "pulp test" }, "devDependencies": { "eslint": "^3.17.1", "pulp": "^10.0.4", "purescript-psa": "^0.5.0-rc.1", "rimraf": "^2.6.1" } } purescript-strings-3.3.1/src/000077500000000000000000000000001314166174400162035ustar00rootroot00000000000000purescript-strings-3.3.1/src/Data/000077500000000000000000000000001314166174400170545ustar00rootroot00000000000000purescript-strings-3.3.1/src/Data/Char.js000066400000000000000000000004311314166174400202650ustar00rootroot00000000000000"use strict"; exports.toCharCode = function (c) { return c.charCodeAt(0); }; exports.fromCharCode = function (c) { return String.fromCharCode(c); }; exports.toLower = function (c) { return c.toLowerCase(); }; exports.toUpper = function (c) { return c.toUpperCase(); }; purescript-strings-3.3.1/src/Data/Char.purs000066400000000000000000000007651314166174400206540ustar00rootroot00000000000000-- | A type and functions for single characters. module Data.Char ( fromCharCode , toCharCode , toLower , toUpper ) where -- | Returns the numeric Unicode value of the character. foreign import toCharCode :: Char -> Int -- | Constructs a character from the given Unicode numeric value. foreign import fromCharCode :: Int -> Char -- | Converts a character to lowercase. foreign import toLower :: Char -> Char -- | Converts a character to uppercase. foreign import toUpper :: Char -> Char purescript-strings-3.3.1/src/Data/Char/000077500000000000000000000000001314166174400177315ustar00rootroot00000000000000purescript-strings-3.3.1/src/Data/Char/Gen.purs000066400000000000000000000024561314166174400213640ustar00rootroot00000000000000module Data.Char.Gen where import Prelude import Control.Monad.Gen (class MonadGen, chooseInt, oneOf) import Data.Char as C import Data.NonEmpty ((:|)) -- | Generates a character of the Unicode basic multilingual plane. genUnicodeChar :: forall m. MonadGen m => m Char genUnicodeChar = C.fromCharCode <$> chooseInt 0 65536 -- | Generates a character in the ASCII character set, excluding control codes. genAsciiChar :: forall m. MonadGen m => m Char genAsciiChar = C.fromCharCode <$> chooseInt 32 127 -- | Generates a character in the ASCII character set. genAsciiChar' :: forall m. MonadGen m => m Char genAsciiChar' = C.fromCharCode <$> chooseInt 0 127 -- | Generates a character that is a numeric digit. genDigitChar :: forall m. MonadGen m => m Char genDigitChar = C.fromCharCode <$> chooseInt 48 57 -- | Generates a character from the basic latin alphabet. genAlpha :: forall m. MonadGen m => m Char genAlpha = oneOf (genAlphaLowercase :| [genAlphaUppercase]) -- | Generates a lowercase character from the basic latin alphabet. genAlphaLowercase :: forall m. MonadGen m => m Char genAlphaLowercase = C.fromCharCode <$> chooseInt 97 122 -- | Generates an uppercase character from the basic latin alphabet. genAlphaUppercase :: forall m. MonadGen m => m Char genAlphaUppercase = C.fromCharCode <$> chooseInt 65 90 purescript-strings-3.3.1/src/Data/String.js000066400000000000000000000070051314166174400206620ustar00rootroot00000000000000"use strict"; exports._charAt = function (just) { return function (nothing) { return function (i) { return function (s) { return i >= 0 && i < s.length ? just(s.charAt(i)) : nothing; }; }; }; }; exports.singleton = function (c) { return c; }; exports._charCodeAt = function (just) { return function (nothing) { return function (i) { return function (s) { return i >= 0 && i < s.length ? just(s.charCodeAt(i)) : nothing; }; }; }; }; exports._toChar = function (just) { return function (nothing) { return function (s) { return s.length === 1 ? just(s) : nothing; }; }; }; exports.fromCharArray = function (a) { return a.join(""); }; exports._indexOf = function (just) { return function (nothing) { return function (x) { return function (s) { var i = s.indexOf(x); return i === -1 ? nothing : just(i); }; }; }; }; exports["_indexOf'"] = function (just) { return function (nothing) { return function (x) { return function (startAt) { return function (s) { if (startAt < 0 || startAt > s.length) return nothing; var i = s.indexOf(x, startAt); return i === -1 ? nothing : just(i); }; }; }; }; }; exports._lastIndexOf = function (just) { return function (nothing) { return function (x) { return function (s) { var i = s.lastIndexOf(x); return i === -1 ? nothing : just(i); }; }; }; }; exports["_lastIndexOf'"] = function (just) { return function (nothing) { return function (x) { return function (startAt) { return function (s) { if (startAt < 0 || startAt > s.length) return nothing; var i = s.lastIndexOf(x, startAt); return i === -1 ? nothing : just(i); }; }; }; }; }; exports.length = function (s) { return s.length; }; exports._localeCompare = function (lt) { return function (eq) { return function (gt) { return function (s1) { return function (s2) { var result = s1.localeCompare(s2); return result < 0 ? lt : result > 0 ? gt : eq; }; }; }; }; }; exports.replace = function (s1) { return function (s2) { return function (s3) { return s3.replace(s1, s2); }; }; }; exports.replaceAll = function (s1) { return function (s2) { return function (s3) { return s3.replace(new RegExp(s1.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&"), "g"), s2); }; }; }; exports.take = function (n) { return function (s) { return s.substr(0, n); }; }; exports.drop = function (n) { return function (s) { return s.substring(n); }; }; exports.count = function (p) { return function (s) { var i = 0; while (i < s.length && p(s.charAt(i))) i++; return i; }; }; exports.split = function (sep) { return function (s) { return s.split(sep); }; }; exports._splitAt = function (just) { return function (nothing) { return function (i) { return function (s) { return i >= 0 && i < s.length ? just({ before: s.substring(0, i), after: s.substring(i) }) : nothing; }; }; }; }; exports.toCharArray = function (s) { return s.split(""); }; exports.toLower = function (s) { return s.toLowerCase(); }; exports.toUpper = function (s) { return s.toUpperCase(); }; exports.trim = function (s) { return s.trim(); }; exports.joinWith = function (s) { return function (xs) { return xs.join(s); }; }; purescript-strings-3.3.1/src/Data/String.purs000066400000000000000000000200061314166174400212330ustar00rootroot00000000000000-- | Wraps the functions of Javascript's `String` object. -- | A String represents a sequence of characters. -- | For details of the underlying implementation, see [String Reference at MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String). module Data.String ( Pattern(..) , Replacement(..) , charAt , charCodeAt , fromCharArray , toChar , contains , indexOf , indexOf' , lastIndexOf , lastIndexOf' , null , uncons , length , singleton , localeCompare , replace , replaceAll , take , takeWhile , drop , dropWhile , stripPrefix , stripSuffix , count , split , splitAt , toCharArray , toLower , toUpper , trim , joinWith ) where import Prelude import Data.Maybe (Maybe(..), isJust) import Data.Newtype (class Newtype) import Data.String.Unsafe as U -- | A newtype used in cases where there is a string to be matched. newtype Pattern = Pattern String derive instance eqPattern :: Eq Pattern derive instance ordPattern :: Ord Pattern derive instance newtypePattern :: Newtype Pattern _ instance showPattern :: Show Pattern where show (Pattern s) = "(Pattern " <> show s <> ")" -- | A newtype used in cases to specify a replacement for a pattern. newtype Replacement = Replacement String derive instance eqReplacement :: Eq Replacement derive instance ordReplacement :: Ord Replacement derive instance newtypeReplacement :: Newtype Replacement _ instance showReplacement :: Show Replacement where show (Replacement s) = "(Replacement " <> show s <> ")" -- | Returns the character at the given index, if the index is within bounds. charAt :: Int -> String -> Maybe Char charAt = _charAt Just Nothing foreign import _charAt :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> Int -> String -> Maybe Char -- | Returns a string of length `1` containing the given character. foreign import singleton :: Char -> String -- | Returns the numeric Unicode value of the character at the given index, -- | if the index is within bounds. charCodeAt :: Int -> String -> Maybe Int charCodeAt = _charCodeAt Just Nothing foreign import _charCodeAt :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> Int -> String -> Maybe Int toChar :: String -> Maybe Char toChar = _toChar Just Nothing foreign import _toChar :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> String -> Maybe Char -- | Returns `true` if the given string is empty. null :: String -> Boolean null s = s == "" -- | Returns the first character and the rest of the string, -- | if the string is not empty. uncons :: String -> Maybe { head :: Char, tail :: String } uncons "" = Nothing uncons s = Just { head: U.charAt zero s, tail: drop one s } -- | Returns the longest prefix (possibly empty) of characters that satisfy -- | the predicate. takeWhile :: (Char -> Boolean) -> String -> String takeWhile p s = take (count p s) s -- | Returns the suffix remaining after `takeWhile`. dropWhile :: (Char -> Boolean) -> String -> String dropWhile p s = drop (count p s) s -- | If the string starts with the given prefix, return the portion of the -- | string left after removing it, as a Just value. Otherwise, return Nothing. -- | * `stripPrefix (Pattern "http:") "http://purescript.org" == Just "//purescript.org"` -- | * `stripPrefix (Pattern "http:") "https://purescript.org" == Nothing` stripPrefix :: Pattern -> String -> Maybe String stripPrefix prefix@(Pattern prefixS) str = case indexOf prefix str of Just 0 -> Just $ drop (length prefixS) str _ -> Nothing -- | If the string ends with the given suffix, return the portion of the -- | string left after removing it, as a Just value. Otherwise, return Nothing. -- | * `stripSuffix (Pattern ".exe") "psc.exe" == Just "psc"` -- | * `stripSuffix (Pattern ".exe") "psc" == Nothing` stripSuffix :: Pattern -> String -> Maybe String stripSuffix suffix@(Pattern suffixS) str = case lastIndexOf suffix str of Just x | x == length str - length suffixS -> Just $ take x str _ -> Nothing -- | Converts an array of characters into a string. foreign import fromCharArray :: Array Char -> String -- | Checks whether the first string exists in the second string. contains :: Pattern -> String -> Boolean contains pat = isJust <<< indexOf pat -- | Returns the index of the first occurrence of the first string in the -- | second string. Returns `Nothing` if there is no match. indexOf :: Pattern -> String -> Maybe Int indexOf = _indexOf Just Nothing foreign import _indexOf :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> Pattern -> String -> Maybe Int -- | Returns the index of the first occurrence of the first string in the -- | second string, starting at the given index. Returns `Nothing` if there is -- | no match. indexOf' :: Pattern -> Int -> String -> Maybe Int indexOf' = _indexOf' Just Nothing foreign import _indexOf' :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> Pattern -> Int -> String -> Maybe Int -- | Returns the index of the last occurrence of the first string in the -- | second string. Returns `Nothing` if there is no match. lastIndexOf :: Pattern -> String -> Maybe Int lastIndexOf = _lastIndexOf Just Nothing foreign import _lastIndexOf :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> Pattern -> String -> Maybe Int -- | Returns the index of the last occurrence of the first string in the -- | second string, starting at the given index. Returns `Nothing` if there is -- | no match. lastIndexOf' :: Pattern -> Int -> String -> Maybe Int lastIndexOf' = _lastIndexOf' Just Nothing foreign import _lastIndexOf' :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> Pattern -> Int -> String -> Maybe Int -- | Returns the number of characters the string is composed of. foreign import length :: String -> Int -- | Locale-aware sort order comparison. localeCompare :: String -> String -> Ordering localeCompare = _localeCompare LT EQ GT foreign import _localeCompare :: Ordering -> Ordering -> Ordering -> String -> String -> Ordering -- | Replaces the first occurence of the first argument with the second argument. foreign import replace :: Pattern -> Replacement -> String -> String -- | Replaces all occurences of the first argument with the second argument. foreign import replaceAll :: Pattern -> Replacement -> String -> String -- | Returns the first `n` characters of the string. foreign import take :: Int -> String -> String -- | Returns the string without the first `n` characters. foreign import drop :: Int -> String -> String -- | Returns the number of contiguous characters at the beginning -- | of the string for which the predicate holds. foreign import count :: (Char -> Boolean) -> String -> Int -- | Returns the substrings of the second string separated along occurences -- | of the first string. -- | * `split (Pattern " ") "hello world" == ["hello", "world"]` foreign import split :: Pattern -> String -> Array String -- | Returns the substrings of split at the given index, if the index is within bounds. splitAt :: Int -> String -> Maybe { before :: String, after :: String } splitAt = _splitAt Just Nothing foreign import _splitAt :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> Int -> String -> Maybe { before :: String, after :: String } -- | Converts the string into an array of characters. foreign import toCharArray :: String -> Array Char -- | Returns the argument converted to lowercase. foreign import toLower :: String -> String -- | Returns the argument converted to uppercase. foreign import toUpper :: String -> String -- | Removes whitespace from the beginning and end of a string, including -- | [whitespace characters](http://www.ecma-international.org/ecma-262/5.1/#sec-7.2) -- | and [line terminators](http://www.ecma-international.org/ecma-262/5.1/#sec-7.3). foreign import trim :: String -> String -- | Joins the strings in the array together, inserting the first argument -- | as separator between them. foreign import joinWith :: String -> Array String -> String purescript-strings-3.3.1/src/Data/String/000077500000000000000000000000001314166174400203225ustar00rootroot00000000000000purescript-strings-3.3.1/src/Data/String/CaseInsensitiveString.purs000066400000000000000000000014611314166174400255220ustar00rootroot00000000000000module Data.String.CaseInsensitive where import Prelude import Data.Newtype (class Newtype) import Data.String (toLower) -- | A newtype for case insensitive string comparisons and ordering. newtype CaseInsensitiveString = CaseInsensitiveString String instance eqCaseInsensitiveString :: Eq CaseInsensitiveString where eq (CaseInsensitiveString s1) (CaseInsensitiveString s2) = toLower s1 == toLower s2 instance ordCaseInsensitiveString :: Ord CaseInsensitiveString where compare (CaseInsensitiveString s1) (CaseInsensitiveString s2) = compare (toLower s1) (toLower s2) instance showCaseInsensitiveString :: Show CaseInsensitiveString where show (CaseInsensitiveString s) = "(CaseInsensitiveString " <> show s <> ")" derive instance newtypeCaseInsensitiveString :: Newtype CaseInsensitiveString _ purescript-strings-3.3.1/src/Data/String/CodePoints.js000066400000000000000000000056701314166174400227370ustar00rootroot00000000000000"use strict"; /* global Symbol */ var hasArrayFrom = typeof Array.from === "function"; var hasStringIterator = typeof Symbol !== "undefined" && Symbol != null && typeof Symbol.iterator !== "undefined" && typeof String.prototype[Symbol.iterator] === "function"; var hasFromCodePoint = typeof String.prototype.fromCodePoint === "function"; var hasCodePointAt = typeof String.prototype.codePointAt === "function"; exports._unsafeCodePointAt0 = function (fallback) { return hasCodePointAt ? function (str) { return str.codePointAt(0); } : fallback; }; exports._codePointAt = function (fallback) { return function (Just) { return function (Nothing) { return function (unsafeCodePointAt0) { return function (index) { return function (str) { var length = str.length; if (index < 0 || index >= length) return Nothing; if (hasStringIterator) { var iter = str[Symbol.iterator](); for (var i = index;; --i) { var o = iter.next(); if (o.done) return Nothing; if (i === 0) return Just(unsafeCodePointAt0(o.value)); } } return fallback(index)(str); }; }; }; }; }; }; exports._count = function (fallback) { return function (unsafeCodePointAt0) { if (hasStringIterator) { return function (pred) { return function (str) { var iter = str[Symbol.iterator](); for (var cpCount = 0; ; ++cpCount) { var o = iter.next(); if (o.done) return cpCount; var cp = unsafeCodePointAt0(o.value); if (!pred(cp)) return cpCount; } }; }; } return fallback; }; }; exports._fromCodePointArray = function (singleton) { return hasFromCodePoint ? function (cps) { // Function.prototype.apply will fail for very large second parameters, // so we don't use it for arrays with 10,000 or more entries. if (cps.length < 10e3) { return String.fromCodePoint.apply(String, cps); } return cps.map(singleton).join(""); } : function (cps) { return cps.map(singleton).join(""); }; }; exports._singleton = function (fallback) { return hasFromCodePoint ? String.fromCodePoint : fallback; }; exports._take = function (fallback) { return function (n) { if (hasStringIterator) { return function (str) { var accum = ""; var iter = str[Symbol.iterator](); for (var i = 0; i < n; ++i) { var o = iter.next(); if (o.done) return accum; accum += o.value; } return accum; }; } return fallback(n); }; }; exports._toCodePointArray = function (fallback) { return function (unsafeCodePointAt0) { if (hasArrayFrom) { return function (str) { return Array.from(str, unsafeCodePointAt0); }; } return fallback; }; }; purescript-strings-3.3.1/src/Data/String/CodePoints.purs000066400000000000000000000240341314166174400233070ustar00rootroot00000000000000-- | These functions allow PureScript strings to be treated as if they were -- | sequences of Unicode code points instead of their true underlying -- | implementation (sequences of UTF-16 code units). For nearly all uses of -- | strings, these functions should be preferred over the ones in Data.String. module Data.String.CodePoints ( module StringReExports , CodePoint() , codePointAt , codePointFromInt , codePointToInt , count , drop , dropWhile , fromCodePointArray , indexOf , indexOf' , lastIndexOf , lastIndexOf' , length , singleton , splitAt , take , takeWhile , toCodePointArray , uncons ) where import Prelude import Data.Array as Array import Data.Char as Char import Data.Maybe (Maybe(Just, Nothing)) import Data.String as String import Data.String.Unsafe as Unsafe -- WARN: If a new function is added to Data.String, a version of that function -- should be exported from this module, which should be the same except that it -- should operate on the code point level rather than the code unit level. If -- the function's behaviour does not change based on whether we consider -- strings as sequences of code points or code units, it can simply be -- re-exported from Data.String. import Data.String (Pattern(..), Replacement(..), charAt, charCodeAt, contains, fromCharArray, joinWith, localeCompare, null, replace, replaceAll, split, stripPrefix, stripSuffix, toChar, toCharArray, toLower, toUpper, trim) as StringReExports import Data.Tuple (Tuple(Tuple)) import Data.Unfoldable (unfoldr) -- | CodePoint is an Int bounded between 0 and 0x10FFFF, corresponding to -- | Unicode code points. newtype CodePoint = CodePoint Int derive instance eqCodePoint :: Eq CodePoint derive instance ordCodePoint :: Ord CodePoint -- I would prefer that this smart constructor not need to exist and instead -- CodePoint just implements Enum, but the Enum module already depends on this -- one. To avoid the circular dependency, we just expose these two functions. codePointFromInt :: Int -> Maybe CodePoint codePointFromInt n | 0 <= n && n <= 0x10FFFF = Just (CodePoint n) codePointFromInt n = Nothing codePointToInt :: CodePoint -> Int codePointToInt (CodePoint n) = n unsurrogate :: Int -> Int -> CodePoint unsurrogate lead trail = CodePoint ((lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000) isLead :: Int -> Boolean isLead cu = 0xD800 <= cu && cu <= 0xDBFF isTrail :: Int -> Boolean isTrail cu = 0xDC00 <= cu && cu <= 0xDFFF fromCharCode :: Int -> String fromCharCode = String.singleton <<< Char.fromCharCode -- WARN: this function expects the String parameter to be non-empty unsafeCodePointAt0 :: String -> CodePoint unsafeCodePointAt0 = _unsafeCodePointAt0 unsafeCodePointAt0Fallback foreign import _unsafeCodePointAt0 :: (String -> CodePoint) -> String -> CodePoint unsafeCodePointAt0Fallback :: String -> CodePoint unsafeCodePointAt0Fallback s = let cu0 = Unsafe.charCodeAt 0 s in let cu1 = Unsafe.charCodeAt 1 s in if isLead cu0 && isTrail cu1 then unsurrogate cu0 cu1 else CodePoint cu0 -- | Returns the first code point of the string after dropping the given number -- | of code points from the beginning, if there is such a code point. Operates -- | in constant space and in time linear to the given index. codePointAt :: Int -> String -> Maybe CodePoint codePointAt n _ | n < 0 = Nothing codePointAt 0 "" = Nothing codePointAt 0 s = Just (unsafeCodePointAt0 s) codePointAt n s = _codePointAt codePointAtFallback Just Nothing unsafeCodePointAt0 n s foreign import _codePointAt :: (Int -> String -> Maybe CodePoint) -> (forall a. a -> Maybe a) -> (forall a. Maybe a) -> (String -> CodePoint) -> Int -> String -> Maybe CodePoint codePointAtFallback :: Int -> String -> Maybe CodePoint codePointAtFallback n s = case uncons s of Just { head, tail } -> if n == 0 then Just head else codePointAtFallback (n - 1) tail _ -> Nothing -- | Returns the number of code points in the leading sequence of code points -- | which all match the given predicate. Operates in constant space and in -- | time linear to the length of the string. count :: (CodePoint -> Boolean) -> String -> Int count = _count countFallback unsafeCodePointAt0 foreign import _count :: ((CodePoint -> Boolean) -> String -> Int) -> (String -> CodePoint) -> (CodePoint -> Boolean) -> String -> Int countFallback :: (CodePoint -> Boolean) -> String -> Int countFallback p s = countTail p s 0 countTail :: (CodePoint -> Boolean) -> String -> Int -> Int countTail p s accum = case uncons s of Just { head, tail } -> if p head then countTail p tail (accum + 1) else accum _ -> accum -- | Drops the given number of code points from the beginning of the string. If -- | the string does not have that many code points, returns the empty string. -- | Operates in constant space and in time linear to the given number. drop :: Int -> String -> String drop n s = String.drop (String.length (take n s)) s -- | Drops the leading sequence of code points which all match the given -- | predicate from the string. Operates in constant space and in time linear -- | to the length of the string. dropWhile :: (CodePoint -> Boolean) -> String -> String dropWhile p s = drop (count p s) s -- | Creates a string from an array of code points. Operates in space and time -- | linear to the length of the array. fromCodePointArray :: Array CodePoint -> String fromCodePointArray = _fromCodePointArray singletonFallback foreign import _fromCodePointArray :: (CodePoint -> String) -> Array CodePoint -> String -- | Returns the number of code points preceding the first match of the given -- | pattern in the string. Returns Nothing when no matches are found. indexOf :: String.Pattern -> String -> Maybe Int indexOf p s = (\i -> length (String.take i s)) <$> String.indexOf p s -- | Returns the number of code points preceding the first match of the given -- | pattern in the string. Pattern matches preceding the given index will be -- | ignored. Returns Nothing when no matches are found. indexOf' :: String.Pattern -> Int -> String -> Maybe Int indexOf' p i s = let s' = drop i s in (\k -> i + length (String.take k s')) <$> String.indexOf p s' -- | Returns the number of code points preceding the last match of the given -- | pattern in the string. Returns Nothing when no matches are found. lastIndexOf :: String.Pattern -> String -> Maybe Int lastIndexOf p s = (\i -> length (String.take i s)) <$> String.lastIndexOf p s -- | Returns the number of code points preceding the first match of the given -- | pattern in the string. Pattern matches following the given index will be -- | ignored. Returns Nothing when no matches are found. lastIndexOf' :: String.Pattern -> Int -> String -> Maybe Int lastIndexOf' p i s = let i' = String.length (take i s) in (\k -> length (String.take k s)) <$> String.lastIndexOf' p i' s -- | Returns the number of code points in the string. Operates in constant -- | space and in time linear to the length of the string. length :: String -> Int length = Array.length <<< toCodePointArray -- | Creates a string containing just the given code point. Operates in -- | constant space and time. singleton :: CodePoint -> String singleton = _singleton singletonFallback foreign import _singleton :: (CodePoint -> String) -> CodePoint -> String singletonFallback :: CodePoint -> String singletonFallback (CodePoint cp) | cp <= 0xFFFF = fromCharCode cp singletonFallback (CodePoint cp) = let lead = ((cp - 0x10000) / 0x400) + 0xD800 in let trail = (cp - 0x10000) `mod` 0x400 + 0xDC00 in fromCharCode lead <> fromCharCode trail -- | Returns a record with strings created from the code points on either side -- | of the given index. If the index is not within the string, Nothing is -- | returned. splitAt :: Int -> String -> Maybe { before :: String, after :: String } splitAt i s = let cps = toCodePointArray s in if i < 0 || Array.length cps < i then Nothing else Just { before: fromCodePointArray (Array.take i cps), after: fromCodePointArray (Array.drop i cps) } -- | Returns a string containing the given number of code points from the -- | beginning of the given string. If the string does not have that many code -- | points, returns the empty string. Operates in constant space and in time -- | linear to the given number. take :: Int -> String -> String take = _take takeFallback foreign import _take :: (Int -> String -> String) -> Int -> String -> String takeFallback :: Int -> String -> String takeFallback n _ | n < 1 = "" takeFallback n s = case uncons s of Just { head, tail } -> singleton head <> takeFallback (n - 1) tail _ -> s -- | Returns a string containing the leading sequence of code points which all -- | match the given predicate from the string. Operates in constant space and -- | in time linear to the length of the string. takeWhile :: (CodePoint -> Boolean) -> String -> String takeWhile p s = take (count p s) s -- | Creates an array of code points from a string. Operates in space and time -- | linear to the length of the string. toCodePointArray :: String -> Array CodePoint toCodePointArray = _toCodePointArray toCodePointArrayFallback unsafeCodePointAt0 foreign import _toCodePointArray :: (String -> Array CodePoint) -> (String -> CodePoint) -> String -> Array CodePoint toCodePointArrayFallback :: String -> Array CodePoint toCodePointArrayFallback s = unfoldr unconsButWithTuple s unconsButWithTuple :: String -> Maybe (Tuple CodePoint String) unconsButWithTuple s = (\{ head, tail } -> Tuple head tail) <$> uncons s -- | Returns a record with the first code point and the remaining code points -- | of the string. Returns Nothing if the string is empty. Operates in -- | constant space and time. uncons :: String -> Maybe { head :: CodePoint, tail :: String } uncons s = case String.length s of 0 -> Nothing 1 -> Just { head: CodePoint (Unsafe.charCodeAt 0 s), tail: "" } _ -> let cu0 = Unsafe.charCodeAt 0 s in let cu1 = Unsafe.charCodeAt 1 s in if isLead cu0 && isTrail cu1 then Just { head: unsurrogate cu0 cu1, tail: String.drop 2 s } else Just { head: CodePoint cu0, tail: String.drop 1 s } purescript-strings-3.3.1/src/Data/String/Gen.purs000066400000000000000000000023071314166174400217500ustar00rootroot00000000000000module Data.String.Gen where import Prelude import Control.Monad.Gen (class MonadGen, chooseInt, unfoldable, sized, resize) import Control.Monad.Rec.Class (class MonadRec) import Data.Char.Gen as CG import Data.String as S -- | Generates a string using the specified character generator. genString :: forall m. MonadRec m => MonadGen m => m Char -> m String genString genChar = sized \size -> do newSize <- chooseInt 1 (max 1 size) resize (const newSize) $ S.fromCharArray <$> unfoldable genChar -- | Generates a string using characters from the Unicode basic multilingual -- | plain. genUnicodeString :: forall m. MonadRec m => MonadGen m => m String genUnicodeString = genString CG.genUnicodeChar -- | Generates a string using the ASCII character set, excluding control codes. genAsciiString :: forall m. MonadRec m => MonadGen m => m String genAsciiString = genString CG.genAsciiChar -- | Generates a string using the ASCII character set. genAsciiString' :: forall m. MonadRec m => MonadGen m => m String genAsciiString' = genString CG.genAsciiChar' -- | Generates a string made up of numeric digits. genDigitString :: forall m. MonadRec m => MonadGen m => m String genDigitString = genString CG.genDigitChar purescript-strings-3.3.1/src/Data/String/Regex.js000066400000000000000000000035331314166174400217360ustar00rootroot00000000000000"use strict"; exports["showRegex'"] = function (r) { return "" + r; }; exports["regex'"] = function (left) { return function (right) { return function (s1) { return function (s2) { try { return right(new RegExp(s1, s2)); } catch (e) { return left(e.message); } }; }; }; }; exports.source = function (r) { return r.source; }; exports["flags'"] = function (r) { return { multiline: r.multiline, ignoreCase: r.ignoreCase, global: r.global, sticky: !!r.sticky, unicode: !!r.unicode }; }; exports.test = function (r) { return function (s) { var lastIndex = r.lastIndex; var result = r.test(s); r.lastIndex = lastIndex; return result; }; }; exports._match = function (just) { return function (nothing) { return function (r) { return function (s) { var m = s.match(r); if (m == null) { return nothing; } else { var list = []; for (var i = 0; i < m.length; i++) { list.push(m[i] == null ? nothing : just(m[i])); } return just(list); } }; }; }; }; exports.replace = function (r) { return function (s1) { return function (s2) { return s2.replace(r, s1); }; }; }; exports["replace'"] = function (r) { return function (f) { return function (s2) { return s2.replace(r, function (match) { return f(match)(Array.prototype.splice.call(arguments, 1, arguments.length - 3)); }); }; }; }; exports._search = function (just) { return function (nothing) { return function (r) { return function (s) { var result = s.search(r); return result === -1 ? nothing : just(result); }; }; }; }; exports.split = function (r) { return function (s) { return s.split(r); }; }; purescript-strings-3.3.1/src/Data/String/Regex.purs000066400000000000000000000100541314166174400223070ustar00rootroot00000000000000-- | Wraps Javascript's `RegExp` object that enables matching strings with -- | patternes defined by regular expressions. -- | For details of the underlying implementation, see [RegExp Reference at MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp). module Data.String.Regex ( Regex(..) , regex , source , flags , renderFlags , parseFlags , test , match , replace , replace' , search , split ) where import Prelude import Data.Either (Either(..)) import Data.Maybe (Maybe(..)) import Data.String (Pattern(..), contains) import Data.String.Regex.Flags (RegexFlags(..), RegexFlagsRec) -- | Wraps Javascript `RegExp` objects. foreign import data Regex :: Type foreign import showRegex' :: Regex -> String instance showRegex :: Show Regex where show = showRegex' foreign import regex' :: (String -> Either String Regex) -> (Regex -> Either String Regex) -> String -> String -> Either String Regex -- | Constructs a `Regex` from a pattern string and flags. Fails with -- | `Left error` if the pattern contains a syntax error. regex :: String -> RegexFlags -> Either String Regex regex s f = regex' Left Right s $ renderFlags f -- | Returns the pattern string used to construct the given `Regex`. foreign import source :: Regex -> String -- | Returns the `RegexFlags` used to construct the given `Regex`. flags :: Regex -> RegexFlags flags = RegexFlags <<< flags' -- | Returns the `RegexFlags` inner record used to construct the given `Regex`. foreign import flags' :: Regex -> RegexFlagsRec -- | Returns the string representation of the given `RegexFlags`. renderFlags :: RegexFlags -> String renderFlags (RegexFlags f) = (if f.global then "g" else "") <> (if f.ignoreCase then "i" else "") <> (if f.multiline then "m" else "") <> (if f.sticky then "y" else "") <> (if f.unicode then "u" else "") -- | Parses the string representation of `RegexFlags`. parseFlags :: String -> RegexFlags parseFlags s = RegexFlags { global: contains (Pattern "g") s , ignoreCase: contains (Pattern "i") s , multiline: contains (Pattern "m") s , sticky: contains (Pattern "y") s , unicode: contains (Pattern "u") s } -- | Returns `true` if the `Regex` matches the string. In contrast to -- | `RegExp.prototype.test()` in JavaScript, `test` does not affect -- | the `lastIndex` property of the Regex. foreign import test :: Regex -> String -> Boolean foreign import _match :: (forall r. r -> Maybe r) -> (forall r. Maybe r) -> Regex -> String -> Maybe (Array (Maybe String)) -- | Matches the string against the `Regex` and returns an array of matches -- | if there were any. Each match has type `Maybe String`, where `Nothing` -- | represents an unmatched optional capturing group. -- | See [reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match). match :: Regex -> String -> Maybe (Array (Maybe String)) match = _match Just Nothing -- | Replaces occurences of the `Regex` with the first string. The replacement -- | string can include special replacement patterns escaped with `"$"`. -- | See [reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace). foreign import replace :: Regex -> String -> String -> String -- | Transforms occurences of the `Regex` using a function of the matched -- | substring and a list of submatch strings. -- | See the [reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#Specifying_a_function_as_a_parameter). foreign import replace' :: Regex -> (String -> Array String -> String) -> String -> String foreign import _search :: (forall r. r -> Maybe r) -> (forall r. Maybe r) -> Regex -> String -> Maybe Int -- | Returns `Just` the index of the first match of the `Regex` in the string, -- | or `Nothing` if there is no match. search :: Regex -> String -> Maybe Int search = _search Just Nothing -- | Split the string into an array of substrings along occurences of the `Regex`. foreign import split :: Regex -> String -> Array String purescript-strings-3.3.1/src/Data/String/Regex/000077500000000000000000000000001314166174400213745ustar00rootroot00000000000000purescript-strings-3.3.1/src/Data/String/Regex/Flags.purs000066400000000000000000000047531314166174400233540ustar00rootroot00000000000000module Data.String.Regex.Flags where import Prelude import Control.MonadPlus (guard) import Data.Monoid (class Monoid) import Data.String (joinWith) type RegexFlagsRec = { global :: Boolean , ignoreCase :: Boolean , multiline :: Boolean , sticky :: Boolean , unicode :: Boolean } -- | Flags that control matching. data RegexFlags = RegexFlags RegexFlagsRec -- | All flags set to false. noFlags :: RegexFlags noFlags = RegexFlags { global: false , ignoreCase: false , multiline: false , sticky: false , unicode: false } -- | Only global flag set to true global :: RegexFlags global = RegexFlags { global: true , ignoreCase: false , multiline: false , sticky: false , unicode: false } -- | Only ignoreCase flag set to true ignoreCase :: RegexFlags ignoreCase = RegexFlags { global: false , ignoreCase: true , multiline: false , sticky: false , unicode: false } -- | Only multiline flag set to true multiline :: RegexFlags multiline = RegexFlags { global: false , ignoreCase: false , multiline: true , sticky: false , unicode: false } -- | Only sticky flag set to true sticky :: RegexFlags sticky = RegexFlags { global: false , ignoreCase: false , multiline: false , sticky: true , unicode: false } -- | Only unicode flag set to true unicode :: RegexFlags unicode = RegexFlags { global: false , ignoreCase: false , multiline: false , sticky: false , unicode: true } instance semigroupRegexFlags :: Semigroup RegexFlags where append (RegexFlags x) (RegexFlags y) = RegexFlags { global: x.global || y.global , ignoreCase: x.ignoreCase || y.ignoreCase , multiline: x.multiline || y.multiline , sticky: x.sticky || y.sticky , unicode: x.unicode || y.unicode } instance monoidRegexFlags :: Monoid RegexFlags where mempty = noFlags instance eqRegexFlags :: Eq RegexFlags where eq (RegexFlags x) (RegexFlags y) = x.global == y.global && x.ignoreCase == y.ignoreCase && x.multiline == y.multiline && x.sticky == y.sticky && x.unicode == y.unicode instance showRegexFlags :: Show RegexFlags where show (RegexFlags flags) = let usedFlags = [] <> (guard flags.global $> "global") <> (guard flags.ignoreCase $> "ignoreCase") <> (guard flags.multiline $> "multiline") <> (guard flags.sticky $> "sticky") <> (guard flags.unicode $> "unicode") in if usedFlags == [] then "noFlags" else "(" <> joinWith " <> " usedFlags <> ")" purescript-strings-3.3.1/src/Data/String/Regex/Unsafe.purs000066400000000000000000000007031314166174400235300ustar00rootroot00000000000000module Data.String.Regex.Unsafe ( unsafeRegex ) where import Data.Either (fromRight) import Data.String.Regex (Regex, regex) import Data.String.Regex.Flags (RegexFlags) import Partial.Unsafe (unsafePartial) -- | Constructs a `Regex` from a pattern string and flags. Fails with -- | an exception if the pattern contains a syntax error. unsafeRegex :: String -> RegexFlags -> Regex unsafeRegex s f = unsafePartial fromRight (regex s f) purescript-strings-3.3.1/src/Data/String/Unsafe.js000066400000000000000000000010401314166174400220740ustar00rootroot00000000000000"use strict"; exports.charCodeAt = function (i) { return function (s) { if (i >= 0 && i < s.length) return s.charCodeAt(i); throw new Error("Data.String.Unsafe.charCodeAt: Invalid index."); }; }; exports.charAt = function (i) { return function (s) { if (i >= 0 && i < s.length) return s.charAt(i); throw new Error("Data.String.Unsafe.charAt: Invalid index."); }; }; exports.char = function (s) { if (s.length === 1) return s.charAt(0); throw new Error("Data.String.Unsafe.char: Expected string of length 1."); }; purescript-strings-3.3.1/src/Data/String/Unsafe.purs000066400000000000000000000012161314166174400224560ustar00rootroot00000000000000-- | Unsafe string and character functions. module Data.String.Unsafe ( char , charAt , charCodeAt ) where -- | Returns the numeric Unicode value of the character at the given index. -- | -- | **Unsafe:** throws runtime exception if the index is out of bounds. foreign import charCodeAt :: Int -> String -> Int -- | Returns the character at the given index. -- | -- | **Unsafe:** throws runtime exception if the index is out of bounds. foreign import charAt :: Int -> String -> Char -- | Converts a string of length `1` to a character. -- | -- | **Unsafe:** throws runtime exception if length is not `1`. foreign import char :: String -> Char purescript-strings-3.3.1/test/000077500000000000000000000000001314166174400163735ustar00rootroot00000000000000purescript-strings-3.3.1/test/Test/000077500000000000000000000000001314166174400173125ustar00rootroot00000000000000purescript-strings-3.3.1/test/Test/Data/000077500000000000000000000000001314166174400201635ustar00rootroot00000000000000purescript-strings-3.3.1/test/Test/Data/Char.purs000066400000000000000000000011771314166174400217610ustar00rootroot00000000000000module Test.Data.Char (testChar) where import Prelude (Unit, (==), ($), discard) import Control.Monad.Eff (Eff) import Control.Monad.Eff.Console (CONSOLE, log) import Data.Char import Test.Assert (ASSERT, assert) testChar :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit testChar = do log "toCharCode" assert $ toCharCode 'a' == 97 assert $ toCharCode '\n' == 10 log "fromCharCode" assert $ fromCharCode 97 == 'a' assert $ fromCharCode 10 == '\n' log "toLower" assert $ toLower 'A' == 'a' assert $ toLower 'a' == 'a' log "toUpper" assert $ toUpper 'a' == 'A' assert $ toUpper 'A' == 'A' purescript-strings-3.3.1/test/Test/Data/String.purs000066400000000000000000000141171314166174400223500ustar00rootroot00000000000000module Test.Data.String (testString) where import Prelude (Unit, Ordering(..), (==), ($), discard, negate, not, (/=), (&&)) import Control.Monad.Eff (Eff) import Control.Monad.Eff.Console (CONSOLE, log) import Data.Maybe (Maybe(..), isNothing, maybe) import Data.String import Test.Assert (ASSERT, assert) testString :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit testString = do log "charAt" assert $ charAt 0 "" == Nothing assert $ charAt 0 "a" == Just 'a' assert $ charAt 1 "a" == Nothing assert $ charAt 0 "ab" == Just 'a' assert $ charAt 1 "ab" == Just 'b' assert $ charAt 2 "ab" == Nothing log "singleton" assert $ singleton 'a' == "a" log "charCodeAt" assert $ charCodeAt 0 "" == Nothing assert $ charCodeAt 0 "a" == Just 97 assert $ charCodeAt 1 "a" == Nothing assert $ charCodeAt 0 "ab" == Just 97 assert $ charCodeAt 1 "ab" == Just 98 assert $ charCodeAt 2 "ab" == Nothing log "toChar" assert $ toChar "" == Nothing assert $ toChar "a" == Just 'a' assert $ toChar "ab" == Nothing log "null" assert $ null "" assert $ not (null "a") log "uncons" assert $ isNothing (uncons "") assert $ case uncons "a" of Nothing -> false Just m -> m.head == 'a' && m.tail == "" assert $ case uncons "ab" of Nothing -> false Just m -> m.head == 'a' && m.tail == "b" log "takeWhile" assert $ takeWhile (\c -> true) "abc" == "abc" assert $ takeWhile (\c -> false) "abc" == "" assert $ takeWhile (\c -> c /= 'b') "aabbcc" == "aa" log "dropWhile" assert $ dropWhile (\c -> true) "abc" == "" assert $ dropWhile (\c -> false) "abc" == "abc" assert $ dropWhile (\c -> c /= 'b') "aabbcc" == "bbcc" log "stripPrefix" assert $ stripPrefix (Pattern "") "" == Just "" assert $ stripPrefix (Pattern "") "abc" == Just "abc" assert $ stripPrefix (Pattern "a") "abc" == Just "bc" assert $ stripPrefix (Pattern "!") "abc" == Nothing assert $ stripPrefix (Pattern "!") "" == Nothing log "fromCharArray" assert $ fromCharArray [] == "" assert $ fromCharArray ['a', 'b'] == "ab" log "contains" assert $ contains (Pattern "") "" assert $ contains (Pattern "") "abcd" assert $ contains (Pattern "bc") "abcd" assert $ not (contains (Pattern "cb") "abcd") log "indexOf" assert $ indexOf (Pattern "") "" == Just 0 assert $ indexOf (Pattern "") "abcd" == Just 0 assert $ indexOf (Pattern "bc") "abcd" == Just 1 assert $ indexOf (Pattern "cb") "abcd" == Nothing log "indexOf'" assert $ indexOf' (Pattern "") 0 "" == Just 0 assert $ indexOf' (Pattern "") (-1) "ab" == Nothing assert $ indexOf' (Pattern "") 0 "ab" == Just 0 assert $ indexOf' (Pattern "") 1 "ab" == Just 1 assert $ indexOf' (Pattern "") 2 "ab" == Just 2 assert $ indexOf' (Pattern "") 3 "ab" == Nothing assert $ indexOf' (Pattern "bc") 0 "abcd" == Just 1 assert $ indexOf' (Pattern "bc") 1 "abcd" == Just 1 assert $ indexOf' (Pattern "bc") 2 "abcd" == Nothing assert $ indexOf' (Pattern "cb") 0 "abcd" == Nothing log "lastIndexOf" assert $ lastIndexOf (Pattern "") "" == Just 0 assert $ lastIndexOf (Pattern "") "abcd" == Just 4 assert $ lastIndexOf (Pattern "bc") "abcd" == Just 1 assert $ lastIndexOf (Pattern "cb") "abcd" == Nothing log "lastIndexOf'" assert $ lastIndexOf' (Pattern "") 0 "" == Just 0 assert $ lastIndexOf' (Pattern "") (-1) "ab" == Nothing assert $ lastIndexOf' (Pattern "") 0 "ab" == Just 0 assert $ lastIndexOf' (Pattern "") 1 "ab" == Just 1 assert $ lastIndexOf' (Pattern "") 2 "ab" == Just 2 assert $ lastIndexOf' (Pattern "") 3 "ab" == Nothing assert $ lastIndexOf' (Pattern "bc") 0 "abcd" == Nothing assert $ lastIndexOf' (Pattern "bc") 1 "abcd" == Just 1 assert $ lastIndexOf' (Pattern "bc") 2 "abcd" == Just 1 assert $ lastIndexOf' (Pattern "cb") 0 "abcd" == Nothing log "length" assert $ length "" == 0 assert $ length "a" == 1 assert $ length "ab" == 2 log "localeCompare" assert $ localeCompare "" "" == EQ assert $ localeCompare "a" "a" == EQ assert $ localeCompare "a" "b" == LT assert $ localeCompare "b" "a" == GT log "replace" assert $ replace (Pattern "b") (Replacement "") "abc" == "ac" assert $ replace (Pattern "b") (Replacement "!") "abc" == "a!c" assert $ replace (Pattern "d") (Replacement "!") "abc" == "abc" log "replaceAll" assert $ replaceAll (Pattern "b") (Replacement "") "abbbbbc" == "ac" assert $ replaceAll (Pattern "[b]") (Replacement "!") "a[b]c" == "a!c" log "take" assert $ take 0 "ab" == "" assert $ take 1 "ab" == "a" assert $ take 2 "ab" == "ab" assert $ take 3 "ab" == "ab" assert $ take (-1) "ab" == "" log "drop" assert $ drop 0 "ab" == "ab" assert $ drop 1 "ab" == "b" assert $ drop 2 "ab" == "" assert $ drop 3 "ab" == "" assert $ drop (-1) "ab" == "ab" log "count" assert $ count (_ == 'a') "" == 0 assert $ count (_ == 'a') "ab" == 1 assert $ count (_ == 'a') "aaab" == 3 assert $ count (_ == 'a') "abaa" == 1 log "split" assert $ split (Pattern "") "" == [] assert $ split (Pattern "") "a" == ["a"] assert $ split (Pattern "") "ab" == ["a", "b"] assert $ split (Pattern "b") "aabcc" == ["aa", "cc"] assert $ split (Pattern "d") "abc" == ["abc"] log "splitAt" let testSplitAt i str res = assert $ case splitAt i str of Nothing -> isNothing res Just { before, after } -> maybe false (\r -> r.before == before && r.after == after) res testSplitAt 1 "" Nothing testSplitAt 0 "a" $ Just {before: "", after: "a"} testSplitAt 1 "ab" $ Just {before: "a", after: "b"} testSplitAt 3 "aabcc" $ Just {before: "aab", after: "cc"} testSplitAt (-1) "abc" $ Nothing log "toCharArray" assert $ toCharArray "" == [] assert $ toCharArray "a" == ['a'] assert $ toCharArray "ab" == ['a', 'b'] log "toLower" assert $ toLower "bAtMaN" == "batman" log "toUpper" assert $ toUpper "bAtMaN" == "BATMAN" log "trim" assert $ trim " abc " == "abc" log "joinWith" assert $ joinWith "" [] == "" assert $ joinWith "" ["a", "b"] == "ab" assert $ joinWith "--" ["a", "b", "c"] == "a--b--c" purescript-strings-3.3.1/test/Test/Data/String/000077500000000000000000000000001314166174400214315ustar00rootroot00000000000000purescript-strings-3.3.1/test/Test/Data/String/CaseInsensitive.purs000066400000000000000000000011501314166174400254350ustar00rootroot00000000000000module Test.Data.String.CaseInsensitive (testCaseInsensitiveString) where import Prelude (Unit, (==), ($), discard, compare, Ordering(..)) import Control.Monad.Eff (Eff) import Control.Monad.Eff.Console (CONSOLE, log) import Data.String.CaseInsensitive import Test.Assert (ASSERT, assert) testCaseInsensitiveString :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit testCaseInsensitiveString = do log "equality" assert $ CaseInsensitiveString "aB" == CaseInsensitiveString "AB" log "comparison" assert $ compare (CaseInsensitiveString "qwerty") (CaseInsensitiveString "QWERTY") == EQ purescript-strings-3.3.1/test/Test/Data/String/CodePoints.purs000066400000000000000000000205471314166174400244230ustar00rootroot00000000000000module Test.Data.String.CodePoints (testStringCodePoints) where import Prelude import Control.Monad.Eff (Eff) import Control.Monad.Eff.Console (CONSOLE, log) import Data.Maybe (Maybe(..), isNothing, maybe) import Data.String.CodePoints import Test.Assert (ASSERT, assert) str :: String str = "a\xDC00\xD800\xD800\x16805\x16A06\&z" testStringCodePoints :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit testStringCodePoints = do log "codePointAt" assert $ codePointAt (-1) str == Nothing assert $ codePointAt 0 str == (codePointFromInt 0x61) assert $ codePointAt 1 str == (codePointFromInt 0xDC00) assert $ codePointAt 2 str == (codePointFromInt 0xD800) assert $ codePointAt 3 str == (codePointFromInt 0xD800) assert $ codePointAt 4 str == (codePointFromInt 0x16805) assert $ codePointAt 5 str == (codePointFromInt 0x16A06) assert $ codePointAt 6 str == (codePointFromInt 0x7A) assert $ codePointAt 7 str == Nothing log "count" assert $ count (\_ -> true) "" == 0 assert $ count (\_ -> false) str == 0 assert $ count (\_ -> true) str == 7 assert $ count (\x -> codePointToInt x < 0xFFFF) str == 4 assert $ count (\x -> codePointToInt x < 0xDC00) str == 1 log "drop" assert $ drop (-1) str == str assert $ drop 0 str == str assert $ drop 1 str == "\xDC00\xD800\xD800\x16805\x16A06\&z" assert $ drop 2 str == "\xD800\xD800\x16805\x16A06\&z" assert $ drop 3 str == "\xD800\x16805\x16A06\&z" assert $ drop 4 str == "\x16805\x16A06\&z" assert $ drop 5 str == "\x16A06\&z" assert $ drop 6 str == "z" assert $ drop 7 str == "" assert $ drop 8 str == "" log "dropWhile" assert $ dropWhile (\_ -> true) str == "" assert $ dropWhile (\_ -> false) str == str assert $ dropWhile (\c -> codePointToInt c < 0xFFFF) str == "\x16805\x16A06\&z" assert $ dropWhile (\c -> codePointToInt c < 0xDC00) str == "\xDC00\xD800\xD800\x16805\x16A06\&z" log "indexOf" assert $ indexOf (Pattern "") "" == Just 0 assert $ indexOf (Pattern "") str == Just 0 assert $ indexOf (Pattern str) str == Just 0 assert $ indexOf (Pattern "a") str == Just 0 assert $ indexOf (Pattern "\xDC00\xD800\xD800") str == Just 1 assert $ indexOf (Pattern "\xD800") str == Just 2 assert $ indexOf (Pattern "\xD800\xD800") str == Just 2 assert $ indexOf (Pattern "\xD800\xD81A") str == Just 3 assert $ indexOf (Pattern "\xD800\x16805") str == Just 3 assert $ indexOf (Pattern "\x16805") str == Just 4 assert $ indexOf (Pattern "\x16A06") str == Just 5 assert $ indexOf (Pattern "z") str == Just 6 assert $ indexOf (Pattern "\0") str == Nothing assert $ indexOf (Pattern "\xD81A") str == Just 4 log "indexOf'" assert $ indexOf' (Pattern "") 0 "" == Just 0 assert $ indexOf' (Pattern str) 0 str == Just 0 assert $ indexOf' (Pattern str) 1 str == Nothing assert $ indexOf' (Pattern "a") 0 str == Just 0 assert $ indexOf' (Pattern "a") 1 str == Nothing assert $ indexOf' (Pattern "z") 0 str == Just 6 assert $ indexOf' (Pattern "z") 1 str == Just 6 assert $ indexOf' (Pattern "z") 2 str == Just 6 assert $ indexOf' (Pattern "z") 3 str == Just 6 assert $ indexOf' (Pattern "z") 4 str == Just 6 assert $ indexOf' (Pattern "z") 5 str == Just 6 assert $ indexOf' (Pattern "z") 6 str == Just 6 assert $ indexOf' (Pattern "z") 7 str == Nothing log "lastIndexOf" assert $ lastIndexOf (Pattern "") "" == Just 0 assert $ lastIndexOf (Pattern "") str == Just 7 assert $ lastIndexOf (Pattern str) str == Just 0 assert $ lastIndexOf (Pattern "a") str == Just 0 assert $ lastIndexOf (Pattern "\xDC00\xD800\xD800") str == Just 1 assert $ lastIndexOf (Pattern "\xD800") str == Just 3 assert $ lastIndexOf (Pattern "\xD800\xD800") str == Just 2 assert $ lastIndexOf (Pattern "\xD800\xD81A") str == Just 3 assert $ lastIndexOf (Pattern "\xD800\x16805") str == Just 3 assert $ lastIndexOf (Pattern "\x16805") str == Just 4 assert $ lastIndexOf (Pattern "\x16A06") str == Just 5 assert $ lastIndexOf (Pattern "z") str == Just 6 assert $ lastIndexOf (Pattern "\0") str == Nothing assert $ lastIndexOf (Pattern "\xD81A") str == Just 5 log "lastIndexOf'" assert $ lastIndexOf' (Pattern "") 0 "" == Just 0 assert $ lastIndexOf' (Pattern str) 0 str == Just 0 assert $ lastIndexOf' (Pattern str) 1 str == Just 0 assert $ lastIndexOf' (Pattern "a") 0 str == Just 0 assert $ lastIndexOf' (Pattern "a") 7 str == Just 0 assert $ lastIndexOf' (Pattern "z") 0 str == Nothing assert $ lastIndexOf' (Pattern "z") 1 str == Nothing assert $ lastIndexOf' (Pattern "z") 2 str == Nothing assert $ lastIndexOf' (Pattern "z") 3 str == Nothing assert $ lastIndexOf' (Pattern "z") 4 str == Nothing assert $ lastIndexOf' (Pattern "z") 5 str == Nothing assert $ lastIndexOf' (Pattern "z") 6 str == Just 6 assert $ lastIndexOf' (Pattern "z") 7 str == Just 6 assert $ lastIndexOf' (Pattern "\xD800") 7 str == Just 3 assert $ lastIndexOf' (Pattern "\xD800") 6 str == Just 3 assert $ lastIndexOf' (Pattern "\xD800") 5 str == Just 3 assert $ lastIndexOf' (Pattern "\xD800") 4 str == Just 3 assert $ lastIndexOf' (Pattern "\xD800") 3 str == Just 3 assert $ lastIndexOf' (Pattern "\xD800") 2 str == Just 2 assert $ lastIndexOf' (Pattern "\xD800") 1 str == Nothing assert $ lastIndexOf' (Pattern "\xD800") 0 str == Nothing assert $ lastIndexOf' (Pattern "\x16A06") 7 str == Just 5 assert $ lastIndexOf' (Pattern "\x16A06") 6 str == Just 5 assert $ lastIndexOf' (Pattern "\x16A06") 5 str == Just 5 assert $ lastIndexOf' (Pattern "\x16A06") 4 str == Nothing assert $ lastIndexOf' (Pattern "\x16A06") 3 str == Nothing log "length" assert $ length "" == 0 assert $ length "a" == 1 assert $ length "ab" == 2 assert $ length str == 7 log "singleton" assert $ (singleton <$> codePointFromInt 0x30) == Just "0" assert $ (singleton <$> codePointFromInt 0x16805) == Just "\x16805" log "splitAt" let testSplitAt i s res = assert $ case splitAt i s of Nothing -> isNothing res Just { before, after } -> maybe false (\r -> r.before == before && r.after == after) res testSplitAt 0 "" $ Just {before: "", after: ""} testSplitAt 1 "" Nothing testSplitAt 0 "a" $ Just {before: "", after: "a"} testSplitAt 1 "ab" $ Just {before: "a", after: "b"} testSplitAt 3 "aabcc" $ Just {before: "aab", after: "cc"} testSplitAt (-1) "abc" $ Nothing testSplitAt 0 str $ Just {before: "", after: str} testSplitAt 1 str $ Just {before: "a", after: "\xDC00\xD800\xD800\x16805\x16A06\&z"} testSplitAt 2 str $ Just {before: "a\xDC00", after: "\xD800\xD800\x16805\x16A06\&z"} testSplitAt 3 str $ Just {before: "a\xDC00\xD800", after: "\xD800\x16805\x16A06\&z"} testSplitAt 4 str $ Just {before: "a\xDC00\xD800\xD800", after: "\x16805\x16A06\&z"} testSplitAt 5 str $ Just {before: "a\xDC00\xD800\xD800\x16805", after: "\x16A06\&z"} testSplitAt 6 str $ Just {before: "a\xDC00\xD800\xD800\x16805\x16A06", after: "z"} testSplitAt 7 str $ Just {before: str, after: ""} testSplitAt 8 str $ Nothing log "take" assert $ take (-1) str == "" assert $ take 0 str == "" assert $ take 1 str == "a" assert $ take 2 str == "a\xDC00" assert $ take 3 str == "a\xDC00\xD800" assert $ take 4 str == "a\xDC00\xD800\xD800" assert $ take 5 str == "a\xDC00\xD800\xD800\x16805" assert $ take 6 str == "a\xDC00\xD800\xD800\x16805\x16A06" assert $ take 7 str == str assert $ take 8 str == str log "takeWhile" assert $ takeWhile (\_ -> true) str == str assert $ takeWhile (\_ -> false) str == "" assert $ takeWhile (\c -> codePointToInt c < 0xFFFF) str == "a\xDC00\xD800\xD800" assert $ takeWhile (\c -> codePointToInt c < 0xDC00) str == "a" log "uncons" let testUncons s res = assert $ case uncons s of Nothing -> isNothing res Just { head, tail } -> maybe false (\r -> r.head == codePointToInt head && r.tail == tail) res testUncons str $ Just {head: 0x61, tail: "\xDC00\xD800\xD800\x16805\x16A06\&z"} testUncons (drop 1 str) $ Just {head: 0xDC00, tail: "\xD800\xD800\x16805\x16A06\&z"} testUncons (drop 2 str) $ Just {head: 0xD800, tail: "\xD800\x16805\x16A06\&z"} testUncons (drop 3 str) $ Just {head: 0xD800, tail: "\x16805\x16A06\&z"} testUncons (drop 4 str) $ Just {head: 0x16805, tail: "\x16A06\&z"} testUncons (drop 5 str) $ Just {head: 0x16A06, tail: "z"} testUncons (drop 6 str) $ Just {head: 0x7A, tail: ""} testUncons "" Nothing purescript-strings-3.3.1/test/Test/Data/String/Regex.purs000066400000000000000000000035321314166174400234210ustar00rootroot00000000000000module Test.Data.String.Regex (testStringRegex) where import Prelude (Unit, ($), (<>), discard, (==), not) import Control.Monad.Eff (Eff) import Control.Monad.Eff.Console (CONSOLE, log) import Data.Either (isLeft) import Data.Maybe (Maybe(..)) import Data.String.Regex import Data.String.Regex.Flags (global, ignoreCase, noFlags) import Data.String.Regex.Unsafe (unsafeRegex) import Test.Assert (ASSERT, assert) testStringRegex :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit testStringRegex = do log "regex" assert $ test (unsafeRegex "^a" noFlags) "abc" assert $ not (test (unsafeRegex "^b" noFlags) "abc") assert $ isLeft (regex "+" noFlags) log "flags" assert $ "quxbarfoobaz" == replace (unsafeRegex "foo" noFlags) "qux" "foobarfoobaz" assert $ "quxbarquxbaz" == replace (unsafeRegex "foo" global) "qux" "foobarfoobaz" assert $ "quxbarquxbaz" == replace (unsafeRegex "foo" (global <> ignoreCase)) "qux" "foobarFOObaz" log "match" assert $ match (unsafeRegex "^abc$" noFlags) "abc" == Just [Just "abc"] log "replace" assert $ replace (unsafeRegex "-" noFlags) "!" "a-b-c" == "a!b-c" log "replace'" assert $ replace' (unsafeRegex "-" noFlags) (\s xs -> "!") "a-b-c" == "a!b-c" log "search" assert $ search (unsafeRegex "b" noFlags) "abc" == Just 1 assert $ search (unsafeRegex "d" noFlags) "abc" == Nothing log "split" assert $ split (unsafeRegex "" noFlags) "" == [] assert $ split (unsafeRegex "" noFlags) "abc" == ["a", "b", "c"] assert $ split (unsafeRegex "b" noFlags) "" == [""] assert $ split (unsafeRegex "b" noFlags) "abc" == ["a", "c"] log "test" -- Ensure that we have referential transparency for calls to 'test'. No -- global state should be maintained between these two calls: let pattern = unsafeRegex "a" (parseFlags "g") assert $ test pattern "a" assert $ test pattern "a" purescript-strings-3.3.1/test/Test/Data/String/Unsafe.purs000066400000000000000000000010621314166174400235640ustar00rootroot00000000000000module Test.Data.String.Unsafe (testStringUnsafe) where import Prelude (Unit, (==), ($), discard) import Control.Monad.Eff (Eff) import Control.Monad.Eff.Console (CONSOLE, log) import Data.String.Unsafe import Test.Assert (ASSERT, assert) testStringUnsafe :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit testStringUnsafe = do log "charCodeAt" assert $ charCodeAt 0 "ab" == 97 assert $ charCodeAt 1 "ab" == 98 log "charAt" assert $ charAt 0 "ab" == 'a' assert $ charAt 1 "ab" == 'b' log "char" assert $ char "a" == 'a' purescript-strings-3.3.1/test/Test/Main.purs000066400000000000000000000011501314166174400211060ustar00rootroot00000000000000module Test.Main where import Prelude import Control.Monad.Eff (Eff) import Control.Monad.Eff.Console (CONSOLE) import Test.Assert (ASSERT) import Test.Data.Char (testChar) import Test.Data.String (testString) import Test.Data.String.CodePoints (testStringCodePoints) import Test.Data.String.Regex (testStringRegex) import Test.Data.String.Unsafe (testStringUnsafe) import Test.Data.String.CaseInsensitive (testCaseInsensitiveString) main :: Eff (console :: CONSOLE, assert :: ASSERT) Unit main = do testChar testString testStringCodePoints testStringUnsafe testStringRegex testCaseInsensitiveString