diff --git a/CHANGELOG.md b/CHANGELOG.md index 3e74184..86fae43 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - CHANGELOG.md - Stack integration +- Borsh serialization for `HexString` +- `Read` implementation for `HexString` ### Changed diff --git a/README.md b/README.md index 45afa52..5bdd5d1 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,4 @@ haskell-hexstring ================= -[![Build Status](https://travis-ci.org/solatis/haskell-hexstring.png?branch=master)](https://travis-ci.org/solatis/haskell-hexstring) -[![Coverage Status](https://coveralls.io/repos/solatis/haskell-hexstring/badge.svg?branch=master)](https://coveralls.io/r/solatis/haskell-hexstring?branch=master) -[![MIT](http://b.repl.ca/v1/license-MIT-blue.png)](http://en.wikipedia.org/wiki/MIT_License) -[![Haskell](http://b.repl.ca/v1/language-haskell-lightgrey.png)](http://haskell.org) - Fast and safe representation of a hex string diff --git a/hexstring.cabal b/hexstring.cabal index 56b5d84..23eb6cd 100644 --- a/hexstring.cabal +++ b/hexstring.cabal @@ -5,7 +5,7 @@ cabal-version: 1.12 -- see: https://github.com/sol/hpack name: hexstring -version: 0.12.0 +version: 0.12.1.0 synopsis: Fast and safe representation of a hex string description: Provides an interface for converting any object that has a 'Binary' instance to and from a hexadecimal Text representation. author: Rene Vergara, @@ -35,7 +35,10 @@ library , base >=4.7 && <5 , base16-bytestring , binary + , borsh >=0.2 , bytestring + , foreign-rust + , generics-sop , text default-language: Haskell2010 diff --git a/package.yaml b/package.yaml index 680f2d2..a1a042d 100644 --- a/package.yaml +++ b/package.yaml @@ -1,5 +1,5 @@ name: hexstring -version: 0.12.0 +version: 0.12.1.0 git: "https://git.vergara.tech/Vergara_Tech/haskell-hexstring" license: MIT author: @@ -27,6 +27,9 @@ library: - bytestring - base16-bytestring - aeson + - generics-sop + - borsh >= 0.2 + - foreign-rust tests: hextring-test: diff --git a/src/Data/HexString.hs b/src/Data/HexString.hs index 3caebcf..10a5200 100644 --- a/src/Data/HexString.hs +++ b/src/Data/HexString.hs @@ -1,69 +1,91 @@ -module Data.HexString ( HexString - , hexString - , fromBinary - , toBinary - , fromBytes - , toBytes - , toText ) where +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE DeriveAnyClass #-} +{-# LANGUAGE DerivingVia #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE OverloadedStrings #-} -import Control.Applicative (pure) +module Data.HexString + ( HexString(..) + , hexString + , fromRawBytes + , fromBinary + , toBytes + , fromText + , toText + ) where -import Data.Aeson -import Data.Word (Word8) +import Codec.Borsh +import Control.Applicative (pure) -import qualified Data.ByteString as BS -import qualified Data.ByteString.Base16 as BS16 (decodeLenient, encode) -import qualified Data.ByteString.Lazy as BSL +import Data.Aeson +import Data.Word (Word8) -import qualified Data.Text as T -import qualified Data.Text.Encoding as TE +import qualified Data.ByteString as BS +import qualified Data.ByteString.Base16 as BS16 (decode, decodeLenient, encode) +import qualified Data.ByteString.Lazy as BSL -import qualified Data.Binary as B (Binary, decode, encode) +import Data.Structured +import qualified Data.Text as T +import qualified Data.Text.Encoding as TE + +import qualified Data.Binary as B (Binary, decode, encode) + +import qualified GHC.Generics as GHC +import qualified Generics.SOP as SOP +import Text.Read -- | Represents a Hex string. Guarantees that all characters it contains -- are valid hex characters. -data HexString = - HexString BS.ByteString - deriving ( Show, Eq, Ord ) +newtype HexString = HexString + { hexBytes :: BS.ByteString + } deriving stock (Eq, GHC.Generic) + deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo) + deriving anyclass (Data.Structured.Show) + deriving (BorshSize, ToBorsh, FromBorsh) via AsStruct HexString + +instance Prelude.Show HexString where + show = T.unpack . toText + +instance Read HexString where + readsPrec _ s = [((fromText . T.pack) s, "")] instance FromJSON HexString where parseJSON = withText "HexString" $ pure . hexString . TE.encodeUtf8 instance ToJSON HexString where - toJSON = String . toText + toJSON = Data.Aeson.String . toText -- | Smart constructor which validates that all the text are actually -- hexadecimal characters. hexString :: BS.ByteString -> HexString hexString bs = - let isValidHex :: Word8 -> Bool - isValidHex c - | (48 <= c) && (c < 58) = True - | (97 <= c) && (c < 103) = True - | otherwise = False - - in if BS.all isValidHex bs - then HexString bs - else error ("Not a valid hex string: " ++ show bs) + case BS16.decode bs of + Right s -> HexString s + Left e -> error e -- | Converts a 'B.Binary' to a 'HexString' value -fromBinary :: B.Binary a => a -> HexString -fromBinary = hexString . BS16.encode . BSL.toStrict . B.encode +fromBinary :: B.Binary a => a -> HexString +fromBinary = HexString . BSL.toStrict . B.encode -- | Converts a 'HexString' to a 'B.Binary' value toBinary :: B.Binary a => HexString -> a -toBinary (HexString bs) = B.decode . BSL.fromStrict . BS16.decodeLenient $ bs +toBinary (HexString bs) = (B.decode . BSL.fromStrict) bs -- | Reads a 'BS.ByteString' as raw bytes and converts to hex representation. We -- cannot use the instance Binary of 'BS.ByteString' because it provides -- a leading length, which is not what we want when dealing with raw bytes. -fromBytes :: BS.ByteString -> HexString -fromBytes = hexString . BS16.encode +fromRawBytes :: BS.ByteString -> HexString +fromRawBytes = HexString -- | Access to the raw bytes in a 'BS.ByteString' format. toBytes :: HexString -> BS.ByteString -toBytes (HexString bs) = BS16.decodeLenient bs +toBytes (HexString bs) = bs + +-- | Reads a human-readable hex string into a `HexString` +fromText :: T.Text -> HexString +fromText = hexString . TE.encodeUtf8 -- | Access to a 'T.Text' representation of the 'HexString' toText :: HexString -> T.Text -toText (HexString bs) = TE.decodeUtf8 bs +toText (HexString bs) = (TE.decodeUtf8 . BS16.encode) bs diff --git a/stack.yaml b/stack.yaml index 346aa08..7879a40 100644 --- a/stack.yaml +++ b/stack.yaml @@ -2,3 +2,9 @@ resolver: lts-21.22 packages: - . + +extra-deps: + - git: https://github.com/well-typed/borsh.git + commit: d2fcfa159e0a844b1ec5e8ed3e232d4b380fa831 + - git: https://git.vergara.tech/Vergara_Tech/haskell-foreign-rust.git + commit: 787c2e813eb3a5d16c375d4b37dfefbd2adcdf05 diff --git a/test/Data/HexStringSpec.hs b/test/Data/HexStringSpec.hs index 93b4b90..a8d6673 100644 --- a/test/Data/HexStringSpec.hs +++ b/test/Data/HexStringSpec.hs @@ -1,27 +1,27 @@ +{-# LANGUAGE OverloadedStrings #-} + module Data.HexStringSpec where -import Data.HexString ( hexString - , fromBytes - , toBytes ) +import Data.HexString (fromRawBytes, fromText, hexString, toBytes, toText) import qualified Data.ByteString.Char8 as BS8 -import Test.Hspec +import Test.Hspec spec :: Spec spec = do describe "when constructing a hex string" $ do - it "should accept strings that fall within a valid range" $ - hexString (BS8.pack "0123456789abcdef") `shouldBe` hexString (BS8.pack "0123456789abcdef") - it "should reject strings outside the range" $ do - putStrLn (show (hexString (BS8.pack "/"))) `shouldThrow` anyErrorCall - putStrLn (show (hexString (BS8.pack ":"))) `shouldThrow` anyErrorCall - putStrLn (show (hexString (BS8.pack "`"))) `shouldThrow` anyErrorCall - putStrLn (show (hexString (BS8.pack "g"))) `shouldThrow` anyErrorCall - + print (hexString (BS8.pack "/")) `shouldThrow` anyErrorCall + print (hexString (BS8.pack ":")) `shouldThrow` anyErrorCall + print (hexString (BS8.pack "`")) `shouldThrow` anyErrorCall + print (hexString (BS8.pack "g")) `shouldThrow` anyErrorCall describe "when interpreting a hex string" $ do it "should convert the hex string properly when interpreting as bytes" $ - toBytes (hexString (BS8.pack "ffff")) `shouldBe` BS8.pack "\255\255" + toBytes (hexString "ffff") `shouldBe` BS8.pack "\255\255" it "should convert bytes to the proper hex string" $ - fromBytes (BS8.pack "\255\255") `shouldBe` hexString (BS8.pack "ffff") + fromRawBytes (BS8.pack "\255\255") `shouldBe` hexString (BS8.pack "ffff") + it "should convert the hex string to text" $ + toText (hexString "ffff") `shouldBe` "ffff" + it "should read text into the hex string" $ + fromText "ffff" `shouldBe` hexString (BS8.pack "ffff")