module Text.HTML.WraXML.String where

import qualified Text.HTML.Basic.Character as HtmlChar
import qualified Text.XML.WraXML.String as XmlString
import Text.XML.WraXML.Utility (compose)

import qualified Data.String.Unicode as Unicode
import qualified Data.Char as Char

import qualified Control.Monad.Exception.Synchronous as Exc


type T = [Atom]

type Atom = HtmlChar.T


{- |
Literal translation from pure strings.
This can only work, if the string does not contain special characters.
-}
fromString :: String -> T
fromString :: String -> T
fromString = forall a b. (a -> b) -> [a] -> [b]
map Char -> T
HtmlChar.fromUnicode

{- |
default routine
-}
fromUnicodeString :: String -> T
fromUnicodeString :: String -> T
fromUnicodeString = forall a b. (a -> b) -> [a] -> [b]
map Char -> T
HtmlChar.asciiFromUnicode

fromUnicodeStringInternetExploder :: String -> T
fromUnicodeStringInternetExploder :: String -> T
fromUnicodeStringInternetExploder =
   forall a b. (a -> b) -> [a] -> [b]
map Char -> T
HtmlChar.asciiFromUnicodeInternetExploder


toUnicodeStringOrFormat :: T -> String
toUnicodeStringOrFormat :: T -> String
toUnicodeStringOrFormat =
   forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a. [a -> a] -> a -> a
compose String
"" forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall a b. (a -> b) -> [a] -> [b]
map T -> ShowS
HtmlChar.toUnicodeOrFormat

toUnicodeString :: T -> String
toUnicodeString :: T -> String
toUnicodeString =
   forall a b. (a -> b) -> [a] -> [b]
map (forall e a. (e -> a) -> Exceptional e a -> a
Exc.resolve forall a. HasCallStack => String -> a
error forall b c a. (b -> c) -> (a -> b) -> a -> c
. T -> Exceptional String Char
HtmlChar.toUnicode)


{- |
Decode plain characters using the given decoder,
and decode entities by HXT's XML entity table.
Decoding errors for both conversions are embedded where they occur.
-}
toUnicodeStringDecodingEmbedError ::
   Unicode.DecodingFctEmbedErrors -> T -> XmlString.EmbeddedExceptions
toUnicodeStringDecodingEmbedError :: DecodingFctEmbedErrors -> T -> EmbeddedExceptions
toUnicodeStringDecodingEmbedError DecodingFctEmbedErrors
f =
   forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall a. (String -> a) -> (Int -> a) -> (String -> a) -> T -> [a]
HtmlChar.switchUnicodeRuns
      (forall a b. (a -> b) -> [a] -> [b]
map forall e a. Either e a -> Exceptional e a
Exc.fromEither forall b c a. (b -> c) -> (a -> b) -> a -> c
. DecodingFctEmbedErrors
f)
      ((forall a. a -> [a] -> [a]
:[]) forall b c a. (b -> c) -> (a -> b) -> a -> c
. T -> Exceptional String Char
HtmlChar.toUnicode forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> T
HtmlChar.fromCharRef)
      ((forall a. a -> [a] -> [a]
:[]) forall b c a. (b -> c) -> (a -> b) -> a -> c
. T -> Exceptional String Char
HtmlChar.toUnicode forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> T
HtmlChar.fromEntityRef)



{- |
Convert characters to lower case.
This uses ISO latin encoding and may fail for exotic characters.
-}
toLower :: T -> T
toLower :: T -> T
toLower = forall a b. (a -> b) -> [a] -> [b]
map T -> T
HtmlChar.toLower

toUpper :: T -> T
toUpper :: T -> T
toUpper = forall a b. (a -> b) -> [a] -> [b]
map T -> T
HtmlChar.toUpper


toCanonicalUnicodeString :: T -> String
toCanonicalUnicodeString :: T -> String
toCanonicalUnicodeString = forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
Char.toLower forall b c a. (b -> c) -> (a -> b) -> a -> c
. T -> String
toUnicodeString

equalIgnoreCase :: T -> T -> Bool
equalIgnoreCase :: T -> T -> Bool
equalIgnoreCase T
x T
y =
   T -> String
toCanonicalUnicodeString T
x forall a. Eq a => a -> a -> Bool
== T -> String
toCanonicalUnicodeString T
y

elemIgnoreCase :: T -> [T] -> Bool
elemIgnoreCase :: T -> [T] -> Bool
elemIgnoreCase T
x [T]
ys =
   forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem (T -> String
toCanonicalUnicodeString T
x) (forall a b. (a -> b) -> [a] -> [b]
map T -> String
toCanonicalUnicodeString [T]
ys)