, Data.Git.Harder.Pack

                     , binary

                     , bytestring

                     , cryptonite

                     , memory

                     , monad-hash

                     , unordered-containers

                     , zlib

{-# LANGUAGE OverloadedStrings #-}

import Codec.Compression.Zlib (compress)

import Control.Monad.IO.Class (liftIO)

import Control.Monad.Trans.Hash

import Crypto.Hash.Algorithms (SHA1)

import Data.ByteArray (convert)

import Data.Foldable (foldlM)

--import Data.Git.Ref (Ref, toBinary)

import Data.Git.Repository (resolveTreeish)

--import Data.Git.Revision (Revision (..))

import Data.Git.Storage (Git, getObjectRaw)

import Data.Git.Storage.Object (ObjectInfo (..))

import Data.Git.Types (ObjectType (..), Commit (..))

import Data.HashSet (HashSet)

import Data.Maybe (fromMaybe)

import Data.Word (Word8, Word32, Word64)

import qualified Data.ByteString.Lazy as BL (ByteString, toChunks)

import qualified Data.HashSet as S

import Data.Git.Harder

putPackHeader :: Word32 -> Put

    putByteString "PACK"     -- Signature

    putWord32be 2            -- Version number

    putWord32be numOfObjects -- Number of objects contained in the pack

putPackHeader' :: Int -> Put

putPackHeader' n =

    case toIntegralSized n of

        Nothing -> error "Invalid number of objects to pack"

        Just w  -> putPackHeader w

        treeIds = map (ObjId . commitTreeish) commits

        visit s oid _ _ = return (S.insert oid s, TAContinue)

    let initial = S.fromList commitIds `S.union` S.fromList treeIds

low7bits :: (Integral a, Bits a) => a -> Word8

    let mw = toIntegralSized $ n .&. 0x7f

putExtensibleWord :: (Integral a, Bits a) => a -> Put

    :: (Integral a, Bits a)

    in  if rest == zeroBits

            then putWord8 $ stops first

            else do

                putWord8 $ continues first

                let first' = low7bits rest

                    rest' = unsafeShiftR rest 7

                putExtensibleWord' first' rest'

compressObject (ObjectInfo (t, s, _mp) odata _ochains) = CompressedObject

    updateHashMulti $ BL.toChunks lbs

        header <- writeHashed $ putPackHeader' $ S.size oidset

extra-deps:

  - monad-hash-0.1