cookbook 2.3.1.0 → 2.3.2.0

raw patch · 8 files changed

+207/−139 lines, 8 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• Cookbook/Ingredients/Lists/Encompass.hs +8/−7
• Cookbook/Project/Quill/Quill.hs +1/−2
• Cookbook/Project/Quill/Quill2.hs +0/−128
• Cookbook/Project/Quill/Quill2/Q2Api.hs +96/−0
• Cookbook/Project/Quill/Quill2/Q2Io.hs +28/−0
• Cookbook/Project/Quill/Quill2/Q2Parse.hs +48/−0
• Cookbook/Project/Quill/Quill2/Q2Prelude.hs +24/−0
• cookbook.cabal +2/−2

@@ -16,14 +16,15 @@  -- | Get the entire section of a list contained within the scope delimited by the parameters, even sub-scopes. encompassing :: (Eq a) => [a] -> (a,a) -> [a]-encompassing (x:xs) (a,b) = helper (x:xs) (a,b) 0+encompassing (x:xs) (a,b) = helper (x:xs) 0   where-    helper [] _ _ = []-    helper (y:ys) (c,d) e-      | y == d && e <= 1 = []-      | y == c = condInp    $ helper ys (c,d) (e + 1)-      | y == d = y : helper ys (c,d) (e - 1)-      | otherwise = condInp $ helper ys (c,d) e+    helper [] _  = []+    helper (y:ys) e+      | y == b && e <= 1 = []+      | y == a && a == b = if e == 0 then [] else condInp $ helper ys (e + 1)+      | y == a = condInp $ helper ys (e + 1)+      | y == b = y : helper ys (e - 1)+      | otherwise = condInp $ helper ys e       where         condInp = ([y | e > 0] ++) 

