diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,9 @@ # Changelog for `sarif` +## 0.2 - 1 November 2026 + +* Added Aeson instances for all objects listed in the SARIF v2.1.0 specification. [#5](https://github.com/mbg/sarif/pull/5) by [@lllssskkk](https://github.com/lllssskkk) + ## 0.1 - 22 December 2022 * First release with an initial implementation of some key aspects of the SARIF specification diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -1,3 +1,14 @@ # SARIF implementation for Haskell +![GitHub](https://img.shields.io/github/license/mbg/sarif) +![Haskell CI](https://github.com/mbg/sarif/actions/workflows/build.yml/badge.svg?branch=main) +![stackage-nightly](https://github.com/mbg/sarif/actions/workflows/stackage-nightly.yml/badge.svg?branch=main) +[![Hackage](https://img.shields.io/hackage/v/sarif)](https://hackage.haskell.org/package/sarif) + This Haskell library provides types and JSON instances for the [Static Analysis Results Interchange Format (SARIF)](https://sarifweb.azurewebsites.net). Static analysis tools written in Haskell may use this library to export their results which can then be consumed by e.g. [GitHub Code Scanning](https://docs.github.com/en/code-security/code-scanning/integrating-with-code-scanning). + +## References + +- [SARIF website](https://sarifweb.azurewebsites.net) +- [SARIF specification](https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.pdf) +- [SARIF tutorials](https://github.com/microsoft/sarif-tutorials/) diff --git a/sarif.cabal b/sarif.cabal --- a/sarif.cabal +++ b/sarif.cabal @@ -1,11 +1,11 @@ cabal-version: 1.12 --- This file has been generated from package.yaml by hpack version 0.35.1. +-- This file has been generated from package.yaml by hpack version 0.39.6. -- -- see: https://github.com/sol/hpack name: sarif -version: 0.1 +version: 0.2 synopsis: SARIF implementation for Haskell description: Provides types and JSON instances for the Static Analysis Results Interchange Format (SARIF). category: Data @@ -29,15 +29,59 @@ exposed-modules: Data.Aeson.Optional Data.SARIF + Data.SARIF.Address Data.SARIF.Artifact + Data.SARIF.ArtifactChange + Data.SARIF.ArtifactContent + Data.SARIF.ArtifactLocation + Data.SARIF.Attachment + Data.SARIF.AutomationDetails + Data.SARIF.CodeFlow + Data.SARIF.ConfigurationOverride + Data.SARIF.Conversion + Data.SARIF.Edge + Data.SARIF.EdgeTraversal + Data.SARIF.Exception + Data.SARIF.ExternalProperties + Data.SARIF.ExternalPropertyFileReference + Data.SARIF.ExternalPropertyFileReferences + Data.SARIF.Fix + Data.SARIF.Graph + Data.SARIF.GraphTraversal + Data.SARIF.Invocation Data.SARIF.Level Data.SARIF.Location + Data.SARIF.LocationRelationship Data.SARIF.Log + Data.SARIF.LogicalLocation + Data.SARIF.Message Data.SARIF.MultiformatMessageString + Data.SARIF.Node + Data.SARIF.Notification + Data.SARIF.PhysicalLocation + Data.SARIF.Rectangle + Data.SARIF.Region + Data.SARIF.Replacement + Data.SARIF.ReportingConfiguration Data.SARIF.ReportingDescriptor + Data.SARIF.ReportingDescriptorReference + Data.SARIF.ReportingDescriptorRelationship Data.SARIF.Result + Data.SARIF.ResultProvenance Data.SARIF.Run + Data.SARIF.SpecialLocations + Data.SARIF.Stack + Data.SARIF.StackFrame + Data.SARIF.Suppression + Data.SARIF.ThreadFlow + Data.SARIF.ThreadFlowLocation Data.SARIF.Tool + Data.SARIF.ToolComponent + Data.SARIF.ToolComponentReference + Data.SARIF.TranslationMetadata + Data.SARIF.VersionControlDetails + Data.SARIF.WebRequest + Data.SARIF.WebResponse other-modules: Paths_sarif hs-source-dirs: @@ -47,6 +91,7 @@ DeriveGeneric OverloadedStrings RecordWildCards + LambdaCase ghc-options: -Wall build-depends: aeson @@ -54,5 +99,6 @@ , bytestring , containers , text + , time , uuid-types default-language: Haskell2010 diff --git a/src/Data/Aeson/Optional.hs b/src/Data/Aeson/Optional.hs --- a/src/Data/Aeson/Optional.hs +++ b/src/Data/Aeson/Optional.hs @@ -19,8 +19,8 @@ -------------------------------------------------------------------------------- import Data.Aeson as Aeson hiding (object, (.=)) -import Data.Aeson.Types (Pair) import qualified Data.Aeson as JSON (object) +import Data.Aeson.Types (Pair) import Data.Maybe #if !MIN_VERSION_aeson(2,0,0) import Data.Text diff --git a/src/Data/SARIF.hs b/src/Data/SARIF.hs --- a/src/Data/SARIF.hs +++ b/src/Data/SARIF.hs @@ -7,20 +7,64 @@ -- | Re-exports all modules from this library. You probably want to import -- this module as qualified. -module Data.SARIF ( - module SARIF -) where +module Data.SARIF + ( module SARIF, + ) +where -------------------------------------------------------------------------------- +import Data.SARIF.Address as SARIF import Data.SARIF.Artifact as SARIF +import Data.SARIF.ArtifactChange as SARIF +import Data.SARIF.ArtifactContent as SARIF +import Data.SARIF.ArtifactLocation as SARIF +import Data.SARIF.Attachment as SARIF +import Data.SARIF.AutomationDetails as SARIF +import Data.SARIF.CodeFlow as SARIF +import Data.SARIF.ConfigurationOverride as SARIF +import Data.SARIF.Conversion as SARIF +import Data.SARIF.Edge as SARIF +import Data.SARIF.EdgeTraversal as SARIF +import Data.SARIF.Exception as SARIF +import Data.SARIF.ExternalPropertyFileReference as SARIF +import Data.SARIF.ExternalPropertyFileReferences as SARIF +import Data.SARIF.Fix as SARIF +import Data.SARIF.Graph as SARIF +import Data.SARIF.GraphTraversal as SARIF +import Data.SARIF.Invocation as SARIF import Data.SARIF.Level as SARIF import Data.SARIF.Location as SARIF +import Data.SARIF.LocationRelationship as SARIF import Data.SARIF.Log as SARIF +import Data.SARIF.LogicalLocation as SARIF +import Data.SARIF.Message as SARIF import Data.SARIF.MultiformatMessageString as SARIF +import Data.SARIF.Node as SARIF +import Data.SARIF.Notification as SARIF +import Data.SARIF.PhysicalLocation as SARIF +import Data.SARIF.Rectangle as SARIF +import Data.SARIF.Region as SARIF +import Data.SARIF.Replacement as SARIF +import Data.SARIF.ReportingConfiguration as SARIF import Data.SARIF.ReportingDescriptor as SARIF +import Data.SARIF.ReportingDescriptorReference as SARIF +import Data.SARIF.ReportingDescriptorRelationship as SARIF import Data.SARIF.Result as SARIF +import Data.SARIF.ResultProvenance as SARIF import Data.SARIF.Run as SARIF +import Data.SARIF.SpecialLocations as SARIF +import Data.SARIF.Stack as SARIF +import Data.SARIF.StackFrame as SARIF +import Data.SARIF.Suppression as SARIF +import Data.SARIF.ThreadFlow as SARIF +import Data.SARIF.ThreadFlowLocation as SARIF import Data.SARIF.Tool as SARIF +import Data.SARIF.ToolComponent as SARIF +import Data.SARIF.ToolComponentReference as SARIF +import Data.SARIF.TranslationMetadata as SARIF +import Data.SARIF.VersionControlDetails as SARIF +import Data.SARIF.WebRequest as SARIF +import Data.SARIF.WebResponse as SARIF -------------------------------------------------------------------------------- diff --git a/src/Data/SARIF/Address.hs b/src/Data/SARIF/Address.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Address.hs @@ -0,0 +1,115 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- +module Data.SARIF.Address + ( Address (..), + ) +where + +-------------------------------------------------------------------------------- + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.Text + +-------------------------------------------------------------------------------- + +data AddressKind + = DataKind + | HeaderKind + | FunctionKind + | InstructionKind + | PageKind + | SectionKind + | SegmentKind + | StackKind + | ModuleKind + | TableKind + deriving (Eq, Ord, Show) + +instance ToJSON AddressKind where + toJSON DataKind = String "data" + toJSON HeaderKind = String "header" + toJSON FunctionKind = String "function" + toJSON InstructionKind = String "instruction" + toJSON PageKind = String "page" + toJSON SectionKind = String "section" + toJSON SegmentKind = String "segment" + toJSON StackKind = String "stack" + toJSON ModuleKind = String "module" + toJSON TableKind = String "table" + +instance FromJSON AddressKind where + parseJSON = withText "AddressKind" $ \t -> + case t of + "data" -> pure DataKind + "header" -> pure HeaderKind + "function" -> pure FunctionKind + "instruction" -> pure InstructionKind + "page" -> pure PageKind + "section" -> pure SectionKind + "segment" -> pure SegmentKind + "stack" -> pure StackKind + "module" -> pure ModuleKind + "table" -> pure TableKind + _ -> fail $ "Unknown AddressKind: " ++ unpack t + +-------------------------------------------------------------------------------- + +-- | Represents default configurations for `ReportingDescriptor` values. That is +-- properties which may be overriden by individual results. +data Address + = MkAddress + { -- | The index property of an Address object + addressIndex :: Maybe Int + -- | The absoluteAddress property of an Address object + , addressAbsoluteAddress :: Maybe Integer + -- | The relativeAddress property of an Address object + , addressRelativeAddress :: Maybe Integer + -- | The offsetFromParent property of an Address object + , addressOffsetFromParent :: Maybe Integer + -- | The length property of an Address object + , addressLength :: Maybe Integer + -- | The name property of an Address object + , addressName :: Maybe Text + -- | The fullyQualifiedName property of an Address object + , addressFullyQualifiedName :: Maybe Text + -- | The kind property of an Address object + , addressKind :: Maybe AddressKind + -- | The parentIndex property of an Address object + , addressParentIndex :: Maybe Int + -- | The properties property of an Address object + , addressProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Address where + toJSON MkAddress {..} = + object + [ "index" .=? addressIndex, + "absoluteAddress" .=? addressAbsoluteAddress, + "relativeAddress" .=? addressRelativeAddress, + "offsetFromParent" .=? addressOffsetFromParent, + "length" .=? addressLength, + "name" .=? addressName, + "fullyQualifiedName" .=? addressFullyQualifiedName, + "kind" .=? addressKind, + "parentIndex" .=? addressParentIndex + ] + +instance FromJSON Address where + parseJSON = withObject "Address" $ \obj -> + MkAddress + <$> obj .:? "index" + <*> (obj .:? "absoluteAddress") + <*> obj .:? "relativeAddress" + <*> obj .:? "offsetFromParent" + <*> obj .:? "length" + <*> obj .:? "name" + <*> obj .:? "fullyQualifiedName" + <*> obj .:? "kind" + <*> obj .:? "parentIndex" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Artifact.hs b/src/Data/SARIF/Artifact.hs --- a/src/Data/SARIF/Artifact.hs +++ b/src/Data/SARIF/Artifact.hs @@ -6,36 +6,173 @@ -------------------------------------------------------------------------------- -- | Provides the `Artifact` type to represent SARIF artifacts. -module Data.SARIF.Artifact ( - Artifact(..) -) where +module Data.SARIF.Artifact + ( Artifact (..), + ) +where -------------------------------------------------------------------------------- import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ArtifactContent +import Data.SARIF.ArtifactLocation +import Data.SARIF.Message import Data.Text -import Data.SARIF.Location - -------------------------------------------------------------------------------- --- | An artifact represents e.g. a source file. -data Artifact = MkArtifact { - -- | The location where the artifact was found. - artifactLocation :: ArtifactLocation, - -- | The mime type of the artifact. - artifactMimeType :: Maybe Text -} deriving (Eq, Show) +data ArtifactRole + = ArtifactAnalysisTargetRole + | ArtifactAttachmentRole + | ArtifactConversionSourceRole + | ArtifactDebugOutputFileRole + | ArtifactDirectoryRole + | ArtifactDriverRole + | ArtifactExtensionRole + | ArtifactExternalPropertyFileRole + | ArtifactMemoryContentsRole + | ArtifactPolicyRole + | ArtifactReferencedOnCommandLineRole + | ArtifactRepositoryRootRole + | ArtifactResponseFileRole + | ArtifactResultFileRole + | ArtifactStandardStreamRole + | ArtifactTaxonomyRole + | ArtifactToolSpecifiedConfigurationRole + | ArtifactTracedFileRole + | ArtifactTranslationRole + | ArtifactUserSpecifiedConfigurationRole + | ArtifactAddedRole + | ArtifactDeletedRole + | ArtifiedModifiedRole + | ArtifactRenamedRole + | ArtifactUncontrolledRole + | ArtifactUnmodifiedRole + deriving (Eq, Ord, Show) +instance ToJSON ArtifactRole where + toJSON ArtifactAnalysisTargetRole = String "analysisTarget" + toJSON ArtifactAttachmentRole = String "attachment" + toJSON ArtifactConversionSourceRole = String "conversionSource" + toJSON ArtifactDebugOutputFileRole = String "debugOutputFile" + toJSON ArtifactDirectoryRole = String "directory" + toJSON ArtifactDriverRole = String "driver" + toJSON ArtifactExtensionRole = String "extension" + toJSON ArtifactExternalPropertyFileRole = String "externalPropertyFile" + toJSON ArtifactMemoryContentsRole = String "memoryContents" + toJSON ArtifactPolicyRole = String "policy" + toJSON ArtifactReferencedOnCommandLineRole = String "referencedOnCommandLine" + toJSON ArtifactRepositoryRootRole = String "repositoryRoot" + toJSON ArtifactResponseFileRole = String "responseFile" + toJSON ArtifactResultFileRole = String "resultFile" + toJSON ArtifactStandardStreamRole = String "standardStream" + toJSON ArtifactTaxonomyRole = String "taxonomy" + toJSON ArtifactToolSpecifiedConfigurationRole = String "toolSpecifiedConfiguration" + toJSON ArtifactTracedFileRole = String "tracedFile" + toJSON ArtifactTranslationRole = String "translation" + toJSON ArtifactUserSpecifiedConfigurationRole = String "userSpecifiedConfiguration" + toJSON ArtifactAddedRole = String "added" + toJSON ArtifactDeletedRole = String "deleted" + toJSON ArtifiedModifiedRole = String "modified" + toJSON ArtifactRenamedRole = String "renamed" + toJSON ArtifactUncontrolledRole = String "uncontrolled" + toJSON ArtifactUnmodifiedRole = String "unmodified" + +instance FromJSON ArtifactRole where + parseJSON = withText "ArtifactRole" $ \case + "analysisTarget" -> pure ArtifactAnalysisTargetRole + "attachment" -> pure ArtifactAttachmentRole + "conversionSource" -> pure ArtifactConversionSourceRole + "debugOutputFile" -> pure ArtifactDebugOutputFileRole + "directory" -> pure ArtifactDirectoryRole + "driver" -> pure ArtifactDriverRole + "extension" -> pure ArtifactExtensionRole + "externalPropertyFile" -> pure ArtifactExternalPropertyFileRole + "memoryContents" -> pure ArtifactMemoryContentsRole + "policy" -> pure ArtifactPolicyRole + "referencedOnCommandLine" -> pure ArtifactReferencedOnCommandLineRole + "repositoryRoot" -> pure ArtifactRepositoryRootRole + "responseFile" -> pure ArtifactResponseFileRole + "resultFile" -> pure ArtifactResultFileRole + "standardStream" -> pure ArtifactStandardStreamRole + "taxonomy" -> pure ArtifactTaxonomyRole + "toolSpecifiedConfiguration" -> pure ArtifactToolSpecifiedConfigurationRole + "tracedFile" -> pure ArtifactTracedFileRole + "translation" -> pure ArtifactTranslationRole + "userSpecifiedConfiguration" -> pure ArtifactUserSpecifiedConfigurationRole + "added" -> pure ArtifactAddedRole + "deleted" -> pure ArtifactDeletedRole + "modified" -> pure ArtifiedModifiedRole + "renamed" -> pure ArtifactRenamedRole + "uncontrolled" -> pure ArtifactUncontrolledRole + "unmodified" -> pure ArtifactUnmodifiedRole + other -> fail $ "Unknown ArtifactRole: " <> unpack other + +data Artifact + = MkArtifact + { -- | The location where the artifact was found. + artifactLocation :: Maybe ArtifactLocation + -- | The parentIndex property of the artifact. + , artifactParentIndex :: Maybe Int + -- | The offset property of the artifact. + , artifactOffset :: Maybe Int + -- | The length property of the artifact. + , artifactLength :: Maybe Int + -- | The roles property of the artifact. + , artifactRoles :: Maybe [ArtifactRole] + -- | The mimeType property of the artifact. + , artifactMimeType :: Maybe Text + -- | The contents property of the artifact. + , artifactContents :: Maybe ArtifactContent + -- | The encoding property of the artifact. + , artifactEncoding :: Maybe Text + -- | The sourceLanguage property of the artifact. + , artifactSourceLanguage :: Maybe Text + -- | The hashes property of the artifact. + , artifactHashes :: Maybe [(Text, Text)] + -- | The lastModifiedTimeUtc property of the artifact. + , artifactLastModifiedTimeUtc :: Maybe Text + -- | The description property of the artifact. + , artifactDescription :: Maybe Message + -- | The properties property of an Artifact object + , artifactProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + instance ToJSON Artifact where - toJSON MkArtifact{..} = object - [ "location" .= artifactLocation - , "mimeType" .=? artifactMimeType - ] + toJSON MkArtifact {..} = + object + [ "location" .=? artifactLocation, + "parentIndex" .=? artifactParentIndex, + "offset" .=? artifactOffset, + "length" .=? artifactLength, + "roles" .=? artifactRoles, + "mimeType" .=? artifactMimeType, + "contents" .=? artifactContents, + "encoding" .=? artifactEncoding, + "sourceLanguage" .=? artifactSourceLanguage, + "hashes" .=? artifactHashes, + "lastModifiedTimeUtc" .=? artifactLastModifiedTimeUtc, + "description" .=? artifactDescription, + "properties" .=? artifactProperties + ] instance FromJSON Artifact where - parseJSON = withObject "Artifact" $ \obj -> - MkArtifact <$> obj .: "location" - <*> obj .:? "mimeType" + parseJSON = withObject "Artifact" $ \v -> + MkArtifact + <$> v .:? "location" + <*> v .:? "parentIndex" + <*> v .:? "offset" + <*> v .:? "length" + <*> v .:? "roles" + <*> v .:? "mimeType" + <*> v .:? "contents" + <*> v .:? "encoding" + <*> v .:? "sourceLanguage" + <*> v .:? "hashes" + <*> v .:? "lastModifiedTimeUtc" + <*> v .:? "description" + <*> v .:? "properties" --------------------------------------------------------------------------------- +-- -------------------------------------------------------------------------------- diff --git a/src/Data/SARIF/ArtifactChange.hs b/src/Data/SARIF/ArtifactChange.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/ArtifactChange.hs @@ -0,0 +1,41 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `ArtifactChange` type to represent SARIF artifacts. +module Data.SARIF.ArtifactChange where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ArtifactLocation +import Data.SARIF.Replacement +import Data.Text + +data ArtifactChange + = MkArtifactChange + { -- | The artifactLocation property of the artifact change + artifactChangeArtifactLocation :: ArtifactLocation + -- | The replacement property of the artifact change + , artifactChangeReplacementArtifacts :: [Replacement] + -- | The properties property of an ArtifactChange object + , artifactChangeProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON ArtifactChange where + toJSON MkArtifactChange {..} = + object + [ "artifactLocation" .= artifactChangeArtifactLocation, + "replacements" .= artifactChangeReplacementArtifacts, + "properties" .=? artifactChangeProperties + ] + +instance FromJSON ArtifactChange where + parseJSON = withObject "ArtifactChange" $ \obj -> + MkArtifactChange + <$> obj .: "artifactLocation" + <*> obj .: "replacements" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/ArtifactContent.hs b/src/Data/SARIF/ArtifactContent.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/ArtifactContent.hs @@ -0,0 +1,47 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `ArtifactContent` type to represent SARIF artifacts. +module Data.SARIF.ArtifactContent + ( ArtifactContent (..), + ) +where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.MultiformatMessageString +import Data.Text + +data ArtifactContent + = MkArtifactContent + { -- | The text property of an artifactContent object + artifactContentText :: Maybe Text + -- | The binary property of an artifactContent object + , artifactContentBinary :: Maybe Text + -- | The rendered property of an artifactContent object + , artifactContentRendered :: Maybe MultiformatMessageString + -- | The properties property of an ArtifactContent object + , artifactContentProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON ArtifactContent where + toJSON MkArtifactContent {..} = + object + [ "text" .=? artifactContentText, + "binary" .=? artifactContentBinary, + "rendered" .=? artifactContentRendered, + "properties" .=? artifactContentProperties + ] + +instance FromJSON ArtifactContent where + parseJSON = withObject "ArtifactContent" $ \obj -> + MkArtifactContent + <$> obj .: "text" + <*> obj .:? "binary" + <*> obj .:? "rendered" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/ArtifactLocation.hs b/src/Data/SARIF/ArtifactLocation.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/ArtifactLocation.hs @@ -0,0 +1,52 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `ArtifactLocation` type to represent SARIF artifacts. +module Data.SARIF.ArtifactLocation + ( ArtifactLocation (..), + ) +where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Message +import Data.Text + +data ArtifactLocation + = MkArtifactLocation + { -- | The uri property of an artifactLocation object + artifactLocUri :: Maybe Text + -- | The uriBasedId property of an artifactLocation object + , artifactLocUriBaseId :: Maybe Text + -- | The index property of an artifactLocation object + , artifactLocIndex :: Maybe Int + -- | The description property of an artifactLocation object + , artifactLocDescription :: Maybe Message + -- | The properties property of an ArtifactLocation object + , artifactLocProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + + +instance ToJSON ArtifactLocation where + toJSON MkArtifactLocation {..} = + object + [ "uri" .=? artifactLocUri, + "uriBaseId" .=? artifactLocUriBaseId, + "index" .=? artifactLocIndex, + "description" .=? artifactLocDescription, + "properties" .=? artifactLocProperties + ] + +instance FromJSON ArtifactLocation where + parseJSON = withObject "ArtifactLocation" $ \obj -> + MkArtifactLocation + <$> (obj .:? "uri") + <*> (obj .:? "uriBaseId") + <*> obj .:? "index" + <*> obj .:? "description" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Attachment.hs b/src/Data/SARIF/Attachment.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Attachment.hs @@ -0,0 +1,51 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `Attachment` type to represent SARIF artifacts. +module Data.SARIF.Attachment where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Location +import Data.SARIF.Message +import Data.SARIF.Rectangle +import Data.SARIF.Region +import Data.Text + +data Attachment + = MkAttachment + { -- | The description property of the attachment + attachmentDescription :: Maybe Message + -- | The location property of the attachment + , attachmentLocation :: Maybe Location + -- | The region property of the attachment + , attachmentRegion :: Maybe [Region] + -- | The rectangle property of the attachment + , attachmentRectangle :: Maybe [Rectangle] + -- | The properties property of an Attachment object + , attachmentProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Attachment where + toJSON MkAttachment {..} = + object + [ "description" .=? attachmentDescription, + "location" .=? attachmentLocation, + "region" .=? attachmentRegion, + "rectangle" .=? attachmentRectangle, + "properties" .=? attachmentProperties + ] + +instance FromJSON Attachment where + parseJSON = withObject "Attachment" $ \obj -> + MkAttachment + <$> obj .:? "description" + <*> obj .:? "location" + <*> obj .:? "region" + <*> obj .:? "rectangle" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/AutomationDetails.hs b/src/Data/SARIF/AutomationDetails.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/AutomationDetails.hs @@ -0,0 +1,48 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `AutomationDetails` type to represent SARIF artifacts. +module Data.SARIF.AutomationDetails (AutomationDetails (..)) where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Message +import Data.Text + +data AutomationDetails + = MkAutomationDetails + { -- | The description property of the automation details + automationDetailsDescription :: Maybe Message + -- | The id property of the automation details + , automationDetailsId :: Maybe Text + -- | The guid property of the automation details + , automationDetailsGuid :: Maybe Text + -- | The correlationGuid property of the automation details + , automationDetailsCorrelationGuid :: Maybe Text + -- | The properties property of the automation details + , automationDetailsProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON AutomationDetails where + toJSON MkAutomationDetails {..} = + object + [ "description" .=? automationDetailsDescription, + "id" .=? automationDetailsId, + "guid" .=? automationDetailsGuid, + "correlationGuid" .=? automationDetailsCorrelationGuid, + "properties" .=? automationDetailsProperties + ] + +instance FromJSON AutomationDetails where + parseJSON = withObject "AutomationDetails" $ \obj -> + MkAutomationDetails + <$> obj .:? "description" + <*> obj .:? "id" + <*> obj .:? "guid" + <*> obj .:? "correlationGuid" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/CodeFlow.hs b/src/Data/SARIF/CodeFlow.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/CodeFlow.hs @@ -0,0 +1,37 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `CodeFlow` type to represent SARIF artifacts. +module Data.SARIF.CodeFlow where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ThreadFlow +import Data.Text + +data CodeFlow + = MkCodeFlow + { codeFlowMessage :: Maybe Text + , codeFlowThreadFlows :: [ThreadFlow] + , codeFlowProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON CodeFlow where + toJSON MkCodeFlow {..} = + object + [ "message" .=? codeFlowMessage, + "threadFlows" .= codeFlowThreadFlows, + "properties" .=? codeFlowProperties + ] + +instance FromJSON CodeFlow where + parseJSON = withObject "CodeFlow" $ \obj -> + MkCodeFlow + <$> obj .:? "message" + <*> obj .: "threadFlows" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/ConfigurationOverride.hs b/src/Data/SARIF/ConfigurationOverride.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/ConfigurationOverride.hs @@ -0,0 +1,41 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `ConfigurationOverride` type to represent SARIF artifacts. +module Data.SARIF.ConfigurationOverride where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ReportingConfiguration +import Data.SARIF.ReportingDescriptorReference +import Data.Text + +data ConfigurationOverride + = MkConfigurationOverride + { -- | The descriptor property of the configuration override + configurationOverrideDescriptor :: ReportingDescriptorReference + -- | The configuration property of the configuration override + , configurationOverrideConfiguration :: ReportingConfiguration + -- | The properties property of the ConfigurationOverride object + , configurationOverrideProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON ConfigurationOverride where + toJSON MkConfigurationOverride {..} = + object + [ "descriptor" .= configurationOverrideDescriptor, + "configuration" .= configurationOverrideConfiguration, + "properties" .=? configurationOverrideProperties + ] + +instance FromJSON ConfigurationOverride where + parseJSON = withObject "ConfigurationOverride" $ \obj -> + MkConfigurationOverride + <$> obj .: "descriptor" + <*> obj .: "configuration" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Conversion.hs b/src/Data/SARIF/Conversion.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Conversion.hs @@ -0,0 +1,46 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `Conversion` type to represent SARIF artifacts. +module Data.SARIF.Conversion where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ArtifactLocation +import Data.SARIF.Invocation +import Data.SARIF.Tool +import Data.Text + +data Conversion + = MkConversion + { -- | The tool property of the conversion + conversionTool :: Tool + -- | The invocation property of the conversion + , conversionInvocation :: Maybe Invocation + -- | The analysisToolLogFiles property of the conversion + , conversionAnalysisToolLogFiles :: Maybe [ArtifactLocation] + -- | The properties property of the Conversion object + , conversionProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Conversion where + toJSON MkConversion {..} = + object + [ "tool" .= conversionTool, + "invocation" .=? conversionInvocation, + "analysisToolLogFiles" .=? conversionAnalysisToolLogFiles, + "properties" .=? conversionProperties + ] + +instance FromJSON Conversion where + parseJSON = withObject "Conversion" $ \obj -> + MkConversion + <$> obj .: "tool" + <*> obj .:? "invocation" + <*> obj .:? "analysisToolLogFiles" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Edge.hs b/src/Data/SARIF/Edge.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Edge.hs @@ -0,0 +1,49 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `Edge` type to represent SARIF artifacts. +module Data.SARIF.Edge where + +import Data.Aeson.Optional +import Data.Map +import Data.SARIF.Message +import Data.SARIF.Node +import Data.Text + +data Edge + = MkEdge + { -- | The id property of the edge + edgeId :: Text + -- | The label property of the edge + , edgeLabel :: Maybe Message + -- | The sourceNodeId property of the edge + , edgeSourceNodeId :: Node + -- | The targetNodeId property of the edge + , edgeTargetNodeId :: Node + -- | The properties property of the Edge object + , edgeProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Edge where + toJSON MkEdge {..} = + object + [ "id" .= edgeId, + "label" .=? edgeLabel, + "sourceNodeId" .= edgeSourceNodeId, + "targetNodeId" .= edgeTargetNodeId, + "properties" .=? edgeProperties + ] + +instance FromJSON Edge where + parseJSON = withObject "Edge" $ \obj -> + MkEdge + <$> obj .: "id" + <*> obj .:? "label" + <*> obj .: "sourceNodeId" + <*> obj .: "targetNodeId" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/EdgeTraversal.hs b/src/Data/SARIF/EdgeTraversal.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/EdgeTraversal.hs @@ -0,0 +1,50 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `EdgeTraversal` type to represent SARIF artifacts. +module Data.SARIF.EdgeTraversal where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Edge +import Data.SARIF.Message +import Data.SARIF.MultiformatMessageString +import Data.Text + +data EdgeTraversal + = MkEdgeTraversal + { -- | The edgeId property of the edge traversal + edgeTraversalEdgeId :: Edge + -- | The message property of the edge traversal + , edgeTraversalMessage :: Maybe Message + -- | The finalState property of the edge traversal + , edgeTraversalFinalState :: Maybe (Map Text MultiformatMessageString) + -- | The stepOverEdgeCount property of the edge traversal + , edgeTraversalStepOverEdgeCount :: Maybe Int + -- | The properties property of the EdgeTraversal object + , edgeTraversalProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON EdgeTraversal where + toJSON MkEdgeTraversal {..} = + object + [ "edgeId" .= edgeTraversalEdgeId, + "message" .=? edgeTraversalMessage, + "finalState" .=? edgeTraversalFinalState, + "stepOverEdgeCount" .=? edgeTraversalStepOverEdgeCount, + "properties" .=? edgeTraversalProperties + ] + +instance FromJSON EdgeTraversal where + parseJSON = withObject "EdgeTraversal" $ \obj -> + MkEdgeTraversal + <$> obj .: "edgeId" + <*> obj .:? "message" + <*> obj .:? "finalState" + <*> obj .:? "stepOverEdgeCount" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Exception.hs b/src/Data/SARIF/Exception.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Exception.hs @@ -0,0 +1,48 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `Exception` type to represent SARIF artifacts. +module Data.SARIF.Exception (Exception (..)) where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Stack +import Data.Text + +data Exception + = MkException + { -- | The kind property of the exception + exceptionKind :: Text + -- | The message property of the exception + , exceptionMessage :: Text + -- | The stack property of the exception + , exceptionStack :: Maybe Stack + -- | The innerExceptions property of the exception + , exceptionInnerExceptions :: Maybe [Exception] + -- | The properties property of the Exception object + , exceptionProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Exception where + toJSON MkException {..} = + object + [ "kind" .= exceptionKind, + "message" .= exceptionMessage, + "stack" .=? exceptionStack, + "innerExceptions" .=? exceptionInnerExceptions, + "properties" .=? exceptionProperties + ] + +instance FromJSON Exception where + parseJSON = withObject "Exception" $ \obj -> + MkException + <$> obj .: "kind" + <*> obj .: "message" + <*> obj .:? "stack" + <*> obj .:? "innerExceptions" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/ExternalProperties.hs b/src/Data/SARIF/ExternalProperties.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/ExternalProperties.hs @@ -0,0 +1,47 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `ExternalProperties` type to represent SARIF artifacts. +module Data.SARIF.ExternalProperties where + +import Data.Aeson.Optional +import Data.SARIF.ExternalPropertyFileReferences +import Data.Text + +data ExternalProperties + = MkExternalProperties + { -- | The schema property of the external properties + externalPropertiesSchema :: Maybe Text + -- | The version property of the external properties + , externalPropertiesVersion :: Maybe Text + -- | The guid property of the external properties + , externalPropertiesGuid :: Text + -- | The runGuid property of the external properties + , externalPropertiesRunGuid :: Maybe Text + -- | The properties property of the external properties + , externalPropertiesProperties :: Maybe ExternalPropertyFileReferences + } + deriving (Eq, Ord, Show) + +instance ToJSON ExternalProperties where + toJSON MkExternalProperties {..} = + object + [ "$schema" .=? externalPropertiesSchema, + "version" .=? externalPropertiesVersion, + "guid" .= externalPropertiesGuid, + "runGuid" .=? externalPropertiesRunGuid, + "properties" .=? externalPropertiesProperties + ] + +instance FromJSON ExternalProperties where + parseJSON = withObject "ExternalProperties" $ \obj -> + MkExternalProperties + <$> obj .:? "$schema" + <*> obj .:? "version" + <*> obj .: "guid" + <*> obj .:? "runGuid" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/ExternalPropertyFileReference.hs b/src/Data/SARIF/ExternalPropertyFileReference.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/ExternalPropertyFileReference.hs @@ -0,0 +1,44 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `ExternalPropertyFileReference` type to represent SARIF artifacts. +module Data.SARIF.ExternalPropertyFileReference where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ArtifactLocation +import Data.Text + +data ExternalPropertyFileReference + = MkExternalPropertyFileReference + { -- | The location property of the external property file reference + externalPropertyFileReferenceLocation :: Maybe ArtifactLocation + -- | The guid property of the external property file reference + , externalPropertyFileReferenceGuid :: Maybe Text + -- | The itemCount property of the external property file reference + , externalPropertyFileReferenceItemCount :: Maybe Int + -- | The properties property of the ExternalPropertyFileReference object + , externalPropertyFileReferenceProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON ExternalPropertyFileReference where + toJSON MkExternalPropertyFileReference {..} = + object + [ "location" .=? externalPropertyFileReferenceLocation, + "guid" .=? externalPropertyFileReferenceGuid, + "itemCount" .=? externalPropertyFileReferenceItemCount, + "properties" .=? externalPropertyFileReferenceProperties + ] + +instance FromJSON ExternalPropertyFileReference where + parseJSON = withObject "ExternalPropertyFileReference" $ \obj -> + MkExternalPropertyFileReference + <$> obj .:? "location" + <*> obj .:? "guid" + <*> obj .:? "itemCount" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/ExternalPropertyFileReferences.hs b/src/Data/SARIF/ExternalPropertyFileReferences.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/ExternalPropertyFileReferences.hs @@ -0,0 +1,96 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `ExternalPropertyFileReferences` type to represent SARIF artifacts. +module Data.SARIF.ExternalPropertyFileReferences (ExternalPropertyFileReferences (..)) where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ExternalPropertyFileReference +import Data.Text + +data ExternalPropertyFileReferences + = MkExternalPropertyFileReferences + { -- | The addresses property of the external property file references + externalPropertyFileReferencesAddresses :: Maybe [ExternalPropertyFileReference] + -- | The artifacts property of the external property file references + , externalPropertyFileReferencesArtifacts :: Maybe [ExternalPropertyFileReference] + -- | The conversion property of the external property file references + , externalPropertyFileReferencesConversion :: Maybe ExternalPropertyFileReference + -- | The graphs property of the external property file references + , externalPropertyFileReferencesGraphs :: Maybe [ExternalPropertyFileReference] + -- | The invocations property of the external property file references + , externalPropertyFileReferencesInvocations :: Maybe [ExternalPropertyFileReference] + -- | The logicalLocations property of the external property file references + , externalPropertyFileReferencesLogicalLocations :: Maybe [ExternalPropertyFileReference] + -- | The policies property of the external property file references + , externalPropertyFileReferencesPolicies :: Maybe [ExternalPropertyFileReference] + -- | The externalizedProperties property of the external property file references + , externalPropertyFileReferencesExternalizedProperties :: Maybe ExternalPropertyFileReference + -- | The webRequests property of the external property file references + , externalPropertyFileReferencesWebRequests :: Maybe [ExternalPropertyFileReference] + -- | The webResponses property of the external property file references + , externalPropertyFileReferencesWebResponses :: Maybe [ExternalPropertyFileReference] + -- | The results property of the external property file references + , externalPropertyFileReferencesResults :: Maybe [ExternalPropertyFileReference] + -- | The taxonomies property of the external property file references + , externalPropertyFileReferencesTaxonomies :: Maybe [ExternalPropertyFileReference] + -- | The threadFlowLocations property of the external property file references + , externalPropertyFileReferencesThreadFlowLocations :: Maybe [ExternalPropertyFileReference] + -- | The translations property of the external property file references + , externalPropertyFileReferencesTranslations :: Maybe [ExternalPropertyFileReference] + -- | The driver property of the external property file references + , externalPropertyFileReferencesDriver :: Maybe ExternalPropertyFileReference + -- | The extensions property of the external property file references + , externalPropertyFileReferencesExtensions :: Maybe [ExternalPropertyFileReference] + -- | The properties property of the ExternalPropertyFileReferences object + , externalPropertyFileReferencesProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON ExternalPropertyFileReferences where + toJSON MkExternalPropertyFileReferences {..} = + object + [ "addresses" .=? externalPropertyFileReferencesAddresses, + "artifacts" .=? externalPropertyFileReferencesArtifacts, + "conversion" .=? externalPropertyFileReferencesConversion, + "graphs" .=? externalPropertyFileReferencesGraphs, + "invocations" .=? externalPropertyFileReferencesInvocations, + "logicalLocations" .=? externalPropertyFileReferencesLogicalLocations, + "policies" .=? externalPropertyFileReferencesPolicies, + "externalizedProperties" .=? externalPropertyFileReferencesExternalizedProperties, + "webRequests" .=? externalPropertyFileReferencesWebRequests, + "webResponses" .=? externalPropertyFileReferencesWebResponses, + "results" .=? externalPropertyFileReferencesResults, + "taxonomies" .=? externalPropertyFileReferencesTaxonomies, + "threadFlowLocations" .=? externalPropertyFileReferencesThreadFlowLocations, + "translations" .=? externalPropertyFileReferencesTranslations, + "driver" .=? externalPropertyFileReferencesDriver, + "extensions" .=? externalPropertyFileReferencesExtensions, + "properties" .=? externalPropertyFileReferencesProperties + ] + +instance FromJSON ExternalPropertyFileReferences where + parseJSON = withObject "ExternalPropertyFileReferences" $ \obj -> + MkExternalPropertyFileReferences + <$> obj .:? "addresses" + <*> obj .:? "artifacts" + <*> obj .:? "conversion" + <*> obj .:? "graphs" + <*> obj .:? "invocations" + <*> obj .:? "logicalLocations" + <*> obj .:? "policies" + <*> obj .:? "externalizedProperties" + <*> obj .:? "webRequests" + <*> obj .:? "webResponses" + <*> obj .:? "results" + <*> obj .:? "taxonomies" + <*> obj .:? "threadFlowLocations" + <*> obj .:? "translations" + <*> obj .:? "driver" + <*> obj .:? "extensions" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Fix.hs b/src/Data/SARIF/Fix.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Fix.hs @@ -0,0 +1,41 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `Fix` type to represent SARIF artifacts. +module Data.SARIF.Fix where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ArtifactChange +import Data.SARIF.Message +import Data.Text + +data Fix + = MkFix + { -- | The description property of the fix + fixDescription :: Message + -- | The artifactChanges property of the fix + , fixArtifactChanges :: [ArtifactChange] + -- | The properties property of the Fix object + , fixProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Fix where + toJSON MkFix {..} = + object + [ "description" .= fixDescription, + "artifactChanges" .= fixArtifactChanges, + "properties" .=? fixProperties + ] + +instance FromJSON Fix where + parseJSON = withObject "Fix" $ \obj -> + MkFix + <$> obj .: "description" + <*> obj .: "artifactChanges" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Graph.hs b/src/Data/SARIF/Graph.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Graph.hs @@ -0,0 +1,46 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `Graph` type to represent SARIF artifacts. +module Data.SARIF.Graph (Graph (..)) where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Edge +import Data.SARIF.Message +import Data.SARIF.Node +import Data.Text + +data Graph + = MkGraph + { -- | The description property of the graph + graphDescription :: Maybe Message + -- | The nodes property of the graph, + , graphNodes :: Maybe [Node] + -- | The edges property of the graph + , graphEdges :: Maybe [Edge] + -- | The properties property of the Graph object + , graphProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Graph where + toJSON MkGraph {..} = + object + [ "description" .=? graphDescription, + "nodes" .=? graphNodes, + "edges" .=? graphEdges, + "properties" .=? graphProperties + ] + +instance FromJSON Graph where + parseJSON = withObject "Graph" $ \obj -> + MkGraph + <$> obj .:? "description" + <*> obj .:? "nodes" + <*> obj .:? "edges" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/GraphTraversal.hs b/src/Data/SARIF/GraphTraversal.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/GraphTraversal.hs @@ -0,0 +1,58 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `GraphTraversal` type to represent SARIF artifacts. +module Data.SARIF.GraphTraversal where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.EdgeTraversal +import Data.SARIF.Message +import Data.SARIF.MultiformatMessageString +import Data.Text + +data GraphTraversal + = MkGraphTraversal + { -- | The resultGraphIndex property of the graph traversal + graphTraversalResultGraphIndex :: Maybe Int + -- | The runGraphIndex property of the graph traversal + , graphTraversalRunGraphIndex :: Maybe Int + -- | The description property of the graph traversal + , graphTraversalDescription :: Maybe Message + -- | The initialState property of the graph traversal + , graphTraversalInitialState :: Map Text MultiformatMessageString + -- | The immutableState property of the graph traversal + , graphTraversalImmutableState :: Map Text MultiformatMessageString + -- | The edgeTraversals property of the graph traversal + , graphTraversalEdgeTraversals :: Maybe [EdgeTraversal] + -- | The properties property of the GraphTraversal object + , graphTraversalProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON GraphTraversal where + toJSON MkGraphTraversal {..} = + object + [ "resultGraphIndex" .=? graphTraversalResultGraphIndex, + "runGraphIndex" .=? graphTraversalRunGraphIndex, + "description" .=? graphTraversalDescription, + "initialState" .= graphTraversalInitialState, + "immutableState" .= graphTraversalImmutableState, + "edgeTraversals" .=? graphTraversalEdgeTraversals, + "properties" .=? graphTraversalProperties + ] + +instance FromJSON GraphTraversal where + parseJSON = withObject "GraphTraversal" $ \obj -> + MkGraphTraversal + <$> obj .:? "resultGraphIndex" + <*> obj .:? "runGraphIndex" + <*> obj .:? "description" + <*> obj .: "initialState" + <*> obj .: "immutableState" + <*> obj .:? "edgeTraversals" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Invocation.hs b/src/Data/SARIF/Invocation.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Invocation.hs @@ -0,0 +1,134 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `Invocation` type to represent SARIF artifacts. +module Data.SARIF.Invocation (Invocation (..)) where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ArtifactLocation +import Data.SARIF.ConfigurationOverride +import Data.SARIF.Notification +import Data.Text + +data Invocation + = MkInvocation + { -- | The commandLine property of the invocation + invocationCommandLine :: Maybe Text + -- | The arguments property of the invocation + , invocationArguments :: Maybe [Text] + -- | The responseFiles property of the invocation + , invocationResponseFiles :: Maybe [ArtifactLocation] + -- | The ruleConfigurationOverrides property of the invocation + , invocationRuleConfigurationOverrides :: Maybe [ConfigurationOverride] + -- | The notificationConfigurationOverrides property of the invocation + , invocationNotificationConfigurationOverrides :: Maybe [ConfigurationOverride] + -- | The startTimeUtc property of the invocation + , invocationStartTimeUtc :: Maybe Text + -- | The endTimeUtc property of the invocation + , invocationEndTimeUtc :: Maybe Text + -- | The exitCode property of the invocation + , invocationExitCode :: Maybe Int + -- | The exitCodeDescription property of the invocation + , invocationExitCodeDescription :: Maybe Text + -- | The exitSignalName property of the invocation + , invocationExitSignalName :: Maybe Text + -- | The exitSignalNumber property of the invocation + , invocationExitSignalNumber :: Maybe Int + -- | The processStartFailureMessage property of the invocation + , invocationProcessStartFailureMessage :: Maybe Text + -- | The executionSuccessful property of the invocation + , invocationExecutionSuccessful :: Bool + -- | The machine property of the invocation + , invocationMachine :: Maybe Text + -- | The account property of the invocation + , invocationAccount :: Maybe Text + -- | The processId property of the invocation + , invocationProcessId :: Maybe Int + -- | The executableLocation property of the invocation + , invocationExecutableLocation :: Maybe ArtifactLocation + -- | The workingDirectory property of the invocation + , invocationWorkingDirectory :: Maybe ArtifactLocation + -- | The environmentVariables property of the invocation + , invocationEnvironmentVariables :: Maybe (Map Text Text) + -- | The toolExecutionNotifications property of the invocation + , invocationToolExecutionNotifications :: Maybe [Notification] + -- | The toolConfigurationNotifications property of the invocation + , invocationToolConfigurationNotifications :: Maybe [Notification] + -- | The stdin property of the invocation + , invocationStdin :: Maybe ArtifactLocation + -- | The stdout property of the invocation + , invocationStdout :: Maybe ArtifactLocation + -- | The stderr property of the invocation + , invocationStderr :: Maybe ArtifactLocation + -- | The stdoutStderr property of the invocation + , invocationStdoutStderr :: Maybe ArtifactLocation + -- | The properties property of the Invocation object + , invocationProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Invocation where + toJSON MkInvocation {..} = + object + [ "commandLine" .=? invocationCommandLine, + "arguments" .=? invocationArguments, + "responseFiles" .=? invocationResponseFiles, + "ruleConfigurationOverrides" .=? invocationRuleConfigurationOverrides, + "notificationConfigurationOverrides" .=? invocationNotificationConfigurationOverrides, + "startTimeUtc" .=? invocationStartTimeUtc, + "endTimeUtc" .=? invocationEndTimeUtc, + "exitCode" .=? invocationExitCode, + "exitCodeDescription" .=? invocationExitCodeDescription, + "exitSignalName" .=? invocationExitSignalName, + "exitSignalNumber" .=? invocationExitSignalNumber, + "processStartFailureMessage" .=? invocationProcessStartFailureMessage, + "executionSuccessful" .= invocationExecutionSuccessful, + "machine" .=? invocationMachine, + "account" .=? invocationAccount, + "processId" .=? invocationProcessId, + "executableLocation" .=? invocationExecutableLocation, + "workingDirectory" .=? invocationWorkingDirectory, + "environmentVariables" .=? invocationEnvironmentVariables, + "toolExecutionNotifications" .=? invocationToolExecutionNotifications, + "toolConfigurationNotifications" .=? invocationToolConfigurationNotifications, + "stdin" .=? invocationStdin, + "stdout" .=? invocationStdout, + "stderr" .=? invocationStderr, + "stdoutStderr" .=? invocationStdoutStderr, + "properties" .=? invocationProperties + ] + +instance FromJSON Invocation where + parseJSON = withObject "Invocation" $ \obj -> + MkInvocation + <$> obj .:? "commandLine" + <*> obj .:? "arguments" + <*> obj .:? "responseFiles" + <*> obj .:? "ruleConfigurationOverrides" + <*> obj .:? "notificationConfigurationOverrides" + <*> obj .:? "startTimeUtc" + <*> obj .:? "endTimeUtc" + <*> obj .:? "exitCode" + <*> obj .:? "exitCodeDescription" + <*> obj .:? "exitSignalName" + <*> obj .:? "exitSignalNumber" + <*> obj .:? "processStartFailureMessage" + <*> obj .: "executionSuccessful" + <*> obj .:? "machine" + <*> obj .:? "account" + <*> obj .:? "processId" + <*> obj .:? "executableLocation" + <*> obj .:? "workingDirectory" + <*> obj .:? "environmentVariables" + <*> obj .:? "toolExecutionNotifications" + <*> obj .:? "toolConfigurationNotifications" + <*> obj .:? "stdin" + <*> obj .:? "stdout" + <*> obj .:? "stderr" + <*> obj .:? "stdoutStderr" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Level.hs b/src/Data/SARIF/Level.hs --- a/src/Data/SARIF/Level.hs +++ b/src/Data/SARIF/Level.hs @@ -5,41 +5,39 @@ -- file in the root directory of this source tree. -- -------------------------------------------------------------------------------- --- | Provides the `Level` type, which enumerates SARIF result levels. --- See https://docs.oasis-open.org/sarif/sarif/v2.1.0/cs01/sarif-v2.1.0-cs01.html#_Ref493511208 -module Data.SARIF.Level ( - Level(..) -) where +-- | Provides the `Level` type to represent SARIF artifacts. +module Data.SARIF.Level + ( Level (..), + ) +where -------------------------------------------------------------------------------- -import Data.Aeson.Optional hiding (Error) - --------------------------------------------------------------------------------- +import Data.Aeson.Optional -- | A `Level` value represents the severity of a result. data Level - -- | The concept of “severity” does not apply. - = None - -- | A minor problem or an opportunity to improve the code was found. - | Note - -- | A problem was found. - | Warning - -- | A serious problem was found. - | Error - deriving (Eq, Show) + -- | The concept of “severity” does not apply. + = LevelNone + -- | A minor problem or an opportunity to improve the code was found. + | LevelNote + -- | A problem was found. + | LevelWarning + -- | A serious problem was found. + | LevelError + deriving (Eq, Ord, Show) instance ToJSON Level where - toJSON None = "none" - toJSON Note = "note" - toJSON Warning = "warning" - toJSON Error = "error" + toJSON LevelNone = "none" + toJSON LevelNote = "note" + toJSON LevelWarning = "warning" + toJSON LevelError = "error" instance FromJSON Level where - parseJSON (String "none") = pure None - parseJSON (String "note") = pure Note - parseJSON (String "warning") = pure Warning - parseJSON (String "error") = pure Error - parseJSON _ = fail "Unexpected value for result level" + parseJSON (String "none") = pure LevelNone + parseJSON (String "note") = pure LevelNote + parseJSON (String "warning") = pure LevelWarning + parseJSON (String "error") = pure LevelError + parseJSON _ = fail "Unexpected value for result level" -------------------------------------------------------------------------------- diff --git a/src/Data/SARIF/Location.hs b/src/Data/SARIF/Location.hs --- a/src/Data/SARIF/Location.hs +++ b/src/Data/SARIF/Location.hs @@ -5,94 +5,63 @@ -- file in the root directory of this source tree. -- -------------------------------------------------------------------------------- --- | Provides types used to refer to different sorts of locations, such as --- files, as well as parts of files. -module Data.SARIF.Location ( - Location(..), - ArtifactLocation(..), - Region(..), - PhysicalLocation(..) -) where +-- | Provides the `Location` type to represent SARIF artifacts. +module Data.SARIF.Location + ( Location (..), + ) +where -------------------------------------------------------------------------------- -import Data.Aeson -import Data.Text +import Data.Aeson.Optional +-- import Data.SARIF.LocationRelationship --------------------------------------------------------------------------------- +import Data.Map.Strict +import Data.SARIF.LocationRelationship +import Data.SARIF.LogicalLocation +import Data.SARIF.Message +import Data.SARIF.PhysicalLocation +import Data.SARIF.Region +import Data.Text --- | Represents locations. -newtype Location = MkLocation { - -- | The physical location (i.e. part of a file) to which this location - -- refers to. - locationPhysicalLocation :: Maybe PhysicalLocation -} deriving (Eq, Show) +data Location + = MkLocation + { -- | The id property of a location object + locationId :: Maybe Integer + -- | The physicalLocation property of a location object + , locationPhysicalLocation :: Maybe PhysicalLocation + -- | The logicalLocations property of a location object + , locationLogicalLocations :: Maybe [LogicalLocation] + -- | The message property of a location object + , locationMessage :: Maybe Message + -- | The annotations property of a location object + , locationAnnotations :: Maybe [Region] + -- | The relationship property of a location object + , locationRelationship :: Maybe [LocationRelationship] + -- | The properties property of the Location object + , locationProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) instance ToJSON Location where - toJSON MkLocation{..} = object - [ "physicalLocation" .= locationPhysicalLocation - ] + toJSON MkLocation {..} = + object + [ "id" .=? locationId, + "physicalLocation" .=? locationPhysicalLocation, + "logicalLocation" .=? locationLogicalLocations, + "message" .=? locationMessage, + "annotations" .=? locationAnnotations, + "relationships" .=? locationRelationship, + "properties" .=? locationProperties + ] instance FromJSON Location where - parseJSON = withObject "Location" $ \obj -> - MkLocation <$> obj .:? "physicalLocation" - --- | Represents artifact locations such as file paths. -newtype ArtifactLocation = MkArtifactLocation { - artifactLocationUri :: Text -} deriving (Eq, Show) - -instance ToJSON ArtifactLocation where - toJSON MkArtifactLocation{..} = object - [ "uri" .= artifactLocationUri - ] - -instance FromJSON ArtifactLocation where - parseJSON = withObject "ArtifactLocation" $ \obj -> - MkArtifactLocation <$> obj .: "uri" - --- | Represents regions of code with a start and an end. -data Region = MkRegion { - -- | The line on which this region starts. - regionStartLine :: Int, - -- | The column within the starting line where this region starts. - regionStartColumn :: Int, - -- | The line on which this region ends. - regionEndLine :: Int, - -- | The column within the ending line where this region ends. - regionEndColumn :: Int -} deriving (Eq, Show) - -instance ToJSON Region where - toJSON MkRegion{..} = object - [ "startLine" .= regionStartLine - , "startColumn" .= regionStartColumn - , "endLine" .= regionEndLine - , "endColumn" .= regionEndColumn - ] - -instance FromJSON Region where - parseJSON = withObject "Region" $ \obj -> - MkRegion <$> obj .: "startLine" - <*> obj .: "startColumn" - <*> obj .: "endLine" - <*> obj .: "endColumn" - --- | Represents parts of artifacts, e.g. a `Region` within a file. -data PhysicalLocation = MkPhysicalLocation { - physicalLocationArtifactLocation :: ArtifactLocation, - physicalLocationRegion :: Region -} deriving (Eq, Show) - -instance ToJSON PhysicalLocation where - toJSON MkPhysicalLocation{..} = object - [ "artifactLocation" .= physicalLocationArtifactLocation - , "region" .= physicalLocationRegion - ] - -instance FromJSON PhysicalLocation where - parseJSON = withObject "PhysicalLocation" $ \obj -> - MkPhysicalLocation <$> obj .: "artifactLocation" - <*> obj .: "region" - --------------------------------------------------------------------------------- + parseJSON = withObject "Location" $ \obj -> + MkLocation + <$> obj .:? "id" + <*> obj .:? "physicalLocation" + <*> obj .:? "logicalLocations" + <*> obj .:? "message" + <*> obj .:? "annotations" + <*> obj .:? "relationships" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/LocationRelationship.hs b/src/Data/SARIF/LocationRelationship.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/LocationRelationship.hs @@ -0,0 +1,71 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `LocationRelationship` type to represent SARIF artifacts. +module Data.SARIF.LocationRelationship + ( LocationRelationship (..), + ) +where + +-------------------------------------------------------------------------------- + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Message +import Data.Text + +-------------------------------------------------------------------------------- + +data LocationRelationshipKind + = LocationRelIncludes + | LocationRelIsIncludedBy + | LocationRelRelevant + | LocationRelCustom Text + deriving (Eq, Ord, Show) + +instance ToJSON LocationRelationshipKind where + toJSON LocationRelIncludes = String "includes" + toJSON LocationRelIsIncludedBy = String "isIncludedBy" + toJSON LocationRelRelevant = String "relevant" + toJSON (LocationRelCustom customKind) = String customKind + +instance FromJSON LocationRelationshipKind where + parseJSON = withText "LocationRelationshipKind" $ \case + "includes" -> pure LocationRelIncludes + "isIncludedBy" -> pure LocationRelIsIncludedBy + "relevant" -> pure LocationRelRelevant + t' -> pure $ LocationRelCustom t' + +data LocationRelationship + = MkLocationRelationship + { -- | The target property of a LocationRelationship object + logicalRelTarget :: Integer + -- | The name property of a LocationRelationship object + , logicalRelKinds :: Maybe [LocationRelationshipKind] + -- | The description property of a LocationRelationship object + , logicalRelDescription :: Maybe Message + -- | The properties property of the LocationRelationship object + , logicalRelProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON LocationRelationship where + toJSON MkLocationRelationship {..} = + object + [ "target" .= logicalRelTarget, + "kinds" .= logicalRelKinds, + "description" .=? logicalRelDescription, + "properties" .=? logicalRelProperties + ] + +instance FromJSON LocationRelationship where + parseJSON = withObject "LocationRelationship" $ \obj -> + MkLocationRelationship + <$> obj .: "target" + <*> obj .:? "kinds" + <*> obj .:? "description" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Log.hs b/src/Data/SARIF/Log.hs --- a/src/Data/SARIF/Log.hs +++ b/src/Data/SARIF/Log.hs @@ -5,54 +5,54 @@ -- file in the root directory of this source tree. -- -------------------------------------------------------------------------------- --- | Provides the top-level structure of SARIF. -module Data.SARIF.Log ( - Log(..), - defaultLog, +-- | Provides the `Log` type to represent SARIF artifacts. +module Data.SARIF.Log + ( Log (..), decodeSarifFileStrict, - encodeSarifAsLBS -) where + encodeSarifAsLBS, + ) +where -------------------------------------------------------------------------------- -import Data.Aeson +import Data.Aeson.Optional import qualified Data.ByteString.Lazy as LBS +import Data.SARIF.ExternalPropertyFileReferences +import Data.SARIF.Run import Data.Text -import Data.SARIF.Run (Run(..)) - -------------------------------------------------------------------------------- -- | Each SARIF file contains one `Log` value at the top. -data Log = MkLog { - -- | The version identifier of the SARIF format used by the file. - logVersion :: Text, - -- | A list of descriptions of runs of static analysis tools. - logRuns :: [Run] -} deriving (Eq, Show) - --- | The URL of the JSON schema that describes SARIF. -schemaUrl :: Text -schemaUrl = "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json" +data Log + = MkLog + { -- | The version identifier of the SARIF format used by the file. + logVersion :: Text + -- | An absolute URI to the JSON schema describing the SARIF format version of this log file. + , logSchema :: Maybe Text + -- | A list of descriptions of runs of static analysis tools. + , logRuns :: Maybe [Run] + -- | The inlineExternalProperties property of the log + , logProperties :: Maybe ExternalPropertyFileReferences + } + deriving (Eq, Ord, Show) instance ToJSON Log where - toJSON MkLog{..} = object - [ "version" .= logVersion - , "runs" .= logRuns - , "$schema" .= schemaUrl - ] + toJSON MkLog {..} = + object + [ "version" .= logVersion, + "runs" .=? logRuns, + "$schema" .=? logSchema, + "inlineExternalProperties" .=? logProperties + ] instance FromJSON Log where - parseJSON = withObject "Log" $ \obj -> - MkLog <$> obj .: "version" - <*> obj .: "runs" - --- | Represents a default `Log` value. -defaultLog :: Log -defaultLog = MkLog{ - logVersion = "2.1.0", - logRuns = [] -} + parseJSON = withObject "Log" $ \obj -> + MkLog + <$> obj .: "version" + <*> obj .:? "$schema" + <*> obj .:? "runs" + <*> obj .:? "inlineExternalProperties" -- | `decodeSarifFileStrict` @filepath@ is a type-specialised version of -- `eitherDecodeFileStrict` for `Log`. diff --git a/src/Data/SARIF/LogicalLocation.hs b/src/Data/SARIF/LogicalLocation.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/LogicalLocation.hs @@ -0,0 +1,129 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `LogicalLocation` type to represent SARIF artifacts. +{-# LANGUAGE ScopedTypeVariables #-} + +module Data.SARIF.LogicalLocation + ( LogicalLocation (..), + ) +where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.Text + +-------------------------------------------------------------------------------- + +data LogicalLocationKind + = ExecutableCodeFunctionKind + | ExecutableCodeMemberKind + | ExecutableCodeModuleKind + | ExecutableCodeNamespaceKind + | ExecutableCodeResourceKind + | ExecutableCodeTypeKind + | ExecutableCodeParameterKind + | ExecutableCodeVariableKind + | XMLHTMLElementKind + | XMLHTMLAttributeKind + | XMLHTMLTextKind + | XMLHTMLCommentKind + | XMLHTMLProcessingInstructionKind + | XMLHTMLDtdKind + | XMLHTMLDeclarationKind + | JSONObjectKind + | JSONArrayKind + | JSONPropertyKind + | JSONValueKind + deriving (Eq, Ord, Show) + +instance ToJSON LogicalLocationKind where + toJSON ExecutableCodeFunctionKind = String "function" + toJSON ExecutableCodeMemberKind = String "member" + toJSON ExecutableCodeModuleKind = String "module" + toJSON ExecutableCodeNamespaceKind = String "namespace" + toJSON ExecutableCodeResourceKind = String "resource" + toJSON ExecutableCodeTypeKind = String "type" + toJSON ExecutableCodeParameterKind = String "parameter" + toJSON ExecutableCodeVariableKind = String "variable" + toJSON XMLHTMLElementKind = String "element" + toJSON XMLHTMLAttributeKind = String "attribute" + toJSON XMLHTMLTextKind = String "text" + toJSON XMLHTMLCommentKind = String "comment" + toJSON XMLHTMLProcessingInstructionKind = String "processingInstruction" + toJSON XMLHTMLDtdKind = String "dtd" + toJSON XMLHTMLDeclarationKind = String "declaration" + toJSON JSONObjectKind = String "object" + toJSON JSONArrayKind = String "array" + toJSON JSONPropertyKind = String "property" + toJSON JSONValueKind = String "value" + +instance FromJSON LogicalLocationKind where + parseJSON = withText "LogicalLocationKind" $ \t -> + case t of + "function" -> pure ExecutableCodeFunctionKind + "member" -> pure ExecutableCodeMemberKind + "module" -> pure ExecutableCodeModuleKind + "namespace" -> pure ExecutableCodeNamespaceKind + "resource" -> pure ExecutableCodeResourceKind + "type" -> pure ExecutableCodeTypeKind + "parameter" -> pure ExecutableCodeParameterKind + "variable" -> pure ExecutableCodeVariableKind + "element" -> pure XMLHTMLElementKind + "attribute" -> pure XMLHTMLAttributeKind + "text" -> pure XMLHTMLTextKind + "comment" -> pure XMLHTMLCommentKind + "processingInstruction" -> pure XMLHTMLProcessingInstructionKind + "dtd" -> pure XMLHTMLDtdKind + "declaration" -> pure XMLHTMLDeclarationKind + "object" -> pure JSONObjectKind + "array" -> pure JSONArrayKind + "property" -> pure JSONPropertyKind + "value" -> pure JSONValueKind + _ -> fail $ "Unknown LogicalLocationKind: " ++ unpack t + +data LogicalLocation + = MkLogicalLocation + { -- | The index property of a logicalLocation object + logicalLocIndex :: Maybe Integer + -- | The name property of a logicalLocation object + , logicalLocName :: Text + -- | The fullyQualifiedName property of a logicalLocation object + , logicalLocFullyQualifiedName :: Maybe Text + -- | The decoratedName property of a logicalLocation object + , logicalLocDecoratedName :: Maybe Text + -- | The kind property of a logicalLocation object + , logicalLocKind :: LogicalLocationKind + -- | The parentIndex property of a logicalLocation object + , logicalLocParentIndex :: Maybe Integer + -- | The properties property of the LogicalLocation object + , logicalLocProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON LogicalLocation where + toJSON MkLogicalLocation {..} = + object + [ "index" .=? logicalLocIndex, + "name" .= logicalLocName, + "fullyQualifiedName" .=? logicalLocFullyQualifiedName, + "decoratedName" .=? logicalLocDecoratedName, + "kind" .= logicalLocKind, + "parentIndex" .=? logicalLocParentIndex, + "properties" .=? logicalLocProperties + ] + +instance FromJSON LogicalLocation where + parseJSON = withObject "LogicalLocation" $ \obj -> + MkLogicalLocation + <$> obj .:? "index" + <*> obj .: "name" + <*> obj .:? "fullyQualifiedName" + <*> obj .:? "decoratedName" + <*> obj .: "kind" + <*> obj .:? "parentIndex" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Message.hs b/src/Data/SARIF/Message.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Message.hs @@ -0,0 +1,52 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `Message` type to represent SARIF artifacts. +module Data.SARIF.Message + ( Message (..), + ) +where + +-------------------------------------------------------------------------------- + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.Text + +data Message + = MkMessage + { -- | The text property of a message object + messageText :: Maybe Text + -- | The markdown property of a message object + , messageMarkdown :: Maybe Text + -- | The id property of a message object + , messageId :: Maybe Text + -- | The arguments property of a message object + , messageArguments :: Maybe [Text] + -- | The properties property of the Message object + , messageProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Message where + toJSON MkMessage {..} = + object + [ "text" .=? messageText, + "markdown" .=? messageMarkdown, + "id" .=? messageId, + "arguments" .=? messageArguments, + "properties" .=? messageProperties + ] + +instance FromJSON Message where + parseJSON = withObject "Message" $ \obj -> + MkMessage + <$> (obj .:? "text") + <*> (obj .:? "markdown") + <*> obj .:? "id" + <*> obj .:? "arguments" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/MultiformatMessageString.hs b/src/Data/SARIF/MultiformatMessageString.hs --- a/src/Data/SARIF/MultiformatMessageString.hs +++ b/src/Data/SARIF/MultiformatMessageString.hs @@ -5,47 +5,41 @@ -- file in the root directory of this source tree. -- -------------------------------------------------------------------------------- --- | Provides the `MultiformatMessageString` type which is used to represent --- messages in different formats, such as text or markdown. -module Data.SARIF.MultiformatMessageString ( - MultiformatMessageString(..), - defaultMultiformatMessageString -) where +-- | Provides the `MultiformatMessageString` type to represent SARIF artifacts. +module Data.SARIF.MultiformatMessageString + ( MultiformatMessageString (..), + ) +where + -------------------------------------------------------------------------------- import Data.Aeson.Optional +import Data.Map.Strict import Data.Text --------------------------------------------------------------------------------- - --- | Represents a message in at least textual representation, but also allowing --- it to be provided in other formats such as markdown. -data MultiformatMessageString = MkMultiformatMessageString { - -- | A textual representation of the message, which is mandatory. - mmsText :: Text, - -- | Optionally, a markdown representation of the message. - mmsMarkdown :: Maybe Text -} deriving (Eq, Show) +data MultiformatMessageString + = MkMultiformatMessageString + { -- | A textual representation of the message, which is mandatory. + mmsText :: Text + -- | Optionally, a markdown representation of the message. + , mmsMarkdown :: Maybe Text + -- | The properties property of the MultiformatMessageString object + , mmsProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) instance ToJSON MultiformatMessageString where - toJSON MkMultiformatMessageString{..} = object - [ "text" .= mmsText - , "markdown" .=? mmsMarkdown - ] + toJSON MkMultiformatMessageString {..} = + object + [ "text" .= mmsText, + "markdown" .=? mmsMarkdown, + "properties" .=? mmsProperties + ] instance FromJSON MultiformatMessageString where - parseJSON = withObject "MultiformatMessageString" $ \obj -> - MkMultiformatMessageString <$> obj .: "text" - <*> obj .:? "markdown" - --- | `defaultMultiformatMessageString` @messageText@ constructs a --- `MultiformatMessageString` value where @messageText@ is the textual --- representation of the message. -defaultMultiformatMessageString :: Text -> MultiformatMessageString -defaultMultiformatMessageString text = MkMultiformatMessageString{ - mmsText = text, - mmsMarkdown = Nothing -} - --------------------------------------------------------------------------------- + parseJSON = withObject "MultiformatMessageString" $ \obj -> + MkMultiformatMessageString + <$> obj .: "text" + <*> obj .:? "markdown" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Node.hs b/src/Data/SARIF/Node.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Node.hs @@ -0,0 +1,49 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `Node` type to represent SARIF artifacts. +module Data.SARIF.Node where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Location +import Data.SARIF.Message +import Data.Text + +data Node + = MkNode + { -- | The id property of the node + nodeId :: Text + -- | The message property of the node + , nodeMessage :: Maybe Message + -- | The location property of the node + , nodeLocation :: Location + -- | The children property of the node + , nodeChildren :: Maybe [Node] + -- | The properties property of the Node object + , nodeProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Node where + toJSON MkNode {..} = + object + [ "id" .= nodeId, + "message" .=? nodeMessage, + "location" .= nodeLocation, + "children" .=? nodeChildren, + "properties" .=? nodeProperties + ] + +instance FromJSON Node where + parseJSON = withObject "Node" $ \obj -> + MkNode + <$> obj .: "id" + <*> obj .:? "message" + <*> obj .: "location" + <*> obj .:? "children" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Notification.hs b/src/Data/SARIF/Notification.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Notification.hs @@ -0,0 +1,88 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `Notification` type to represent SARIF artifacts. +module Data.SARIF.Notification where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Exception +import Data.SARIF.Location +import Data.SARIF.Message +import Data.SARIF.ReportingDescriptorReference +import Data.Text + +data NotificationLevel + = NotificationErrorLevel + | NotificationWarningLevel + | NotificationNoteLevel + | NotificationNoneLevel + deriving (Eq, Ord, Show) + +instance ToJSON NotificationLevel where + toJSON NotificationErrorLevel = String "error" + toJSON NotificationWarningLevel = String "warning" + toJSON NotificationNoteLevel = String "note" + toJSON NotificationNoneLevel = String "none" + +instance FromJSON NotificationLevel where + parseJSON = withText "NotificationLevel" $ \case + "error" -> pure NotificationErrorLevel + "warning" -> pure NotificationWarningLevel + "note" -> pure NotificationNoteLevel + "none" -> pure NotificationNoneLevel + _ -> fail "Unknown NotificationLevel" + +data Notification + = MkNotification + { -- | The descriptor property of the notification + notificationDescriptor :: ReportingDescriptorReference + -- | The associatedRule property of the notification + , notificationAssociatedRule :: Maybe ReportingDescriptorReference + -- | The locations property of the notification + , notificationLocations :: Maybe [Location] + -- | The message property of the notification + , notificationMessage :: Maybe Message + -- | The level property of the notification + , notificationLevel :: Maybe NotificationLevel + -- | The threadId property of the notification + , notificationThreadId :: Maybe Int + -- | The timeUtc property of the notification + , notificationTimeUtc :: Maybe Text + -- | The exception property of the notification + , notificationException :: Maybe Exception + -- | The properties property of the Notification object + , notificationProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Notification where + toJSON MkNotification {..} = + object + [ "descriptor" .= notificationDescriptor, + "associatedRule" .=? notificationAssociatedRule, + "locations" .=? notificationLocations, + "message" .=? notificationMessage, + "level" .=? notificationLevel, + "threadId" .=? notificationThreadId, + "timeUtc" .=? notificationTimeUtc, + "exception" .=? notificationException, + "properties" .=? notificationProperties + ] + +instance FromJSON Notification where + parseJSON = withObject "Notification" $ \obj -> + MkNotification + <$> obj .: "descriptor" + <*> obj .:? "associatedRule" + <*> obj .:? "locations" + <*> obj .:? "message" + <*> obj .:? "level" + <*> obj .:? "threadId" + <*> obj .:? "timeUtc" + <*> obj .:? "exception" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/PhysicalLocation.hs b/src/Data/SARIF/PhysicalLocation.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/PhysicalLocation.hs @@ -0,0 +1,55 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `PhysicalLocation` type to represent SARIF artifacts. +module Data.SARIF.PhysicalLocation + ( PhysicalLocation (..), + ) +where + +-------------------------------------------------------------------------------- + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Address +import Data.SARIF.ArtifactLocation +import Data.SARIF.Region +import Data.Text + +data PhysicalLocation + = MkPhysicalLocation + { -- | The artifactLocation property of a physicalLocation object + physicalLocArtifactLocation :: Maybe ArtifactLocation + -- | The region property of a physicalLocation object + , physicalLocRegion :: Maybe Region + -- | The contextRegion property of a physicalLocation object + , physicalLocContextRegion :: Maybe Region + -- | The address property of a physicalLocation object + , physicalLocAddress :: Maybe Address + -- | The properties property of the PhysicalLocation object + , physicalLocProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON PhysicalLocation where + toJSON MkPhysicalLocation {..} = + object + [ "artifactLocation" .=? physicalLocArtifactLocation, + "region" .=? physicalLocRegion, + "contextRegion" .=? physicalLocContextRegion, + "address" .=? physicalLocAddress, + "properties" .=? physicalLocProperties + ] + +instance FromJSON PhysicalLocation where + parseJSON = withObject "PhysicalLocation" $ \obj -> + MkPhysicalLocation + <$> obj .:? "artifactLocation" + <*> obj .:? "region" + <*> obj .:? "contextRegion" + <*> obj .:? "address" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Rectangle.hs b/src/Data/SARIF/Rectangle.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Rectangle.hs @@ -0,0 +1,52 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `Rectangle` type to represent SARIF artifacts. +module Data.SARIF.Rectangle where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Message +import Data.Text + +data Rectangle + = MkRectangle + { -- | The top property of the rectangle + rectangleTop :: Int + -- | The left property of the rectangle + , rectangleLeft :: Int + -- | The bottom property of the rectangle + , rectangleBottom :: Int + -- | The right property of the rectangle + , rectangleRight :: Int + -- | The message property of the rectangle + , rectangleMessage :: Message + -- | The properties property of the Rectangle object + , rectangleProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Rectangle where + toJSON MkRectangle {..} = + object + [ "top" .= rectangleTop, + "left" .= rectangleLeft, + "bottom" .= rectangleBottom, + "right" .= rectangleRight, + "message" .= rectangleMessage, + "properties" .=? rectangleProperties + ] + +instance FromJSON Rectangle where + parseJSON = withObject "Rectangle" $ \obj -> + MkRectangle + <$> obj .: "top" + <*> obj .: "left" + <*> obj .: "bottom" + <*> obj .: "right" + <*> obj .: "message" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Region.hs b/src/Data/SARIF/Region.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Region.hs @@ -0,0 +1,82 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `Region` type to represent SARIF artifacts. +module Data.SARIF.Region + ( Region (..), + ) +where + +-------------------------------------------------------------------------------- + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ArtifactContent +import Data.SARIF.Message +import Data.Text + +data Region + = MkRegion + { -- | The startLine property of a region object + regionStartLine :: Maybe Int + -- | The startColumn property of a region object + , regionStartColumn :: Maybe Int + -- | The endLine property of a region object + , regionEndLine :: Maybe Int + -- | The endColumn property of a region object + , regionEndColumn :: Maybe Int + -- | The charOffset property of a region object + , regionCharOffset :: Maybe Int + -- | The charLength property of a region object + , regionCharLength :: Maybe Int + -- | The byteOffset property of a region object + , regionByteOffset :: Maybe Int + -- | The byteLength property of a region object + , regionByteLength :: Maybe Int + -- | The snippet property of a region object + , regionSnippet :: Maybe ArtifactContent + -- | The message property of a region object + , regionMessage :: Maybe Message + -- | The sourceLanguage property of a region object + , regionSourceLanguage :: Maybe Text + -- | The properties property of the Region object + , regionProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Region where + toJSON MkRegion {..} = + object + [ "startLine" .=? regionStartLine, + "startColumn" .=? regionStartColumn, + "endLine" .=? regionEndLine, + "endColumn" .=? regionEndColumn, + "charOffset" .=? regionCharOffset, + "charLength" .=? regionCharLength, + "byteOffset" .=? regionByteOffset, + "byteLength" .=? regionByteLength, + "snippet" .=? regionSnippet, + "message" .=? regionMessage, + "sourceLanguage" .=? regionSourceLanguage, + "properties" .=? regionProperties + ] + +instance FromJSON Region where + parseJSON = withObject "Region" $ \obj -> + MkRegion + <$> obj .:? "startLine" + <*> obj .:? "startColumn" + <*> obj .:? "endLine" + <*> obj .:? "endColumn" + <*> obj .:? "charOffset" + <*> obj .:? "charLength" + <*> obj .:? "byteOffset" + <*> obj .:? "byteLength" + <*> obj .:? "snippet" + <*> obj .:? "message" + <*> obj .:? "sourceLanguage" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Replacement.hs b/src/Data/SARIF/Replacement.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Replacement.hs @@ -0,0 +1,41 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `Replacement` type to represent SARIF artifacts. +module Data.SARIF.Replacement where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ArtifactContent +import Data.SARIF.Region +import Data.Text + +data Replacement + = MkReplacement + { -- | The deletedRegion property of the replacement + replacementDeletedRegion :: Region + -- | The insertedContent property of the replacement + , replacementInsertedContent :: Maybe ArtifactContent + -- | The properties property of the Replacement object + , replacementProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Replacement where + toJSON MkReplacement {..} = + object + [ "deletedRegion" .= replacementDeletedRegion, + "insertedContent" .=? replacementInsertedContent, + "properties" .=? replacementProperties + ] + +instance FromJSON Replacement where + parseJSON = withObject "Replacement" $ \obj -> + MkReplacement + <$> obj .: "deletedRegion" + <*> obj .:? "insertedContent" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/ReportingConfiguration.hs b/src/Data/SARIF/ReportingConfiguration.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/ReportingConfiguration.hs @@ -0,0 +1,53 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `ReportingConfiguration` type to represent SARIF artifacts. +module Data.SARIF.ReportingConfiguration + ( ReportingConfiguration (..), + ) +where + +-------------------------------------------------------------------------------- + +import Data.Aeson.Optional +import qualified Data.Map.Lazy as M +import Data.SARIF.Level +import Data.Text + +data ReportingConfiguration + = MkReportingConfiguration + { -- | Flag indicating whether theDescriptor was checked for during the scan. + reportingConfigurationEnabled :: Bool + -- | The default severity of the reporting descriptor. + , reportingConfigurationLevel :: Maybe Level + -- | A float representing the priority or importance of the result. + , reportingConfigurationRank :: Maybe Double + -- | Configuration information that is specific to that descriptor + , reportingConfigurationParameters :: Maybe (M.Map Text Value) + -- | The properties property of the ReportingConfiguration object + , reportingConfigurationProperties :: Maybe (M.Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON ReportingConfiguration where + toJSON MkReportingConfiguration {..} = + object + [ "enabled" .= reportingConfigurationEnabled, + "level" .=? reportingConfigurationLevel, + "rank" .=? reportingConfigurationRank, + "parameters" .=? reportingConfigurationParameters, + "properties" .=? reportingConfigurationProperties + ] + +instance FromJSON ReportingConfiguration where + parseJSON = withObject "ReportingConfiguration" $ \obj -> + MkReportingConfiguration + <$> (obj .: "enabled") + <*> (obj .:? "level") + <*> obj .:? "rank" + <*> obj .:? "parameters" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/ReportingDescriptor.hs b/src/Data/SARIF/ReportingDescriptor.hs --- a/src/Data/SARIF/ReportingDescriptor.hs +++ b/src/Data/SARIF/ReportingDescriptor.hs @@ -5,106 +5,93 @@ -- file in the root directory of this source tree. -- -------------------------------------------------------------------------------- --- | Provides the `ReportingDescriptor` type, which is essentially used to --- represent descriptions of rules that a static analysis tool has applied. -module Data.SARIF.ReportingDescriptor ( - ReportingConfiguration(..), - defaultReportingConfiguration, - ReportingDescriptor(..), - defaultReportingDescriptor -) where +-- | Provides the `ReportingDescriptor` type to represent SARIF artifacts. +{-# LANGUAGE ScopedTypeVariables #-} +module Data.SARIF.ReportingDescriptor + ( ReportingDescriptor (..), + ) +where + -------------------------------------------------------------------------------- import Data.Aeson.Optional -import qualified Data.Map.Lazy as M -import Data.Text - -import Data.SARIF.Level +import Data.Map.Strict import Data.SARIF.MultiformatMessageString - --------------------------------------------------------------------------------- - --- | Represents default configurations for `ReportingDescriptor` values. That is --- properties which may be overriden by individual results. -newtype ReportingConfiguration = MkReportingConfiguration { - -- | The default severity of the reporting descriptor. - rcLevel :: Maybe Level -} deriving (Eq, Show) - -instance ToJSON ReportingConfiguration where - toJSON MkReportingConfiguration{..} = object - [ "level" .=? rcLevel - ] -instance FromJSON ReportingConfiguration where - parseJSON = withObject "ReportingConfiguration" $ \obj -> - MkReportingConfiguration <$> obj .: "level" - --- | `defaultReportingConfiguration` is a default --- `ReportingConfiguration` value. -defaultReportingConfiguration :: ReportingConfiguration -defaultReportingConfiguration = MkReportingConfiguration{ - rcLevel = Nothing -} +import Data.SARIF.ReportingConfiguration +import Data.SARIF.ReportingDescriptorRelationship +import Data.Text +import Data.UUID.Types --- | Represents rules that a static analysis tool -data ReportingDescriptor = MkReportingDescriptor { - -- | The unique ID of the rule. - rdId :: Text, - -- | A friendly name for the rule, which should be one word in - -- upper camel case. - rdName :: Maybe Text, - -- | A short description for the rule, which may contain spaces - -- and symbols. - rdShortDescription :: Maybe MultiformatMessageString, - -- | The full description. - rdFullDescription :: Maybe MultiformatMessageString, - -- | A URL to some help for this rule. - rdHelpUri :: Maybe Text, - -- | A recommendation for what to do in order to resolve an occurrence - -- of this rule. - rdHelp :: Maybe MultiformatMessageString, - -- | The default reporting configuration for the rule. - rdDefaultConfiguration :: Maybe ReportingConfiguration, - -- | Extra properties for this rule. - rdProperties :: M.Map Text Value -} deriving (Eq, Show) +data ReportingDescriptor + = MkReportingDescriptor + { -- | The unique ID of the rule. + reportingDescriptorId :: Text + -- | Previously used IDs for the rule. + , reportingDescriptorDeprecatedIds :: Maybe [Text] + -- | A GUID which identifies the ReportingDescriptor. + , reportingDescriptorGuid :: Maybe UUID + -- | A list of deprecated GUIDs which previously identified the rule. + , reportingDescriptorDeprecatedGuids :: Maybe [UUID] + -- | A friendly name for the rule, which should be one word in + -- upper camel case. + , reportingDescriptorName :: Maybe Text + -- | A list of names for the rule that were previously used. + , reportingDescriptorDeprecatedNames :: Maybe [Text] + -- | A short description for the rule, which may contain spaces + -- and symbols. + , reportingDescriptorShortDescription :: Maybe MultiformatMessageString + -- | The full description. + , reportingDescriptorFullDescription :: Maybe MultiformatMessageString + -- | A mapping from arbitrary name to its corresponding message string. + , reportingDescriptorMessageStrings :: Maybe (Map Text MultiformatMessageString) + -- | A URL to some help for this rule. + , reportingDescriptorHelpUri :: Maybe Text + -- | A recommendation for what to do in order to resolve an occurrence + -- of this rule. + , reportingDescriptorHelp :: Maybe MultiformatMessageString + -- | The default reporting configuration for the rule. + , reportingDescriptorDefaultConfiguration :: Maybe ReportingConfiguration + -- | Extra properties for this rule. + , reportingDescriptorRelationships :: Maybe ReportingDescriptorRelationship + -- | The properties property of the ReportingDescriptor object + , reportingDescriptorProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) instance ToJSON ReportingDescriptor where - toJSON MkReportingDescriptor{..} = object - [ "id" .= rdId - , "name" .=? rdName - , "shortDescription" .=? rdShortDescription - , "fullDescription" .=? rdFullDescription - , "helpUri" .=? rdHelpUri - , "help" .=? rdHelp - , "defaultConfiguration" .=? rdDefaultConfiguration - , "properties" .= rdProperties - ] + toJSON MkReportingDescriptor {..} = + object + [ "id" .= reportingDescriptorId, + "deprecatedIds" .=? reportingDescriptorDeprecatedIds, + "guid" .=? reportingDescriptorGuid, + "deprecatedGuids" .=? reportingDescriptorDeprecatedGuids, + "name" .=? reportingDescriptorName, + "deprecatedNames" .=? reportingDescriptorDeprecatedNames, + "shortDescription" .=? reportingDescriptorShortDescription, + "fullDescription" .= reportingDescriptorFullDescription, + "messageStrings" .=? reportingDescriptorMessageStrings, + "helpUri" .=? reportingDescriptorHelpUri, + "help" .=? reportingDescriptorHelp, + "defaultConfiguration" .=? reportingDescriptorDefaultConfiguration, + "relationships" .=? reportingDescriptorRelationships, + "properties" .=? reportingDescriptorProperties + ] instance FromJSON ReportingDescriptor where - parseJSON = withObject "ReportingDescriptor" $ \obj -> - MkReportingDescriptor <$> obj .: "id" - <*> obj .:? "name" - <*> obj .:? "shortDescription" - <*> obj .:? "fullDescription" - <*> obj .:? "helpUri" - <*> obj .:? "help" - <*> obj .:? "defaultConfiguration" - <*> obj .: "properties" .!= M.empty - --- | `defaultReportingDescriptor` @id@ constructs a default --- `ReportingDescriptor` with the given @id@, which must be unique. -defaultReportingDescriptor :: Text -> ReportingDescriptor -defaultReportingDescriptor ident = MkReportingDescriptor{ - rdId = ident, - rdName = Nothing, - rdShortDescription = Nothing, - rdFullDescription = Nothing, - rdHelpUri = Nothing, - rdHelp = Nothing, - rdDefaultConfiguration = Nothing, - rdProperties = M.empty -} - --------------------------------------------------------------------------------- + parseJSON = withObject "ReportingDescriptor" $ \obj -> + MkReportingDescriptor + <$> obj .: "id" + <*> obj .:? "deprecatedIds" + <*> obj .:? "guid" + <*> obj .:? "deprecatedGuids" + <*> obj .:? "name" + <*> obj .:? "deprecatedNames" + <*> obj .:? "shortDescription" + <*> obj .:? "fullDescription" + <*> obj .:? "messageStrings" + <*> obj .:? "helpUri" + <*> obj .:? "help" + <*> obj .:? "defaultConfiguration" + <*> obj .:? "relationships" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/ReportingDescriptorReference.hs b/src/Data/SARIF/ReportingDescriptorReference.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/ReportingDescriptorReference.hs @@ -0,0 +1,54 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `ReportingDescriptorReference` type to represent SARIF artifacts. +module Data.SARIF.ReportingDescriptorReference + ( ReportingDescriptorReference (..), + ) +where + +-------------------------------------------------------------------------------- + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ToolComponentReference +import Data.Text +import Data.UUID.Types + +data ReportingDescriptorReference + = MkReportingDescriptorReference + { -- | An identifier which should equals to the `id` property of a reportingDescriptor + reportingDescriptorReferenceId :: Maybe Text + -- | An index into the `toolComponent.rules` array + , reportingDescriptorReferenceIndex :: Maybe Integer + -- | A GUID which identifies the ReportingDescriptor. + , reportingDescriptorReferenceGuid :: Maybe UUID + -- | A reference to a `ToolComponent`. + , reportingDescriptorReferenceToolComponent :: Maybe ToolComponentReference + -- | The properties property of the ReportingDescriptorReference object + , reportingDescriptorReferenceProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON ReportingDescriptorReference where + toJSON MkReportingDescriptorReference {..} = + object + [ "id" .=? reportingDescriptorReferenceId, + "index" .=? reportingDescriptorReferenceIndex, + "guid" .=? reportingDescriptorReferenceGuid, + "toolComponent" .=? reportingDescriptorReferenceToolComponent, + "properties" .=? reportingDescriptorReferenceProperties + ] + +instance FromJSON ReportingDescriptorReference where + parseJSON = withObject "ReportingDescriptorReference" $ \obj -> + MkReportingDescriptorReference + <$> (obj .: "id") + <*> (obj .:? "index") + <*> obj .:? "guid" + <*> obj .:? "toolComponent" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/ReportingDescriptorRelationship.hs b/src/Data/SARIF/ReportingDescriptorRelationship.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/ReportingDescriptorRelationship.hs @@ -0,0 +1,87 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `ReportingDescriptorRelationship` type to represent SARIF artifacts. +module Data.SARIF.ReportingDescriptorRelationship where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Message +import Data.SARIF.ReportingDescriptorReference +import Data.Text + +data ReportingDescriptorRelationshipKind + = ReportingDescriptorRelationshipEqualKind + | ReportingDescriptorRelationshipSupersetKind + | ReportingDescriptorRelationshipSubsetKind + | ReportingDescriptorRelationshipDisjointKind + | ReportingDescriptorRelationshipIncomparableKind + | ReportingDescriptorRelationshipCanFollowKind + | ReportingDescriptorRelationshipCanPrecedeKind + | ReportingDescriptorRelationshipWillFollowKind + | ReportingDescriptorRelationshipWillPrecedeKind + | ReportingDescriptorRelationshipRelevantKind + | ReportingDescriptorRelationshipCustomKind Text + deriving (Eq, Ord, Show) + +instance ToJSON ReportingDescriptorRelationshipKind where + toJSON ReportingDescriptorRelationshipEqualKind = String "equal" + toJSON ReportingDescriptorRelationshipSupersetKind = String "superset" + toJSON ReportingDescriptorRelationshipSubsetKind = String "subset" + toJSON ReportingDescriptorRelationshipDisjointKind = String "disjoint" + toJSON ReportingDescriptorRelationshipIncomparableKind = String "incomparable" + toJSON ReportingDescriptorRelationshipCanFollowKind = String "canFollow" + toJSON ReportingDescriptorRelationshipCanPrecedeKind = String "canPrecede" + toJSON ReportingDescriptorRelationshipWillFollowKind = String "willFollow" + toJSON ReportingDescriptorRelationshipWillPrecedeKind = String "willPrecede" + toJSON ReportingDescriptorRelationshipRelevantKind = String "relevant" + toJSON (ReportingDescriptorRelationshipCustomKind t) = String t + +instance FromJSON ReportingDescriptorRelationshipKind where + parseJSON = withText "ReportingDescriptorRelationshipKind" $ \t -> + case t of + "equal" -> pure ReportingDescriptorRelationshipEqualKind + "superset" -> pure ReportingDescriptorRelationshipSupersetKind + "subset" -> pure ReportingDescriptorRelationshipSubsetKind + "disjoint" -> pure ReportingDescriptorRelationshipDisjointKind + "incomparable" -> pure ReportingDescriptorRelationshipIncomparableKind + "canFollow" -> pure ReportingDescriptorRelationshipCanFollowKind + "canPrecede" -> pure ReportingDescriptorRelationshipCanPrecedeKind + "willFollow" -> pure ReportingDescriptorRelationshipWillFollowKind + "willPrecede" -> pure ReportingDescriptorRelationshipWillPrecedeKind + "relevant" -> pure ReportingDescriptorRelationshipRelevantKind + _ -> pure (ReportingDescriptorRelationshipCustomKind t) + +data ReportingDescriptorRelationship + = MkReportingDescriptorRelationship + { -- | The target property of the reporting descriptor relationship + reportingDescriptorRelationshipTarget :: ReportingDescriptorReference + -- | The kinds property of the reporting descriptor relationship + , reportingDescriptorRelationshipKinds :: [ReportingDescriptorRelationshipKind] + -- | The description property of the reporting descriptor relationship + , reportingDescriptorRelationshipDescription :: Maybe Message + -- | The properties property of the ReportingDescriptorRelationship object + , reportingDescriptorRelationshipProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON ReportingDescriptorRelationship where + toJSON MkReportingDescriptorRelationship {..} = + object + [ "target" .= reportingDescriptorRelationshipTarget, + "kinds" .= reportingDescriptorRelationshipKinds, + "description" .=? reportingDescriptorRelationshipDescription, + "properties" .=? reportingDescriptorRelationshipProperties + ] + +instance FromJSON ReportingDescriptorRelationship where + parseJSON = withObject "ReportingDescriptorRelationship" $ \obj -> + MkReportingDescriptorRelationship + <$> obj .: "target" + <*> obj .: "kinds" + <*> obj .:? "description" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Result.hs b/src/Data/SARIF/Result.hs --- a/src/Data/SARIF/Result.hs +++ b/src/Data/SARIF/Result.hs @@ -5,50 +5,242 @@ -- file in the root directory of this source tree. -- -------------------------------------------------------------------------------- --- | Provides the `Result` type which represents results of a --- static analysis tool. -module Data.SARIF.Result ( - Level(..), - Result(..) -) where +-- | Provides the `Result` type to represent SARIF artifacts. +module Data.SARIF.Result + ( ResultKind (..), + Result (..), + ResultLevel (..), + ResultBaselineState (..), + ) +where -------------------------------------------------------------------------------- -import Data.Aeson.Optional hiding (Result, Error) +import Data.Aeson.Optional hiding (Error, Result) +import Data.Map.Strict import Data.Text +import Data.UUID.Types -import Data.SARIF.Level +import Data.SARIF.ArtifactLocation +import Data.SARIF.Attachment +import Data.SARIF.CodeFlow +import Data.SARIF.Fix +import Data.SARIF.Graph +import Data.SARIF.GraphTraversal import Data.SARIF.Location -import Data.SARIF.MultiformatMessageString +import Data.SARIF.Message +import Data.SARIF.ReportingDescriptorReference (ReportingDescriptorReference) +import Data.SARIF.ResultProvenance +import Data.SARIF.Stack +import Data.SARIF.Suppression +import Data.SARIF.WebRequest +import Data.SARIF.WebResponse -------------------------------------------------------------------------------- +data ResultKind + = ResultPassKind + | ResultOpenKind + | ResultInformationalKind + | ResultNoApplicableKind + | ResultReviewKind + | ResultFailKind + deriving (Eq, Ord, Show) + +instance ToJSON ResultKind where + toJSON ResultPassKind = String "pass" + toJSON ResultOpenKind = String "open" + toJSON ResultInformationalKind = String "informational" + toJSON ResultNoApplicableKind = String "noApplicable" + toJSON ResultReviewKind = String "review" + toJSON ResultFailKind = String "fail" + +instance FromJSON ResultKind where + parseJSON = withText "ResultKind" $ \case + "pass" -> pure ResultPassKind + "open" -> pure ResultOpenKind + "informational" -> pure ResultInformationalKind + "noApplicable" -> pure ResultNoApplicableKind + "review" -> pure ResultReviewKind + "fail" -> pure ResultFailKind + _ -> fail "Unknown ResultKind" + +data ResultLevel + = ResultWarningLevel + | ResultErrorLevel + | ResultNoteLevel + | ResultNoneLevel + deriving (Eq, Ord, Show) + +instance ToJSON ResultLevel where + toJSON ResultWarningLevel = String "warning" + toJSON ResultErrorLevel = String "error" + toJSON ResultNoteLevel = String "note" + toJSON ResultNoneLevel = String "none" + +instance FromJSON ResultLevel where + parseJSON = withText "ResultLevel" $ \case + "warning" -> pure ResultWarningLevel + "error" -> pure ResultErrorLevel + "note" -> pure ResultNoteLevel + "none" -> pure ResultNoneLevel + _ -> fail "Unknown Result Level" + +data ResultBaselineState + = ResultBaselineNewState + | ResultBaselineUnchangedState + | ResultBaselineUpdatedState + | ResultBaselineAbsentState + deriving (Eq, Ord, Show) + +instance ToJSON ResultBaselineState where + toJSON ResultBaselineNewState = String "new" + toJSON ResultBaselineUnchangedState = String "unchanged" + toJSON ResultBaselineUpdatedState = String "updated" + toJSON ResultBaselineAbsentState = String "absent" + +instance FromJSON ResultBaselineState where + parseJSON = withText "ResultBaselineState" $ \case + "new" -> pure ResultBaselineNewState + "unchanged" -> pure ResultBaselineUnchangedState + "updated" -> pure ResultBaselineUpdatedState + "absent" -> pure ResultBaselineAbsentState + _ -> fail "Unknown ResultBaselineState" + -- | Represents the results of a run of a static analysis tool. -data Result = MkResult { - -- | The unique ID of the rule of which this result is an occurrence of. - resultRuleId :: Text, - -- | A result-specific message which may refer to specific variable names - -- etc. which caused the rule to trigger. - resultMessage :: MultiformatMessageString, - -- | A list of locations which caused the rule to trigger. - resultLocations :: [Location], - -- | An optional override for the default `Level` of the rule. - resultLevel :: Maybe Level -} deriving (Eq, Show) +data Result + = MkResult + { -- | A unique,stable and opaque identifier for the result. + resultGuid :: Maybe UUID + -- | The identifier of a logically identical result + , resultCorrelationGuid :: Maybe UUID + -- | The unique ID of the rule of which this result is an occurrence of. + , resultRuleId :: Text + -- | A reference to the `ReportingDescriptor` for the rule + , resultRuleIndex :: Maybe Int + -- | The rule descriptor reference that identifies the report descriptor + , resultRule :: Maybe ReportingDescriptorReference + -- | A list of references to taxonomies to which this result belongs. + , resultTaxa :: Maybe [ReportingDescriptorReference] + -- | The kind property of the result. + , resultKind :: Maybe ResultKind + -- | The level property of the result + , resultLevel :: Maybe ResultLevel + -- | A result-specific message which may refer to specific variable names + -- etc. which caused the rule to trigger. + , resultMessage :: Message + -- | The locations property of the result. + , resultLocations :: [Location] + -- | The analysisTarget property of the result + , resultAnalysisTarget :: Maybe ArtifactLocation + -- | The webRequest property of the result + , resultWebRequest :: Maybe WebRequest + -- | The webResponse property of the result + , resultWebResponse :: Maybe WebResponse + -- | The fingerprints property of the result + , resultFingerprints :: Maybe (Map Text Text) + -- | The partialFingerprints property of the result + , resultPartialFingerprints :: Maybe (Map Text Text) + -- | The codeFlows property of the result + , resultCodeFlows :: Maybe [CodeFlow] + -- | The graph property of the result + , resultGraphs :: Maybe [Graph] + -- | The graph traversal property of the result + , resultGraphTraversals :: Maybe [GraphTraversal] + -- | The stacks property of the result + , resultStacks :: Maybe [Stack] + -- | The relatedLocations property of the result + , resultRelatedLocations :: Maybe [Location] + -- | The suppressions property of the result + , resultSuppressions :: Maybe [Suppression] + -- | The baselineState property of the result + , resultBaselineState :: Maybe ResultBaselineState + -- | The rank property of the result + , resultRank :: Maybe Double + -- | The attachments property of the result + , resultAttachments :: Maybe [Attachment] + -- | The workItemUris property of the result + , resultWorkItemUris :: Maybe [Text] + -- | The hostedViewerUri property of the result + , resultHostedViewerUri :: Maybe Text + -- | The provenance property of the result + , resultProvenance :: Maybe ResultProvenance + -- | The fixes property of the result + , resultFixes :: Maybe [Fix] + -- | The occurrenceCount property of the result + , resultOccurrenceCount :: Maybe Int + -- | The properties property of the Result object + , resultProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) instance ToJSON Result where - toJSON MkResult{..} = object - [ "ruleId" .= resultRuleId - , "message" .= resultMessage - , "locations" .= resultLocations - , "level" .=? resultLevel - ] + toJSON MkResult {..} = + object + [ "guid" .=? resultGuid, + "correlationGuid" .=? resultCorrelationGuid, + "ruleId" .= resultRuleId, + "ruleIndex" .=? resultRuleIndex, + "rule" .=? resultRule, + "taxa" .=? resultTaxa, + "kind" .=? resultKind, + "level" .=? resultLevel, + "message" .= resultMessage, + "locations" .= resultLocations, + "analysisTarget" .=? resultAnalysisTarget, + "webRequest" .=? resultWebRequest, + "webResponse" .=? resultWebResponse, + "fingerprints" .=? resultFingerprints, + "partialFingerprints" .=? resultPartialFingerprints, + "codeFlows" .=? resultCodeFlows, + "graphs" .=? resultGraphs, + "graphTraversals" .=? resultGraphTraversals, + "stacks" .=? resultStacks, + "relatedLocations" .=? resultRelatedLocations, + "suppressions" .=? resultSuppressions, + "baselineState" .=? resultBaselineState, + "rank" .=? resultRank, + "attachments" .=? resultAttachments, + "workItemUris" .=? resultWorkItemUris, + "hostedViewerUri" .=? resultHostedViewerUri, + "provenance" .=? resultProvenance, + "fixes" .=? resultFixes, + "occurrenceCount" .=? resultOccurrenceCount, + "properties" .=? resultProperties + ] instance FromJSON Result where - parseJSON = withObject "Result" $ \obj -> - MkResult <$> obj .: "ruleId" - <*> obj .: "message" - <*> obj .: "locations" - <*> obj .: "level" + parseJSON = withObject "Result" $ \obj -> + MkResult + <$> obj .:? "guid" + <*> obj .:? "correlationGuid" + <*> obj .: "ruleId" + <*> obj .:? "ruleIndex" + <*> obj .:? "rule" + <*> obj .:? "taxa" + <*> obj .:? "kind" + <*> obj .:? "level" + <*> obj .: "message" + <*> obj .: "locations" + <*> obj .:? "analysisTarget" + <*> obj .:? "webRequest" + <*> obj .:? "webResponse" + <*> obj .:? "fingerprints" + <*> obj .:? "partialFingerprints" + <*> obj .:? "codeFlows" + <*> obj .:? "graphs" + <*> obj .:? "graphTraversals" + <*> obj .:? "stacks" + <*> obj .:? "relatedLocations" + <*> obj .:? "suppressions" + <*> obj .:? "baselineState" + <*> obj .:? "rank" + <*> obj .:? "attachments" + <*> obj .:? "workItemUris" + <*> obj .:? "hostedViewerUri" + <*> obj .:? "provenance" + <*> obj .:? "fixes" + <*> obj .:? "occurrenceCount" + <*> obj .:? "properties" -------------------------------------------------------------------------------- diff --git a/src/Data/SARIF/ResultProvenance.hs b/src/Data/SARIF/ResultProvenance.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/ResultProvenance.hs @@ -0,0 +1,56 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `ResultProvenance` type to represent SARIF artifacts. +module Data.SARIF.ResultProvenance where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.PhysicalLocation +import Data.Text + +data ResultProvenance + = MkResultProvenance + { -- | The firstDetectionTimeUtc property of the result provenance + resultProvenanceFirstDetectionTimeUtc :: Maybe Text + -- | The lastDetectionTimeUtc property of the result provenance + , resultProvenanceLastDetectionTimeUtc :: Maybe Text + -- | The firstDetectionRunGuid property of the result provenance + , resultProvenanceFirstDetectionRunGuid :: Maybe Text + -- | The lastDetectionRunGuid property of the result provenance + , resultProvenanceLastDetectionRunGuid :: Maybe Text + -- | The invocationIndex property of the result provenance + , resultProvenanceInvocationIndex :: Maybe Int + -- | The conversionSources property of the result provenance + , resultProvenanceConversionSources :: Maybe [PhysicalLocation] + -- | The properties property of the ResultProvenance object + , resultProvenanceProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON ResultProvenance where + toJSON MkResultProvenance {..} = + object + [ "firstDetectionTimeUtc" .=? resultProvenanceFirstDetectionTimeUtc, + "lastDetectionTimeUtc" .=? resultProvenanceLastDetectionTimeUtc, + "firstDetectionRunGuid" .=? resultProvenanceFirstDetectionRunGuid, + "lastDetectionRunGuid" .=? resultProvenanceLastDetectionRunGuid, + "invocationIndex" .=? resultProvenanceInvocationIndex, + "conversionSources" .=? resultProvenanceConversionSources, + "properties" .=? resultProvenanceProperties + ] + +instance FromJSON ResultProvenance where + parseJSON = withObject "ResultProvenance" $ \obj -> + MkResultProvenance + <$> obj .:? "firstDetectionTimeUtc" + <*> obj .:? "lastDetectionTimeUtc" + <*> obj .:? "firstDetectionRunGuid" + <*> obj .:? "lastDetectionRunGuid" + <*> obj .:? "invocationIndex" + <*> obj .:? "conversionSources" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Run.hs b/src/Data/SARIF/Run.hs --- a/src/Data/SARIF/Run.hs +++ b/src/Data/SARIF/Run.hs @@ -5,44 +5,180 @@ -- file in the root directory of this source tree. -- -------------------------------------------------------------------------------- --- | Provides the `Run` type which represents a single run of a --- static analysis tool. -module Data.SARIF.Run ( - Run(..) -) where +-- | Provides the `Run` type to represent SARIF artifacts. +module Data.SARIF.Run + ( Run (..), + RunColumnKind (..), + ) +where -------------------------------------------------------------------------------- -import Data.Aeson hiding (Result) - +import Data.Aeson.Optional hiding (Result) +import Data.Map.Strict +import Data.SARIF.Address import Data.SARIF.Artifact -import Data.SARIF.Result (Result(..)) -import Data.SARIF.Tool (Tool(..)) +import Data.SARIF.ArtifactLocation +import Data.SARIF.AutomationDetails +import Data.SARIF.Conversion +import Data.SARIF.ExternalPropertyFileReferences +import Data.SARIF.Graph +import Data.SARIF.Invocation +import Data.SARIF.LogicalLocation +import Data.SARIF.Result +import Data.SARIF.SpecialLocations +import Data.SARIF.ThreadFlowLocation +import Data.SARIF.Tool +import Data.SARIF.ToolComponent +import Data.SARIF.VersionControlDetails +import Data.SARIF.WebRequest +import Data.SARIF.WebResponse +import Data.Text -------------------------------------------------------------------------------- +data RunColumnKind + = RunUtf16CodeUnitsColumnKind + | RunUnicodeCodePointsColumnKind + | RunCustomColumnKind Text + deriving (Eq, Ord, Show) + +instance ToJSON RunColumnKind where + toJSON RunUtf16CodeUnitsColumnKind = String "utf16CodeUnits" + toJSON RunUnicodeCodePointsColumnKind = String "unicodeCodePoints" + toJSON (RunCustomColumnKind t) = String t + +instance FromJSON RunColumnKind where + parseJSON = withText "RunColumnKind" $ \case + "utf16CodeUnits" -> pure RunUtf16CodeUnitsColumnKind + "unicodeCodePoints" -> pure RunUnicodeCodePointsColumnKind + other -> pure $ RunCustomColumnKind other + -- | Represents individual runs of static analysis tools. -data Run = MkRun { - -- | A description of the tool that was run. - runTool :: Tool, - -- | A list of the artifacts that were scanned by the tool. - runArtifacts :: [Artifact], - -- | The results produced by the tool as a result of scanning - -- the artifacts. - runResults :: [Result] -} deriving (Eq, Show) +data Run + = MkRun + { -- | The externalPropertyFileReferences property of a run + runExternalPropertyFileReferences :: Maybe ExternalPropertyFileReferences + -- | The automationDetails property of a run + , runAutomationDetails :: Maybe AutomationDetails + -- | The runAggregates property of a run + , runAggregates :: Maybe [AutomationDetails] + -- | The baselineGuid property of a run + , runBaselineGuid :: Maybe Text + -- | The tool property of a run + , runTool :: Maybe Tool + -- | The language property of a run + , runLanguage :: Maybe Text + -- | The taxonomies property of a run + , runTaxonomies :: Maybe [ToolComponent] + -- | The translations property of a run + , runTranslations :: Maybe [ToolComponent] + -- | The policies property of a run + , runPolicies :: Maybe [ToolComponent] + -- | The invocations property of a run + , runInvocations :: Maybe [Invocation] + -- | The conversion property of a run + , runConversion :: Maybe Conversion + -- | The versionControlProvenance property of a run + , runVersionControlProvenance :: Maybe VersionControlDetails + -- | The originalUriBaseIds property of a run + , runOriginalUriBaseIds :: Maybe (Map Text ArtifactLocation) + -- | The artifacts property of a run + , runArtifacts :: Maybe [Artifact] + -- | The specialLocations property of a run + , runSpecialLocations :: Maybe [SpecialLocations] + -- | The logicalLocations property of a run + , runLogicalLocations :: Maybe [LogicalLocation] + -- | The addresses property of a run + , runAddresses :: Maybe [Address] + -- | The threadFlowLocations property of a run + , runThreadFlowLocations :: Maybe [ThreadFlowLocation] + -- | The graphs property of a run + , runGraphs :: Maybe [Graph] + -- | The webRequests property of a run + , runWebRequests :: Maybe [WebRequest] + -- | The webResponses property of a run + , runWebResponses :: Maybe [WebResponse] + -- | The results property of a run + , runResults :: Maybe [Result] + -- | The defaultEncoding property of a run + , runDefaultEncoding :: Maybe Text + -- | The defaultSourceLanguage property of a run + , runDefaultSourceLanguage :: Maybe Text + -- | The newlineSequences property of a run + , runNewlineSequences :: Maybe [Text] + -- | The columnKind property of a run + , runColumnKind :: Maybe RunColumnKind + -- | The redactionTokens property of a run + , runRedactionTokens :: Maybe [Text] + -- | The properties property of the Run object + , runProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) +-------------------------------------------------------------------------------- + instance ToJSON Run where - toJSON MkRun{..} = object - [ "tool" .= runTool - , "artifacts" .= runArtifacts - , "results" .= runResults - ] + toJSON MkRun {..} = + object + [ "externalPropertyFileReferences" .=? runExternalPropertyFileReferences, + "automationDetails" .=? runAutomationDetails, + "runAggregates" .=? runAggregates, + "baselineGuid" .=? runBaselineGuid, + "tool" .=? runTool, + "language" .=? runLanguage, + "taxonomies" .=? runTaxonomies, + "translations" .=? runTranslations, + "policies" .=? runPolicies, + "invocations" .=? runInvocations, + "conversion" .=? runConversion, + "versionControlProvenance" .=? runVersionControlProvenance, + "originalUriBaseIds" .=? runOriginalUriBaseIds, + "artifacts" .=? runArtifacts, + "specialLocations" .=? runSpecialLocations, + "logicalLocations" .=? runLogicalLocations, + "addresses" .=? runAddresses, + "threadFlowLocations" .=? runThreadFlowLocations, + "graphs" .=? runGraphs, + "webRequests" .=? runWebRequests, + "webResponses" .=? runWebResponses, + "results" .=? runResults, + "defaultEncoding" .=? runDefaultEncoding, + "defaultSourceLanguage" .=? runDefaultSourceLanguage, + "newlineSequences" .=? runNewlineSequences, + "columnKind" .=? runColumnKind, + "redactionTokens" .=? runRedactionTokens, + "properties" .=? runProperties + ] instance FromJSON Run where - parseJSON = withObject "Run" $ \obj -> - MkRun <$> obj .: "tool" - <*> obj .: "artifacts" .!= [] - <*> obj .: "results" .!= [] - --------------------------------------------------------------------------------- + parseJSON = withObject "Run" $ \obj -> + MkRun + <$> obj .:? "externalPropertyFileReferences" + <*> obj .:? "automationDetails" + <*> obj .:? "runAggregates" + <*> obj .:? "baselineGuid" + <*> obj .:? "tool" + <*> obj .:? "language" + <*> obj .:? "taxonomies" + <*> obj .:? "translations" + <*> obj .:? "policies" + <*> obj .:? "invocations" + <*> obj .:? "conversion" + <*> obj .:? "versionControlProvenance" + <*> obj .:? "originalUriBaseIds" + <*> obj .:? "artifacts" + <*> obj .:? "specialLocations" + <*> obj .:? "logicalLocations" + <*> obj .:? "addresses" + <*> obj .:? "threadFlowLocations" + <*> obj .:? "graphs" + <*> obj .:? "webRequests" + <*> obj .:? "webResponses" + <*> obj .:? "results" + <*> obj .:? "defaultEncoding" + <*> obj .:? "defaultSourceLanguage" + <*> obj .:? "newlineSequences" + <*> obj .:? "columnKind" + <*> obj .:? "redactionTokens" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/SpecialLocations.hs b/src/Data/SARIF/SpecialLocations.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/SpecialLocations.hs @@ -0,0 +1,36 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `SpecialLocations` type to represent SARIF artifacts. +module Data.SARIF.SpecialLocations (SpecialLocations (..)) where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ArtifactLocation +import Data.Text + +data SpecialLocations + = MkSpecialLocations + { -- | The displayBase property of the special locations + specialLocationsDisplayBase :: Maybe ArtifactLocation + -- | The properties property of the SpecialLocations object + , specialLocationsProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON SpecialLocations where + toJSON MkSpecialLocations {..} = + object + [ "displayBase" .=? specialLocationsDisplayBase, + "properties" .=? specialLocationsProperties + ] + +instance FromJSON SpecialLocations where + parseJSON = withObject "SpecialLocations" $ \obj -> + MkSpecialLocations + <$> obj .:? "displayBase" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Stack.hs b/src/Data/SARIF/Stack.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Stack.hs @@ -0,0 +1,41 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `Stack` type to represent SARIF artifacts. +module Data.SARIF.Stack (Stack (..)) where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Message +import Data.SARIF.StackFrame +import Data.Text + +data Stack + = MkStack + { -- | The message property of a thread flow object + stackMessage :: Maybe Message + -- | The frames property of a thread flow object + , stackFrames :: [StackFrame] + -- | The properties property of the Stack object + , stackProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Stack where + toJSON MkStack {..} = + object + [ "message" .=? stackMessage, + "frames" .= stackFrames, + "properties" .=? stackProperties + ] + +instance FromJSON Stack where + parseJSON = withObject "Stack" $ \obj -> + MkStack + <$> obj .:? "message" + <*> obj .: "frames" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/StackFrame.hs b/src/Data/SARIF/StackFrame.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/StackFrame.hs @@ -0,0 +1,48 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `StackFrame` type to represent SARIF artifacts. +module Data.SARIF.StackFrame (StackFrame (..)) where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Location +import Data.Text + +data StackFrame + = MkStackFrame + { -- | The location property of a stack frame object + stackFrameLocation :: Maybe Location + -- | The module property of a stack frame object + , stackFrameModule :: Maybe Text + -- | The threadId property of a stack frame object + , stackFrameThreadId :: Maybe Integer + -- | The parameters property of a stack frame object + , stackFrameParameters :: Maybe [Text] + -- | The properties property of the StackFrame object + , stackFrameProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON StackFrame where + toJSON MkStackFrame {..} = + object + [ "location" .=? stackFrameLocation, + "module" .=? stackFrameModule, + "threadId" .=? stackFrameThreadId, + "parameters" .=? stackFrameParameters, + "properties" .=? stackFrameProperties + ] + +instance FromJSON StackFrame where + parseJSON = withObject "StackFrame" $ \obj -> + MkStackFrame + <$> obj .:? "location" + <*> obj .:? "module" + <*> obj .:? "threadId" + <*> obj .:? "parameters" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Suppression.hs b/src/Data/SARIF/Suppression.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/Suppression.hs @@ -0,0 +1,80 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `Suppression` type to represent SARIF artifacts. +module Data.SARIF.Suppression (Suppression (..), SuppressionKind (..), SuppressionStatus (..)) where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Location +import Data.Text +import Data.UUID.Types + +data SuppressionKind + = SuppressionInSourceKind + | SuppressionExternalKind + deriving (Eq, Ord, Show) + +instance ToJSON SuppressionKind where + toJSON SuppressionInSourceKind = String "inSource" + toJSON SuppressionExternalKind = String "external" + +instance FromJSON SuppressionKind where + parseJSON = withText "SuppressionKind" $ \case + "inSource" -> pure SuppressionInSourceKind + "external" -> pure SuppressionExternalKind + _ -> fail "Unknown SuppressionKind" + +data SuppressionStatus + = SuppressionAcceptedStatus + | SuppressionRejectedStatus + | SuppressionUnderReviewStatus + deriving (Eq, Ord, Show) + +instance ToJSON SuppressionStatus where + toJSON SuppressionAcceptedStatus = String "accepted" + toJSON SuppressionRejectedStatus = String "rejected" + toJSON SuppressionUnderReviewStatus = String "underReview" + +instance FromJSON SuppressionStatus where + parseJSON = withText "SuppressionStatus" $ \case + "accepted" -> pure SuppressionAcceptedStatus + "rejected" -> pure SuppressionRejectedStatus + "underReview" -> pure SuppressionUnderReviewStatus + _ -> fail "Unknown SuppressionStatus" + +data Suppression + = MkSuppression + { suppressionKind :: SuppressionKind + , suppressionStatus :: Maybe SuppressionStatus + , suppressionLocation :: Maybe Location + , suppressionGUID :: Maybe UUID + , suppressionJustification :: Maybe Text + , suppressionProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON Suppression where + toJSON MkSuppression {..} = + object + [ "kind" .= suppressionKind, + "status" .=? suppressionStatus, + "location" .=? suppressionLocation, + "guid" .=? suppressionGUID, + "justification" .=? suppressionJustification, + "properties" .=? suppressionProperties + ] + +instance FromJSON Suppression where + parseJSON = withObject "Suppression" $ \o -> + MkSuppression + <$> o .: "kind" + <*> o .:? "status" + <*> o .:? "location" + <*> o .:? "guid" + <*> o .:? "justification" + <*> o .:? "properties" diff --git a/src/Data/SARIF/ThreadFlow.hs b/src/Data/SARIF/ThreadFlow.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/ThreadFlow.hs @@ -0,0 +1,53 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `ThreadFlow` type to represent SARIF artifacts. +module Data.SARIF.ThreadFlow (ThreadFlow (..)) where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Message +import Data.SARIF.ThreadFlowLocation +import Data.Text + +data ThreadFlow + = MkThreadFlow + { -- | The id property of a thread flow object + threadFlowId :: Maybe Text + -- | The message property of a thread flow object + , threadFlowMessage :: Maybe Message + -- | The initialState property of a thread flow object + , threadFlowInitialState :: Maybe (Map Text Text) + -- | The immutableState property of a thread flow object + , threadFlowImmutableState :: Maybe (Map Text Text) + -- | The locations property of a thread flow object + , threadFlowLocations :: [ThreadFlowLocation] + -- | The properties property of the ThreadFlow object + , threadFlowProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON ThreadFlow where + toJSON MkThreadFlow {..} = + object + [ "id" .=? threadFlowId, + "message" .=? threadFlowMessage, + "initialState" .=? threadFlowInitialState, + "immutableState" .=? threadFlowImmutableState, + "locations" .= threadFlowLocations, + "properties" .=? threadFlowProperties + ] + +instance FromJSON ThreadFlow where + parseJSON = withObject "ThreadFlow" $ \obj -> + MkThreadFlow + <$> obj .:? "id" + <*> obj .:? "message" + <*> obj .:? "initialState" + <*> obj .:? "immutableState" + <*> obj .: "locations" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/ThreadFlowLocation.hs b/src/Data/SARIF/ThreadFlowLocation.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/ThreadFlowLocation.hs @@ -0,0 +1,185 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `ThreadFlowLocation` type to represent SARIF artifacts. +module Data.SARIF.ThreadFlowLocation (ThreadFlowLocation (..), ThreadFlowLocationKind (..), ThreadFlowImportance (..)) where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.Location +import Data.SARIF.MultiformatMessageString +import Data.SARIF.ReportingDescriptorReference +import Data.SARIF.Stack +import Data.SARIF.WebRequest +import Data.SARIF.WebResponse +import Data.Text +import Data.Time + +data ThreadFlowLocationKind + = ThreadFlowLocationAcquireKind + | ThreadFlowLocationReleaseKind + | ThreadFlowLocationEnterKind + | ThreadFlowLocationExitKind + | ThreadFlowLocationCallKind + | ThreadFlowLocationReturnKind + | ThreadFlowLocationBranchKind + | ThreadFlowLocationTaintKind + | ThreadFlowLocationFunctionKind + | ThreadFlowLocationHandlerKind + | ThreadFlowLocationLockKind + | ThreadFlowLocationMemoryKind + | ThreadFlowLocationResourceKind + | ThreadFlowLocationScopeKind + | ThreadFlowLocationValueKind + | ThreadFlowLocationImplicitKind + | ThreadFlowLocationFalseKind + | ThreadFlowLocationTrueKind + | ThreadFlowLocationCautionKind + | ThreadFlowLocationDangerKind + | ThreadFlowLocationUnknownKind + | ThreadFlowLocationUnreachableKind + | ThreadFlowLocationCustomKind Text + deriving (Eq, Ord, Show) + +instance ToJSON ThreadFlowLocationKind where + toJSON ThreadFlowLocationAcquireKind = String "acquire" + toJSON ThreadFlowLocationReleaseKind = String "release" + toJSON ThreadFlowLocationEnterKind = String "enter" + toJSON ThreadFlowLocationExitKind = String "exixt" + toJSON ThreadFlowLocationCallKind = String "call" + toJSON ThreadFlowLocationReturnKind = String "return" + toJSON ThreadFlowLocationBranchKind = String "branch" + toJSON ThreadFlowLocationTaintKind = String "taint" + toJSON ThreadFlowLocationFunctionKind = String "function" + toJSON ThreadFlowLocationHandlerKind = String "handler" + toJSON ThreadFlowLocationLockKind = String "lock" + toJSON ThreadFlowLocationMemoryKind = String "memory" + toJSON ThreadFlowLocationResourceKind = String "resource" + toJSON ThreadFlowLocationScopeKind = String "scope" + toJSON ThreadFlowLocationValueKind = String "value" + toJSON ThreadFlowLocationImplicitKind = String "implicit" + toJSON ThreadFlowLocationFalseKind = String "false" + toJSON ThreadFlowLocationTrueKind = String "true" + toJSON ThreadFlowLocationCautionKind = String "caution" + toJSON ThreadFlowLocationDangerKind = String "danger" + toJSON ThreadFlowLocationUnknownKind = String "unknown" + toJSON ThreadFlowLocationUnreachableKind = String "unreachable" + toJSON (ThreadFlowLocationCustomKind text) = String text + +instance FromJSON ThreadFlowLocationKind where + parseJSON = withText "ThreadFlowLocationKind" $ \case + "acquire" -> pure ThreadFlowLocationAcquireKind + "release" -> pure ThreadFlowLocationReleaseKind + "enter" -> pure ThreadFlowLocationEnterKind + "exit" -> pure ThreadFlowLocationExitKind + "call" -> pure ThreadFlowLocationCallKind + "return" -> pure ThreadFlowLocationReturnKind + "branch" -> pure ThreadFlowLocationBranchKind + "taint" -> pure ThreadFlowLocationTaintKind + "function" -> pure ThreadFlowLocationFunctionKind + "handler" -> pure ThreadFlowLocationHandlerKind + "lock" -> pure ThreadFlowLocationLockKind + "memory" -> pure ThreadFlowLocationMemoryKind + "resource" -> pure ThreadFlowLocationResourceKind + "scope" -> pure ThreadFlowLocationScopeKind + "value" -> pure ThreadFlowLocationValueKind + "implicit" -> pure ThreadFlowLocationImplicitKind + "false" -> pure ThreadFlowLocationFalseKind + "true" -> pure ThreadFlowLocationTrueKind + "caution" -> pure ThreadFlowLocationCautionKind + "danger" -> pure ThreadFlowLocationDangerKind + "unknown" -> pure ThreadFlowLocationUnknownKind + "unreachable" -> pure ThreadFlowLocationUnreachableKind + custom -> pure $ ThreadFlowLocationCustomKind custom + +data ThreadFlowImportance + = ThreadFlowImportantImportance + | ThreadFlowEssentialImportance + | ThreadFlowUnimportantImportance + deriving (Eq, Ord, Show) + +instance ToJSON ThreadFlowImportance where + toJSON ThreadFlowImportantImportance = String "important" + toJSON ThreadFlowEssentialImportance = String "essential" + toJSON ThreadFlowUnimportantImportance = String "unimportant" + +instance FromJSON ThreadFlowImportance where + parseJSON = withText "ThreadFlowImportance" $ \case + "important" -> pure ThreadFlowImportantImportance + "essential" -> pure ThreadFlowEssentialImportance + "unimportant" -> pure ThreadFlowUnimportantImportance + _ -> fail "Unknown ThreadFlowImportance" + +data ThreadFlowLocation + = MkThreadFlowLocation + { -- | The index property of a thread flow location object + threadFlowLocationIndex :: Maybe Integer + -- | The location property of a thread flow location object + , threadFlowLocationLocation :: Location + -- | The module property of a thread flow location object + , threadFlowLocationModule :: Maybe Text + -- | The stack property of a thread flow location object + , threadFlowLocationStack :: Maybe Stack + -- | The webRequest property of a thread flow location object + , threadFlowLocationWebRequest :: Maybe WebRequest + -- | The webResponse property of a thread flow location object + , threadFlowLocationWebResponse :: Maybe WebResponse + -- | The kinds property of a thread flow location object + , threadFlowLocationKinds :: Maybe [ThreadFlowLocationKind] + -- | The state property of a thread flow location object + , threadFlowLocationState :: Maybe (Map Text MultiformatMessageString) + -- | The nestingLevel property of a thread flow locatiob object + , threadFlowLocationNestingLevel :: Maybe Integer + -- | The executionOrder property of a thread flow location object + , threadFlowLocationExecutionOrder :: Maybe Integer + -- | The executionTimeUtc property of a thread flow location object + , threadFlowLocationExecutionTimeUtc :: Maybe UTCTime + -- | The importance property of a thread flow location object + , threadFlowLocationImportance :: Maybe Integer + -- | The taxa property of a thread flow location object + , threadFlowLocationTaxa :: Maybe [ReportingDescriptorReference] + -- | The properties property of the ThreadFlowLocation object + , threadFlowLocationProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON ThreadFlowLocation where + toJSON MkThreadFlowLocation {..} = + object + [ "index" .=? threadFlowLocationIndex, + "location" .= threadFlowLocationLocation, + "module" .=? threadFlowLocationModule, + "stack" .=? threadFlowLocationStack, + "webRequest" .=? threadFlowLocationWebRequest, + "webResponse" .=? threadFlowLocationWebResponse, + "kinds" .=? threadFlowLocationKinds, + "state" .=? threadFlowLocationState, + "nestingLevel" .=? threadFlowLocationNestingLevel, + "executionOrder" .=? threadFlowLocationExecutionOrder, + "executionTimeUtc" .=? threadFlowLocationExecutionTimeUtc, + "importance" .=? threadFlowLocationImportance, + "taxa" .=? threadFlowLocationTaxa, + "properties" .=? threadFlowLocationProperties + ] + +instance FromJSON ThreadFlowLocation where + parseJSON = withObject "ThreadFlowLocation" $ \obj -> + MkThreadFlowLocation + <$> obj .:? "index" + <*> obj .: "location" + <*> obj .:? "module" + <*> obj .:? "stack" + <*> obj .:? "webRequest" + <*> obj .:? "webResponse" + <*> obj .:? "kinds" + <*> obj .:? "state" + <*> obj .:? "nestingLevel" + <*> obj .:? "executionOrder" + <*> obj .:? "executionTimeUtc" + <*> obj .:? "importance" + <*> obj .:? "taxa" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/Tool.hs b/src/Data/SARIF/Tool.hs --- a/src/Data/SARIF/Tool.hs +++ b/src/Data/SARIF/Tool.hs @@ -5,94 +5,38 @@ -- file in the root directory of this source tree. -- -------------------------------------------------------------------------------- --- | Provides the `Tool` type which is used to describe static analysis tools. -module Data.SARIF.Tool ( - Tool(..), - ToolComponent(..), - defaultToolComponent -) where +-- | Provides the `Tool` type to represent SARIF artifacts. --------------------------------------------------------------------------------- +module Data.SARIF.Tool + ( Tool (..), + ) +where -import GHC.Generics +-------------------------------------------------------------------------------- import Data.Aeson.Optional -import Data.Text -import Data.UUID.Types - -import Data.SARIF.ReportingDescriptor - --------------------------------------------------------------------------------- +import Data.SARIF.ToolComponent --- | Used to describe static analysis tools. -data Tool = MkTool { - -- | The description of the tool itself. - toolDriver :: ToolComponent, - -- | Descriptions of any extensions to the tool that were used. - toolExtensions :: [ToolComponent] -} deriving (Eq, Show, Generic) +data Tool + = MkTool + { -- | The description of the tool itself. + toolDriver :: ToolComponent + -- | Descriptions of any extensions to the tool that were used. + , toolExtensions :: Maybe [ToolComponent] + } + deriving (Eq, Ord, Show) instance ToJSON Tool where - toJSON MkTool{..} = object - [ "driver" .= toolDriver - , "extensions" .= toolExtensions - ] + toJSON MkTool {..} = + object + [ "driver" .= toolDriver, + "extensions" .=? toolExtensions + ] instance FromJSON Tool where - parseJSON = withObject "Tool" $ \obj -> - MkTool <$> obj .: "driver" - <*> obj .: "extensions" .!= [] - --- | A description of a tool component, such as a static analysis tool or --- an extension to one. -data ToolComponent = MkToolComponent { - -- | The short name of the tool component. - toolComponentName :: Maybe Text, - -- | The full name of the tool component. - toolComponentFullName :: Maybe Text, - -- | The semver of the tool component. - toolComponentSemanticVersion :: Maybe Text, - -- | The version of the tool component. - toolComponentVersion :: Maybe Text, - -- | A GUID which identifies the tool component. - toolComponentGUID :: Maybe UUID, - -- | A URI pointing to more information about the tool component. - toolComponentInformationUri :: Maybe Text, - -- | A list of rules that the tool component applies. - toolComponentRules :: [ReportingDescriptor] -} deriving (Eq, Show, Generic) - -instance ToJSON ToolComponent where - toJSON MkToolComponent{..} = object - [ "name" .= toolComponentName - , "fullName" .=? toolComponentFullName - , "semanticVersion" .=? toolComponentSemanticVersion - , "version" .=? toolComponentVersion - , "guid" .=? toolComponentGUID - , "informationUri" .=? toolComponentInformationUri - , "rules" .= toolComponentRules - ] - -instance FromJSON ToolComponent where - parseJSON = withObject "ToolComponent" $ \obj -> - MkToolComponent <$> obj .: "name" - <*> obj .: "fullName" - <*> obj .:? "semanticVersion" - <*> obj .:? "version" - <*> obj .:? "guid" - <*> obj .:? "informationUri" - <*> obj .: "rules" .!= [] - --- | `defaultToolComponent` is a default value of the `ToolComponent` type. -defaultToolComponent :: ToolComponent -defaultToolComponent = MkToolComponent{ - toolComponentName = Nothing, - toolComponentFullName = Nothing, - toolComponentSemanticVersion = Nothing, - toolComponentVersion = Nothing, - toolComponentGUID = Nothing, - toolComponentInformationUri = Nothing, - toolComponentRules = [] -} + parseJSON = withObject "tool" $ \obj -> + MkTool + <$> obj .: "driver" + <*> (obj .:? "extensions") .!= Just [] -------------------------------------------------------------------------------- diff --git a/src/Data/SARIF/ToolComponent.hs b/src/Data/SARIF/ToolComponent.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/ToolComponent.hs @@ -0,0 +1,159 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `ToolComponent` type to represent SARIF artifacts. +module Data.SARIF.ToolComponent (ToolComponent (..)) where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ArtifactLocation +import Data.SARIF.MultiformatMessageString +import Data.SARIF.ReportingDescriptor +import Data.SARIF.ToolComponentReference +import Data.SARIF.TranslationMetadata +import Data.Text +import Data.Time +import Data.UUID.Types + +data ToolComponentContent + = ToolComponentLocalizedDataContent + | ToolComponentContentNonLocalizedData + deriving (Eq, Ord, Show) + +instance ToJSON ToolComponentContent where + toJSON ToolComponentLocalizedDataContent = String "localizedData" + toJSON ToolComponentContentNonLocalizedData = String "nonLocalizedData" + +instance FromJSON ToolComponentContent where + parseJSON = withText "ToolComponentContent" $ \case + "localizedData" -> pure ToolComponentLocalizedDataContent + "nonLocalizedData" -> pure ToolComponentContentNonLocalizedData + _ -> fail "Unknown ToolComponentContent" + +-- | A description of a tool component, such as a static analysis tool or +-- an extension to one. +data ToolComponent + = MkToolComponent + { -- | A GUID which identifies the tool component. + toolComponentGUID :: Maybe UUID + -- | The short name of the tool component. + , toolComponentName :: Maybe Text + -- | The full name of the tool component. + , toolComponentFullName :: Maybe Text + -- | The name of the product to which the tool component belongs. + , toolComponentProduct :: Maybe Text + -- | The name of the suite of products to which the tool component belongs. + , toolComponentProductSuit :: Maybe Text + -- | The semver of the tool component. + , toolComponentSemanticVersion :: Maybe Text + -- | The version of the tool component. + , toolComponentVersion :: Maybe Text + -- | The UTC date and time at which the tool component was released. + , toolComponentReleaseDateUtc :: Maybe UTCTime + -- | A URI for downloading this tool component version. + , toolComponentDownloadUri :: Maybe Text + -- | A URI pointing to more information about the tool component. + , toolComponentInformationUri :: Maybe Text + -- | The name of the company or organization that produced the tool componen + , toolComponentOrganization :: Maybe Text + -- | One sentence description of the tool component. + , toolComponentShortDescription :: Maybe MultiformatMessageString + -- | A full description of the tool component. + , toolComponentFullDescription :: Maybe MultiformatMessageString + -- | the language of the string contained in the component + , toolComponentLanguage :: Maybe Text + -- | Mapping from Message ID to its corresponding message string. + , toolComponentGlobalMessageStrings :: Maybe (Map Text MultiformatMessageString) + -- | A list of rules that the tool component applies. + , toolComponentRules :: Maybe [ReportingDescriptor] + -- | A list of notifications information provided by the tool component + , toolComponentNotifications :: Maybe [ReportingDescriptor] + -- | A list of taxonomies that + , toolComponentTaxa :: Maybe [ReportingDescriptor] + -- | The supportedTaxonomies property of the tool component + , toolComponentSupportedTaxonomies :: Maybe [ToolComponentReference] + -- | The translationMetadata property of the tool component + , toolComponentTranslationMetadata :: Maybe TranslationMetadata + -- | The locations property of the tool component + , toolComponentLocations :: Maybe [ArtifactLocation] + -- | The contents property of the tool component + , toolComponentContents :: Maybe [Text] + -- | The isComprehensive property of the tool component + , toolComponentIsComprehensive :: Maybe Bool + -- | The localizedDataSemanticVersion property of the tool component + , toolComponentLocalizedDataSemanticVersion :: Maybe Text + -- | The minimumRequiredLocalizedDataSemanticVersion property of the tool component + , toolComponentMinimumRequiredLocalizedDataSemanticVersion :: Maybe Text + -- | The associatedComponent property of the tool component + , toolComponentAssociatedComponent :: Maybe ToolComponentReference + -- | The properties property of a ToolComponent object + , toolComponentProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON ToolComponent where + toJSON MkToolComponent {..} = + object + [ "guid" .=? toolComponentGUID, + "name" .= toolComponentName, + "fullName" .=? toolComponentFullName, + "semanticVersion" .=? toolComponentSemanticVersion, + "version" .=? toolComponentVersion, + "releaseDateUtc" .=? toolComponentReleaseDateUtc, + "downloadUri" .=? toolComponentDownloadUri, + "informationUri" .=? toolComponentInformationUri, + "organization" .=? toolComponentOrganization, + "shortDescription" .=? toolComponentShortDescription, + "fullDescription" .=? toolComponentFullDescription, + "language" .=? toolComponentLanguage, + "globalMessageStrings" .=? toolComponentGlobalMessageStrings, + "rules" .=? toolComponentRules, + "notifications" .=? toolComponentNotifications, + "taxa" .=? toolComponentTaxa, + "supportedTaxonomies" .=? toolComponentSupportedTaxonomies, + "translationMetadata" .=? toolComponentTranslationMetadata, + "locations" .=? toolComponentLocations, + "contents" .=? toolComponentContents, + "isComprehensive" .=? toolComponentIsComprehensive, + "localizedDataSemanticVersion" .=? toolComponentLocalizedDataSemanticVersion, + "minimumRequiredLocalizedDataSemanticVersion" + .=? toolComponentMinimumRequiredLocalizedDataSemanticVersion, + "associatedComponent" + .=? toolComponentAssociatedComponent, + "properties" .=? toolComponentProperties + ] + +instance FromJSON ToolComponent where + parseJSON = withObject "ToolComponent" $ \obj -> + MkToolComponent + <$> obj .:? "guid" + <*> obj .:? "name" + <*> obj .:? "fullName" + <*> obj .:? "product" + <*> obj .:? "productSuite" + <*> obj .:? "semanticVersion" + <*> obj .:? "version" + <*> obj .:? "releaseDateUtc" + <*> obj .:? "downloadUri" + <*> obj .:? "informationUri" + <*> obj .:? "organization" + <*> obj .:? "shortDescription" + <*> obj .:? "fullDescription" + <*> obj .:? "language" + <*> obj .:? "globalMessageStrings" + <*> obj .:? "rules" + <*> obj .:? "notifications" + <*> obj .:? "taxa" + <*> obj .:? "supportedTaxonomies" + <*> obj .:? "translationMetadata" + <*> obj .:? "locations" + <*> obj .:? "contents" + <*> obj .:? "isComprehensive" + <*> obj .:? "localizedDataSemanticVersion" + <*> obj .:? "minimumRequiredLocalizedDataSemanticVersion" + <*> obj .:? "associatedComponent" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/ToolComponentReference.hs b/src/Data/SARIF/ToolComponentReference.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/ToolComponentReference.hs @@ -0,0 +1,49 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `ToolComponentReference` type to represent SARIF artifacts. +module Data.SARIF.ToolComponentReference + ( ToolComponentReference (..), + ) +where + +-------------------------------------------------------------------------------- + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.Text +import Data.UUID.Types + +data ToolComponentReference + = MkToolComponentReference + { -- | A name which should equals to the `name` property of a toolComponent + toolComponentReferenceName :: Maybe Text + -- | An index into the `extensions` array + , toolComponentReferenceIndex :: Maybe Text + -- | A GUID which should equals to the `guid` property of a toolComponent + , toolComponentReferenceGuid :: Maybe UUID + -- | The properties property of a ToolComponentReference object + , toolComponentReferenceProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON ToolComponentReference where + toJSON MkToolComponentReference {..} = + object + [ "name" .=? toolComponentReferenceName, + "index" .=? toolComponentReferenceIndex, + "guid" .=? toolComponentReferenceGuid, + "properties" .=? toolComponentReferenceProperties + ] + +instance FromJSON ToolComponentReference where + parseJSON = withObject "ToolComponentReference" $ \obj -> + MkToolComponentReference + <$> (obj .:? "name") + <*> (obj .:? "index") + <*> obj .:? "guid" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/TranslationMetadata.hs b/src/Data/SARIF/TranslationMetadata.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/TranslationMetadata.hs @@ -0,0 +1,56 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `TranslationMetadata` type to represent SARIF artifacts. +module Data.SARIF.TranslationMetadata (TranslationMetadata (..)) where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.MultiformatMessageString +import Data.Text + +data TranslationMetadata + = MkTranslationMetadata + { -- | the name property of the translation metadata + translationMetadataName :: Text + -- | The fullName property of the translation metadata + , translationMetadataFullName :: Maybe Text + -- | The shortDescription property of the translation metadata + , translationMetadataShortDescription :: Maybe MultiformatMessageString + -- | The fullDescription property of the translation metadata + , translationMetadataFullDescription :: Maybe MultiformatMessageString + -- | The downloadUri property of the translation metadata + , translationMetadataDownloadUri :: Maybe Text + -- | The informationUri property of the translation metadata + , translationMetadataInformationUri :: Maybe Text + -- | The properties property of a TranslationMetadata object + , translationMetadataProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON TranslationMetadata where + toJSON MkTranslationMetadata {..} = + object + [ "name" .= translationMetadataName, + "fullName" .=? translationMetadataFullName, + "shortDescription" .=? translationMetadataShortDescription, + "fullDescription" .=? translationMetadataFullDescription, + "downloadUri" .=? translationMetadataDownloadUri, + "informationUri" .=? translationMetadataInformationUri, + "properties" .=? translationMetadataProperties + ] + +instance FromJSON TranslationMetadata where + parseJSON = withObject "TranslationMetadata" $ \obj -> + MkTranslationMetadata + <$> obj .: "name" + <*> obj .:? "fullName" + <*> obj .:? "shortDescription" + <*> obj .:? "fullDescription" + <*> obj .:? "downloadUri" + <*> obj .:? "informationUri" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/VersionControlDetails.hs b/src/Data/SARIF/VersionControlDetails.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/VersionControlDetails.hs @@ -0,0 +1,56 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `VersionControlDetails` type to represent SARIF artifacts. +module Data.SARIF.VersionControlDetails (VersionControlDetails (..)) where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ArtifactLocation +import Data.Text + +data VersionControlDetails + = MkVersionControlDetails + { -- | The repositoryUri property of the version control details + versionControlDetailsRepositoryUri :: Text + -- | The revisionId property of the version control details + , versionControlDetailsRevisionId :: Text + -- | The branch property of the version control details + , versionControlDetailsBranch :: Maybe Text + -- | The revisionTag property of the version control details + , versionControlDetailsRevisionTag :: Maybe Text + -- | The asOfTimeUtc property of the version control details + , versionControlDetailsAsOfTimeUtc :: Maybe Text + -- | The mappedTo property of the version control details + , versionControlDetailsMappedTo :: Maybe ArtifactLocation + -- | The properties property of a VersionControlDetails object + , versionControlDetailsProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON VersionControlDetails where + toJSON MkVersionControlDetails {..} = + object + [ "repositoryUri" .= versionControlDetailsRepositoryUri, + "revisionId" .= versionControlDetailsRevisionId, + "branch" .=? versionControlDetailsBranch, + "revisionTag" .=? versionControlDetailsRevisionTag, + "asOfTimeUtc" .=? versionControlDetailsAsOfTimeUtc, + "mappedTo" .=? versionControlDetailsMappedTo, + "properties" .=? versionControlDetailsProperties + ] + +instance FromJSON VersionControlDetails where + parseJSON = withObject "VersionControlDetails" $ \obj -> + MkVersionControlDetails + <$> obj .: "repositoryUri" + <*> obj .: "revisionId" + <*> obj .:? "branch" + <*> obj .:? "revisionTag" + <*> obj .:? "asOfTimeUtc" + <*> obj .:? "mappedTo" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/WebRequest.hs b/src/Data/SARIF/WebRequest.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/WebRequest.hs @@ -0,0 +1,67 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `WebRequest` type to represent SARIF artifacts. +module Data.SARIF.WebRequest + ( WebRequest (..), + ) +where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ArtifactContent +import Data.Text + +data WebRequest + = MkWebRequest + { -- | The index property of a web request object + webRequestIndex :: Maybe Integer + -- | The protocal property of a web request object + , webRequestProtocol :: Text + -- | The version property of a web request object + , webRequestVersion :: Text + -- | The target property of a web request object + , webRequestTarget :: Text + -- | The method property of a web request object + , webRequestMethod :: Text + -- | The headers property of a web request object + , webRequestHeaders :: Map Text Text + -- | The parameters property of a web request object + , webRequestParameters :: Maybe (Map Text Text) + -- | The body property of a web request object + , webRequestBody :: Maybe ArtifactContent + -- | The properties property of a WebRequest object + , webRequestProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON WebRequest where + toJSON MkWebRequest {..} = + object + [ "index" .=? webRequestIndex, + "protocol" .= webRequestProtocol, + "version" .= webRequestVersion, + "target" .= webRequestTarget, + "method" .= webRequestMethod, + "headers" .= webRequestHeaders, + "parameters" .=? webRequestParameters, + "body" .=? webRequestBody, + "properties" .=? webRequestProperties + ] + +instance FromJSON WebRequest where + parseJSON = withObject "WebRequest" $ \obj -> + MkWebRequest + <$> obj .:? "index" + <*> obj .: "protocol" + <*> obj .: "version" + <*> obj .: "target" + <*> obj .: "method" + <*> obj .: "headers" + <*> obj .:? "parameters" + <*> obj .:? "body" + <*> obj .:? "properties" diff --git a/src/Data/SARIF/WebResponse.hs b/src/Data/SARIF/WebResponse.hs new file mode 100644 --- /dev/null +++ b/src/Data/SARIF/WebResponse.hs @@ -0,0 +1,67 @@ +-------------------------------------------------------------------------------- +-- SARIF implementation for Haskell +-------------------------------------------------------------------------------- +-- This source code is licensed under the MIT license found in the LICENSE -- +-- file in the root directory of this source tree. -- +-------------------------------------------------------------------------------- + +-- | Provides the `WebResponse` type to represent SARIF artifacts. +module Data.SARIF.WebResponse + ( WebResponse (..), + ) +where + +import Data.Aeson.Optional +import Data.Map.Strict +import Data.SARIF.ArtifactContent +import Data.Text + +data WebResponse + = MkWebResponse + { -- | The index property of a web response object + webResponseIndex :: Maybe Integer + -- | The protocal property of a web request object + , webResponseProtocol :: Text + -- | The version property of a web response object + , webResponseVersion :: Text + -- | The target property of a web response object + , webResponseStatusCode :: Integer + -- | The method property of a web response object + , webResponseReasonPhrase :: Text + -- | The headers property of a web response object + , webResponseHeaders :: Map Text Text + -- | The body property of a web response object + , webResponseBody :: Maybe ArtifactContent + -- | The noResponseReceived property of a web response object + , webResponseNoResponseReceived :: Maybe Bool + -- | The properties property of a WebResponse object + , webResponseProperties :: Maybe (Map Text Value) + } + deriving (Eq, Ord, Show) + +instance ToJSON WebResponse where + toJSON MkWebResponse {..} = + object + [ "index" .=? webResponseIndex, + "protocol" .= webResponseProtocol, + "version" .= webResponseVersion, + "statusCode" .= webResponseStatusCode, + "reasonPhrase" .= webResponseReasonPhrase, + "headers" .= webResponseHeaders, + "body" .=? webResponseBody, + "noResponseReceived" .=? webResponseNoResponseReceived, + "properties" .=? webResponseProperties + ] + +instance FromJSON WebResponse where + parseJSON = withObject "WebResponse" $ \obj -> + MkWebResponse + <$> obj .:? "index" + <*> obj .: "protocol" + <*> obj .: "version" + <*> obj .: "statusCode" + <*> obj .: "reasonPhrase" + <*> obj .: "headers" + <*> obj .:? "body" + <*> obj .:? "noResponseReceived" + <*> obj .:? "properties"