opendatatable (empty) → 0.0.0
raw patch · 6 files changed
+749/−0 lines, 6 filesdep +basedep +hxtdep +template-haskellsetup-changed
Dependencies added: base, hxt, template-haskell, th-lift
Files
- Data/OpenDataTable.hs +281/−0
- Data/OpenDataTable/Parser.hs +269/−0
- Data/OpenDataTable/Pickle.hs +142/−0
- LICENSE +23/−0
- Setup.hs +2/−0
- opendatatable.cabal +32/−0
+ Data/OpenDataTable.hs view
@@ -0,0 +1,281 @@+{-# LANGUAGE TemplateHaskell #-}++module Data.OpenDataTable+ ( Binding(..)+ , Delete(..)+ , Function(..)+ , FunctionType(..)+ , Input(..)+ , InputInfo(..)+ , InputType(..)+ , Insert(..)+ , NextPage(..)+ , Meta(..)+ , OpenDataTable(..)+ , Paging(..)+ , PagingModel(..)+ , PagingSize(..)+ , PagingStart(..)+ , PagingTotal(..)+ , ParamType(..)+ , Product(..)+ , SecurityLevel(..)+ , Select(..)+ , Update(..) ) where++import Language.Haskell.TH.Lift (deriveLift)++import Text.Read+import Text.ParserCombinators.ReadP hiding (choice)++strValMap = map (\(x, y) -> lift $ string x >> return y)++data OpenDataTable+ = OpenDataTable+ { openDataTableXmlns :: Maybe String+ , openDataTableSecurityLevel :: Maybe SecurityLevel+ , openDataTableHttps :: Maybe Bool+ , openDataTableMeta :: Meta+ , openDataTableExecute :: Maybe String+ , openDataTableBindings :: [Binding]+ } deriving (Read, Show, Eq)++data SecurityLevel+ = SecurityLevelAny | SecurityLevelApp | SecurityLevelUser+ deriving (Eq)++instance Read SecurityLevel where+ readPrec = choice $ strValMap+ [ ("any", SecurityLevelAny)+ , ("app", SecurityLevelApp)+ , ("user", SecurityLevelUser) ]++instance Show SecurityLevel where+ showsPrec _ SecurityLevelAny = showString "any"+ showsPrec _ SecurityLevelApp = showString "app"+ showsPrec _ SecurityLevelUser = showString "user"++data Meta+ = Meta+ { metaAuthor :: Maybe String+ , metaDescription :: Maybe String+ , metaDocumentationURL :: Maybe String+ , metaApiKeyURL :: Maybe String+ , metaSampleQuery :: [String]+ } deriving (Read, Show, Eq)++data Binding+ = SelectBinding Select+ | InsertBinding Insert+ | UpdateBinding Update+ | DeleteBinding Delete+ | FunctionBinding Function+ deriving (Read, Show, Eq)++data Select+ = Select+ { selectItemPath :: Maybe String+ , selectProduces :: Maybe Product+ , selectPollingFrequencySeconds :: Maybe Integer+ , selectUrl :: Maybe String+ , selectInputs :: [Input]+ , selectExecute :: Maybe String+ , selectPaging :: Maybe Paging+ } deriving (Read, Show, Eq)++data Paging+ = Paging+ { pagingModel :: Maybe PagingModel+ , pagingMatrix :: Maybe Bool+ , pagingPageSize :: Maybe PagingSize+ , pagingStart :: Maybe PagingStart+ , pagingTotal :: Maybe PagingTotal+ , pagingNextPage :: Maybe NextPage+ } deriving (Read, Show, Eq)++data PagingModel+ = PagingModelOffset | PagingModelPage | PagingModelURL+ deriving (Eq)++instance Read PagingModel where+ readPrec = choice $ strValMap+ [ ("offset", PagingModelOffset)+ , ("page", PagingModelPage)+ , ("url", PagingModelURL) ]++instance Show PagingModel where+ showsPrec _ PagingModelOffset = showString "offset"+ showsPrec _ PagingModelPage = showString "page"+ showsPrec _ PagingModelURL = showString "url"++data PagingSize+ = PagingSize+ { pagingSizeId :: String+ , pagingSizeMax :: Integer+ } deriving (Read, Show, Eq)++data PagingStart+ = PagingStart+ { pagingStartId :: String+ , pagingStartDefault :: Integer+ } deriving (Read, Show, Eq)++data PagingTotal+ = PagingTotal+ { pagingTotalDefault :: Integer+ } deriving (Read, Show, Eq)++data NextPage+ = NextPage+ { nextPagePath :: String+ } deriving (Read, Show, Eq)++data Insert+ = Insert+ { insertItemPath :: Maybe String+ , insertPollingFrequencySeconds :: Maybe Integer+ , insertProduces :: Maybe Product+ , insertUrls :: [String]+ , insertInputs :: [Input]+ } deriving (Read, Show, Eq)++data Update+ = Update+ { updateItemPath :: Maybe String+ , updatePollingFrequencySeconds :: Maybe Integer+ , updateProduces :: Maybe Product+ , updateUrls :: [String]+ , updateInputs :: [Input]+ } deriving (Read, Show, Eq)++data Delete+ = Delete+ { deleteItemPath :: Maybe String+ , deletePollingFrequencySeconds :: Maybe Integer+ , deleteProduces :: Maybe Product+ , deleteUrls :: [String]+ , deleteInputs :: [Input]+ } deriving (Read, Show, Eq)++data Product+ = ProductXML | ProductJSON+ deriving (Eq)++instance Read Product where+ readPrec = choice $ strValMap+ [ ("XML", ProductXML)+ , ("JSON", ProductJSON) ]++instance Show Product where+ showsPrec _ ProductXML = showString "XML"+ showsPrec _ ProductJSON = showString "JSON"++data Function+ = Function+ { functionName :: Maybe String+ , functionType :: FunctionType+ } deriving (Read, Show, Eq)++data FunctionType+ = FunctionTypeStream | FunctionTypeReduce+ deriving (Eq)++instance Read FunctionType where+ readPrec = choice $ strValMap+ [ ("stream", FunctionTypeStream)+ , ("reduce", FunctionTypeReduce) ]++instance Show FunctionType where+ showsPrec _ FunctionTypeStream = showString "stream"+ showsPrec _ FunctionTypeReduce = showString "reduce"++data Input+ = InputKey InputInfo+ | InputValue InputInfo+ | InputMap InputInfo+ deriving (Read, Show, Eq)++data InputInfo+ = InputInfo+ { inputInfoId :: String+ , inputInfoAs :: Maybe String+ , inputInfoType :: InputType+ , inputInfoParamType :: ParamType+ , inputInfoRequired :: Bool+ , inputInfoDefault :: Maybe String+ , inputInfoPrivate :: Maybe Bool+ , inputInfoConst :: Maybe Bool+ , inputInfoBatchable :: Maybe Bool+ , inputInfoMaxBatchItems :: Maybe Integer+ } deriving (Read, Show, Eq)++data InputType =+ InputTypeBool |+ InputTypeDate |+ InputTypeDouble |+ InputTypeFloat |+ InputTypeInt |+ InputTypeString+ deriving (Eq)++instance Read InputType where+ readPrec = choice $ strValMap+ [ ("xs:bool", InputTypeBool)+ , ("xs:boolean", InputTypeBool)+ , ("xs:date", InputTypeDate)+ , ("xs:double", InputTypeDouble)+ , ("xs:float", InputTypeFloat)+ , ("xs:int", InputTypeInt)+ , ("xs:integer", InputTypeInt)+ , ("xs:number", InputTypeDouble)+ , ("xs:string", InputTypeString)]++instance Show InputType where+ showsPrec _ InputTypeBool = showString "xs:bool"+ showsPrec _ InputTypeDate = showString "xs:date"+ showsPrec _ InputTypeDouble = showString "xs:double"+ showsPrec _ InputTypeFloat = showString "xs:float"+ showsPrec _ InputTypeInt = showString "xs:int"+ showsPrec _ InputTypeString = showString "xs:string"++data ParamType+ = ParamTypeQuery | ParamTypeMatrix | ParamTypeHeader+ | ParamTypePath | ParamTypeVariable+ deriving (Eq)++instance Read ParamType where+ readPrec = choice $ strValMap+ [ ("query", ParamTypeQuery)+ , ("matrix", ParamTypeMatrix)+ , ("header", ParamTypeHeader)+ , ("path", ParamTypePath)+ , ("variable", ParamTypeVariable) ]++instance Show ParamType where+ showsPrec _ ParamTypeQuery = showString "query"+ showsPrec _ ParamTypeMatrix = showString "matrix"+ showsPrec _ ParamTypeHeader = showString "header"+ showsPrec _ ParamTypePath = showString "path"+ showsPrec _ ParamTypeVariable = showString "variable"++$(deriveLift ''OpenDataTable)+$(deriveLift ''SecurityLevel)+$(deriveLift ''Delete)+$(deriveLift ''Meta)+$(deriveLift ''Binding)+$(deriveLift ''Select)+$(deriveLift ''Paging)+$(deriveLift ''PagingModel)+$(deriveLift ''PagingSize)+$(deriveLift ''PagingStart)+$(deriveLift ''PagingTotal)+$(deriveLift ''NextPage)+$(deriveLift ''Insert)+$(deriveLift ''Update)+$(deriveLift ''Product)+$(deriveLift ''Function)+$(deriveLift ''FunctionType)+$(deriveLift ''Input)+$(deriveLift ''InputInfo)+$(deriveLift ''InputType)+$(deriveLift ''ParamType)
+ Data/OpenDataTable/Parser.hs view
@@ -0,0 +1,269 @@+{-# LANGUAGE Arrows #-}++module Data.OpenDataTable.Parser+ ( parseBindings+ , parseInput+ , parseInputInfo+ , parsePaging+ , parsePagingNextPage+ , parsePagingPageSize+ , parsePagingStart+ , parsePagingTotal+ , parseMeta+ , parseOpenDataTable+ , parseSelect ) where++import Text.Read+import Data.Maybe++import Text.XML.HXT.Core (arr, deep, constA, isElem, orElse, returnA,+ isA, listA, getText, none,+ hasName, getChildren, getAttrValue0,+ (<<<), (>>>),+ XmlTree, ArrowXml, ArrowList, ArrowChoice)++import Data.OpenDataTable++readBoolMaybe :: String -> Maybe Bool+readBoolMaybe "true" = Just True+readBoolMaybe "false" = Just False+readBoolMaybe _ = Nothing++atTag :: ArrowXml a => String -> a XmlTree XmlTree+atTag tag = deep (isElem >>> hasName tag)++atOptionalTag :: ArrowXml a => String -> a XmlTree (Maybe XmlTree)+atOptionalTag tag = deep (isElem >>> hasName tag >>> arr Just)+ `orElse` (constA Nothing)++text :: ArrowXml a => a XmlTree String+text = getChildren >>> getText++textAtTag :: ArrowXml a => String -> a XmlTree String+textAtTag tag = atTag tag >>> text++getList :: ArrowXml a => String -> a XmlTree c -> a XmlTree [c]+getList tag cont = listA ( atTag tag >>> cont)++getOptionalList :: (ArrowChoice a, ArrowXml a) =>+ String -> a XmlTree b -> a (Maybe XmlTree) [b]+getOptionalList tag cont =+ proc x -> do+ case x of+ Nothing -> returnA -< []+ Just xml -> returnA <<< getList tag cont -< xml++significant :: String -> Bool+significant = not . all (`elem` " \n\r\t")++optionalAttr :: ArrowXml a => String -> a XmlTree (Maybe String)+optionalAttr attr =+ (getAttrValue0 attr >>> isA significant >>> arr Just)+ `orElse` (constA Nothing)++optionalTextAtTag :: ArrowXml a => String -> a XmlTree (Maybe String)+optionalTextAtTag tag =+ (textAtTag tag >>> arr Just)+ `orElse` (constA Nothing)++optionalTextAtOptionalTag :: (ArrowChoice a, ArrowXml a) =>+ String -> a (Maybe XmlTree) (Maybe String)+optionalTextAtOptionalTag tag =+ proc mx -> do+ case mx of+ Nothing -> returnA -< Nothing+ Just x -> optionalTextAtTag tag -< x++readOptionalAttrVal :: (ArrowChoice a, ArrowList a) =>+ (b -> Maybe c) -> a (Maybe b) (Maybe c)+readOptionalAttrVal reader =+ proc x -> do+ case x of+ Nothing -> returnA -< Nothing+ Just attr -> do+ let mRead = reader attr+ case mRead of+ Nothing -> none -< Nothing+ Just val -> returnA -< Just val++readOptionalAttr :: (ArrowList a, ArrowChoice a, Read c) =>+ a (Maybe String) (Maybe c)+readOptionalAttr = readOptionalAttrVal readMaybe++readOptionalAttrBool :: (ArrowList a, ArrowChoice a) =>+ a (Maybe String) (Maybe Bool)+readOptionalAttrBool = readOptionalAttrVal readBoolMaybe++readAttrVal :: (ArrowChoice a, ArrowList a) => (b -> Maybe c) -> a b c+readAttrVal reader =+ proc x -> do+ let mRead = reader x+ case mRead of+ Nothing -> none -< Nothing+ Just val -> returnA -< val++readAttr :: (ArrowChoice a, ArrowList a, Read b) =>+ a String b+readAttr = readAttrVal readMaybe++readAttrBool :: (ArrowChoice a, ArrowList a) =>+ a String Bool+readAttrBool = readAttrVal readBoolMaybe++parseOpenDataTable :: (ArrowXml a, ArrowChoice a) =>+ a XmlTree OpenDataTable+parseOpenDataTable =+ proc x -> do+ mHttps <- optionalAttr "https" -< x+ https <- readOptionalAttr -< mHttps+ xmlns <- optionalAttr "xmlns" -< x+ securityLevel <- readOptionalAttr+ <<< optionalAttr "securityLevel" -< x+ meta <- parseMeta -< x+ mExecute <- optionalAttr "execute" -< x+ execute <- readOptionalAttr -< mExecute+ bindings <- parseBindings -< x+ returnA -< OpenDataTable+ xmlns+ securityLevel+ https+ meta+ execute+ bindings++parseMeta :: (ArrowXml a) => a XmlTree Meta+parseMeta =+ proc x -> do+ meta <- atTag "meta" -< x+ author <- optionalTextAtTag "author" -< meta+ apiKeyUrl <- optionalTextAtTag "apiKeyUrl" -< meta+ description <- optionalTextAtTag "description" -< meta+ sampleQueries <- getList "sampleQuery" text -< meta+ documentationUrl <- optionalTextAtTag "documentationURL" -< meta+ returnA -< Meta+ author+ description+ documentationUrl+ apiKeyUrl+ sampleQueries++parseBindings :: (ArrowXml a, ArrowChoice a) => a XmlTree [Binding]+parseBindings =+ proc x -> do+ bindings <- atTag "bindings" -< x+ selects <- listA (atTag "select" >>> parseSelect) -< bindings+ returnA -< SelectBinding `fmap` selects++parseSelect :: (ArrowXml a, ArrowChoice a) => a XmlTree Select+parseSelect =+ proc x -> do+ itemPath <- optionalAttr "itemPath" -< x+ produces <- readOptionalAttr+ <<< optionalAttr "produces" -< x+ pollingFrequencySeconds <- readOptionalAttr+ <<< optionalAttr "pollingFrequencySeconds" -< x+ url <- optionalTextAtOptionalTag "url"+ <<< atOptionalTag "urls" -< x+ inputs <- parseInput -< x+ execute <- optionalTextAtTag "execute" -< x+ paging <- (arr Just <<< parsePaging)+ `orElse` (constA Nothing) -< x+ returnA -< Select+ itemPath+ produces+ pollingFrequencySeconds+ url+ inputs+ execute+ paging++parseInput :: (ArrowXml a, ArrowChoice a) => a XmlTree [Input]+parseInput =+ proc x -> do+ inputs <- atOptionalTag "inputs" -< x+ keys <- getOptionalList "key" parseInputInfo -< inputs+ returnA -< InputKey `fmap` keys++parseInputInfo :: (ArrowXml a, ArrowChoice a) => a XmlTree InputInfo+parseInputInfo =+ proc x -> do+ id <- getAttrValue0 "id" -< x+ as <- optionalAttr "as" -< x+ typ <- readAttr+ <<< getAttrValue0 "type" -< x+ paramType <- readAttr <<< getAttrValue0 "paramType" -< x+ required <- readOptionalAttrBool <<< optionalAttr "required" -< x+ def <- optionalAttr "default" -< x+ private <- readOptionalAttrBool+ <<< optionalAttr "private" -< x+ const <- readOptionalAttrBool+ <<< optionalAttr "const" -< x+ batchable <- readOptionalAttrBool+ <<< optionalAttr "batchable" -< x+ maxBatchItems <- readOptionalAttr+ <<< optionalAttr "maxBatchItems" -< x+ returnA -< InputInfo+ id+ as+ typ+ paramType+ (fromMaybe False required)+ def+ private+ const+ batchable+ maxBatchItems++parsePaging :: (ArrowXml a, ArrowChoice a) => a XmlTree Paging+parsePaging =+ proc x -> do+ paging <- atTag "paging" -< x+ mModel <- optionalAttr "model" -< paging+ model <- readOptionalAttr -< mModel+ matrix <- readOptionalAttrBool+ <<< optionalAttr "matrix" -< paging+ pageSize <- (arr Just <<< parsePagingPageSize)+ `orElse` (constA Nothing) -< paging+ pageStart <- (arr Just <<< parsePagingStart)+ `orElse` (constA Nothing) -< paging+ pageTotal <- (arr Just <<< parsePagingTotal)+ `orElse` (constA Nothing) -< paging+ nextPage <- (arr Just <<< parsePagingNextPage)+ `orElse` (constA Nothing) -< paging+ returnA -< Paging+ model+ matrix+ pageSize+ pageStart+ pageTotal+ nextPage++parsePagingPageSize :: ArrowXml a => a XmlTree PagingSize+parsePagingPageSize =+ proc x -> do+ pageSize <- atTag "pagesize" -< x+ id <- getAttrValue0 "id" -< pageSize+ max <- getAttrValue0 "max" -< pageSize+ returnA -< PagingSize id $ read max++parsePagingStart :: ArrowXml a => a XmlTree PagingStart+parsePagingStart =+ proc x -> do+ pagingStart <- atTag "start" -< x+ id <- getAttrValue0 "id" -< pagingStart+ def <- getAttrValue0 "default" -< pagingStart+ returnA -< PagingStart id $ read def++parsePagingTotal :: ArrowXml a => a XmlTree PagingTotal+parsePagingTotal =+ proc x -> do+ pagingTotal <- atTag "total" -< x+ def <- getAttrValue0 "default" -< pagingTotal+ returnA -< PagingTotal $ read def++parsePagingNextPage :: ArrowXml a => a XmlTree NextPage+parsePagingNextPage =+ proc x -> do+ nextPage <- atTag "nextpage" -< x+ path <- getAttrValue0 "path" -< nextPage+ returnA -< NextPage path
+ Data/OpenDataTable/Pickle.hs view
@@ -0,0 +1,142 @@+module Data.OpenDataTable.Pickle+ () where++import Text.XML.HXT.Core+import Text.XML.HXT.Arrow.Pickle.Schema++import Data.OpenDataTable++instance XmlPickler OpenDataTable where+ xpickle = xpOpenDataTable++xpOpenDataTable :: PU OpenDataTable+xpOpenDataTable+ = xpWrap ( \ ((xmlns, securityLevel, https, meta, execute, bindings)) ->+ OpenDataTable xmlns securityLevel https meta execute bindings+ , \ ot -> (openDataTableXmlns ot, openDataTableSecurityLevel ot,+ openDataTableHttps ot, openDataTableMeta ot,+ openDataTableExecute ot, openDataTableBindings ot)) $+ xpElem "table" $+ xp6Tuple+ (xpOption $ xpAddFixedAttr "xmlns" "http://query.yahooapis.com/v1/schema/table.xsd" xpText)+ (xpOption $ xpAttr "securityLevel" xpPrim)+ (xpOption $ xpAttr "https" xpPrim)+ xpMeta+ (xpOption (xpElem "execute" $ xpTextDT scString))+ xpBindings++instance XmlPickler Meta where+ xpickle = xpMeta++xpMeta :: PU Meta+xpMeta+ = xpElem "meta" $+ xpWrap ( \ ((aut, des, doc, sam, api)) -> Meta api aut doc des sam+ , \ m -> (metaAuthor m, metaDescription m, metaDocumentationURL m,+ metaSampleQuery m, metaApiKeyURL m)) $+ xp5Tuple+ (xpOption $ xpElem "author" xpText)+ (xpOption $ xpElem "description" xpText)+ (xpOption $ xpElem "documentationURL" xpText)+ (xpList $ xpElem "sampleQuery" xpText)+ (xpOption $ xpElem "apiKeyUrl" xpText)++xpBindings :: PU [Binding]+xpBindings = xpElem "bindings" $+ xpList xpBinding++instance XmlPickler Binding where+ xpickle = xpBinding++xpBinding :: PU Binding+xpBinding = xpWrap ( SelectBinding, \ (SelectBinding s) -> s ) $+ xpickle++instance XmlPickler Select where+ xpickle = xpSelect++xpSelect :: PU Select+xpSelect = xpElem "select" $+ xpWrap ( \ ((ite, pro, pol, url, inp, exe, pag)) ->+ Select ite pro pol url inp exe pag,+ \ s -> (selectItemPath s, selectProduces s,+ selectPollingFrequencySeconds s,+ selectUrl s, selectInputs s,+ selectExecute s, selectPaging s) ) $+ xp7Tuple+ (xpOption (xpAttr "itemPath" xpText))+ (xpOption (xpAttr "produces" xpPrim))+ (xpOption (xpAttr "pollingFrequencySeconds" xpPrim))+ (xpOption (xpElem "urls" $ xpElem "url" xpText))+ (xpElem "inputs" $ xpList $ xpInput)+ (xpOption (xpElem "execute" $ xpTextDT scString))+ (xpElem "paging" xpickle)++xpInput :: PU Input+xpInput = xpWrap ( InputKey, \ (InputKey i) -> i ) $+ xpElem "key" xpickle++instance XmlPickler InputInfo where+ xpickle = xpInputInfo++xpInputInfo :: PU InputInfo+xpInputInfo = xpWrap ( \ ((id, as, typ, par, req, def, pri, con, bat, max)) ->+ InputInfo id as typ par req def pri con bat max,+ \ i -> (inputInfoId i, inputInfoAs i, inputInfoType i,+ inputInfoParamType i, inputInfoRequired i,+ inputInfoDefault i, inputInfoPrivate i,+ inputInfoConst i, inputInfoBatchable i,+ inputInfoMaxBatchItems i)) $+ xp10Tuple+ (xpAttr "id" xpText)+ (xpOption $ xpAttr "as" xpText)+ (xpAttr "type" xpPrim)+ (xpAttr "paramType" xpPrim)+ (xpAttr "required" xpPrim)+ (xpOption $ xpAttr "default" xpText)+ (xpOption $ xpAttr "private" xpPrim)+ (xpOption $ xpAttr "const" xpPrim)+ (xpOption $ xpAttr "batchable" xpPrim)+ (xpOption $ xpAttr "maxBatchItems" xpPrim)++instance XmlPickler Paging where+ xpickle = xpPaging++xpPaging :: PU Paging+xpPaging = xpWrap ( \ ((mod, mat, siz, sta, tot, nex)) ->+ Paging mod mat siz sta tot nex,+ \ p -> (pagingModel p, pagingMatrix p, pagingPageSize p,+ pagingStart p, pagingTotal p, pagingNextPage p)) $+ xp6Tuple+ (xpOption $ xpAttr "model" xpPrim)+ (xpOption $ xpAttr "matrix" xpPrim)+ (xpOption $ xpickle)+ (xpOption $ xpickle)+ (xpOption $ xpickle)+ (xpOption $ xpickle)++instance XmlPickler PagingSize where+ xpickle = xpElem "pagesize" $+ xpWrap ( \ ((id, max)) -> PagingSize id max,+ \ ps -> (pagingSizeId ps, pagingSizeMax ps)) $+ xpPair+ (xpAttr "id" xpText)+ (xpAttr "max" xpPrim)++instance XmlPickler PagingStart where+ xpickle = xpElem "start" $+ xpWrap ( \ ((id, def)) -> PagingStart id def,+ \ ps -> (pagingStartId ps, pagingStartDefault ps)) $+ xpPair+ (xpAttr "id" xpText)+ (xpAttr "default" xpPrim)++instance XmlPickler PagingTotal where+ xpickle = xpElem "total" $+ xpWrap ( PagingTotal, pagingTotalDefault) $+ (xpAttr "default" xpPrim)++instance XmlPickler NextPage where+ xpickle = xpElem "nextpage" $+ xpWrap ( NextPage, nextPagePath) $+ (xpAttr "path" xpText)
+ LICENSE view
@@ -0,0 +1,23 @@+Copyright (c) 2014, Fabian Bergmark+All rights reserved.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met:++* Redistributions of source code must retain the above copyright notice, this+ list of conditions and the following disclaimer.++* Redistributions in binary form must reproduce the above copyright notice,+ this list of conditions and the following disclaimer in the documentation+ and/or other materials provided with the distribution.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain
+ opendatatable.cabal view
@@ -0,0 +1,32 @@+name: opendatatable+version: 0.0.0+synopsis: A library for working with Open Data Tables+description: Open Data Table definition, parser and pickler.+homepage: https://github.com/fabianbergmark/OpenDataTable+category: Web+author: Fabian Bergmark+maintainer: fabian.bergmark@gmail.com+license: BSD2+license-file: LICENSE+cabal-version: >= 1.10+build-type: Simple++extra-source-files: LICENSE++source-repository head+ type: git+ location: https://github.com/fabianbergmark/OpenDataTable.git++library+ default-language: Haskell2010++ exposed-modules: Data.OpenDataTable+ Data.OpenDataTable.Parser+ Data.OpenDataTable.Pickle++ ghc-options: -fno-warn-orphans -fno-warn-unused-binds -fno-warn-unused-matches++ build-depends: base == 4.*+ , template-haskell == 2.9.*+ , th-lift == 0.6.*+ , hxt == 9.3.*