@@ -7,8 +7,7 @@    Portability :   Portable (Cookbook A library for reading simple databases. As what was originally a quirk of the library, database tables can be split up and still parsed as if they were a unit, giving it the ability to read the same table from multiple files in parallel. Quill supports a comment syntax, whitespace-insignificant parsing, and a full CRUD API. Quill will EVENTUALLY be replaced by Scribe2, but the planning for Scribe2 has not yet begun. -}--module Cookbook.Project.Quill.Quill where +module Cookbook.Project.Quill.Quill {-# DEPRECATED "Quill2 Deprecates this. Scheduled for removal on June 1st, 2014." #-} where   import qualified Cookbook.Essential.Common         as Cm import qualified Cookbook.Essential.Continuous     as Ct

@@ -1,128 +0,0 @@-{- |-   Module      :   Cookbook.Project.Quill.Quill2-   Copyright   :   (c) 2014 by Nate Pisarski-   License     :   BSD3-   Maintainer  :   nathanpisarski@gmail.com-   Stability   :   Stable-   Portability :   Portable (Cookbook-Another library for managing databases. It GREATLY breaks compatibility with Quill, and it will eventually deprecate Quill. It's a whitespace-independant string-based flat file language for database information. Some advantages that Quill2 has over Quill include: Record database entries, list support, better commenting support, more complete API, and greater error handling / safety.--}--module Cookbook.Project.Quill.Quill2 where--import qualified Cookbook.Essential.Common         as Cm-import qualified Cookbook.Essential.Continuous     as Ct--import qualified Cookbook.Ingredients.Lists.Modify    as Md-import qualified Cookbook.Ingredients.Lists.Access    as Ac-import qualified Cookbook.Ingredients.Lists.Encompass as En-import qualified Cookbook.Ingredients.Tupples.Look    as Lk---- Data types and Instances--- | The body of a table or list.-data Element a = List [a] | Table [(a,a)] deriving (Eq, Show)---- | Helper type. Binds a name to a body.-type Quill = (String,Element String)-  --- Preprocessing functions - Turning raw text into a more easily workable format.---- | Strip comments from a sanitized string. Comments start with /* and end with */.-decomment :: String -> String-decomment = (`Ct.splice` ("/*", "*/"))---- | Prepare the lines of a file for processing.-prepare :: [String] -> String-prepare = decomment . (`Ct.remove` '\n') . unlines---- Text processing - Turning the preprocessed text into data.---- | Process a single entry in the database into a Table.-pTable :: String -> Quill-pTable x = typ-  where-    name = Md.between (Ct.before x '{') ('(',')') --table(name) or list(name)-    typ  = (name,if (Ct.before x '{') `Ac.contains` "table" then Table (parseTables body) else List body)-    body = Md.splitOn (En.encompassing x ('{','}')) ';'-    quoted y = if ('`','\'') `Ac.surrounds` y then En.encompassing x ('`','\'') else Ct.remove y ' '-    parseTables [] = []-    parseTables (x:xs) =(quoted $ Ct.before x ':', Ct.after x ':') : parseTables xs---- | Turn the lines of a file into a list of tables, AKA a Database.-pFile :: [String] -> [Quill]-pFile x = case allTables of-  [] -> []-  (y:ys) -> pTable y : pFile ys-  where-    prepared  = prepare x-    allTables = Md.splitOn prepared '}'---- API functions for creating and reading tables.--data QuillStatus = QuillSuccess Quill | QuillMissing | QuillMultiple deriving (Eq,Show)--getQuillName :: Quill -> String-getQuillName = fst--getQuill :: [Quill] -> String -> QuillStatus-getQuill [] _ = QuillMissing-getQuill (x:xs) c-  | Ac.count (map getQuillName (x:xs)) c > 1 = QuillMultiple-  | getQuillName x  == c = QuillSuccess x-  | otherwise = getQuill xs c--lookUp :: [Quill] -> (String, String) -> String-lookUp x (a,b) = case (getQuill x a) of-  QuillMissing  -> error $ "Table not found."-  QuillMultiple -> error $ "Multiple values of " ++ a ++ " detected. Database eror, fix manually."-  (QuillSuccess (c,d)) -> case d of-    (List f) -> error "Cannot look up the value of a list."-    (Table f) -> let c = Lk.lookList f b in if (c == []) then (error $ "Item " ++ b ++ " not found in table " ++ a) else (if (length c > 1) then multipleInnerError else (head c))-    where multipleInnerError = error $ "Multiple values of " ++ b ++ " found in table " ++ a ++ ". Database corrupted, change manually."--removeQuill :: [Quill] -> String -> [Quill]-removeQuill [] _ = []-removeQuill ((x,y):xs) c-  | x == c = removeQuill xs c -- See [Q2N1]-  | otherwise = (x,y) : removeQuill xs c--removeItem :: [Quill] -> (String, String) -> [Quill]-removeItem x (a,b) = case (getQuill x a) of-  QuillSuccess (c,j) -> case j of-    (Table d) -> (c,(Table [(y,t) | (y,t) <- d, y /= b])) : (removeQuill x a)-    (List d) -> (c,List $ Ct.remove d c) : removeQuill x a-  _ -> (let l = lookUp x (a,b) in x) -- This goes against everything that haskell means.--addQuill :: [Quill] -> Quill -> [Quill]-addQuill x c = c : x--addToQuill :: Quill -> (String, String) -> Quill-addToQuill (x,b) c = case b of-  (Table z) -> (x, Table (c:z))-  (List z) ->  (x, List (z))--addItem :: [Quill] -> (String, String, String) -> [Quill]-addItem x (a, b, c)= case getQuill x a of-  QuillSuccess (y, ys) -> case ys of-    (Table d) -> (y,Table $ (b,c) : d) : removeQuill x a-    (List d)  -> (y,List  $ (c:d)) : removeQuill x a-  QuillMultiple -> error "Multiple found"-  QuillMissing -> error "Not found quill!"--changeItem :: [Quill] -> (String, String, String) -> [Quill]-changeItem x (a,b,c) = addItem (removeItem x (a,b)) (a,b,c)---- Helping functions for writing / reading to files.--- | Turn a Quill table into a string.-toString :: Quill -> String-toString (nm,typ) = case typ of-  (List a)  -> ("list(" ++ nm ++ "){" ++ (Cm.flt (map (\c -> (c ++ ";")) a))) ++ "}"-  (Table a) -> ("table(" ++ nm ++ "){" ++ (Cm.flt $ stringify a)) ++ "}"-  where-    stringify [] = []-    stringify ((a,b):xs) = (a ++ ":" ++ b ++ ";") : stringify xs---- [Q2N1]--- I had a long debate about this function. What it does is removes tables, but it will remove ALL tables. Since--- Quill2 treats multiple tables of the same name as an error, I'm choosing to make it a sanitization function as--- well. Database clients beware.

@@ -0,0 +1,96 @@+{- |+   Module      :   Cookbook.Project.Quill.Quill2.Q2Api+   Copyright   :   (c) 2014 by Nate Pisarski+   License     :   BSD3+   Maintainer  :   nathanpisarski@gmail.com+   Stability   :   Stable+   Portability :   Portable (Cookbook)+Q2Api is the user-facing part of Quill. It has all the functions necessar to Create, Read, Update, and Delete information from the database, and turn a database back into a Quill-readable string.+-}++module Cookbook.Project.Quill.Quill2.Q2Api where++import qualified Cookbook.Ingredients.Tupples.Look as Lk+import qualified Cookbook.Essential.Common         as Cm+import qualified Cookbook.Essential.Continuous     as Ct+import qualified Cookbook.Ingredients.Lists.Access as Ac++import Cookbook.Project.Quill.Quill2.Q2Prelude++-- | Get the name of a Quill.+getQuillName :: Quill -> String+getQuillName = fst++-- | Return the element of the Quill, specifically useful for lists.+getQuillBody :: Quill -> Element String+getQuillBody = snd++-- | Find a quill in the database by name, returning it or a possible error type.+getQuill :: [Quill] -> String -> QuillStatus+getQuill [] _ = QuillMissing+getQuill (x:xs) c+  | Ac.count (map getQuillName (x:xs)) c > 1 = QuillMultiple+  | getQuillName x  == c = QuillSuccess x+  | otherwise = getQuill xs c++-- | Look up the value of a Quill TABLE. Will produce an error on a list.+lookUp :: [Quill] -> (String, String) -> String+lookUp x (a,b) = case (getQuill x a) of+  QuillMissing  -> error $ "Table not found."+  QuillMultiple -> error $ "Multiple values of " ++ a ++ " detected. Database eror, fix manually."+  (QuillSuccess (c,d)) -> case d of+    (List f) -> error "Cannot look up the value of a list."+    (Table f) -> let c = Lk.lookList f b in if (c == []) then (error $ "Item " ++ b ++ " not found in table " ++ a) else (if (length c > 1) then multipleInnerError else (head c))+    where multipleInnerError = error $ "Multiple values of " ++ b ++ " found in table " ++ a ++ ". Database corrupted, change manually."++-- | Remove a quill from the database by name.+removeQuill :: [Quill] -> String -> [Quill]+removeQuill [] _ = []+removeQuill ((x,y):xs) c+  | x == c = removeQuill xs c -- See [Q2N1]+  | otherwise = (x,y) : removeQuill xs c++-- | Remove an item from a Quill within a database. Works aggressively, meaning it removes all copies to help sanitize QuillMultiples out.+removeItem :: [Quill] -> (String, String) -> [Quill]+removeItem x (a,b) = case (getQuill x a) of+  QuillSuccess (c,j) -> case j of+    (Table d) -> (c,(Table [(y,t) | (y,t) <- d, y /= b])) : (removeQuill x a)+    (List d) -> (c,List $ Ct.remove d c) : removeQuill x a+  _ -> (let l = lookUp x (a,b) in x) -- This goes against everything that haskell means.++-- | Adds a Quill databse to the file.+addQuill :: [Quill] -> Quill -> [Quill]+addQuill x c = c : x++-- | Add a QuillAddition to the databse. QuillAddition is a safe encapsulation of list and table values.+addItem :: [Quill] -> QuillAddition -> [Quill]+addItem x qa= case getQuill x a of+  QuillSuccess (y, ys) -> case ys of+    (Table d) -> case qa of+      (ATable (_,b,c)) -> (y,Table $ (b,c) : d) : removeQuill x a+      (AList _ ) -> error $ "$ Type Mismatch! Attempted to add a List type to Table in table " ++ (show qa)+    (List d)  -> case qa of+      (AList (_,b)) -> (y, List $ (b:d)) : removeQuill x a+      (ATable _) -> error $ "Type MisMatch! Attempted to add Table type to List in table " ++ (show qa)+  QuillMultiple -> error "Multiple found"+  QuillMissing -> error "Not found quill!"+  where+    a = case qa of+      (ATable (g,b,c)) -> g+      (AList  (g,b))   -> g++-- | Change an item within the database using a Quill addition. Wrapper of addItem and removeItem.+changeItem :: [Quill] -> QuillAddition -> [Quill]+changeItem x y = case y of+                      (ATable (a,b,c)) -> addItem (removeItem x (a,b)) y+                      (AList  (a,b)) -> addItem (removeItem x (a,b)) y+++-- | Turn a Quill table into a string.+toString :: Quill -> String+toString (nm,typ) = case typ of+  (List a)  -> ("list(" ++ nm ++ "){" ++ (Cm.flt (map (\c -> (c ++ ";")) a))) ++ "}"+  (Table a) -> ("table(" ++ nm ++ "){" ++ (Cm.flt $ stringify a)) ++ "}"+  where+    stringify [] = []+    stringify ((a,b):xs) = (a ++ ":" ++ b ++ ";") : stringify xs

@@ -0,0 +1,28 @@+{- |+   Module      :   Cookbook.Project.Quill.Quill2.Q2Io+   Copyright   :   (c) 2014 by Nate Pisarski+   License     :   BSD3+   Maintainer  :   nathanpisarski@gmail.com+   Stability   :   Stable+   Portability :   Portable (Cookbook)+Q2Io is a helper library for interacting with Quill files. It aids in the reading of and writing to files on the user's system.+-}++module Cookbook.Project.Quill.Quill2.Q2Io where++import qualified Cookbook.Project.Quill.Quill2.Q2Api as Q2Api++import qualified Cookbook.Essential.IO as Io++import Cookbook.Project.Quill.Quill2.Q2Prelude+import Cookbook.Project.Quill.Quill2.Q2Parse++import System.IO++-- | Read a Quill database from a file.+fromFile :: FilePath ->  IO ([Quill])+fromFile x = fmap pFile $ Io.filelines x++-- | Send a Quill database into a parsable format in a file.+toFile :: FilePath -> [Quill] -> IO ()+toFile x c = writeFile x $ unlines $ map Q2Api.toString c

@@ -0,0 +1,48 @@+{- |+   Module      :   Cookbook.Project.Quill.Quill2.Q2Parse+   Copyright   :   (c) 2014 by Nate Pisarski+   License     :   BSD3+   Maintainer  :   nathanpisarski@gmail.com+   Stability   :   Stable+   Portability :   Portable (Cookbook)+Q2Parse is the "engine" of Quill2. It is able to turn a string (or a list of them) into a Quill database. The syntax of Quill currently supports Whitespace-inclusive strings, comments, and whitespace-independence.+-}++module Cookbook.Project.Quill.Quill2.Q2Parse where++import qualified Cookbook.Essential.Common         as Cm+import qualified Cookbook.Essential.Continuous     as Ct++import qualified Cookbook.Ingredients.Lists.Modify    as Md+import qualified Cookbook.Ingredients.Lists.Access    as Ac+import qualified Cookbook.Ingredients.Lists.Encompass as En++import Cookbook.Project.Quill.Quill2.Q2Prelude++-- | Remove all C-style comments frm the code. Does not support single-line comments, because Quill2 is fully whitespace independant.+decomment :: String -> String+decomment = (`Ct.splice` ("/*", "*/"))++-- | Prepare the lines of a file for processing.+prepare :: [String] -> String+prepare = decomment . (`Ct.remove` '\n') . unlines++-- | Process a single entry in the database into a Table.+pTable :: String -> Quill+pTable x = typ+  where+    name = Md.between (Ct.before x '{') ('(',')') --table(name) or list(name)+    typ  = (name,if (Ct.before x '{') `Ac.contains` "table" then Table (parseTables body) else List body)+    body = Md.splitOn (En.encompassing x ('{','}')) ';'+    quoted y = if ('`','\'') `Ac.surrounds` y then En.encompassing x ('`','\'') else Ct.remove y ' '+    parseTables [] = []+    parseTables (x:xs) =(quoted $ Ct.before x ':', Ct.after x ':') : parseTables xs++-- | Turn the lines of a file into a list of tables, AKA a Database.+pFile :: [String] -> [Quill]+pFile x = case allTables of+  [] -> []+  (y:ys) -> pTable y : pFile ys+  where+    prepared  = prepare x+    allTables = Md.splitOn prepared '}'

@@ -0,0 +1,24 @@+{- |+   Module      :   Cookbook.Project.Quill.Quill2.Q2Prelude+   Copyright   :   (c) 2014 by Nate Pisarski+   License     :   BSD3+   Maintainer  :   nathanpisarski@gmail.com+   Stability   :   Stable+   Portability :   Portable (Cookbook)+Q2Prelude is the entry-level module for Quill2. It defines the data types that define data, databases, and errors throughout the rest of Quill2.+-}++module Cookbook.Project.Quill.Quill2.Q2Prelude where+       +-- | The body of a table or list.+data Element a = List [a] | Table [(a,a)] deriving (Eq, Show)++-- | Helper type. Binds a name to a body.+type Quill = (String,Element String)++-- | Encapsulates errors in the quill database. Currently supports Missing elements and Multiple Instances.+data QuillStatus = QuillSuccess Quill | QuillMissing | QuillMultiple deriving (Eq, Show)++-- | Safe way of adding items to a Quill database. Allows type-checking on Lists and Tables when manipulating Elements.+data QuillAddition = AList (String, String) | ATable (String, String, String) deriving (Eq, Show)+

@@ -3,7 +3,7 @@ -- PVP summary:      +-+------- breaking API changes --                   | | +----- non-breaking API additions --                   | | | +--- code changes with no API change-version:             2.3.1.0+version:             2.3.2.0 synopsis:	Tiered general-purpose libraries with domain-specific applications. description:		Cookbook is a line of libraries covering a wide variety of Haskell applications. Every application that I make, I add its functions to Cookbook, turning Cookbook into an all-encompassing general-purpose library over time. The claim-to-fame for the library is its use of overloaded typeclasses, called "Continuities".  license:             BSD3@@ -16,7 +16,7 @@ build-type:          Simple cabal-version:       >=1.8 library -  exposed-modules:      Cookbook.Essential.Common, Cookbook.Essential.Continuous, Cookbook.Essential.IO,   Cookbook.Project.Configuration.Configuration, Cookbook.Project.Preprocess.Preprocess, Cookbook.Ingredients.Functional.Break, Cookbook.Ingredients.Lists.Access, Cookbook.Ingredients.Lists.Modify, Cookbook.Ingredients.Lists.Stats, Cookbook.Ingredients.Tupples.Look, Cookbook.Ingredients.Tupples.Assemble,  Cookbook.Recipes.Sanitize, Cookbook.Recipes.Math,Cookbook.Recipes.DataStructures,Cookbook.Recipes.Algorithm, Cookbook.Project.Quill.Quill, Cookbook.Recipes.Cline, Cookbook.Ingredients.Lists.Encompass, Cookbook.Project.Quill.Quill2+  exposed-modules:      Cookbook.Essential.Common, Cookbook.Essential.Continuous, Cookbook.Essential.IO,   Cookbook.Project.Configuration.Configuration, Cookbook.Project.Preprocess.Preprocess, Cookbook.Ingredients.Functional.Break, Cookbook.Ingredients.Lists.Access, Cookbook.Ingredients.Lists.Modify, Cookbook.Ingredients.Lists.Stats, Cookbook.Ingredients.Tupples.Look, Cookbook.Ingredients.Tupples.Assemble,  Cookbook.Recipes.Sanitize, Cookbook.Recipes.Math,Cookbook.Recipes.DataStructures,Cookbook.Recipes.Algorithm, Cookbook.Project.Quill.Quill, Cookbook.Recipes.Cline, Cookbook.Ingredients.Lists.Encompass, Cookbook.Project.Quill.Quill2.Q2Parse, Cookbook.Project.Quill.Quill2.Q2Prelude, Cookbook.Project.Quill.Quill2.Q2Api, Cookbook.Project.Quill.Quill2.Q2Io   build-depends:       base ==4.6.*, directory, strict source-repository head   type: git