Configuration for the clod program

Result of processing a file

• Success indicates the file was successfully processed and included
• Skipped indicates the file was skipped with a reason (matched ignore pattern, binary file, etc.)

Errors that can occur during Clod operation

These represent the different categories of errors that can occur during file processing, allowing for specific error handling for each case.

Database error types for more specific error reporting

The Clod monad

This monad stack combines:

• Reader for dependency injection of ClodConfig
• Error handling with ExceptT for ClodError
• IO for filesystem, git, and other side effects

This replaces the previous effects-based approach with a simpler, more traditional monad stack.

File entry in the checksum database

Main database structure

Serialization-friendly version of ClodDatabase

Convert to serializable form

Convert from serializable form

Validation type for collecting multiple errors This allows us to accumulate errors instead of stopping at the first one

Convert from Validated to Either for compatibility

Convert from Either to Validated for integration

Run a ClodM computation, returning either an error or a result

Is used within a monadic computation to begin exception processing.

A handler function to handle previous errors and return to normal execution. A common idiom is:

do { action1; action2; action3 } `catchError` handler

where the action functions can call throwError. Note that handler and the do-block must have the same return type.

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

Retrieves the monad environment.

Retrieves a function of the current environment.

Executes a computation in a modified environment.

The inverse of ExceptT.

Newtype for ignore patterns to prevent mixing with other string types

Newtype for optimized filename used in Claude's UI

Newtype for original filepath in the repository

Newtype for file checksums to prevent mixing with other string types

Capability for reading files within certain directories

Capability for writing files within certain directories

Create a file read capability for specified directories

Create a file write capability for specified directories

Check if a path is within allowed directories This improved version handles path traversal attacks by comparing canonical paths

View the value pointed to by a Getter or Lens or the result of folding over all the results of a Fold or Traversal that points at a monoidal values.

This is the same operation as view with the arguments flipped.

The fixity and semantics are such that subsequent field accesses can be performed with (.).

>>> (a,b)^._2
b

>>> ("hello","world")^._2
"world"

>>> import Data.Complex
>>> ((0, 1 :+ 2), 3)^._1._2.to magnitude
2.23606797749979

(^.) ::             s -> Getter s a     -> a
(^.) :: Monoid m => s -> Fold s m       -> m
(^.) ::             s -> Iso' s a       -> a
(^.) ::             s -> Lens' s a      -> a
(^.) :: Monoid m => s -> Traversal' s m -> m

Replace the target of a Lens or all of the targets of a Setter or Traversal with a constant value.

This is an infix version of set, provided for consistency with (.=).

f <$ a ≡ mapped .~ f $ a

>>> (a,b,c,d) & _4 .~ e
(a,b,c,e)

>>> (42,"world") & _1 .~ "hello"
("hello","world")

>>> (a,b) & both .~ c
(c,c)

(.~) :: Setter s t a b    -> b -> s -> t
(.~) :: Iso s t a b       -> b -> s -> t
(.~) :: Lens s t a b      -> b -> s -> t
(.~) :: Traversal s t a b -> b -> s -> t

Modifies the target of a Lens or all of the targets of a Setter or Traversal with a user supplied function.

This is an infix version of over.

fmap f ≡ mapped %~ f
fmapDefault f ≡ traverse %~ f

>>> (a,b,c) & _3 %~ f
(a,b,f c)

>>> (a,b) & both %~ f
(f a,f b)

>>> _2 %~ length $ (1,"hello")
(1,5)

>>> traverse %~ f $ [a,b,c]
[f a,f b,f c]

>>> traverse %~ even $ [1,2,3]
[False,True,False]

>>> traverse.traverse %~ length $ [["hello","world"],["!!!"]]
[[5,5],[3]]

(%~) :: Setter s t a b    -> (a -> b) -> s -> t
(%~) :: Iso s t a b       -> (a -> b) -> s -> t
(%~) :: Lens s t a b      -> (a -> b) -> s -> t
(%~) :: Traversal s t a b -> (a -> b) -> s -> t

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

This is a version of flip id, where id is specialized from a -> a to (a -> b) -> (a -> b) which by the associativity of (->) is (a -> b) -> a -> b. flipping this yields a -> (a -> b) -> b which is the type signature of &

Examples

>>> 5 & (+1) & show
"6"

>>> sqrt $ [1 / n^2 | n <- [1..1000]] & sum & (*6)
3.1406380562059946

Since: base-4.8.0.0

Lens for projectPath field

Lens for stagingDir field

Lens for configDir field

Lens for databaseFile field

Lens for timestamp field

Lens for currentStaging field

Lens for previousStaging field

Lens for testMode field

Lens for verbose field

Lens for flushMode field

Lens for lastMode field

Lens for ignorePatterns field

Lens for dbFiles field

Lens for dbChecksums field

Lens for dbLastStagingDir field

Lens for dbLastRunTime field

Lens for entryPath field

Lens for entryChecksum field

Lens for entryLastModified field

Lens for entryOptimizedName field

Lens for allowedReadDirs field

Lens for allowedWriteDirs field