df894c0...master · compaREST

.github/actions/common_setup/action.yamlnew file+42

since splitsnapshots

unifiedsplit

@@ -0,0 +1,42 @@

1+name: "Common setup"

2+description: "Common setup steps"

3+inputs:

4+ authToken:

5+ description: "Cachix auth token"

6+ required: true

7+runs:

8+ using: "composite"

9+ steps:

10+ - name: Increase swap if linux

11+ shell: bash

12+ run: |

13+ if [ "$RUNNER_OS" == "Linux" ]; then

14+

15+ echo "Is Linux"

16+

17+ free -h

18+

19+ sudo swapoff /mnt/swapfile

20+ sudo fallocate -l 12G /mnt/swapfile

21+ sudo mkswap /mnt/swapfile

22+ sudo swapon /mnt/swapfile

23+

24+ free -h

25+

26+ else

27+

28+ echo "Not Linux"

29+

30+ fi

31+

32+ - name: Install Nix

33+ uses: cachix/install-nix-action@v16

34+ with:

35+ extra_nix_config: |

36+ system-features = kvm

37+ trusted-public-keys = hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=

38+ substituters = https://hydra.iohk.io https://cache.nixos.org/

39+ - uses: cachix/cachix-action@v10

40+ with:

41+ name: typeable

42+ authToken: "${{ inputs.authToken }}"

.github/workflows/github-actions-image.yamlnew file+311

@@ -0,0 +1,311 @@

1+name: Github Action Docker Image

2+

3+on:

4+ push:

5+ branches: [master]

6+ pull_request:

7+ branches: [master]

8+ release:

9+ types: [prereleased]

10+

11+jobs:

12+ check-formatting:

13+ name: Check Haskell formatting

14+ runs-on: ubuntu-latest

15+ steps:

16+ - uses: actions/checkout@v2

17+

18+ - name: Common setup

19+ uses: ./.github/actions/common_setup

20+ with:

21+ authToken: ${{ secrets.CACHIX_AUTH_TOKEN }}

22+

23+ - name: Run fourmolu

24+ run: |

25+ nix-shell nix/ci.nix -j auto --run "git ls-files '*.hs' | xargs fourmolu -m inplace -o -XRecursiveDo -o -XTypeApplications -o -XPatternSynonyms -o -XBangPatterns"

26+ git diff --exit-code

27+

28+ policeman:

29+ runs-on: ubuntu-latest

30+ steps:

31+ - uses: actions/checkout@v2

32+ with:

33+ submodules: recursive

34+

35+ - name: Common setup

36+ uses: ./.github/actions/common_setup

37+ with:

38+ authToken: ${{ secrets.CACHIX_AUTH_TOKEN }}

39+

40+ - name: Run policeman

41+ run: |

42+ jq --argjson msg "$( $(nix-build ci/policeman.nix)/bin/policeman | grep -v "⚙" | jq -aRs . )" ".[0].message = \$msg" <policeman.json >message.json

43+ cat message.json

44+

45+ - name: Post notice

46+ uses: yuzutech/annotations-action@v0.4.0

47+ with:

48+ title: 👮 Policeman

49+ repo-token: "${{ secrets.GITHUB_TOKEN }}"

50+ input: "./message.json"

51+

52+ check_versions:

53+ runs-on: ubuntu-latest

54+ steps:

55+ - uses: actions/checkout@v2

56+ with:

57+ submodules: recursive

58+

59+ - name: Check library version

60+ if: github.event_name == 'release'

61+ run: |

62+ if [ "$(awk -F ':' '/^version/ {gsub(/ /, "", $2); print $2}' compaREST.cabal)" != "${{ github.event.release.tag_name }}" ]; then

63+ echo "::error file=compaREST.cabal::Library version does not match release version."

64+ exit 1

65+ fi

66+

67+ - name: Check docker tag

68+ if: github.event_name == 'release'

69+ run: |

70+ if [ "$(yq eval '.runs.image' action.yaml | awk -F ':' '{print $NF}')" != "${{ github.event.release.tag_name }}" ]; then

71+ echo "::error file=action.yaml::Action docker tag does not match release tag."

72+ exit 1

73+ fi

74+

75+ - name: Check changelog

76+ if: github.event_name == 'release'

77+ run: |

78+ if ! grep '^## ${{ github.event.release.tag_name }}$' CHANGELOG.md; then

79+ echo "::error file=CHANGELOG.md::CHANGELOG.md does not contain an entry for this release."

80+ exit 1

81+ fi

82+

83+ Linux:

84+ needs: check_versions

85+ runs-on: ubuntu-latest

86+ steps:

87+ - uses: actions/checkout@v2

88+ with:

89+ submodules: recursive

90+

91+ - name: Common setup

92+ uses: ./.github/actions/common_setup

93+ with:

94+ authToken: ${{ secrets.CACHIX_AUTH_TOKEN }}

95+

96+ - name: Test

97+ shell: bash

98+ run: |

99+ $(nix-build -A test -j auto --no-out-link)/bin/compaREST-tests

100+

101+ - name: Build Linux static binary

102+ shell: bash

103+ run: |

104+ cp $(nix-build -A compaRESTStaticBin -j auto --no-out-link)/bin/compaREST compaREST

105+

106+ - name: Upload compaREST Linux Binary

107+ uses: actions/upload-artifact@v2

108+ with:

109+ name: compaREST-Linux

110+ path: compaREST

111+

112+ - name: Build Docker Images

113+ shell: bash

114+ run: |

115+ cp $(nix-build -A compaRESTGithubAction -j auto --no-out-link) compaREST-Github-Action-image.tar.gz

116+ cp $(nix-build -A compaRESTImage -j auto --no-out-link) compaREST-image.tar.gz

117+

118+ - name: Upload compaREST Docker Github Action Image

119+ uses: actions/upload-artifact@v2

120+ with:

121+ name: compaREST Github Action Docker Image

122+ path: compaREST-Github-Action-image.tar.gz

123+

124+ - name: Upload compaREST Docker Image

125+ uses: actions/upload-artifact@v2

126+ with:

127+ name: compaREST Docker Image

128+ path: compaREST-image.tar.gz

129+

130+ - name: Install skopeo

131+ if: github.event_name == 'release'

132+ shell: bash

133+ run: |

134+ sudo apt-get -y update

135+ sudo apt-get -y install skopeo

136+

137+ - name: Login to DockerHub

138+ uses: docker/login-action@v1.10.0

139+ with:

140+ username: ${{ secrets.DOCKER_HUB_USERNAME }}

141+ password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}

142+

143+ - name: Push Nightly Docker Images to DockerHub

144+ if: github.ref == 'refs/heads/master' && github.event_name == 'push'

145+ shell: bash

146+ run: |

147+ skopeo copy docker-archive:$(nix-build -A compaRESTGithubAction -j auto --no-out-link) docker://ilyakooo0/comparest-github-action:nightly

148+ skopeo copy docker-archive:$(nix-build -A compaRESTImage -j auto --no-out-link) docker://ilyakooo0/comparest:nightly

149+

150+ - name: Push Release Docker Images to DockerHub

151+ if: github.event_name == 'release'

152+ shell: bash

153+ run: |

154+ skopeo copy docker-archive:$(nix-build -A compaRESTGithubAction -j auto --no-out-link) docker://ilyakooo0/comparest-github-action:${{ github.event.release.tag_name }}

155+ skopeo copy docker-archive:$(nix-build -A compaRESTImage -j auto --no-out-link) docker://ilyakooo0/comparest:${{ github.event.release.tag_name }}

156+

157+ - name: Zip Release Assets

158+ if: github.event_name == 'release'

159+ shell: bash

160+ run: |

161+ zip compaREST-Linux-x86.zip compaREST

162+

163+ - name: Upload compaREST Github Action Docker Image to release

164+ if: github.event_name == 'release'

165+ uses: svenstaro/upload-release-action@2.2.1

166+ with:

167+ repo_token: ${{ secrets.GITHUB_TOKEN }}

168+ file: compaREST-Github-Action-image.tar.gz

169+ tag: ${{ github.ref }}

170+

171+ - name: Upload compaREST Docker Image to release

172+ if: github.event_name == 'release'

173+ uses: svenstaro/upload-release-action@2.2.1

174+ with:

175+ repo_token: ${{ secrets.GITHUB_TOKEN }}

176+ file: compaREST-image.tar.gz

177+ tag: ${{ github.ref }}

178+

179+ - name: Upload compaREST binary – Linux – x86 to release

180+ if: github.event_name == 'release'

181+ uses: svenstaro/upload-release-action@2.2.1

182+ with:

183+ repo_token: ${{ secrets.GITHUB_TOKEN }}

184+ file: compaREST-Linux-x86.zip

185+ tag: ${{ github.ref }}

186+

187+ dist:

188+ needs: check_versions

189+ runs-on: ubuntu-latest

190+ steps:

191+ - uses: actions/checkout@v2

192+ with:

193+ submodules: recursive

194+

195+ - name: Cache

196+ uses: actions/cache@v1

197+ with:

198+ path: |

199+ ~/.stack

200+ .stack-work

201+ key: ${{ runner.os }}-stack-${{ hashFiles('stack.yaml') }}-${{ hashFiles('**.cabal') }}

202+ restore-keys: |

203+ ${{ runner.os }}-stack-${{ hashFiles('stack.yaml') }}

204+ ${{ runner.os }}-stack

205+

206+ - name: Upgrade stack

207+ shell: bash

208+ # Needed for Hackage token authorization

209+ run: stack upgrade --git

210+

211+ - name: Build dist

212+ run: |

213+ stack sdist --pvp-bounds both --test-tarball

214+ echo "distPath=$(stack path | awk -F ": " '/dist-dir/ {print $2}')" >> $GITHUB_ENV

215+

216+ - name: Upload compaREST sources artifact

217+ uses: actions/upload-artifact@v2

218+ with:

219+ name: compaREST sources

220+ path: ${{ env.distPath }}/*.tar.gz

221+

222+ - name: Upload compaREST sources to release

223+ if: github.event_name == 'release'

224+ uses: svenstaro/upload-release-action@2.2.1

225+ with:

226+ repo_token: ${{ secrets.GITHUB_TOKEN }}

227+ file_glob: true

228+ file: ${{ env.distPath }}/*.tar.gz

229+ tag: ${{ github.ref }}

230+

231+ - name: Publish compaREST candidate to Hackage

232+ shell: bash

233+ if: github.event_name == 'release'

234+ env:

235+ HACKAGE_KEY: ${{ secrets.HACKAGE_KEY }}

236+ run: |

237+ stack upload --pvp-bounds both --test-tarball --candidate .

238+

239+ macOS:

240+ needs: check_versions

241+ runs-on: macos-latest

242+ steps:

243+ - uses: actions/checkout@v2

244+ with:

245+ submodules: recursive

246+

247+ - name: Common setup

248+ uses: ./.github/actions/common_setup

249+ with:

250+ authToken: ${{ secrets.CACHIX_AUTH_TOKEN }}

251+

252+ - name: Build macOS binary bundle

253+ run: |

254+ cp -LR $(nix-build -A macOSCompaRESTBundle -j auto --no-out-link) compaREST

255+

256+ - name: Upload macOS compaREST bundle

257+ uses: actions/upload-artifact@v2

258+ with:

259+ name: compaREST binary – macOS – x86

260+ path: compaREST

261+

262+ - name: Zip Release Assets

263+ if: github.event_name == 'release'

264+ shell: bash

265+ run: |

266+ zip -r compaREST-macOS-x86.zip compaREST

267+

268+ - name: Upload compaREST binary – macOS – x86 to release

269+ if: github.event_name == 'release'

270+ uses: svenstaro/upload-release-action@2.2.1

271+ with:

272+ repo_token: ${{ secrets.GITHUB_TOKEN }}

273+ file: compaREST-macOS-x86.zip

274+ tag: ${{ github.ref }}

275+

276+ Linux-Windows:

277+ needs: check_versions

278+ runs-on: ubuntu-latest

279+ steps:

280+ - uses: actions/checkout@v2

281+ with:

282+ submodules: recursive

283+

284+ - name: Common setup

285+ uses: ./.github/actions/common_setup

286+ with:

287+ authToken: ${{ secrets.CACHIX_AUTH_TOKEN }}

288+

289+ - name: Build Windows binary

290+ run: |

291+ cp -LR $(nix-build -A WindowsCompaRESTBin -j auto --no-out-link)/bin compaREST

292+

293+ - name: Upload Windows compaREST bundle

294+ uses: actions/upload-artifact@v2

295+ with:

296+ name: compaREST binary – Windows

297+ path: compaREST

298+

299+ - name: Zip Release Assets

300+ if: github.event_name == 'release'

301+ shell: bash

302+ run: |

303+ zip -r compaREST-Windows.zip compaREST

304+

305+ - name: Upload compaREST binary – Windows to release

306+ if: github.event_name == 'release'

307+ uses: svenstaro/upload-release-action@2.2.1

308+ with:

309+ repo_token: ${{ secrets.GITHUB_TOKEN }}

310+ file: compaREST-Windows.zip

311+ tag: ${{ github.ref }}

.github/workflows/haskell.ymldeleted−54

@@ -1,54 +0,0 @@

1−name: Haskell CI

2−

3−on:

4− push:

5− branches: [master]

6− pull_request:

7− branches: [master]

8−

9−jobs:

10− linux-build:

11− runs-on: ubuntu-latest

12−

13− steps:

14− - uses: actions/checkout@v2

15− with:

16− submodules: recursive

17− - name: Cache

18− uses: actions/cache@v1

19− with:

20− path: ~/.stack

21− key: ${{ runner.os }}-build-stack-${{ hashFiles('**/stack.yaml') }}-${{ hashFiles('**/*.cabal') }}

22− restore-keys: |

23− ${{ runner.os }}-build-stack-${{ hashFiles('**/stack.yaml') }}

24− ${{ runner.os }}-build-stack-

25− - name: Increase swap

26− run: |

27− free -h

28−

29− sudo swapoff /mnt/swapfile

30− sudo fallocate -l 12G /mnt/swapfile

31− sudo mkswap /mnt/swapfile

32− sudo swapon /mnt/swapfile

33−

34− free -h

35−

36− - name: Build

37− run: |

38− stack build --ghc-options=-O3 --local-bin-path openapi-diff-linux --copy-bins --flag openapi-diff:Static

39− - name: Test

40− run: stack test --ghc-options=-O3 --flag openapi-diff:Static --test-arguments='--hide-successes --no-create'

41−

42− - name: Zip

43− if: github.ref == 'refs/heads/master'

44− run: |

45− zip openapi-diff-linux openapi-diff-linux/openapi-diff

46− - uses: "marvinpinto/action-automatic-releases@latest"

47− if: github.ref == 'refs/heads/master'

48− with:

49− repo_token: "${{ secrets.GITHUB_TOKEN }}"

50− automatic_release_tag: "latest"

51− prerelease: false

52− title: "Pre-Release"

53− files: |

54− *.zip

.github/workflows/remove-artifacts.yamldeleted−17

@@ -1,17 +0,0 @@

1−name: Remove old artifacts

2−

3−on:

4− schedule:

5− - cron: '0 0 * * *'

6−jobs:

7− remove-old-artifacts:

8− runs-on: ubuntu-latest

9− timeout-minutes: 10

10−

11− steps:

12− - name: Remove old artifacts

13− uses: c-hive/gha-remove-artifacts@v1

14− with:

15− age: '7 days'

16− skip-tags: true

17− skip-recent: 10

CHANGELOG.md+1−1

@@ -1,6 +1,6 @@

1# Changelog

2

3−`openapi-diff` uses [PVP Versioning][1].

3+`comparest` uses [PVP Versioning][1].

4

5## 0.0.0.0

6

README.md+13−13

@@ -1,8 +1,8 @@

1−# openapi-diff

1+# CompaREST

2

3−[![Hackage](https://img.shields.io/hackage/v/openapi-diff.svg?logo=haskell)](https://hackage.haskell.org/package/openapi-diff)

3+[![Hackage](https://img.shields.io/hackage/v/comparest.svg?logo=haskell)](https://hackage.haskell.org/package/comparest)

4−[![Stackage Lts](http://stackage.org/package/openapi-diff/badge/lts)](http://stackage.org/lts/package/openapi-diff)

4+[![Stackage Lts](http://stackage.org/package/comparest/badge/lts)](http://stackage.org/lts/package/comparest)

5−[![Stackage Nightly](http://stackage.org/package/openapi-diff/badge/nightly)](http://stackage.org/nightly/package/openapi-diff)

5+[![Stackage Nightly](http://stackage.org/package/comparest/badge/nightly)](http://stackage.org/nightly/package/comparest)

6[![MIT license](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

7

8Compatibility checker for OpenAPI

@@ -241,32 +241,32 @@ docker run --rm -v $(pwd):/data:rw typeable/comparest --client /data/api-1.0.0.y

241# CLI docs

242

243```

244−Usage: openapi-diff (-c|--client ARG) (-s|--server ARG)

244+Usage: comparest (-c|--client ARG) (-s|--server ARG)

245− [--silent | --only-breaking | --all] [-o|--output ARG]

245+ [--silent | --only-breaking | --all] [-o|--output ARG]

246− [--folding-block-quotes-style | --header-style]

246+ [--folding-block-quotes-style | --header-style]

247− [--signal-exit-code]

247+ [--signal-exit-code]

248− A tool to check compatibility between two OpenApi specifications.

248+ A tool to check compatibility between two OpenAPI specifications.

249

250 Usage examples

251

252 Compare files old.yaml with new.yaml and output the resulting report to

253 stdout:

254

255− openapi-diff -c old.yaml -s new.yaml

255+ comparest -c old.yaml -s new.yaml

256

257 Only output breaking changes and write a styled HTML report to file

258 report.html:

259

260− openapi-diff -c old.yaml -s new.yaml --only-breaking -o report

260+ comparest -c old.yaml -s new.yaml --only-breaking -o report

261

262 Don't output anything, only fail if there are breaking changes:

263

264− openapi-diff -c old.json -s new.json --silent

264+ comparest -c old.json -s new.json --silent

265

266 Write full report suitable for embedding into a GitHub comment to

267 report.html:

268

269− openapi-diff -c old.json -s new.json --folding-block-quotes-style -o report.html

269+ comparest -c old.json -s new.json --folding-block-quotes-style -o report.html

270

271Available options:

272 -h,--help Show this help text

action.yamlnew file+47

@@ -0,0 +1,47 @@

1+name: compaREST

2+author: Typeable

3+description: API reliability checker

4+inputs:

5+ GITHUB_TOKEN:

6+ description: "The GitHub access token (e.g. secrets.GITHUB_TOKEN) used to create or update the comment. This defaults to {{ github.token }}."

7+ default: "${{ github.token }}"

8+ required: false

9+ repo:

10+ description: The owner of the repo in which to post the comment.

11+ default: "${{ github.repository }}"

12+ required: false

13+ project_name:

14+ description: The name of the project to which the API pertains.

15+ required: true

16+ footer:

17+ description: A footer that can be appended to the comment.

18+ required: false

19+ default: ""

20+ old:

21+ description: The path to old specification of the API.

22+ required: true

23+ new:

24+ description: The path to new specification of the API.

25+ required: true

26+ sha:

27+ description: The sha of the commit to post the check for.

28+ required: false

29+ default: "${{ github.event.pull_request.head.sha }}"

30+runs:

31+ using: "docker"

32+ image: "docker://typeable/comparest-github-action:0.0.0.0"

33+ env:

34+ GITHUB_TOKEN: "${{ inputs.GITHUB_TOKEN }}"

35+ REPO: "${{ inputs.repo }}"

36+ PROJECT_NAME: "${{ inputs.project_name }}"

37+ FOOTER: "${{ inputs.footer }}"

38+ ROOT: "/github/workspace"

39+ OLD: "${{ inputs.old }}"

40+ NEW: "${{ inputs.new }}"

41+ SHA: "${{ inputs.sha }}"

42+ pre-entrypoint: "/bin/pre"

43+ entrypoint: "/bin/run"

44+

45+branding:

46+ icon: crosshair

47+ color: gray-dark

app/Data/OpenApi/Compare/Options.hsnew file+134

@@ -0,0 +1,134 @@

1+module Data.OpenApi.Compare.Options

2+ ( Options (..),

3+ OutputMode (..),

4+ parseOptions,

5+ )

6+where

7+

8+import Data.OpenApi.Compare.Report

9+import GHC.Generics (Generic)

10+import Options.Applicative

11+import Options.Applicative.Help hiding (fullDesc)

12+

13+parseOptions :: IO Options

14+parseOptions = customExecParser (prefs $ showHelpOnError) optionsParserInfo

15+

16+data Options = Options

17+ { clientFile :: FilePath

18+ , serverFile :: FilePath

19+ , -- | 'Nothing' means "don't produce any output"

20+ mode :: Maybe ReportMode

21+ , outputMode :: OutputMode

22+ , reportTreeStyle :: ReportTreeStyle

23+ , signalExitCode :: Bool

24+ }

25+ deriving stock (Generic)

26+

27+data OutputMode = StdoutMode | FileMode FilePath

28+

29+optionsParserInfo :: ParserInfo Options

30+optionsParserInfo =

31+ info

32+ (helper <*> optionsParser)

33+ ( fullDesc

34+ <> header "CompaREST"

35+ <> progDescDoc

36+ ( Just $

37+ par "A tool to check compatibility between two OpenAPI specifications."

38+ <$$> hardline <> par "Usage examples" <> hardline

39+ <$$> indent

40+ 4

41+ ( par "Compare files old.yaml with new.yaml and output the resulting report to stdout:"

42+ <$$> hardline <> indent 4 "comparest -c old.yaml -s new.yaml"

43+ <$$> hardline <> par "Only output breaking changes and write a styled HTML report to file report.html:"

44+ <$$> hardline <> indent 4 "comparest -c old.yaml -s new.yaml --only-breaking -o report"

45+ <$$> hardline <> par "Don't output anything, only fail if there are breaking changes:"

46+ <$$> hardline <> indent 4 "comparest -c old.json -s new.json --silent"

47+ <$$> hardline <> par "Write full report suitable for embedding into a GitHub comment to report.html:"

48+ <$$> hardline <> indent 4 "comparest -c old.json -s new.json --folding-block-quotes-style -o report.html"

49+ )

50+ )

51+ )

52+

53+optionsParser :: Parser Options

54+optionsParser =

55+ Options

56+ <$> strOption

57+ ( short 'c'

58+ <> long "client"

59+ <> help

60+ "A path to the file containing the specification that will be \

61+ \used for the client of the API. Can be either a YAML or JSON file."

62+ )

63+ <*> strOption

64+ ( short 's'

65+ <> long "server"

66+ <> help

67+ "A path to the file containing the specification that will be \

68+ \used for the server of the API. Can be either a YAML or JSON file."

69+ )

70+ <*> ( flag'

71+ Nothing

72+ ( long "silent"

73+ <> help "Silence all output. Only makes sense in combination with --signal-exit-code."

74+ )

75+ <|> flag'

76+ (Just OnlyErrors)

77+ ( long "only-breaking"

78+ <> help "Only report breaking changes in the output."

79+ )

80+ <|> flag'

81+ (Just All)

82+ ( long "all"

83+ <> help

84+ "Report both incompatible and compatible changes. \

85+ \Compatible changes will not trigger a failure exit code."

86+ )

87+ <|> pure (Just All)

88+ )

89+ <*> ( ( FileMode

90+ <$> strOption

91+ ( short 'o' <> long "output"

92+ <> helpDoc

93+ ( Just $

94+ par "The file path where the output should be written. If the option is omitted the result will be written to stdout."

95+ <$$> hardline <> par "The file extension is used to determine the type of the output file."

96+ <$$> hardline <> par "Supports many formats such as markdown, html, rtf, doc, txt, rst, and many more."

97+ <$$> hardline <> par "Leave out the extension to produce a self-contained HTML report with styling."

98+ )

99+ )

100+ )

101+ <|> pure StdoutMode

102+ )

103+ <*> ( flag'

104+ FoldingBlockquotesTreeStyle

105+ ( long "folding-block-quotes-style"

106+ <> help

107+ "The report tree is structured using \

108+ \summary/detail HTML elements and indented using \

109+ \block quotes. This style renders well on GitHub.\

110+ \Intended for HTML output format. Markdown has rendering \

111+ \bugs on GitHub."

112+ )

113+ <|> flag'

114+ HeadersTreeStyle

115+ ( long "header-style"

116+ <> help

117+ "The report tree is structured using \

118+ \increasing levels of headers."

119+ )

120+ <|> pure HeadersTreeStyle

121+ )

122+ <*> switch

123+ ( long "signal-exit-code"

124+ <> helpDoc

125+ ( Just $

126+ par "Signal API compatibility with the exit code."

127+ <$$> hardline <> par "Exit with 0 if there are no breaking changes."

128+ <$$> par "Exit with 1 if there are breaking changes."

129+ <$$> par "Exit with 2 if could not determine compatibility."

130+ )

131+ )

132+

133+par :: String -> Doc

134+par = foldr1 (</>) . fmap string . words

app/FormatHeuristic.hs+3−3

@@ -2,7 +2,7 @@

2-- Originally based on:

3-- https://github.com/jgm/pandoc/blob/master/src/Text/Pandoc/App/FormatHeuristics.hs

4module FormatHeuristic

5− ( formatFromFilePath

5+ ( formatFromFilePath,

6 )

7where

8

@@ -10,10 +10,10 @@ import Data.ByteString.Lazy (ByteString)

10import Data.Char (toLower)

11import Data.Functor

12import qualified Data.Map as M

13+import qualified Data.OpenApi.Compare.Report.Html.Template as Html

13import Data.Text (Text)

14import Data.Text (Text)

14import qualified Data.Text.Lazy as TL

15import qualified Data.Text.Lazy as TL

15import qualified Data.Text.Lazy.Encoding as TL

16import qualified Data.Text.Lazy.Encoding as TL

16−import qualified OpenAPI.Checker.Report.Html.Template as Html

17import System.FilePath (takeExtension)

18import Text.DocTemplates.Internal

19import Text.Pandoc

@@ -80,7 +80,7 @@ formatFromFilePath x =

80 def

81 { writerTemplate = Just Html.template

82 , -- Not actually used. Needed to silence warning.

83− writerVariables = Context $ M.fromList [("pagetitle", toVal ("OpenApi Diff" :: Text))]

83+ writerVariables = Context $ M.fromList [("pagetitle", toVal ("CompaREST" :: Text))]

84 }

85 _ -> Nothing

86 where

app/Main.hs+4−3

@@ -6,14 +6,15 @@ import Data.Aeson

6import qualified Data.ByteString.Lazy as BSL

7import Data.Default

8import Data.Maybe

9+import Data.OpenApi.Compare.Options

10+import Data.OpenApi.Compare.Run

9import qualified Data.Text.IO as T

11import qualified Data.Text.IO as T

10import qualified Data.Yaml as Yaml

12import qualified Data.Yaml as Yaml

11import FormatHeuristic

13import FormatHeuristic

12−import OpenAPI.Checker.Options

13−import OpenAPI.Checker.Run

14import System.Exit

15import System.IO

16import Text.Pandoc hiding (report)

17+import Text.Pandoc.Builder

17

18

18main :: IO ()

19main :: IO ()

19main = do

20main = do

@@ -47,7 +48,7 @@ main = do

47 }

48 }

48 (report, status) = runReport reportConfig (a, b)

49 (report, status) = runReport reportConfig (a, b)

49 case mode opts of

50 case mode opts of

50− Just _ -> either handler pure <=< runExceptT $ write report

51+ Just _ -> either handler pure <=< runExceptT $ write $ doc report

51 Nothing -> pure ()

52 Nothing -> pure ()

52 when (signalExitCode opts) $

53 when (signalExitCode opts) $

53 case status of

54 case status of

app/OpenAPI/Checker/Options.hsdeleted−115

@@ -1,115 +0,0 @@

1−module OpenAPI.Checker.Options

2− ( Options (..)

3− , OutputMode (..)

4− , parseOptions

5− )

6−where

7−

8−import GHC.Generics (Generic)

9−import OpenAPI.Checker.Report

10−import Options.Applicative

11−import Options.Applicative.Help hiding (fullDesc)

12−

13−parseOptions :: IO Options

14−parseOptions = customExecParser (prefs $ showHelpOnError) optionsParserInfo

15−

16−data Options = Options

17− { clientFile :: FilePath

18− , serverFile :: FilePath

19− , -- | 'Nothing' means "don't produce any output"

20− mode :: Maybe ReportMode

21− , outputMode :: OutputMode

22− , reportTreeStyle :: ReportTreeStyle

23− , signalExitCode :: Bool

24− }

25− deriving stock (Generic)

26−

27−data OutputMode = StdoutMode | FileMode FilePath

28−

29−optionsParserInfo :: ParserInfo Options

30−optionsParserInfo =

31− info

32− (helper <*> optionsParser)

33− (fullDesc

34− <> header "openapi-diff"

35− <> progDescDoc

36− (Just $

37− par "A tool to check compatibility between two OpenApi specifications."

38− <$$> hardline <> par "Usage examples" <> hardline

39− <$$> indent

40− 4

41− (par "Compare files old.yaml with new.yaml and output the resulting report to stdout:"

42− <$$> hardline <> indent 4 "openapi-diff -c old.yaml -s new.yaml"

43− <$$> hardline <> par "Only output breaking changes and write a styled HTML report to file report.html:"

44− <$$> hardline <> indent 4 "openapi-diff -c old.yaml -s new.yaml --only-breaking -o report"

45− <$$> hardline <> par "Don't output anything, only fail if there are breaking changes:"

46− <$$> hardline <> indent 4 "openapi-diff -c old.json -s new.json --silent"

47− <$$> hardline <> par "Write full report suitable for embedding into a GitHub comment to report.html:"

48− <$$> hardline <> indent 4 "openapi-diff -c old.json -s new.json --folding-block-quotes-style -o report.html")))

49−

50−optionsParser :: Parser Options

51−optionsParser =

52− Options

53− <$> strOption

54− (short 'c'

55− <> long "client"

56− <> help

57− "A path to the file containing the specification that will be \

58− \used for the client of the API. Can be either a YAML or JSON file.")

59− <*> strOption

60− (short 's'

61− <> long "server"

62− <> help

63− "A path to the file containing the specification that will be \

64− \used for the server of the API. Can be either a YAML or JSON file.")

65− <*> (flag'

66− Nothing

67− (long "silent"

68− <> help "Silence all output. Only makes sense in combination with --signal-exit-code.")

69− <|> flag'

70− (Just OnlyErrors)

71− (long "only-breaking"

72− <> help "Only report breaking changes in the output.")

73− <|> flag'

74− (Just All)

75− (long "all"

76− <> help

77− "Report both incompatible and compatible changes. \

78− \Compatible changes will not trigger a failure exit code.")

79− <|> pure (Just All))

80− <*> ((FileMode

81− <$> strOption

82− (short 'o' <> long "output"

83− <> helpDoc

84− (Just $

85− par "The file path where the output should be written. If the option is omitted the result will be written to stdout."

86− <$$> hardline <> par "The file extension is used to determine the type of the output file."

87− <$$> hardline <> par "Supports many formats such as markdown, html, rtf, doc, txt, rst, and many more."

88− <$$> hardline <> par "Leave out the extension to produce a self-contained HTML report with styling.")))

89− <|> pure StdoutMode)

90− <*> (flag'

91− FoldingBlockquotesTreeStyle

92− (long "folding-block-quotes-style"

93− <> help

94− "The report tree is structured using \

95− \summary/detail HTML elements and indented using \

96− \block quotes. This style renders well on GitHub.\

97− \Intended for HTML output format. Markdown has rendering \

98− \bugs on GitHub.")

99− <|> flag'

100− HeadersTreeStyle

101− (long "header-style"

102− <> help

103− "The report tree is structured using \

104− \increasing levels of headers.")

105− <|> pure HeadersTreeStyle)

106− <*> switch

107− (long "signal-exit-code"

108− <> helpDoc (Just $

109− par "Signal API compatibility with the exit code."

110− <$$> hardline <> par "Exit with 0 if there are no breaking changes."

111− <$$> par "Exit with 1 if there are breaking changes."

112− <$$> par "Exit with 2 if could not determine compatibility."))

113−

114−par :: String -> Doc

115−par = foldr1 (</>) . fmap string . words

benchmarks/README.md+2−2

@@ -1,6 +1,6 @@

1# OpenApi comparison benchmarks

2

3−This is a nix expression that automatically downloads, builds and runs multiple OpenApi comparison tools on the same set of inputs to compare how well they behave.

3+This is a nix expression that automatically downloads, builds and runs multiple OpenAPI comparison tools on the same set of inputs to compare how well they behave.

4

5To run the benchmarks run the following command in this directory:

6

@@ -12,7 +12,7 @@ nix-build

12

13| Tool | Output file name |

14| -------------------------------------------------------------------------- | ------------------------------------------- |

15−| [Typeable OpenApi Diff](https://github.com/typeable/openapi-diff) | `typeable.md` |

15+| [Typeable CompaREST](https://github.com/typeable/compaREST) | `typeable.md` |

16| [Atlassian OpenApi Diff](https://bitbucket.org/atlassian/openapi-diff) | `atlassian.json`, `atlassian.error.txt` |

17| [OpenApi Tools OpenApi Diff](https://github.com/OpenAPITools/openapi-diff) | `openapitools.md`, `openapitools.error.txt` |

18| [Tufin OpenApi Diff](https://github.com/tufin/oasdiff) | `oasdiff.txt`, `oasdiff.error.txt` |

benchmarks/default.nix+8−12

@@ -1,6 +1,6 @@

1{ sources ? import ./nix/sources.nix

2−, haskellNix ? import sources.haskellNix { }

3, gomod2nix ? sources.gomod2nix

2, gomod2nix ? sources.gomod2nix

3+, haskellNix ? (import ../. {}).haskellNix

4, pkgs ? import haskellNix.sources.nixpkgs-2105 (haskellNix.nixpkgsArgs // {

5 overlays = haskellNix.nixpkgsArgs.overlays ++ [

6 (self: super: {

@@ -8,23 +8,19 @@

8 })

9 ];

10 })

11+, compaRESThsPkgs ? (import ../. {}).hsPkgs

11, npmNix ? import (sources.npmNix + "/npmPackages") { inherit pkgs; }

12, npmNix ? import (sources.npmNix + "/npmPackages") { inherit pkgs; }

12, mavenix ? import (sources.mavenix) { inherit pkgs; }

13, mavenix ? import (sources.mavenix) { inherit pkgs; }

13, bumpToken ? null

14, bumpToken ? null

14, bumpDocumentation ? null

15, bumpDocumentation ? null

15}:

16}:

16let

17let

17− typeable-openapi-diff = (pkgs.haskell-nix.stackProject {

18+ typeable-comparest = compaRESThsPkgs.comparest.components.exes.comparest;

18− src = pkgs.haskell-nix.haskellLib.cleanGit {

19− name = "openapi-diff";

20− src = ./..;

21− };

22− }).openapi-diff.components.exes.openapi-diff;

23− typeable-openapi-diff-exe = typeable-openapi-diff + "/bin/openapi-diff";

19+ typeable-comparest-exe = typeable-comparest + "/bin/comparest";

24− typeable-openapi-diff-differ = pkgs.writeScript "typeable-openapi-diff-differ" ''

20+ typeable-comparest-differ = pkgs.writeScript "typeable-comparest-differ" ''

25 #!${pkgs.stdenv.shell}

21 #!${pkgs.stdenv.shell}

26 set +e

22 set +e

27− ${typeable-openapi-diff-exe} -c $1 -s $2 -o $3/typeable.md

23+ ${typeable-comparest-exe} -c $1 -s $2 -o $3/typeable.md

28 exit 0

24 exit 0

29 '';

25 '';

30

26

@@ -130,7 +126,7 @@ let

130 })

126 })

131 (getInputs root);

127 (getInputs root);

132 differs = [

128 differs = [

133− typeable-openapi-diff-differ

129+ typeable-comparest-differ

134 atlassian-openapi-diff-differ

130 atlassian-openapi-diff-differ

135 openapitools-openapi-diff-differ

131 openapitools-openapi-diff-differ

136 oasdiff-differ

132 oasdiff-differ

@@ -164,7 +160,7 @@ let

164 tools = [

160 tools = [

165 "Typeable"

161 "Typeable"

166 "Atlassian"

162 "Atlassian"

167− "OpenApi Tools"

163+ "OpenAPI Tools"

168 "oasdiff"

164 "oasdiff"

169 "Bump.sh"

165 "Bump.sh"

170 ];

166 ];

ci/policeman.nixnew file+4

@@ -0,0 +1,4 @@

1+{ sources ? import ../nix/sources.nix

2+, pkgs ? import sources.nixpkgs { }

3+}:

4+pkgs.haskellPackages.policeman

openapi-diff.cabal → compaREST.cabalrenamed+83−56

@@ -1,29 +1,24 @@

1cabal-version: 2.4

2−name: openapi-diff

2+name: compaREST

3version: 0.0.0.0

4synopsis: Compatibility checker for OpenAPI

5−description: Compatibility checker for OpenAPI

5+description: Compatibility checker for OpenAPI.

6license: MIT

7license-file: LICENSE

8−author: Aleksey Uymanov

8+author: Typeable

9−maintainer: Aleksey Uymanov <s9gf4ult@gmail.com>

9+maintainer: compaREST@typeable.io

10−copyright: 2021 Aleksey Uymanov

10+copyright: 2021 Typeable

11category: Web

12build-type: Simple

13extra-doc-files: README.md

14 CHANGELOG.md

15tested-with: GHC == 8.10.4

16extra-source-files: awsm-css/dist/awsm.min.css

17−

17+data-files:

18−Flag static

18+ test/golden/**/*.yaml

19− Default: False

19+ test/golden/**/*.md

20− Manual: True

21

20

22common common-options

21common common-options

23− if flag(static)

24− cc-options: -static

25− ld-options: -static -pthread

26− ghc-options: -static

27 ghc-options:

22 ghc-options:

28 -Weverything

23 -Weverything

29 -Wno-implicit-prelude

24 -Wno-implicit-prelude

@@ -38,9 +33,9 @@ common common-options

38 -fconstraint-solver-iterations=0

33 -fconstraint-solver-iterations=0

39 default-language: Haskell2010

34 default-language: Haskell2010

40 build-depends: base >= 4.12.0.0 && < 4.16

35 build-depends: base >= 4.12.0.0 && < 4.16

41− , bytestring

42 , text

36 , text

43

37

38+

44 default-extensions: ApplicativeDo

39 default-extensions: ApplicativeDo

45 , BangPatterns

40 , BangPatterns

46 , ConstraintKinds

41 , ConstraintKinds

@@ -82,6 +77,7 @@ common common-options

82 , QuantifiedConstraints

77 , QuantifiedConstraints

83 , DefaultSignatures

78 , DefaultSignatures

84

79

80+

85library

81library

86 import: common-options

82 import: common-options

87 build-depends:

83 build-depends:

@@ -111,52 +107,53 @@ library

111 , file-embed

107 , file-embed

112 , data-default

108 , data-default

113 , ordered-containers

109 , ordered-containers

110+ , bytestring

114 hs-source-dirs: src

111 hs-source-dirs: src

115− exposed-modules: Data.HList

112+ exposed-modules: Data.OpenApi.Compare.Behavior

116− , OpenAPI.Checker.Behavior

113+ , Data.OpenApi.Compare.Common

117− , OpenAPI.Checker.Formula

114+ , Data.OpenApi.Compare.Formula

118− , OpenAPI.Checker.Memo

115+ , Data.OpenApi.Compare.Memo

119− , OpenAPI.Checker.Orphans

116+ , Data.OpenApi.Compare.Orphans

120− , OpenAPI.Checker.Paths

117+ , Data.OpenApi.Compare.Paths

121− , OpenAPI.Checker.PathsPrefixTree

118+ , Data.OpenApi.Compare.PathsPrefixTree

122− , OpenAPI.Checker.References

119+ , Data.OpenApi.Compare.References

123− , OpenAPI.Checker.Subtree

120+ , Data.OpenApi.Compare.Report

121+ , Data.OpenApi.Compare.Report.Html.Template

122+ , Data.OpenApi.Compare.Report.Jet

123+ , Data.OpenApi.Compare.Run

124+ , Data.OpenApi.Compare.Subtree

125+ , Data.OpenApi.Compare.Validate.Header

126+ , Data.OpenApi.Compare.Validate.Link

124− , OpenAPI.Checker.Validate.MediaTypeObject

127+ , Data.OpenApi.Compare.Validate.MediaTypeObject

128+ , Data.OpenApi.Compare.Validate.OAuth2Flows

125− , OpenAPI.Checker.Validate.OpenApi

129+ , Data.OpenApi.Compare.Validate.OpenApi

126− , OpenAPI.Checker.Validate.Operation

130+ , Data.OpenApi.Compare.Validate.Operation

127− , OpenAPI.Checker.Validate.Param

131+ , Data.OpenApi.Compare.Validate.Param

128− , OpenAPI.Checker.Validate.PathFragment

132+ , Data.OpenApi.Compare.Validate.PathFragment

129− , OpenAPI.Checker.Validate.Products

133+ , Data.OpenApi.Compare.Validate.Products

130− , OpenAPI.Checker.Validate.RequestBody

134+ , Data.OpenApi.Compare.Validate.RequestBody

131− , OpenAPI.Checker.Validate.Responses

135+ , Data.OpenApi.Compare.Validate.Responses

132− , OpenAPI.Checker.Validate.Schema

133− , OpenAPI.Checker.Validate.Schema.TypedJson

136+ , Data.OpenApi.Compare.Validate.Schema

134− , OpenAPI.Checker.Validate.Schema.DNF

137+ , Data.OpenApi.Compare.Validate.Schema.DNF

135− , OpenAPI.Checker.Validate.Schema.Issues

138+ , Data.OpenApi.Compare.Validate.Schema.Issues

136− , OpenAPI.Checker.Validate.Schema.JsonFormula

139+ , Data.OpenApi.Compare.Validate.Schema.JsonFormula

137− , OpenAPI.Checker.Validate.Schema.Partition

140+ , Data.OpenApi.Compare.Validate.Schema.Partition

138− , OpenAPI.Checker.Validate.Schema.Process

141+ , Data.OpenApi.Compare.Validate.Schema.Process

139− , OpenAPI.Checker.Validate.Schema.Traced

142+ , Data.OpenApi.Compare.Validate.Schema.Traced

143+ , Data.OpenApi.Compare.Validate.Schema.TypedJson

140− , OpenAPI.Checker.Validate.SecurityRequirement

144+ , Data.OpenApi.Compare.Validate.SecurityRequirement

145+ , Data.OpenApi.Compare.Validate.SecurityScheme

141− , OpenAPI.Checker.Validate.Server

146+ , Data.OpenApi.Compare.Validate.Server

142− , OpenAPI.Checker.Validate.Sums

147+ , Data.OpenApi.Compare.Validate.Sums

143− , OpenAPI.Checker.Validate.Header

148+ other-modules: Data.HList

144− , OpenAPI.Checker.Validate.Link

145− , OpenAPI.Checker.Common

146− , OpenAPI.Checker.Validate.SecurityScheme

147− , OpenAPI.Checker.Validate.OAuth2Flows

148− , OpenAPI.Checker.Report

149 , Data.OpenUnion.Extra

150− , OpenAPI.Checker.Report.Jet

151− , OpenAPI.Checker.Run

152− , OpenAPI.Checker.Report.Html.Template

153

150

154−executable openapi-diff

151+executable compaREST

155 import: common-options

152 import: common-options

156 hs-source-dirs: app

153 hs-source-dirs: app

157 main-is: Main.hs

154 main-is: Main.hs

158 build-depends:

155 build-depends:

159− openapi-diff

156+ compaREST

160 , pandoc

157 , pandoc

161 , data-default

158 , data-default

162 , bytestring

159 , bytestring

@@ -167,14 +164,41 @@ executable openapi-diff

167 , aeson

164 , aeson

168 , containers

165 , containers

169 , doctemplates

166 , doctemplates

167+ , pandoc-types

170 ghc-options: -threaded

168 ghc-options: -threaded

171 -rtsopts

169 -rtsopts

172 -with-rtsopts=-N

170 -with-rtsopts=-N

173 other-modules:

171 other-modules:

174 FormatHeuristic

172 FormatHeuristic

175− OpenAPI.Checker.Options

173+ Data.OpenApi.Compare.Options

174+

175+executable compaREST-GitHub-Action

176+ import: common-options

177+ hs-source-dirs: github-action

178+ main-is: Main.hs

179+ build-depends:

180+ compaREST

181+ , pandoc

182+ , yaml

183+ , aeson

184+ , github

185+ , freer-simple

186+ , vector

187+ , pandoc-types

188+ , envy

189+ , filepath

190+ , bytestring

191+ ghc-options: -threaded

192+ -rtsopts

193+ -with-rtsopts=-N

194+ other-modules:

195+ Control.Monad.Freer.GitHub

196+ CompaREST.GitHub.API

197+ CompaREST.GitHub.Action.Config

198+ GitHub.Data.Checks

199+ GitHub.Endpoints.Checks

176

200

177−test-suite openapi-diff-test

201+test-suite compaREST-tests

178 import: common-options

202 import: common-options

179 type: exitcode-stdio-1.0

203 type: exitcode-stdio-1.0

180 hs-source-dirs: test

204 hs-source-dirs: test

@@ -182,8 +206,10 @@ test-suite openapi-diff-test

182 other-modules:

206 other-modules:

183 Spec.Golden.Extra

207 Spec.Golden.Extra

184 Spec.Golden.TraceTree

208 Spec.Golden.TraceTree

209+ Paths_compaREST

210+ autogen-modules: Paths_compaREST

185 build-depends:

211 build-depends:

186− , openapi-diff

212+ , compaREST

187 , tasty-golden

213 , tasty-golden

188 , tasty

214 , tasty

189 , bytestring

215 , bytestring

@@ -193,6 +219,7 @@ test-suite openapi-diff-test

193 , pandoc

219 , pandoc

194 , data-default

220 , data-default

195 , lens

221 , lens

222+ , pandoc-types

196 ghc-options: -threaded

223 ghc-options: -threaded

197 -rtsopts

224 -rtsopts

198 -with-rtsopts=-N

225 -with-rtsopts=-N

default.nix+91−10

@@ -1,33 +1,114 @@

1{ sources ? import ./nix/sources.nix

2, haskellNix ? import sources.haskellNix { inherit system; }

3−, pkgs ? import haskellNix.sources.nixpkgs-2105 (haskellNix.nixpkgsArgs // {inherit system;})

3+, pkgs ? import haskellNix.sources.nixpkgs-2105 (haskellNix.nixpkgsArgs // { inherit system; })

4, system ? builtins.currentSystem

5+, nix-filter ? import sources.nix-filter

5}:

6}:

6let

7let

8+ masterPkgs = import sources.nixpkgs { inherit system; };

9+

7 hsPkgs = pkgs.haskell-nix.stackProject {

10 hsPkgs = pkgs.haskell-nix.stackProject {

8− src = ./.;

11+ src = nix-filter {

12+ root = ./.;

13+ name = "compaREST";

14+ include = [

15+ ./stack.yaml

16+ ./stack.yaml.lock

17+ ./compaREST.cabal

18+ ];

19+ };

9

20

10 modules = [

21 modules = [

11 {

22 {

12 dontStrip = false;

23 dontStrip = false;

13 dontPatchELF = false;

24 dontPatchELF = false;

14 enableDeadCodeElimination = true;

25 enableDeadCodeElimination = true;

26+ ghcOptions = [

27+ "-O2"

28+ "-fexpose-all-unfoldings"

29+ "-fspecialise-aggressively"

30+ ];

31+ packages.pandoc.ghcOptions = [ "-O1" ];

32+ packages.compaREST.src = nix-filter {

33+ root = ./.;

34+ name = "compaREST-src";

35+ include = with nix-filter; [

36+ (./compaREST.cabal)

37+ (inDirectory ./test)

38+ (inDirectory ./src)

39+ (inDirectory ./app)

40+ (inDirectory ./github-action)

41+ ./awsm-css/dist/awsm.min.css

42+ ./LICENSE

43+ ];

44+ };

15 }

45 }

16 ];

46 ];

17 };

47 };

18

48

19− compaREST-static = pkgs.runCommand "compaREST-static" { } ''

49+ staticify = name: drv: pkgs.runCommand name { } ''

20− mkdir $out

50+ mkdir -p $out/bin

21− cp ${hsPkgs.projectCross.musl64.hsPkgs.openapi-diff.components.exes.openapi-diff + "/bin/openapi-diff"} $out/compaREST

51+ cp ${drv + "/bin"}/* $out/bin

22

52

23− ${pkgs.nukeReferences}/bin/nuke-refs $out/compaREST

53+ ${pkgs.nukeReferences}/bin/nuke-refs $out/bin/*

24 '';

54 '';

55+

56+ compaRESTBin = hsPkgs.compaREST.components.exes.compaREST;

57+ compaRESTStaticBin = (staticify "compaREST-static" hsPkgs.projectCross.musl64.hsPkgs.compaREST.components.exes.compaREST);

58+

59+

60+ # doesn't work

61+ armDarwinCompaREST = hsPkgs.projectCross.aarch64-darwin.hsPkgs.compaREST.components.exes.compaREST;

62+

25− compaREST = pkgs.dockerTools.buildImage {

63+ compaRESTImage = pkgs.dockerTools.buildImage {

26 name = "compaREST";

64 name = "compaREST";

27− contents = [compaREST-static];

65+ contents = [ compaRESTStaticBin ];

28 config = {

66 config = {

29− Entrypoint = [ "/compaREST" ];

67+ Entrypoint = [ "/bin/compaREST" ];

30 };

68 };

31 };

69 };

32

70

33−in compaREST

71+ macOSCompaRESTBundle = pkgs.runCommand "compaREST-macOS-bundled"

72+ {

73+ buildInputs = [ masterPkgs.macdylibbundler ];

74+ } ''

75+ mkdir -p $out/lib

76+ cp ${compaRESTBin}/bin/compaREST $out/compaREST

77+ chmod 755 $out/compaREST

78+ dylibbundler -b \

79+ -x $out/compaREST \

80+ -d $out/lib \

81+ -p '@executable_path/lib'

82+ '';

83+

84+

85+ compaRESTGithubAction =

86+ let

87+ action = staticify "compaREST-GitHub-Action-static" hsPkgs.projectCross.musl64.hsPkgs.compaREST.components.exes.compaREST-GitHub-Action;

88+ wrapped = pkgs.runCommand "wrapped-compaREST-GitHub-Action" { buildInputs = [ pkgs.makeWrapper ]; } ''

89+ makeWrapper ${action}/bin/compaREST-GitHub-Action $out/bin/pre --add-flags "pre"

90+ makeWrapper ${action}/bin/compaREST-GitHub-Action $out/bin/run --add-flags "run"

91+ '';

92+ in

93+ pkgs.dockerTools.buildImage {

94+ name = "typeable/compaREST-GitHub-Action";

95+ tag = "latest";

96+ contents = [ wrapped pkgs.cacert ];

97+ };

98+

99+ WindowsCompaRESTBin = hsPkgs.projectCross.mingwW64.hsPkgs.compaREST.components.exes.compaREST;

100+in

101+{

102+ inherit

103+ compaRESTImage

104+ compaRESTGithubAction

105+ compaRESTStaticBin

106+ compaRESTBin

107+ hsPkgs

108+ macOSCompaRESTBundle

109+ WindowsCompaRESTBin;

110+

111+ # We use the static version so that we don't have to rebuild everything on CI.

112+ # The only binaries build on CI are static.

113+ test = hsPkgs.projectCross.musl64.hsPkgs.compaREST.components.tests.compaREST-tests;

114+}

docs/Development_guide.mdnew file+149

@@ -0,0 +1,149 @@

1+CompaREST

2+=========

3+The tool works by simultaneously looking at a pair of nodes in OpenAPI schema

4+trees. At every place we try to understand whether one side (the producer) can

5+produce something that the other side (the consumer) cannot consume. This often

6+involves recursively running the same check on child sub-nodes. The necessary

7+criteria are implemented manually for all types of nodes that appear in the

8+schema. The `Subtree` class in `Data.OpenApi.Compare.Subtree` designates types

9+of nodes for which this compatibility checking is defined. The implementations

10+for various types reside in `Data.OpenApi.Compare.Validate.*`.

11+

12+Producer/Consumer

13+-----------------

14+Rather than looking at which schema is the server's and which is the client's,

15+in terms of compatibility checking it is more useful to track which side is the

16+"producer" and which is the "consumer". At the root of the schema the producer

17+is the client, but as we descend into an HTTP response, the direction flips and

18+the producer becomes the server.

19+

20+We deal with a lot of things in pairs, where one thing belongs to the producer

21+and another belongs to the consumer. The `ProdCons` datatype (in

22+`Data.OpenApi.Compare.Subtree`) is just a pair type that provides an Applicative

23+abstraction for working with two things simultaneously.

24+

25+Trees

26+-----

27+We directly use the datatypes defined in the `openapi3` library. For reasons of

28+identifiability and memoization we tag all nodes in the trees with a path from

29+the root. The tree is heterogeneous (nodes have different types), and every type

30+of node has a different arrangement of children. There is a `Step` data family

31+that defines all the possible children (of a specific type) of a node (of a

32+specific type).

33+

34+A `Trace` is a sequence of steps, except in a path the types of adjacent steps

35+have to agree. The `Paths` datatype achieves this. Together all paths form a

36+`Category`, and we often concatenate them using `>>>`. This is defined in

37+`Data.OpenApi.Compare.Paths`.

38+

39+We often keep a node and a path to it next to each other using an environment

40+comonad. `Traced` is a type alias around `Env` which ensures that the type of

41+the path matches the type of the node.

42+

43+Issues

44+------

45+The output of the tool is a list of compatibility issues that came up during

46+checking. The `Issue` data family describes the kinds of issues that can occur

47+at each type of node. An issue is supposed to characterize a set of interactions

48+(requests or responses) that demonstrate that the schemas are incompatible.

49+

50+Each issue is tagged with a `Behavior` that describes the path to reproducing

51+the issue. While a `Trace` describes a syntactic path down the schema tree, a

52+`Behavior` describes which part of an interaction needs to be focused on for the

53+issue to manifest itself.

54+

55+In most places where we keep multiple issues (e.g. the output), to store them we

56+use a prefix tree map, indexed by both types and values of `Behavior`s. See

57+`Data.OpenApi.Compare.PathsPrefixTree`.

58+

59+Report

60+------

61+The checker ultimately outputs a list of `Issue`s, together with `Behavior`s

62+that cause them. We run the checker twice: forwards and backwards -- to detect

63+non-breaking changes. All of this is then compiled into a report in

64+`Data.OpenApi.Compare.Report`. The tree structure of headings is computed from

65+`Behavior`s, using `Jet`s to collapse particular sequences of behavior steps

66+into a single human-readable header item. The text of each paragraph comes from

67+`describeIssue`.

68+

69+We then use the `pandoc` library to render the report in a variety of formats.

70+

71+Formulas

72+--------

73+The schema has references, so it can end up being recursive. Similarly the

74+process for establishing compatibility can end up being recursive. To keep track

75+of this, the checker actually manipulates *formulas* which can have variables in

76+them, defined in (`Data.OpenApi.Compare.Formula`).

77+

78+A formula represents a set of issues, with the empty set corresponding to a

79+successful compatibility check. A formula can have conjunctions, where we only

80+report success if all parts succeeded, and if not we take the union of all

81+issues. A formula can also have disjunctions, but there it's impossible to

82+guarantee that the issues for the parts also make sense as issues for the whole

83+thing. Due to this if all disjuncted parts have issues we instead return a

84+different issue (usually non-descriptive).

85+

86+The `FormulaF` datatype implements a functor that carries formulaic calculations

87+as well as a result value (a co-Yoneda extension of formulas for the most part).

88+The Applicative interface provides conjunction, and the Alternative interface

89+provides disjunction.

90+

91+When we detect recursion we introduce a variable, compute the compatibility

92+check as a formula with that variable, and then we solve a fixed point equation

93+(`maxFixpoint`) with the variable to obtain the answer.

94+

95+This `FomulaF` is further wrapped in a couple monad transformers

96+(`SemanticCompatFormula`, `StructuralCompatFormula`), and the whole checker is

97+then implemented in the resulting Applicative using ApplicativeDo.

98+

99+Memoization

100+-----------

101+The `Data.OpenApi.Compare.Memo` module contains utilities for stateful

102+memoization and recursion detection. The entire checking process is memoized,

103+and can detect, propagate, and resolve recursion.

104+

105+Structural/Semantic Compatibility

106+---------------------------------

107+When we encounter two nodes we first try to optimistically establish whether

108+they're structurally equal, i.e. the trees are exactly the same modulo reference

109+inlining. This check is also memoized and recursion-aware. If the check succeeds

110+we conclude that the schemas are compatible. Otherwise we fall back to the

111+"normal" semantic compatibility.

112+

113+

114+JSON Schema

115+-----------

116+The language that describes JSON payloads is probably the richest part of

117+OpenAPI schemas, and the checker for it also comes with a lot of moving parts.

118+

119+JSON schema allows arbitrary set arithmetic using `allOf`, `anyOf`, `not` and

120+`oneOf`. To fully check `not` and `oneOf` we would need to compare set

121+subtraction, which involves negating a comparison result. If recursion is

122+involved we would need to be able to solve equations with negation, which we

123+cannot do. So `not` is unsupported altogether, and `oneOf` is only supported

124+when it has disjoint branches and behaves like `anyOf`.

125+

126+With that in mind a JSON schema is first pre-processed into a Disjunctive Normal

127+Form (`DNF` in `Data.OpenApi.Compare.Validate.Schema.DNF`). This pre-processing

128+happens in `Data.OpenApi.Compare.Validate.Schema.Process`.

129+

130+The DNF contains elementary clauses that match on a specific aspect of a JSON

131+object (`Condition`). Most clauses only affect objects of a single type, so JSON

132+values and clauses are segregated by type (`JsonType`, `TypedValue` in

133+`Data.OpenApi.Compare.Validate.Schema.JsonFormula`)

134+

135+Then we reduce the problem of comparing two DNF's to the comparison of a

136+conjunction of clauses in the producer with a single clause in the consumer

137+(`checkFormulas` in `Data.OpenApi.Compare.Validate.Schema`).

138+

139+When we do disjunction in the formula we lose information, so we try to avoid

140+having disjunctions in the consumer DNF. This is done by the means of

141+partitioning. We look for factors that would let us partition the set of all

142+objects into several bins, in a way that hopefully corresponds only a single

143+consumer to each producer. This is implemented in

144+`Data.OpenApi.Compare.Validate.Schema.Partition`. Currently we can only

145+partition by an `enum` value that is accessible via a chain of `required`

146+fields.

147+

148+The same partitioning mechanism is used to test whether the branches of a

149+`oneOf` are disjoint, and emit a warning otherwise.

docs/Integration_guide.mdnew file+51

@@ -0,0 +1,51 @@

1+# Integration guide

2+

3+## Github Actions

4+

5+In cases where your OpenAPI spec can be generated from your code, it can be useful to see how a pull request changes your API. For this very purpose we have a Github Action.

6+

7+### Generating the inputs

8+

9+To use it you need to first get the old (before the pull request) and new (after the pull request) specs.

10+

11+For example:

12+

13+- To get the old spec you can:

14+ - Download from a public "production" server (if your api is public and you provide an OpenAPI spec)

15+ - Checkout the base commit of the pull request and generate is programmatically.

16+

17+ You can checkout the base commit like so in Github Actions:

18+

19+ ```bash

20+ git checkout $(git merge-base ${{ github.event.pull_request.head.sha }} ${{ github.event.pull_request.base.sha }})

21+ ```

22+- To get the new spec you can:

23+ - Build and run the spec generation for the head commit of the pull request

24+

25+### Run the action

26+

27+In our example we have already generated the two OpenAPI specs and placed them in the `old-openapi.yaml` and `new-openapi.yaml` files.

28+

29+We can now run our action:

30+

31+##### NOTE: will only work after public release

32+

33+```yaml

34+- uses: typeable/comparest

35+ with:

36+ old: old-openapi.yaml

37+ new: new-openapi.yaml

38+ project_name: TEST

39+```

40+

41+This will create a check on the pull request displaying the changes (if there are any) similar to this:

42+

43+![](img/github-action-report.png)

44+

45+The check will show success when there are no breaking changes, and be neutral otherwise.

46+

47+## Integrating into something other than Github Actions

48+

49+We have a dedicated implementation only for Github Actions. However, we provide a generic CLI which can be used to integrate compaREST into arbitrary workflows and CI systems.

50+

51+You see an example of CLI usage in our [readme](../README.md#assessing-compatibility-automatically).

docs/User_guide.mdnew file+51

@@ -0,0 +1,51 @@

1+CompaREST User Guide

2+====================

3+

4+Running the Tool

5+----------------

6+The tool accepts two OpenAPI 3.0.0 schema files in either JSON or YAML format.

7+One is assumed to be the client version of the schema, and the other is the

8+server version.

9+

10+The tool will look for changes between the schemas and detect whether they are

11+breaking or not -- that is, if they prevent interoperability between the client

12+and the server.

13+

14+Running:

15+```

16+comparest -c client.json -s server.json

17+```

18+will output a markdown report of the changes to the standard output.

19+

20+Compatibility status can be signaled via the exit code using

21+`--signal-exit-code`. In case no report is needed, output can be suppressed with

22+`--silent`. For example:

23+```

24+comparest -c client.json -s server.json --signal-exit-code --silent

25+echo $?

26+```

27+If there were changes that the tool determined to be breaking, the exit code

28+will be 1. If there were some changes the tool couldn't understand, the exit

29+code will be 2. Otherwise if there were no breaking changes, the exit code will

30+be 0.

31+

32+Controlling the Report

33+----------------------

34+By default the report includes breaking changes, as well as non-breaking:

35+changes that would be considered breaking in the opposite direction. To only

36+include breaking changes in the report use `--only-breaking`. The `--all` option

37+restores the default behavior.

38+

39+The report can be formatted in a variety of ways supported by Pandoc. The `-o`

40+option causes the report to be written to a file. The format of the file is

41+determined from the extension. The supported extensions include:

42+ - `.md` for markdown

43+ - `.html` for an HTML snippet

44+ - `.rst` for restructured text

45+ - no extension for a self-contained HTML document with styles

46+

47+By default the report is split up into parts relating to different paths,

48+requests, responses, etc, using headers of various levels. Alternatively, the

49+report can use indended block-quotes to visualize the tree structure of the

50+report. The header style is enabled with `--header-style`, and the block-quote

51+style is enabled with `--folding-block-quotes-style`.

docs/img/github-action-report.pngnew file

Binary file not shown.

github-action/CompaREST/GitHub/API.hsnew file+86

@@ -0,0 +1,86 @@

1+module CompaREST.GitHub.API

2+ ( postStatus,

3+ postStatusProcessing,

4+ )

5+where

6+

7+import CompaREST.GitHub.Action.Config

8+import Control.Monad.Freer

9+import Control.Monad.Freer.GitHub

10+import Control.Monad.Freer.Reader

11+import Control.Monad.IO.Class

12+import Data.Aeson

13+import qualified Data.ByteString.Lazy.Char8 as BSLC

14+import Data.OpenApi.Compare.Report

15+import Data.Proxy

16+import Data.Text (Text)

17+import GitHub

18+import GitHub.Data.Checks

19+import GitHub.Endpoints.Checks

20+

21+postStatusProcessing ::

22+ (Members '[GitHub, Reader Config] effs, MonadIO (Eff effs)) =>

23+ Eff effs ()

24+postStatusProcessing = do

25+ Config {..} <- ask

26+ printJSON $

27+ sendGitHub $

28+ checkR

29+ repoOwner

30+ repoName

31+ Check

32+ { checkName = mkName Proxy $ "compaREST – " <> projectName

33+ , checkSha = sha

34+ , checkDetailsURL = Nothing

35+ , checkExternalId = Nothing

36+ , checkStatus = Just CheckInProgress

37+ , checkStartedAt = Nothing

38+ , checkConclusion = Nothing

39+ , checkCompletedAt = Nothing

40+ , checkOutput = Nothing

41+ , checkActions = Nothing

42+ }

43+

44+postStatus ::

45+ (Members '[GitHub, Reader Config] effs, MonadIO (Eff effs)) =>

46+ -- | 'Nothing' means that there were no changes at all

47+ Maybe (Text, ReportStatus) ->

48+ Eff effs ()

49+postStatus x = do

50+ let (body, (title, conclusion)) = case x of

51+ Just (b, s) -> (b,) $ case s of

52+ BreakingChanges -> ("⚠️ Breaking changes found!", CheckNeutral)

53+ NoBreakingChanges -> ("No breaking changes found ✨", CheckSuccess)

54+ OnlyUnsupportedChanges -> ("🤷 Couldn't determine compatibility", CheckNeutral)

55+ Nothing -> ("", ("✅ The API did not change", CheckSuccess))

56+ Config {..} <- ask

57+ printJSON $

58+ sendGitHub $

59+ checkR

60+ repoOwner

61+ repoName

62+ Check

63+ { checkName = mkName Proxy $ "compaREST – " <> projectName

64+ , checkSha = sha

65+ , checkDetailsURL = Nothing

66+ , checkExternalId = Nothing

67+ , checkStatus = Just CheckCompleted

68+ , checkStartedAt = Nothing

69+ , checkConclusion = Just conclusion

70+ , checkCompletedAt = Nothing

71+ , checkOutput =

72+ Just $

73+ CheckOutput

74+ { checkTitle = title

75+ , checkSummary = body

76+ , checkText = Nothing

77+ , checkAnnotations = Nothing

78+ , checkImages = Nothing

79+ }

80+ , checkActions = Nothing

81+ }

82+

83+printJSON :: MonadIO (Eff effs) => Eff effs Value -> Eff effs ()

84+printJSON m = do

85+ x <- m

86+ liftIO . BSLC.putStrLn $ encode x

github-action/CompaREST/GitHub/Action/Config.hsnew file+43

@@ -0,0 +1,43 @@

1+module CompaREST.GitHub.Action.Config

2+ ( Config (..),

3+ )

4+where

5+

6+import Data.Proxy

7+import Data.Text (Text)

8+import qualified Data.Text as T

9+import qualified GitHub as GH

10+

11+import System.Envy

12+

13+data Config = Config

14+ { githubToken :: GH.Auth

15+ , repoOwner :: GH.Name GH.Owner

16+ , repoName :: GH.Name GH.Repo

17+ , projectName :: Text

18+ , footerText :: Text

19+ , root :: FilePath

20+ , sha :: GH.Name GH.Commit

21+ }

22+

23+instance FromEnv Config where

24+ fromEnv _ = do

25+ token <- GH.OAuth <$> env "GITHUB_TOKEN"

26+ (owner, repo) <-

27+ T.split (== '/') <$> env "REPO" >>= \case

28+ [owner, name] -> pure (owner, name)

29+ _ -> fail "malformed repo"

30+ projectName <- env "PROJECT_NAME"

31+ footerText <- env "FOOTER"

32+ root <- envMaybe "ROOT" .!= "."

33+ sha <- env "SHA"

34+ pure $

35+ Config

36+ { githubToken = token

37+ , repoOwner = GH.mkName Proxy owner

38+ , repoName = GH.mkName Proxy repo

39+ , projectName = projectName

40+ , footerText = footerText

41+ , root = root

42+ , sha = GH.mkName Proxy sha

43+ }

github-action/Control/Monad/Freer/GitHub.hsnew file+27

@@ -0,0 +1,27 @@

1+module Control.Monad.Freer.GitHub

2+ ( GitHub (..),

3+ runGitHub,

4+ sendGitHub,

5+ )

6+where

7+

8+import Control.Monad.Freer

9+import Control.Monad.Freer.Error

10+import Control.Monad.IO.Class

11+import Data.Aeson

12+import GitHub hiding (Error)

13+import qualified GitHub as GH

14+

15+data GitHub r where

16+ SendGHRequest :: FromJSON x => Request 'RW x -> GitHub x

17+

18+runGitHub :: (Member (Error GH.Error) effs, MonadIO (Eff effs)) => Auth -> Eff (GitHub ': effs) ~> Eff effs

19+runGitHub auth =

20+ interpret

21+ ( \(SendGHRequest req) ->

22+ liftIO (executeRequest auth req)

23+ >>= either throwError pure

24+ )

25+

26+sendGitHub :: (FromJSON x, Member GitHub effs) => Request 'RW x -> Eff effs x

27+sendGitHub req = send $ SendGHRequest req

github-action/GitHub/Data/Checks.hsnew file+173

@@ -0,0 +1,173 @@

1+module GitHub.Data.Checks

2+ ( Check (..),

3+ CheckStatus (..),

4+ CheckConclusion (..),

5+ CheckOutput (..),

6+ CheckAnnotation (..),

7+ CheckAnnotationLevel (..),

8+ CheckImage (..),

9+ CheckAction (..),

10+ )

11+where

12+

13+import Data.Aeson

14+import Data.Aeson.Types

15+import Data.Text (Text)

16+import Data.Vector (Vector)

17+import GHC.Generics (Generic)

18+import GitHub

19+import GitHub.Internal.Prelude (UTCTime)

20+

21+data Check = Check

22+ { checkName :: !(Name Check)

23+ , checkSha :: !(Name Commit)

24+ , checkDetailsURL :: !(Maybe URL)

25+ , checkExternalId :: !(Maybe (Id Check))

26+ , checkStatus :: !(Maybe CheckStatus)

27+ , checkStartedAt :: !(Maybe UTCTime)

28+ , checkConclusion :: !(Maybe CheckConclusion)

29+ , checkCompletedAt :: !(Maybe UTCTime)

30+ , checkOutput :: !(Maybe CheckOutput)

31+ , checkActions :: !(Maybe (Vector CheckAction))

32+ }

33+ deriving stock (Show, Eq, Ord, Generic)

34+

35+instance ToJSON Check where

36+ toJSON (Check n sha durl eid s sa c ca o a) =

37+ object'

38+ [ "name" .= n

39+ , "head_sha" .= sha

40+ , "details_url" .= durl

41+ , "external_id" .= eid

42+ , "status" .= s

43+ , "started_at" .= sa

44+ , "conclusion" .= c

45+ , "completed_at" .= ca

46+ , "output" .= o

47+ , "actions" .= a

48+ ]

49+

50+data CheckStatus

51+ = CheckQueued

52+ | CheckInProgress

53+ | CheckCompleted

54+ deriving stock (Show, Enum, Bounded, Eq, Ord, Generic)

55+

56+instance ToJSON CheckStatus where

57+ toJSON CheckQueued = String "queued"

58+ toJSON CheckInProgress = String "in_progress"

59+ toJSON CheckCompleted = String "completed"

60+

61+data CheckConclusion

62+ = CheckActionRequired

63+ | CheckCancelled

64+ | CheckFailure

65+ | CheckNeutral

66+ | CheckSuccess

67+ | CheckSkipped

68+ | CheckStale

69+ | CheckTimedOut

70+ deriving stock (Show, Enum, Bounded, Eq, Ord, Generic)

71+

72+instance ToJSON CheckConclusion where

73+ toJSON CheckActionRequired = String "action_required"

74+ toJSON CheckCancelled = String "cancelled"

75+ toJSON CheckFailure = String "failure"

76+ toJSON CheckNeutral = String "neutral"

77+ toJSON CheckSuccess = String "success"

78+ toJSON CheckSkipped = String "skipped"

79+ toJSON CheckStale = String "stale"

80+ toJSON CheckTimedOut = String "timed_out"

81+

82+data CheckOutput = CheckOutput

83+ { checkTitle :: !Text

84+ , checkSummary :: !Text

85+ , checkText :: !(Maybe Text)

86+ , checkAnnotations :: !(Maybe (Vector CheckAnnotation))

87+ , checkImages :: !(Maybe (Vector CheckImage))

88+ }

89+ deriving stock (Show, Eq, Ord, Generic)

90+

91+instance ToJSON CheckOutput where

92+ toJSON (CheckOutput t s txt a i) =

93+ object'

94+ [ "title" .= t

95+ , "summary" .= s

96+ , "text" .= txt

97+ , "annotations" .= a

98+ , "images" .= i

99+ ]

100+

101+data CheckAnnotation = CheckAnnotation

102+ { checkPath :: !Text

103+ , checkStartLine :: !Int

104+ , checkEndLine :: !Int

105+ , checkStartColumn :: !(Maybe Int)

106+ , checkEndColumn :: !(Maybe Int)

107+ , checkAnnotationLevel :: !CheckAnnotationLevel

108+ , checkMessage :: !Text

109+ , checkTitle :: !(Maybe Text)

110+ , checkRawDetails :: !(Maybe Text)

111+ }

112+ deriving stock (Show, Eq, Ord, Generic)

113+

114+instance ToJSON CheckAnnotation where

115+ toJSON (CheckAnnotation p sl el sc ec al m t rd) =

116+ object'

117+ [ "path" .= p

118+ , "start_line" .= sl

119+ , "end_line" .= el

120+ , "start_column" .= sc

121+ , "end_column" .= ec

122+ , "annotation_level" .= al

123+ , "message" .= m

124+ , "title" .= t

125+ , "raw_details" .= rd

126+ ]

127+

128+data CheckAnnotationLevel

129+ = NoticeAnnotation

130+ | WarningAnnotation

131+ | FailureAnnotation

132+ deriving stock (Show, Enum, Bounded, Eq, Ord, Generic)

133+

134+instance ToJSON CheckAnnotationLevel where

135+ toJSON NoticeAnnotation = String "notice"

136+ toJSON WarningAnnotation = String "warning"

137+ toJSON FailureAnnotation = String "failure"

138+

139+data CheckImage = CheckImage

140+ { checkImageAlt :: !Text

141+ , checkImageURL :: !URL

142+ , checkImageCaption :: !(Maybe Text)

143+ }

144+ deriving stock (Show, Eq, Ord, Generic)

145+

146+instance ToJSON CheckImage where

147+ toJSON (CheckImage a url c) =

148+ object'

149+ [ "alt" .= a

150+ , "image_url" .= url

151+ , "caption" .= c

152+ ]

153+

154+data CheckAction = CheckAction

155+ { checkActionLabel :: !Text

156+ , checkActionDescription :: !Text

157+ , checkActionIdentifier :: !Text

158+ }

159+ deriving stock (Show, Eq, Ord, Generic)

160+

161+instance ToJSON CheckAction where

162+ toJSON (CheckAction l d i) =

163+ object'

164+ [ "label" .= l

165+ , "description" .= d

166+ , "identifier" .= i

167+ ]

168+

169+object' :: [Pair] -> Value

170+object' = object . filter notNull

171+ where

172+ notNull (_, Null) = False

173+ notNull (_, _) = True

github-action/GitHub/Endpoints/Checks.hsnew file+12

@@ -0,0 +1,12 @@

1+module GitHub.Endpoints.Checks

2+ ( checkR,

3+ )

4+where

5+

6+import Data.Aeson

7+import GitHub

8+import GitHub.Data.Checks

9+

10+checkR :: Name Owner -> Name Repo -> Check -> Request 'RW Value

11+checkR user repo =

12+ command Post ["repos", toPathPart user, toPathPart repo, "check-runs"] . encode

github-action/Main.hsnew file+66

@@ -0,0 +1,66 @@

1+module Main (main) where

2+

3+import CompaREST.GitHub.API

4+import CompaREST.GitHub.Action.Config

5+import Control.Exception

6+import Control.Monad.Freer

7+import Control.Monad.Freer.Error

8+import Control.Monad.Freer.GitHub

9+import Control.Monad.Freer.Reader

10+import Data.OpenApi.Compare.Run

11+import Data.Text (Text)

12+import qualified Data.Yaml.Aeson as Yaml

13+import qualified GitHub as GH

14+import System.Environment

15+import System.Envy (decodeEnv)

16+import System.FilePath ((</>))

17+import Text.Pandoc (runPure)

18+import Text.Pandoc.Builder

19+import Text.Pandoc.Options

20+import Text.Pandoc.Writers

21+

22+main :: IO ()

23+main = do

24+ cfg <- decodeEnv >>= either error pure

25+ getArgs >>= \case

26+ ["pre"] -> runPre cfg

27+ ["run"] -> do

28+ oldFile <- getEnv "OLD"

29+ newFile <- getEnv "NEW"

30+ runRun cfg (root cfg </> oldFile) (root cfg </> newFile)

31+ _ -> error "Invalid arguments."

32+

33+runner :: Config -> Eff '[GitHub, Error GH.Error, Reader Config, IO] a -> IO a

34+runner cfg =

35+ runM @IO . runReader cfg

36+ . flip (handleError @GH.Error) (error . displayException)

37+ . runGitHub (githubToken cfg)

38+

39+runPre :: Config -> IO ()

40+runPre cfg = runner cfg postStatusProcessing

41+

42+runRun :: Config -> FilePath -> FilePath -> IO ()

43+runRun cfg old' new' = runner cfg $ do

44+ old <- Yaml.decodeFileThrow old'

45+ new <- Yaml.decodeFileThrow new'

46+ let reportConfig =

47+ ReportConfig

48+ { treeStyle = FoldingBlockquotesTreeStyle

49+ , reportMode = All

50+ }

51+ (report, status) = runReport reportConfig (old, new)

52+

53+ body = markdown report <> "\n\n" <> footerText cfg

54+

55+ result =

56+ if old == new

57+ then Nothing

58+ else Just (body, status)

59+ postStatus result

60+

61+markdown :: Blocks -> Text

62+markdown =

63+ either (error . displayException) id

64+ . runPure

65+ . writeHtml5String def

66+ . doc

nix/ci.nixnew file+6

@@ -0,0 +1,6 @@

1+{ sources ? import ./sources.nix

2+, pkgs ? import sources.nixpkgs { }

3+}:

4+pkgs.mkShell {

5+ packages = [ pkgs.haskellPackages.fourmolu ];

6+}

nix/sources.json+30−6

@@ -5,10 +5,10 @@

5 "homepage": "https://input-output-hk.github.io/haskell.nix",

6 "owner": "input-output-hk",

7 "repo": "haskell.nix",

8− "rev": "8c587f90d2986f87a8212c3469521db512bc7ed9",

8+ "rev": "c8a8f57de3c14fcf1c5cda045ed885fb6d06a00e",

9− "sha256": "0a4mz47ccvl1nl2p08zbn33i1vmak4bjr4z6wqzzflnq90hg5a0s",

9+ "sha256": "0frzmvz8rhb4vgx20qms9xxqbkmg5pwivis4qis63ny5wxclzb34",

10 "type": "tarball",

11− "url": "https://github.com/input-output-hk/haskell.nix/archive/8c587f90d2986f87a8212c3469521db512bc7ed9.tar.gz",

11+ "url": "https://github.com/input-output-hk/haskell.nix/archive/c8a8f57de3c14fcf1c5cda045ed885fb6d06a00e.tar.gz",

12 "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"

13 },

14 "niv": {

@@ -17,10 +17,34 @@

17 "homepage": "https://github.com/nmattia/niv",

18 "owner": "nmattia",

19 "repo": "niv",

20− "rev": "e0ca65c81a2d7a4d82a189f1e23a48d59ad42070",

20+ "rev": "5830a4dd348d77e39a0f3c4c762ff2663b602d4c",

21− "sha256": "1pq9nh1d8nn3xvbdny8fafzw87mj7gsmp6pxkdl65w2g18rmcmzx",

21+ "sha256": "1d3lsrqvci4qz2hwjrcnd8h5vfkg8aypq3sjd4g3izbc8frwz5sm",

22 "type": "tarball",

23− "url": "https://github.com/nmattia/niv/archive/e0ca65c81a2d7a4d82a189f1e23a48d59ad42070.tar.gz",

23+ "url": "https://github.com/nmattia/niv/archive/5830a4dd348d77e39a0f3c4c762ff2663b602d4c.tar.gz",

24+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"

25+ },

26+ "nix-filter": {

27+ "branch": "master",

28+ "description": "a small self-container source filtering lib",

29+ "homepage": "",

30+ "owner": "numtide",

31+ "repo": "nix-filter",

32+ "rev": "3c9e33ed627e009428197b07216613206f06ed80",

33+ "sha256": "19w142crrkywxynmyw4rhz4nglrg64yjawfkw3j91qwkwbfjds84",

34+ "type": "tarball",

35+ "url": "https://github.com/numtide/nix-filter/archive/3c9e33ed627e009428197b07216613206f06ed80.tar.gz",

36+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"

37+ },

38+ "nixpkgs": {

39+ "branch": "master",

40+ "description": "Nix Packages collection",

41+ "homepage": "",

42+ "owner": "NixOS",

43+ "repo": "nixpkgs",

44+ "rev": "f0fe5e9ba08e658474476317717aca7acacef4d4",

45+ "sha256": "1n5syynwmg3x8lj2kyb2ilbxw5nmw7f2kw6yxsi8qadx91hrvkwm",

46+ "type": "tarball",

47+ "url": "https://github.com/NixOS/nixpkgs/archive/f0fe5e9ba08e658474476317717aca7acacef4d4.tar.gz",

24 "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"

48 "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"

25 }

49 }

26}

50}

policeman.jsonnew file+6

@@ -0,0 +1,6 @@

1+[{

2+ "file": "compaREST.cabal",

3+ "annotation_level": "notice",

4+ "end_line": 0,

5+ "start_line": 0

6+}]

src/Data/HList.hs+11−11

@@ -1,11 +1,11 @@

1module Data.HList

2− ( Has

2+ ( Has,

3− , HasAll

3+ HasAll,

4− , getH

4+ getH,

5− , HList (..)

5+ HList (..),

6− , singletonH

6+ singletonH,

7− , ReassembleHList

7+ ReassembleHList,

8− , reassemble

8+ reassemble,

9 )

10where

11

@@ -40,8 +40,8 @@ instance (Has' x xs t, HeadEq x (y : xs) ~ 'False) => Has' x (y ': xs) 'False wh

40 {-# INLINE getH #-}

41

42instance

43− TypeError ('ShowType x ':<>: 'Text " is not a part of the list.")

43+ TypeError ( 'ShowType x ':<>: 'Text " is not a part of the list.") =>

44− => Has' x '[] 'False

44+ Has' x '[] 'False

45 where

46 getH HNil = undefined

47 {-# INLINE getH #-}

@@ -74,8 +74,8 @@ instance ReassembleHList' (x ': xs) '[] 'False where

74 {-# INLINE reassemble #-}

75

76instance

77− (Has y xs, ReassembleHList' xs ys f, (xs == (y ': ys)) ~ 'False)

77+ (Has y xs, ReassembleHList' xs ys f, (xs == (y ': ys)) ~ 'False) =>

78− => ReassembleHList' xs (y ': ys) 'False

78+ ReassembleHList' xs (y ': ys) 'False

79 where

80 reassemble xs = getH @y xs `HCons` reassemble xs

81 {-# INLINE reassemble #-}

src/OpenAPI/Checker/Behavior.hs → src/Data/OpenApi/Compare/Behavior.hsrenamed+13−13

@@ -1,22 +1,22 @@

1−module OpenAPI.Checker.Behavior

1+module Data.OpenApi.Compare.Behavior

2− ( BehaviorLevel (..)

2+ ( BehaviorLevel (..),

3− , Behavable (..)

3+ Behavable (..),

4− , IssueKind (..)

4+ IssueKind (..),

5− , Issuable (..)

5+ Issuable (..),

6− , Orientation (..)

6+ Orientation (..),

7− , toggleOrientation

7+ toggleOrientation,

8− , Behavior

8+ Behavior,

9− , AnIssue (..)

9+ AnIssue (..),

10− , withClass

10+ withClass,

11− , anIssueKind

11+ anIssueKind,

12− , relatedAnIssues

12+ relatedAnIssues,

13 )

14where

15

16import Data.Aeson

17import Data.Kind

18+import Data.OpenApi.Compare.Paths

18import Data.Typeable

19import Data.Typeable

19−import OpenAPI.Checker.Paths

20import Text.Pandoc.Builder

21

22-- | Kind

src/OpenAPI/Checker/Common.hs → src/Data/OpenApi/Compare/Common.hsrenamed+2−2

@@ -1,5 +1,5 @@

1−module OpenAPI.Checker.Common

1+module Data.OpenApi.Compare.Common

2− ( zipAll

2+ ( zipAll,

3 )

4where

5

src/OpenAPI/Checker/Formula.hs → src/Data/OpenApi/Compare/Formula.hsrenamed+35−25

@@ -1,20 +1,21 @@

1−module OpenAPI.Checker.Formula

1+module Data.OpenApi.Compare.Formula

2− ( FormulaF

2+ ( FormulaF,

3− , VarRef

3+ VarRef,

4− , variable

4+ variable,

5− , eitherOf

5+ eitherOf,

6− , anError

6+ anError,

7− , errors

7+ errors,

8− , calculate

8+ calculate,

9− , maxFixpoint

9+ maxFixpoint,

10− , mapErrors

10+ mapErrors,

11+ )

11− ) where

12+where

12

13

13import Data.Kind

14import Data.Kind

14−import Data.Monoid

15import qualified Data.List.NonEmpty as NE

16−import OpenAPI.Checker.Paths

16+import Data.Monoid

17+import Data.OpenApi.Compare.Paths

17−import qualified OpenAPI.Checker.PathsPrefixTree as P

18+import qualified Data.OpenApi.Compare.PathsPrefixTree as P

18

19

19type VarRef = Int

20type VarRef = Int

20

21

@@ -24,15 +25,24 @@ type VarRef = Int

24-- fixpoints always exist, i.e. that @x = f x@ has at least one solution.

25-- fixpoints always exist, i.e. that @x = f x@ has at least one solution.

25data FormulaF (q :: k -> k -> Type) (f :: k -> Type) (r :: k) (a :: Type) where

26data FormulaF (q :: k -> k -> Type) (f :: k -> Type) (r :: k) (a :: Type) where

26 Result :: a -> FormulaF q f r a

27 Result :: a -> FormulaF q f r a

28+ Errors ::

27− Errors :: !(P.PathsPrefixTree q f r) -> FormulaF q f r a

29+ !(P.PathsPrefixTree q f r) ->

28− -- ^ invariant: never empty

30+ -- | invariant: never empty

31+ FormulaF q f r a

32+ Apply ::

29− Apply :: FormulaF q f r (b -> c) -> FormulaF q f r b -> (c -> a) -> FormulaF q f r a

33+ FormulaF q f r (b -> c) ->

34+ FormulaF q f r b ->

35+ (c -> a) ->

30− -- ^ invariant: at least one of LHS and RHS is not 'Errors', and they are

36+ -- | invariant: at least one of LHS and RHS is not 'Errors', and they are

31 -- both not 'Result'

37 -- both not 'Result'

38+ FormulaF q f r a

39+ SelectFirst ::

32− SelectFirst :: NE.NonEmpty (SomeFormulaF b)

40+ NE.NonEmpty (SomeFormulaF b) ->

33− -> !(P.PathsPrefixTree q f r) -> (b -> a) -> FormulaF q f r a

41+ !(P.PathsPrefixTree q f r) ->

42+ (b -> a) ->

34− -- ^ invariant: the list doesn't contain any 'Result's, 'Errors' or

43+ -- | invariant: the list doesn't contain any 'Result's, 'Errors' or

35 -- 'SelectFirst'

44 -- 'SelectFirst'

45+ FormulaF q f r a

36 Variable :: !VarRef -> a -> FormulaF q f r a

46 Variable :: !VarRef -> a -> FormulaF q f r a

37

47

38mkApply :: FormulaF q f r (b -> c) -> FormulaF q f r b -> (c -> a) -> FormulaF q f r a

48mkApply :: FormulaF q f r (b -> c) -> FormulaF q f r b -> (c -> a) -> FormulaF q f r a

@@ -44,13 +54,13 @@ mkApply f x h = Apply f x h

44mkSelectFirst :: [SomeFormulaF b] -> P.PathsPrefixTree q f r -> (b -> a) -> FormulaF q f r a

54mkSelectFirst :: [SomeFormulaF b] -> P.PathsPrefixTree q f r -> (b -> a) -> FormulaF q f r a

45mkSelectFirst fs allE h = case foldMap check fs of

55mkSelectFirst fs allE h = case foldMap check fs of

46 (First (Just x), _) -> Result (h x)

56 (First (Just x), _) -> Result (h x)

47− (First Nothing, x:xs) -> SelectFirst (x NE.:| xs) allE h

57+ (First Nothing, x : xs) -> SelectFirst (x NE.:| xs) allE h

48 (First Nothing, []) -> Errors allE

58 (First Nothing, []) -> Errors allE

49 where

59 where

50 check (SomeFormulaF (Result x)) = (First (Just x), mempty)

60 check (SomeFormulaF (Result x)) = (First (Just x), mempty)

51 check (SomeFormulaF (Errors _)) = (mempty, mempty)

61 check (SomeFormulaF (Errors _)) = (mempty, mempty)

52− check (SomeFormulaF (SelectFirst xs _ h'))

62+ check (SomeFormulaF (SelectFirst xs _ h')) =

53− = (mempty, NE.toList (fmap (fmap h') xs))

63+ (mempty, NE.toList (fmap (fmap h') xs))

54 check x = (mempty, [x])

64 check x = (mempty, [x])

55

65

56data SomeFormulaF (a :: Type) where

66data SomeFormulaF (a :: Type) where

@@ -96,7 +106,7 @@ calculate (Apply f x h) = case calculate f of

96 Right x' -> Right (h (f' x'))

106 Right x' -> Right (h (f' x'))

97calculate (SelectFirst xs e h) = go (NE.toList xs)

107calculate (SelectFirst xs e h) = go (NE.toList xs)

98 where

108 where

99− go (SomeFormulaF r:rs) = case calculate r of

109+ go (SomeFormulaF r : rs) = case calculate r of

100 Left _ -> go rs

110 Left _ -> go rs

101 Right x -> Right (h x)

111 Right x -> Right (h x)

102 go [] = Left e

112 go [] = Left e

src/Data/OpenApi/Compare/Memo.hsnew file+164

@@ -0,0 +1,164 @@

1+{-# LANGUAGE AllowAmbiguousTypes #-}

2+

3+-- | Utilities for effectfully memoizing other, more effectful functions.

4+module Data.OpenApi.Compare.Memo

5+ ( MonadMemo,

6+ MemoState,

7+ runMemo,

8+ modifyMemoNonce,

9+ KnotTier (..),

10+ unknot,

11+ memoWithKnot,

12+ memoTaggedWithKnot,

13+ )

14+where

15+

16+import Control.Monad.State

17+import Data.Dynamic

18+import qualified Data.Map as M

19+import Data.Tagged

20+import qualified Data.TypeRepMap as T

21+import Data.Void

22+import Type.Reflection

23+

24+data Progress a = Finished a | Started | TyingKnot Dynamic

25+

26+data MemoMap a where

27+ MemoMap :: !(M.Map k (Progress v)) -> MemoMap (k, v)

28+

29+data MemoState s = MemoState s (T.TypeRepMap MemoMap)

30+

31+-- | An effectful memoization monad.

32+type MonadMemo s m = MonadState (MemoState s) m

33+

34+memoStateLookup ::

35+ forall k v s.

36+ (Typeable k, Typeable v, Ord k) =>

37+ k ->

38+ MemoState s ->

39+ Maybe (Progress v)

40+memoStateLookup k (MemoState _ t) = case T.lookup @(k, v) t of

41+ Just (MemoMap m) -> M.lookup k m

42+ Nothing -> Nothing

43+

44+memoStateInsert ::

45+ forall k v s.

46+ (Typeable k, Typeable v, Ord k) =>

47+ k ->

48+ Progress v ->

49+ MemoState s ->

50+ MemoState s

51+memoStateInsert k x (MemoState s t) = MemoState s $ T.insert (MemoMap m'') t

52+ where

53+ m'' = M.insert k x m'

54+ m' = case T.lookup @(k, v) t of

55+ Just (MemoMap m) -> m

56+ Nothing -> M.empty

57+

58+modifyMemoNonce :: MonadMemo s m => (s -> s) -> m s

59+modifyMemoNonce f = do

60+ MemoState s t <- get

61+ put $ MemoState (f s) t

62+ pure s

63+

64+-- | Run a memoized computation.

65+runMemo :: Monad m => s -> StateT (MemoState s) m a -> m a

66+runMemo s = (`evalStateT` MemoState s T.empty)

67+

68+-- | A description of how to effectfully tie knots in type @v@, using the @m@

69+-- monad, and by sharing some @d@ data among the recursive instances.

70+data KnotTier v d m = KnotTier

71+ { -- | Create some data that will be connected to this knot

72+ onKnotFound :: m d

73+ , -- | This is what the knot will look like as a value

74+ -- to the inner computations

75+ onKnotUsed :: d -> m v

76+ , -- | Once we're done and we're outside, tie the

77+ -- knot using the datum

78+ tieKnot :: d -> v -> m v

79+ }

80+

81+unknot :: KnotTier v Void m

82+unknot =

83+ KnotTier

84+ { onKnotFound = error "Recursion detected"

85+ , onKnotUsed = absurd

86+ , tieKnot = absurd

87+ }

88+

89+-- | Run a potentially recursive computation. The provided key will be used to

90+-- refer to the result of this computation. If during the computation, another

91+-- attempt to run the computation with the same key is made, we run a

92+-- tying-the-knot procedure.

93+--

94+-- If another attempt to run the computation with the same key is made

95+-- *after we're done*, we will return the memoized value.

96+memoWithKnot ::

97+ forall k v d m s.

98+ (Typeable k, Typeable v, Typeable d, Ord k, MonadMemo s m) =>

99+ KnotTier v d m ->

100+ -- | the computation to memoize

101+ m v ->

102+ -- | key for memoization

103+ k ->

104+ m v

105+memoWithKnot tier f k =

106+ memoStateLookup @k @v k <$> get >>= \case

107+ Just (Finished v) -> pure v

108+ Just Started -> do

109+ d <- onKnotFound tier

110+ modify $ memoStateInsert @k @v k (TyingKnot $ toDyn d)

111+ onKnotUsed tier d

112+ Just (TyingKnot dyn) -> case fromDynamic dyn of

113+ Just d -> onKnotUsed tier d

114+ Nothing ->

115+ error $

116+ "Type mismatch when examining the knot of "

117+ <> show (typeRep @(k -> v))

118+ <> ": expected "

119+ <> show (typeRep @d)

120+ <> ", got "

121+ <> show (dynTypeRep dyn)

122+ Nothing -> do

123+ modify $ memoStateInsert @k @v k Started

124+ v <- f

125+ v' <-

126+ memoStateLookup @k @v k <$> get >>= \case

127+ Just Started -> pure v

128+ Just (TyingKnot dyn) -> case fromDynamic dyn of

129+ Just d -> tieKnot tier d v

130+ Nothing ->

131+ error $

132+ "Type mismatch when tying the knot of "

133+ <> show (typeRep @(k -> v))

134+ <> ": expected "

135+ <> show (typeRep @d)

136+ <> ", got "

137+ <> show (dynTypeRep dyn)

138+ Just (Finished _) ->

139+ error $

140+ "Unexpected Finished when memoizing "

141+ <> show (typeRep @(k -> v))

142+ Nothing -> pure v

143+ -- Normally this would be an error, but the underlying monad can refuse

144+ -- to remember memoization state

145+ modify $ memoStateInsert @k @v k (Finished v')

146+ pure v'

147+

148+-- | Disambiguate memoized computations with an arbitrary tag.

149+memoTaggedWithKnot ::

150+ forall t k v d m s.

151+ ( Typeable t

152+ , Typeable k

153+ , Typeable v

154+ , Typeable d

155+ , Ord k

156+ , MonadMemo s m

157+ ) =>

158+ KnotTier v d m ->

159+ m v ->

160+ k ->

161+ m v

162+memoTaggedWithKnot tier f k =

163+ withTypeable (typeRepKind $ typeRep @t) $

164+ memoWithKnot tier f (Tagged @t k)

src/OpenAPI/Checker/Orphans.hs → src/Data/OpenApi/Compare/Orphans.hsrenamed+1−1

@@ -1,6 +1,6 @@

1{-# OPTIONS_GHC -Wno-orphans #-}

2

3−module OpenAPI.Checker.Orphans () where

3+module Data.OpenApi.Compare.Orphans () where

4

5import Control.Comonad.Env

6import qualified Data.HashMap.Strict.InsOrd as IOHM

src/OpenAPI/Checker/Paths.hs → src/Data/OpenApi/Compare/Paths.hsrenamed+10−10

@@ -1,18 +1,18 @@

1-- | Utilities for traversing heterogeneous trees. A heterogeneous tree is a

2-- collection of datatypes that "contain" eachother in some form of tree

3-- structure.

4−module OpenAPI.Checker.Paths

4+module Data.OpenApi.Compare.Paths

5− ( NiceQuiver

5+ ( NiceQuiver,

6− , AdditionalQuiverConstraints

6+ AdditionalQuiverConstraints,

7− , Paths (..)

7+ Paths (..),

8− , DiffPaths (..)

8+ DiffPaths (..),

9− , catDiffPaths

9+ catDiffPaths,

10− , AnItem (..)

10+ AnItem (..),

11− , step

11+ step,

12

13 -- * Reexports

14− , (>>>)

14+ (>>>),

15− , (<<<)

15+ (<<<),

16 )

17where

18

src/OpenAPI/Checker/PathsPrefixTree.hs → src/Data/OpenApi/Compare/PathsPrefixTree.hsrenamed+39−39

@@ -1,22 +1,22 @@

1{-# LANGUAGE QuantifiedConstraints #-}

2

3−module OpenAPI.Checker.PathsPrefixTree

3+module Data.OpenApi.Compare.PathsPrefixTree

4− ( PathsPrefixTree (PathsPrefixNode)

4+ ( PathsPrefixTree (PathsPrefixNode),

5− , AStep (..)

5+ AStep (..),

6− , empty

6+ empty,

7− , singleton

7+ singleton,

8− , fromList

8+ fromList,

9− , null

9+ null,

10− , foldWith

10+ foldWith,

11− , toList

11+ toList,

12− , filter

12+ filter,

13− , filterWithKey

13+ filterWithKey,

14− , takeSubtree

14+ takeSubtree,

15− , lookup

15+ lookup,

16− , embed

16+ embed,

17− , size

17+ size,

18− , partition

18+ partition,

19− , map

19+ map,

20 )

21where

22

@@ -27,15 +27,15 @@ import qualified Data.HashMap.Strict as HM

27import Data.Kind

28import qualified Data.Map as M

29import Data.Monoid

30+import Data.OpenApi.Compare.Paths

30import qualified Data.Set as S

31import qualified Data.Set as S

31import qualified Data.Text as T

32import qualified Data.Text as T

32import Data.Type.Equality

33import Data.Type.Equality

33import qualified Data.TypeRepMap as TRM

34import qualified Data.TypeRepMap as TRM

34import qualified Data.Vector as V

35import qualified Data.Vector as V

35import qualified GHC.Exts as Exts

36import qualified GHC.Exts as Exts

36−import OpenAPI.Checker.Paths

37import Type.Reflection

38−import Prelude hiding (filter, map, null, lookup)

38+import Prelude hiding (filter, lookup, map, null)

39

40-- | A list of @AnItem r f@, but optimized into a prefix tree.

41data PathsPrefixTree (q :: k -> k -> Type) (f :: k -> Type) (r :: k) = PathsPrefixTree

@@ -102,11 +102,11 @@ deriving stock instance Eq (PathsPrefixTree q f a)

102

103-- Kind of orphan. Treat the map as an infinite tuple of @Maybe (f a)@'s, where

104-- the components are ordered by the @SomeTypeRep@ of the @a@.

105−compareTRM

105+compareTRM ::

106− :: (forall a. Typeable a => Ord (f a))

106+ (forall a. Typeable a => Ord (f a)) =>

107− => TRM.TypeRepMap f

107+ TRM.TypeRepMap f ->

108− -> TRM.TypeRepMap f

108+ TRM.TypeRepMap f ->

109− -> Ordering

109+ Ordering

110compareTRM s1 s2 =

111 foldMap (\k -> compareMaybe compareW (M.lookup k m1) (M.lookup k m2)) mKeys

112 where

@@ -116,11 +116,11 @@ compareTRM s1 s2 =

116 compareMaybe _ Nothing (Just _) = LT

117 compareMaybe _ (Just _) Nothing = GT

118 compareMaybe cmp (Just x) (Just y) = cmp x y

119− compareW

119+ compareW ::

120− :: (forall a. Typeable a => Ord (f a))

120+ (forall a. Typeable a => Ord (f a)) =>

121− => TRM.WrapTypeable f

121+ TRM.WrapTypeable f ->

122− -> TRM.WrapTypeable f

122+ TRM.WrapTypeable f ->

123− -> Ordering

123+ Ordering

124 compareW (TRM.WrapTypeable (x :: f a)) (TRM.WrapTypeable (y :: f b))

125 | Just Refl <- testEquality (typeRep @a) (typeRep @b) = compare x y

126 | otherwise = EQ -- unreachable

@@ -172,10 +172,10 @@ instance Monoid (ASet a) where

172 mempty = AnEmptySet

173

174data AStep (q :: k -> k -> Type) (f :: k -> Type) (r :: k) (a :: k) where

175− AStep

175+ AStep ::

176− :: NiceQuiver q r a =>

176+ NiceQuiver q r a =>

177− !(M.Map (q r a) (PathsPrefixTree q f a))

177+ !(M.Map (q r a) (PathsPrefixTree q f a)) ->

178− -> AStep q f r a

178+ AStep q f r a

179

180mapAStep :: (forall x. f x -> f x) -> AStep q f r a -> AStep q f r a

181mapAStep f (AStep m) = AStep $ M.map (map f) m

@@ -215,12 +215,12 @@ null :: PathsPrefixTree q f r -> Bool

215null (PathsPrefixTree AnEmptySet s) = all (\(TRM.WrapTypeable (AStep x)) -> all null x) (Exts.toList s)

216null _ = False

217

218−foldWith

218+foldWith ::

219− :: forall q f m r.

219+ forall q f m r.

220− Monoid m

220+ Monoid m =>

221− => (forall a. Ord (f a) => Paths q r a -> f a -> m)

221+ (forall a. Ord (f a) => Paths q r a -> f a -> m) ->

222− -> PathsPrefixTree q f r

222+ PathsPrefixTree q f r ->

223− -> m

223+ m

224foldWith k = goTPT Root

225 where

226 goTPT :: forall a. Paths q r a -> PathsPrefixTree q f a -> m

src/OpenAPI/Checker/References.hs → src/Data/OpenApi/Compare/References.hsrenamed+11−12

@@ -1,9 +1,9 @@

1{-# OPTIONS_GHC -Wno-orphans #-}

2

3−module OpenAPI.Checker.References

3+module Data.OpenApi.Compare.References

4− ( Step (..)

4+ ( Step (..),

5− , dereference

5+ dereference,

6− , Typeable

6+ Typeable,

7 )

8where

9

@@ -11,19 +11,18 @@ import Data.HList

11import qualified Data.HashMap.Strict.InsOrd as IOHM

12import Data.Maybe

13import Data.OpenApi

14−import Data.Typeable

14+import Data.OpenApi.Compare.Orphans ()

15−import OpenAPI.Checker.Orphans ()

16−import OpenAPI.Checker.Subtree

15+import Data.OpenApi.Compare.Subtree

17

16

18instance Typeable a => Steppable (Referenced a) a where

17instance Typeable a => Steppable (Referenced a) a where

19 data Step (Referenced a) a = InlineStep

18 data Step (Referenced a) a = InlineStep

20 deriving stock (Eq, Ord, Show)

19 deriving stock (Eq, Ord, Show)

21

20

22−dereference

21+dereference ::

23− :: Typeable a

22+ Typeable a =>

24− => Traced (Definitions a)

23+ Traced (Definitions a) ->

25− -> Traced (Referenced a)

24+ Traced (Referenced a) ->

26− -> Traced a

25+ Traced a

27dereference defs x = case extract x of

26dereference defs x = case extract x of

28 Inline a ->

27 Inline a ->

29 traced (ask x >>> step InlineStep) a

28 traced (ask x >>> step InlineStep) a

src/OpenAPI/Checker/Report.hs → src/Data/OpenApi/Compare/Report.hsrenamed+152−131

@@ -1,13 +1,13 @@

1−module OpenAPI.Checker.Report

1+module Data.OpenApi.Compare.Report

2− ( generateReport

2+ ( generateReport,

3− , CheckerOutput(..)

3+ CheckerOutput (..),

4− , ReportInput (..)

4+ ReportInput (..),

5− , segregateIssues

5+ segregateIssues,

6− , ReportStatus (..)

6+ ReportStatus (..),

7− , Pandoc

7+ Pandoc,

8− , ReportConfig (..)

8+ ReportConfig (..),

9− , ReportTreeStyle (..)

9+ ReportTreeStyle (..),

10− , ReportMode (..)

10+ ReportMode (..),

11 )

12where

13

@@ -23,6 +23,15 @@ import qualified Data.Map as M

23import Data.Map.Ordered (OMap)

24import qualified Data.Map.Ordered as OM

25import Data.Maybe

26+import Data.OpenApi.Compare.Behavior

27+import Data.OpenApi.Compare.Paths

28+import Data.OpenApi.Compare.PathsPrefixTree hiding (empty)

29+import qualified Data.OpenApi.Compare.PathsPrefixTree as P hiding (empty)

30+import Data.OpenApi.Compare.Report.Jet

31+import Data.OpenApi.Compare.Subtree (invertIssueOrientationP)

32+import Data.OpenApi.Compare.Validate.OpenApi

33+import Data.OpenApi.Compare.Validate.Schema.Issues

34+import Data.OpenApi.Compare.Validate.Schema.TypedJson

26import Data.OpenUnion

35import Data.OpenUnion

27import Data.OpenUnion.Extra

36import Data.OpenUnion.Extra

28import Data.Set

37import Data.Set

@@ -32,15 +41,6 @@ import qualified Data.Text as T

32import Data.TypeRepMap hiding (empty)

41import Data.TypeRepMap hiding (empty)

33import Data.Typeable

42import Data.Typeable

34import Generic.Data

43import Generic.Data

35−import OpenAPI.Checker.Behavior

36−import OpenAPI.Checker.Paths

37−import OpenAPI.Checker.PathsPrefixTree hiding (empty)

38−import qualified OpenAPI.Checker.PathsPrefixTree as P hiding (empty)

39−import OpenAPI.Checker.Report.Jet

40−import OpenAPI.Checker.Subtree (invertIssueOrientationP)

41−import OpenAPI.Checker.Validate.OpenApi

42−import OpenAPI.Checker.Validate.Schema.TypedJson

43−import OpenAPI.Checker.Validate.Schema.Issues

44import Text.Pandoc.Builder

45

46type Changes = P.PathsPrefixTree Behave AnIssue 'APILevel

@@ -54,22 +54,27 @@ data CheckerOutput = CheckerOutput

54 deriving anyclass (ToJSON)

55

56data ReportInput = ReportInput

57+ { -- | forward 'CertainIssue', 'ProbablyIssue' and 'Comment'

57− { breakingChanges :: Changes -- ^ forward 'CertainIssue', 'ProbablyIssue' and 'Comment'

58+ breakingChanges :: Changes

58− , nonBreakingChanges :: Changes -- ^ backward 'CertainIssue', 'ProbablyIssue' and 'Comment', except those shadowed by 'relatedIssues'

59+ , -- | backward 'CertainIssue', 'ProbablyIssue' and 'Comment', except those shadowed by 'relatedIssues'

60+ nonBreakingChanges :: Changes

61+ , -- | forward and backward 'Unsupported' (assumed to be the same anyway)

59− , unsupportedChanges :: Changes -- ^ forward and backward 'Unsupported' (assumed to be the same anyway)

62+ unsupportedChanges :: Changes

60− , schemaIssues :: Changes -- ^ forward and backward 'SchemaInvalid' (assumed to be the same anyway)

63+ , -- | forward and backward 'SchemaInvalid' (assumed to be the same anyway)

64+ schemaIssues :: Changes

61 }

65 }

62 deriving stock (Generic)

66 deriving stock (Generic)

63 deriving (Semigroup, Monoid) via (Generically ReportInput)

67 deriving (Semigroup, Monoid) via (Generically ReportInput)

64 deriving anyclass (ToJSON)

68 deriving anyclass (ToJSON)

65

69

66segregateIssues :: CheckerOutput -> ReportInput

70segregateIssues :: CheckerOutput -> ReportInput

67−segregateIssues CheckerOutput {forwardChanges = fwd, backwardChanges = bck} = ReportInput

71+segregateIssues CheckerOutput {forwardChanges = fwd, backwardChanges = bck} =

72+ ReportInput

68− { breakingChanges = P.filter isBreaking fwd

73+ { breakingChanges = P.filter isBreaking fwd

69− , nonBreakingChanges = invertIssueOrientationP $ P.filterWithKey isNonBreaking bck

74+ , nonBreakingChanges = invertIssueOrientationP $ P.filterWithKey isNonBreaking bck

70− , unsupportedChanges = P.filter isUnsupported fwd <> P.filter isUnsupported bck

75+ , unsupportedChanges = P.filter isUnsupported fwd <> P.filter isUnsupported bck

71− , schemaIssues = P.filter isSchemaIssue fwd <> P.filter isSchemaIssue bck

76+ , schemaIssues = P.filter isSchemaIssue fwd <> P.filter isSchemaIssue bck

72− }

77+ }

73 where

78 where

74 isBreaking i = anIssueKind i `elem` [CertainIssue, ProbablyIssue, Comment]

79 isBreaking i = anIssueKind i `elem` [CertainIssue, ProbablyIssue, Comment]

75 isNonBreaking :: Paths Behave 'APILevel a -> AnIssue a -> Bool

80 isNonBreaking :: Paths Behave 'APILevel a -> AnIssue a -> Bool

@@ -104,10 +109,9 @@ data ReportTreeStyle = HeadersTreeStyle | FoldingBlockquotesTreeStyle

104twoRowTable :: [(Inlines, Inlines)] -> Blocks

109twoRowTable :: [(Inlines, Inlines)] -> Blocks

105twoRowTable x = simpleTable (para . fst <$> x) [para . snd <$> x]

110twoRowTable x = simpleTable (para . fst <$> x) [para . snd <$> x]

106

111

107−generateReport :: ReportConfig -> ReportInput -> (Pandoc, ReportStatus)

112+generateReport :: ReportConfig -> ReportInput -> (Blocks, ReportStatus)

108generateReport cfg inp =

113generateReport cfg inp =

109− let

110− schemaIssuesPresent = not $ P.null $ schemaIssues inp

114+ let schemaIssuesPresent = not $ P.null $ schemaIssues inp

111 breakingChangesPresent = not $ P.null $ breakingChanges inp

115 breakingChangesPresent = not $ P.null $ breakingChanges inp

112 nonBreakingChangesPresent = not $ P.null $ nonBreakingChanges inp

116 nonBreakingChangesPresent = not $ P.null $ nonBreakingChanges inp

113 unsupportedChangesPresent = not $ P.null $ unsupportedChanges inp

117 unsupportedChangesPresent = not $ P.null $ unsupportedChanges inp

@@ -116,46 +120,55 @@ generateReport cfg inp =

116 OnlyErrors -> False

120 OnlyErrors -> False

117 builder = buildReport cfg

121 builder = buildReport cfg

118 report =

122 report =

119− doc $

120− header 1 "Summary"

123+ header 1 "Summary"

121− <> twoRowTable

124+ <> twoRowTable

122− (when'

125+ ( when'

123− schemaIssuesPresent

126+ schemaIssuesPresent

127+ [

124− [ ( refOpt schemaIssuesPresent schemaIssuesId "❌ Schema issues"

128+ ( refOpt schemaIssuesPresent schemaIssuesId "‼️ Schema issues"

125− , show' $ P.size $ schemaIssues inp

129+ , show' $ P.size $ schemaIssues inp

126− )

130+ )

127− ]

131+ ]

128− ++

132+ ++ [

129− [ ( refOpt breakingChangesPresent breakingChangesId "⚠️ Breaking changes"

133+ ( refOpt breakingChangesPresent breakingChangesId "❌ Breaking changes"

130 , show' $ P.size $ breakingChanges inp

134 , show' $ P.size $ breakingChanges inp

131 )

135 )

132 ]

136 ]

133− ++ when'

137+ ++ when'

134− nonBreakingChangesShown

138+ nonBreakingChangesShown

139+ [

135− [ ( refOpt nonBreakingChangesPresent nonBreakingChangesId "🙆 Non-breaking changes"

140+ ( refOpt nonBreakingChangesPresent nonBreakingChangesId "⚠️ Non-breaking changes"

136− , show' $ P.size $ nonBreakingChanges inp

141+ , show' $ P.size $ nonBreakingChanges inp

137− )

142+ )

138− ]

143+ ]

144+ ++ when'

145+ unsupportedChangesPresent

146+ [

139− ++ [ ( refOpt unsupportedChangesPresent unsupportedChangesId "🤷 Unsupported feature changes"

147+ ( refOpt unsupportedChangesPresent unsupportedChangesId "❓ Unsupported feature changes"

140− , show' $ P.size $ unsupportedChanges inp

148+ , show' $ P.size $ unsupportedChanges inp

141− )

149+ )

142− ])

150+ ]

151+ )

143− <> when'

152+ <> when'

144− schemaIssuesPresent

153+ schemaIssuesPresent

145− (header 1 (anchor schemaIssuesId <> "❌ Schema issues")

154+ ( header 1 (anchor schemaIssuesId <> "‼️ Schema issues")

146− <> builder (showErrs $ schemaIssues inp))

155+ <> builder (showErrs $ schemaIssues inp)

156+ )

147− <> when'

157+ <> when'

148− breakingChangesPresent

158+ breakingChangesPresent

149− (header 1 (anchor breakingChangesId <> "⚠️ Breaking changes")

159+ ( header 1 (anchor breakingChangesId <> "❌ Breaking changes")

150− <> builder (showErrs $ breakingChanges inp))

160+ <> builder (showErrs $ breakingChanges inp)

161+ )

151− <> when'

162+ <> when'

152− (nonBreakingChangesPresent && nonBreakingChangesShown)

163+ (nonBreakingChangesPresent && nonBreakingChangesShown)

153− (header 1 (anchor nonBreakingChangesId <> "🙆 Non-breaking changes")

164+ ( header 1 (anchor nonBreakingChangesId <> "⚠️ Non-breaking changes")

154− <> builder (showErrs $ nonBreakingChanges inp))

165+ <> builder (showErrs $ nonBreakingChanges inp)

166+ )

155− <> when'

167+ <> when'

156− unsupportedChangesPresent

168+ unsupportedChangesPresent

157− (header 1 (anchor unsupportedChangesId <> "🤷 Unsupported feature changes")

169+ ( header 1 (anchor unsupportedChangesId <> "❓ Unsupported feature changes")

158− <> builder (showErrs $ unsupportedChanges inp))

170+ <> builder (showErrs $ unsupportedChanges inp)

171+ )

159 status =

172 status =

160 if

173 if

161 | breakingChangesPresent -> BreakingChanges

174 | breakingChangesPresent -> BreakingChanges

@@ -185,13 +198,14 @@ showErrs x@(P.PathsPrefixNode currentIssues _) =

185 let -- Extract this pattern if more cases like this arise

198 let -- Extract this pattern if more cases like this arise

186 ( removedPaths :: Maybe (Orientation, [Issue 'APILevel])

199 ( removedPaths :: Maybe (Orientation, [Issue 'APILevel])

187 , otherIssues :: Set (AnIssue a)

200 , otherIssues :: Set (AnIssue a)

188− ) = case eqT @a @'APILevel of

201+ ) = case eqT @a @ 'APILevel of

189 Just Refl

202 Just Refl

190 | (S.toList -> p@((AnIssue ori _) : _), o) <-

203 | (S.toList -> p@((AnIssue ori _) : _), o) <-

191 S.partition

204 S.partition

192− (\((AnIssue _ u)) -> case u of

205+ ( \((AnIssue _ u)) -> case u of

193− NoPathsMatched {} -> True

206+ NoPathsMatched {} -> True

194− AllPathsFailed {} -> True)

207+ AllPathsFailed {} -> True

208+ )

195 currentIssues ->

209 currentIssues ->

196 let p' = p <&> (\(AnIssue _ i) -> i)

210 let p' = p <&> (\(AnIssue _ i) -> i)

197 in (Just (ori, p'), o)

211 in (Just (ori, p'), o)

@@ -202,9 +216,10 @@ showErrs x@(P.PathsPrefixNode currentIssues _) =

202 paths = case removedPaths of

216 paths = case removedPaths of

203 Just (ori, ps) -> do

217 Just (ori, ps) -> do

204 singletonHeader

218 singletonHeader

205− (case ori of

219+ ( case ori of

206− Forward -> "Removed paths"

220+ Forward -> "Removed paths"

207− Backward -> "Added paths")

221+ Backward -> "Added paths"

222+ )

208 $ singletonBody $

223 $ singletonBody $

209 bulletList $

224 bulletList $

210 ps <&> \case

225 ps <&> \case

@@ -240,60 +255,62 @@ jets =

240 , constructReportJet $ \p@(AtPath _) op@(InOperation _) ->

255 , constructReportJet $ \p@(AtPath _) op@(InOperation _) ->

241 strong (describeBehavior op) <> " " <> describeBehavior p :: Inlines

256 strong (describeBehavior op) <> " " <> describeBehavior p :: Inlines

242 , constructReportJet $ \(WithStatusCode c) ResponsePayload PayloadSchema ->

257 , constructReportJet $ \(WithStatusCode c) ResponsePayload PayloadSchema ->

243− "📱⬅️ JSON Response – " <> str (T.pack . show $ c) :: Inlines

258+ "⬅️☁️ JSON Response – " <> str (T.pack . show $ c) :: Inlines

244− , constructReportJet $ \InRequest InPayload PayloadSchema -> "📱➡️ JSON Request" :: Inlines

259+ , constructReportJet $ \InRequest InPayload PayloadSchema -> "➡️☁️ JSON Request" :: Inlines

245 ]

260 ]

246 where

261 where

247 unwrapReportJetResult :: ReportJetResult Behave x -> ReportJet' Behave x

262 unwrapReportJetResult :: ReportJetResult Behave x -> ReportJet' Behave x

248 unwrapReportJetResult (Pure _) = error "There really shouldn't be any results here."

263 unwrapReportJetResult (Pure _) = error "There really shouldn't be any results here."

249 unwrapReportJetResult (Free f) = f

264 unwrapReportJetResult (Free f) = f

250

265

251− jsonPathJet

266+ jsonPathJet ::

252− :: NonEmpty

267+ NonEmpty

253− ( Union

268+ ( Union

254− '[ Behave 'SchemaLevel 'TypedSchemaLevel

269+ '[ Behave 'SchemaLevel 'TypedSchemaLevel

255− , Behave 'TypedSchemaLevel 'SchemaLevel

270+ , Behave 'TypedSchemaLevel 'SchemaLevel

256− ]

271+ ]

257− )

272+ ) ->

258− -> Inlines

273+ Inlines

259 jsonPathJet x = code $ "$" <> showParts (NE.toList x)

274 jsonPathJet x = code $ "$" <> showParts (NE.toList x)

260 where

275 where

261− showParts

276+ showParts ::

262− :: [ Union

277+ [ Union

263− '[ Behave 'SchemaLevel 'TypedSchemaLevel

278+ '[ Behave 'SchemaLevel 'TypedSchemaLevel

264− , Behave 'TypedSchemaLevel 'SchemaLevel

279+ , Behave 'TypedSchemaLevel 'SchemaLevel

265− ]

266− ]

280+ ]

281+ ] ->

267− -> Text

282+ Text

268 showParts [] = mempty

283 showParts [] = mempty

269 showParts (SingletonUnion (OfType Object) : xs@((SingletonUnion (InProperty _)) : _)) = showParts xs

284 showParts (SingletonUnion (OfType Object) : xs@((SingletonUnion (InProperty _)) : _)) = showParts xs

270 showParts (SingletonUnion (OfType Object) : xs@((SingletonUnion InAdditionalProperty) : _)) = showParts xs

285 showParts (SingletonUnion (OfType Object) : xs@((SingletonUnion InAdditionalProperty) : _)) = showParts xs

271 showParts (SingletonUnion (OfType Array) : xs@(SingletonUnion InItems : _)) = showParts xs

286 showParts (SingletonUnion (OfType Array) : xs@(SingletonUnion InItems : _)) = showParts xs

272 showParts (SingletonUnion (OfType Array) : xs@(SingletonUnion (InItem _) : _)) = showParts xs

287 showParts (SingletonUnion (OfType Array) : xs@(SingletonUnion (InItem _) : _)) = showParts xs

273 showParts (y : ys) =

288 showParts (y : ys) =

274− ((\(OfType t) -> "(" <> describeJSONType t <> ")")

289+ ( (\(OfType t) -> "(" <> describeJSONType t <> ")")

275− @@> (\case

290+ @@> ( \case

276− InItems -> "[*]"

291+ InItems -> "[*]"

277− InItem i -> "[" <> T.pack (show i) <> "]"

292+ InItem i -> "[" <> T.pack (show i) <> "]"

278− InProperty p -> "." <> p

293+ InProperty p -> "." <> p

279− InAdditionalProperty -> ".*")

294+ InAdditionalProperty -> ".*"

295+ )

280− @@> typesExhausted)

296+ @@> typesExhausted

297+ )

281 y

298 y

282 <> showParts ys

299 <> showParts ys

283

300

284−observeJetShowErrs

301+observeJetShowErrs ::

285− :: ReportJet' Behave (Maybe Inlines)

302+ ReportJet' Behave (Maybe Inlines) ->

286− -> P.PathsPrefixTree Behave AnIssue a

303+ P.PathsPrefixTree Behave AnIssue a ->

287− -> (Report, P.PathsPrefixTree Behave AnIssue a)

304+ (Report, P.PathsPrefixTree Behave AnIssue a)

288observeJetShowErrs jet p = case observeJetShowErrs' jet p of

305observeJetShowErrs jet p = case observeJetShowErrs' jet p of

289 Just m -> m

306 Just m -> m

290 Nothing -> (mempty, p)

307 Nothing -> (mempty, p)

291

308

292−observeJetShowErrs'

309+observeJetShowErrs' ::

293− :: forall a.

310+ forall a.

294− ReportJet' Behave (Maybe Inlines)

311+ ReportJet' Behave (Maybe Inlines) ->

295− -> P.PathsPrefixTree Behave AnIssue a

312+ P.PathsPrefixTree Behave AnIssue a ->

296− -> Maybe (Report, P.PathsPrefixTree Behave AnIssue a)

313+ Maybe (Report, P.PathsPrefixTree Behave AnIssue a)

297observeJetShowErrs' (ReportJet jet) (P.PathsPrefixNode currentIssues subIssues) =

314observeJetShowErrs' (ReportJet jet) (P.PathsPrefixNode currentIssues subIssues) =

298 let results =

315 let results =

299 subIssues >>= \(WrapTypeable (AStep m)) ->

316 subIssues >>= \(WrapTypeable (AStep m)) ->

@@ -301,21 +318,23 @@ observeJetShowErrs' (ReportJet jet) (P.PathsPrefixNode currentIssues subIssues)

301 maybe (Left $ embed (step bhv) subErrs) Right . listToMaybe $

318 maybe (Left $ embed (step bhv) subErrs) Right . listToMaybe $

302 jet @_ @_ @[] bhv

319 jet @_ @_ @[] bhv

303 & mapMaybe

320 & mapMaybe

304− (\case

321+ ( \case

305− Free jet' -> fmap (embed $ step bhv) <$> observeJetShowErrs' jet' subErrs

322+ Free jet' -> fmap (embed $ step bhv) <$> observeJetShowErrs' jet' subErrs

306− Pure (Just h) ->

323+ Pure (Just h) ->

307− if P.null subErrs

324+ if P.null subErrs

308− then Just mempty

325+ then Just mempty

309− else Just (singletonHeader h (showErrs subErrs), mempty)

326+ else Just (singletonHeader h (showErrs subErrs), mempty)

310− Pure Nothing -> Nothing)

327+ Pure Nothing -> Nothing

328+ )

311 in (fmap . fmap) (PathsPrefixNode currentIssues mempty <>) $

329 in (fmap . fmap) (PathsPrefixNode currentIssues mempty <>) $

312 if any isRight results

330 if any isRight results

313 then

331 then

314 Just $

332 Just $

315 foldMap

333 foldMap

316− (\case

334+ ( \case

317− Left e -> (mempty, e)

335+ Left e -> (mempty, e)

318− Right m -> m)

336+ Right m -> m

337+ )

319 results

338 results

320 else Nothing

339 else Nothing

321

340

@@ -338,8 +357,9 @@ buildReport cfg = case treeStyle cfg of

338 body rprt

357 body rprt

339 <> foldOMapWithKey

358 <> foldOMapWithKey

340 (headers rprt)

359 (headers rprt)

341− (\k v ->

360+ ( \k v ->

342− header level k <> subBuilder v)

361+ header level k <> subBuilder v

362+ )

343 where

363 where

344 subBuilder = headerStyleBuilder (level + 1)

364 subBuilder = headerStyleBuilder (level + 1)

345

365

@@ -348,16 +368,17 @@ buildReport cfg = case treeStyle cfg of

348 body rprt

368 body rprt

349 <> foldOMapWithKey

369 <> foldOMapWithKey

350 (headers rprt)

370 (headers rprt)

351− (\k v ->

371+ ( \k v ->

352− if (OM.size . headers $ rprt) < 2

372+ if (OM.size . headers $ rprt) < 2

353− then para k <> blockQuote (subBuilder v)

373+ then para k <> blockQuote (subBuilder v)

354− else

374+ else

355− rawHtml "<details>"

375+ rawHtml "<details>"

356− <> rawHtml "<summary>"

376+ <> rawHtml "<summary>"

357− <> plain k

377+ <> plain k

358− <> rawHtml "</summary>"

378+ <> rawHtml "</summary>"

359− <> blockQuote (subBuilder v)

379+ <> blockQuote (subBuilder v)

360− <> rawHtml "</details>")

380+ <> rawHtml "</details>"

381+ )

361 where

382 where

362 subBuilder = foldingStyleBuilder

383 subBuilder = foldingStyleBuilder

363

384

src/OpenAPI/Checker/Report/Html/Template.hs → src/Data/OpenApi/Compare/Report/Html/Template.hsrenamed+4−4

@@ -1,7 +1,7 @@

1{-# LANGUAGE TemplateHaskell #-}

2

3−module OpenAPI.Checker.Report.Html.Template

3+module Data.OpenApi.Compare.Report.Html.Template

4− ( template

4+ ( template,

5 )

6where

7

@@ -24,11 +24,11 @@ template =

24 \<meta charset=\"utf-8\">\

25 \<title></title>\

26 \<meta name=\"description\" content=\"\">\

27− \<meta name=\"generator\" content=\"OpenApi Diff\" />\

27+ \<meta name=\"generator\" content=\"CompaREST\" />\

28 \<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0, user-scalable=yes\" />\

29 \</head>\

30 \<body>\

31− \<header><h1>⛄ OpenApi Diff</h1></header>\

31+ \<header><h1>CompaREST</h1></header>\

32 \<main>\

33 \$body$\

34 \</main>\

src/OpenAPI/Checker/Report/Jet.hs → src/Data/OpenApi/Compare/Report/Jet.hsrenamed+5−5

@@ -1,8 +1,8 @@

1−module OpenAPI.Checker.Report.Jet

1+module Data.OpenApi.Compare.Report.Jet

2− ( ReportJet (..)

2+ ( ReportJet (..),

3− , ReportJet'

3+ ReportJet',

4− , ConstructReportJet (..)

4+ ConstructReportJet (..),

5− , ReportJetResult

5+ ReportJetResult,

6 )

7where

8

src/OpenAPI/Checker/Run.hs → src/Data/OpenApi/Compare/Run.hsrenamed+10−9

@@ -1,16 +1,17 @@

1−module OpenAPI.Checker.Run

1+module Data.OpenApi.Compare.Run

2− ( runChecker

2+ ( runChecker,

3− , runReport

3+ runReport,

4− , module OpenAPI.Checker.Report

4+ module Data.OpenApi.Compare.Report,

5 )

6where

7

8import Data.HList

9import Data.OpenApi (OpenApi)

10−import OpenAPI.Checker.Paths

10+import Data.OpenApi.Compare.Paths

11−import OpenAPI.Checker.Report

11+import Data.OpenApi.Compare.Report

12−import OpenAPI.Checker.Subtree

12+import Data.OpenApi.Compare.Subtree

13−import OpenAPI.Checker.Validate.OpenApi ()

13+import Data.OpenApi.Compare.Validate.OpenApi ()

14+import Text.Pandoc.Builder

14

15

15runChecker :: (OpenApi, OpenApi) -> CheckerOutput

16runChecker :: (OpenApi, OpenApi) -> CheckerOutput

16runChecker (client, server) =

17runChecker (client, server) =

@@ -26,5 +27,5 @@ runChecker (client, server) =

26 }

27 }

27 run p c = either id mempty . runCompatFormula . checkCompatibility Root HNil $ toPC p c

28 run p c = either id mempty . runCompatFormula . checkCompatibility Root HNil $ toPC p c

28

29

29−runReport :: ReportConfig -> (OpenApi, OpenApi) -> (Pandoc, ReportStatus)

30+runReport :: ReportConfig -> (OpenApi, OpenApi) -> (Blocks, ReportStatus)

30runReport cfg = generateReport cfg . segregateIssues . runChecker

31runReport cfg = generateReport cfg . segregateIssues . runChecker

src/OpenAPI/Checker/Subtree.hs → src/Data/OpenApi/Compare/Subtree.hsrenamed+128−126

@@ -1,52 +1,52 @@

1{-# OPTIONS_GHC -Wno-orphans #-}

2

3−module OpenAPI.Checker.Subtree

3+module Data.OpenApi.Compare.Subtree

4− ( Steppable (..)

4+ ( Steppable (..),

5− , Step (..)

5+ Step (..),

6− , TraceRoot

6+ TraceRoot,

7− , Trace

7+ Trace,

8− , Traced

8+ Traced,

9− , Traced'

9+ Traced',

10− , pattern Traced

10+ pattern Traced,

11− , traced

11+ traced,

12− , retraced

12+ retraced,

13− , stepTraced

13+ stepTraced,

14− , Subtree (..)

14+ Subtree (..),

15− , checkCompatibility

15+ checkCompatibility,

16− , checkSubstructure

16+ checkSubstructure,

17− , CompatM (..)

17+ CompatM (..),

18− , CompatFormula'

18+ CompatFormula',

19− , SemanticCompatFormula

19+ SemanticCompatFormula,

20− , ProdCons (..)

20+ ProdCons (..),

21− , orientProdCons

21+ orientProdCons,

22− , swapProdCons

22+ swapProdCons,

23− , runCompatFormula

23+ runCompatFormula,

24− , issueAt

24+ issueAt,

25− , anItem

25+ anItem,

26− , anIssue

26+ anIssue,

27− , invertIssueOrientation

27+ invertIssueOrientation,

28− , invertIssueOrientationP

28+ invertIssueOrientationP,

29− , embedFormula

29+ embedFormula,

30− , anyOfAt

30+ anyOfAt,

31− , clarifyIssue

31+ clarifyIssue,

32− , structuralIssue

32+ structuralIssue,

33

34 -- * Structural helpers

35− , structuralMaybe

35+ structuralMaybe,

36− , structuralMaybeWith

36+ structuralMaybeWith,

37− , structuralEq

37+ structuralEq,

38− , iohmStructural

38+ iohmStructural,

39− , iohmStructuralWith

39+ iohmStructuralWith,

40− , structuralList

40+ structuralList,

41

42 -- * Reexports

43− , (>>>)

43+ (>>>),

44− , (<<<)

44+ (<<<),

45− , extract

45+ extract,

46− , ask

46+ ask,

47− , local

47+ local,

48− , step

48+ step,

49− , Typeable

49+ Typeable,

50 )

51where

52

@@ -60,13 +60,13 @@ import qualified Data.HashMap.Strict.InsOrd as IOHM

60import Data.Hashable

61import Data.Kind

62import Data.OpenApi

63+import Data.OpenApi.Compare.Behavior

64+import Data.OpenApi.Compare.Formula

65+import Data.OpenApi.Compare.Memo

66+import Data.OpenApi.Compare.Paths

67+import qualified Data.OpenApi.Compare.PathsPrefixTree as P

63import qualified Data.Set as S

68import qualified Data.Set as S

64import Data.Typeable

69import Data.Typeable

65−import OpenAPI.Checker.Behavior

66−import OpenAPI.Checker.Formula

67−import OpenAPI.Checker.Memo

68−import OpenAPI.Checker.Paths

69−import qualified OpenAPI.Checker.PathsPrefixTree as P

70

71class

72 (Typeable Step, Typeable a, Typeable b, Ord (Step a b), Show (Step a b)) =>

@@ -115,10 +115,10 @@ orientProdCons :: Orientation -> ProdCons x -> ProdCons x

115orientProdCons Forward x = x

116orientProdCons Backward (ProdCons p c) = ProdCons c p

117

118−swapProdCons

118+swapProdCons ::

119− :: SwapEnvRoles xs

119+ SwapEnvRoles xs =>

120− => (HList xs -> ProdCons x -> CompatFormula' q AnIssue r a)

120+ (HList xs -> ProdCons x -> CompatFormula' q AnIssue r a) ->

121− -> (HList xs -> ProdCons x -> CompatFormula' q AnIssue r a)

121+ (HList xs -> ProdCons x -> CompatFormula' q AnIssue r a)

122swapProdCons f e (ProdCons p c) =

123 invertIssueOrientation $

124 f (swapEnvRoles e) (ProdCons c p)

@@ -153,8 +153,8 @@ instance Applicative ProdCons where

153 ProdCons fp fc <*> ProdCons xp xc = ProdCons (fp xp) (fc xc)

154

155newtype CompatM a = CompatM

156− { unCompatM

156+ { unCompatM ::

157− :: StateT (MemoState VarRef) Identity a

157+ StateT (MemoState VarRef) Identity a

158 }

159 deriving newtype

160 ( Functor

@@ -183,64 +183,64 @@ class (Typeable t, Issuable (SubtreeLevel t)) => Subtree (t :: Type) where

183 type CheckEnv t :: [Type]

184 type SubtreeLevel t :: BehaviorLevel

185

186− checkStructuralCompatibility

186+ checkStructuralCompatibility ::

187− :: HList (CheckEnv t)

187+ HList (CheckEnv t) ->

188− -> ProdCons (Traced t)

188+ ProdCons (Traced t) ->

189− -> StructuralCompatFormula ()

189+ StructuralCompatFormula ()

190

191− checkSemanticCompatibility

191+ checkSemanticCompatibility ::

192− :: HList (CheckEnv t)

192+ HList (CheckEnv t) ->

193− -> Behavior (SubtreeLevel t)

193+ Behavior (SubtreeLevel t) ->

194− -> ProdCons (Traced t)

194+ ProdCons (Traced t) ->

195− -> SemanticCompatFormula ()

195+ SemanticCompatFormula ()

196

197{-# WARNING checkStructuralCompatibility "You should not be calling this directly. Use 'checkSubstructure'" #-}

198

199{-# WARNING checkSemanticCompatibility "You should not be calling this directly. Use 'checkCompatibility'" #-}

200

201−checkCompatibility

201+checkCompatibility ::

202− :: forall t xs.

202+ forall t xs.

203− (ReassembleHList xs (CheckEnv t), Subtree t)

203+ (ReassembleHList xs (CheckEnv t), Subtree t) =>

204− => Behavior (SubtreeLevel t)

204+ Behavior (SubtreeLevel t) ->

205− -> HList xs

205+ HList xs ->

206− -> ProdCons (Traced t)

206+ ProdCons (Traced t) ->

207− -> SemanticCompatFormula ()

207+ SemanticCompatFormula ()

208checkCompatibility bhv e = memo bhv SemanticMemoKey $ \pc ->

209 case runCompatFormula $ checkSubstructure e pc of

210 Left _ -> checkSemanticCompatibility (reassemble e) bhv pc

211 Right () -> pure ()

212{-# INLINE checkCompatibility #-}

213

214−checkSubstructure

214+checkSubstructure ::

215− :: (ReassembleHList xs (CheckEnv t), Subtree t)

215+ (ReassembleHList xs (CheckEnv t), Subtree t) =>

216− => HList xs

216+ HList xs ->

217− -> ProdCons (Traced t)

217+ ProdCons (Traced t) ->

218− -> StructuralCompatFormula ()

218+ StructuralCompatFormula ()

219checkSubstructure e = memo Root StructuralMemoKey $ checkStructuralCompatibility (reassemble e)

220{-# INLINE checkSubstructure #-}

221

222−structuralMaybe

222+structuralMaybe ::

223− :: (Subtree a, ReassembleHList xs (CheckEnv a))

223+ (Subtree a, ReassembleHList xs (CheckEnv a)) =>

224− => HList xs

224+ HList xs ->

225− -> ProdCons (Maybe (Traced a))

225+ ProdCons (Maybe (Traced a)) ->

226− -> StructuralCompatFormula ()

226+ StructuralCompatFormula ()

227structuralMaybe e = structuralMaybeWith (checkSubstructure e)

228{-# INLINE structuralMaybe #-}

229

230−structuralMaybeWith

230+structuralMaybeWith ::

231− :: (ProdCons a -> StructuralCompatFormula ())

231+ (ProdCons a -> StructuralCompatFormula ()) ->

232− -> ProdCons (Maybe a)

232+ ProdCons (Maybe a) ->

233− -> StructuralCompatFormula ()

233+ StructuralCompatFormula ()

234structuralMaybeWith f (ProdCons (Just a) (Just b)) = f $ ProdCons a b

235structuralMaybeWith _ (ProdCons Nothing Nothing) = pure ()

236structuralMaybeWith _ _ = structuralIssue

237{-# INLINE structuralMaybeWith #-}

238

239−structuralList

239+structuralList ::

240− :: (Subtree a, ReassembleHList xs (CheckEnv a))

240+ (Subtree a, ReassembleHList xs (CheckEnv a)) =>

241− => HList xs

241+ HList xs ->

242− -> ProdCons [Traced a]

242+ ProdCons [Traced a] ->

243− -> StructuralCompatFormula ()

243+ StructuralCompatFormula ()

244structuralList _ (ProdCons [] []) = pure ()

245structuralList e (ProdCons (a : aa) (b : bb)) = do

246 checkSubstructure e $ ProdCons a b

@@ -253,11 +253,11 @@ structuralEq :: (Eq a, Comonad w) => ProdCons (w a) -> StructuralCompatFormula (

253structuralEq (ProdCons a b) = if extract a == extract b then pure () else structuralIssue

254{-# INLINE structuralEq #-}

255

256−iohmStructural

256+iohmStructural ::

257− :: (ReassembleHList (k ': xs) (CheckEnv v), Ord k, Subtree v, Hashable k, Typeable k, Show k)

257+ (ReassembleHList (k ': xs) (CheckEnv v), Ord k, Subtree v, Hashable k, Typeable k, Show k) =>

258− => HList xs

258+ HList xs ->

259− -> ProdCons (Traced (IOHM.InsOrdHashMap k v))

259+ ProdCons (Traced (IOHM.InsOrdHashMap k v)) ->

260− -> StructuralCompatFormula ()

260+ StructuralCompatFormula ()

261iohmStructural e =

262 iohmStructuralWith (\k -> checkSubstructure (k `HCons` e))

263{-# INLINE iohmStructural #-}

@@ -266,25 +266,26 @@ instance (Typeable k, Typeable v, Ord k, Show k) => Steppable (IOHM.InsOrdHashMa

266 data Step (IOHM.InsOrdHashMap k v) v = InsOrdHashMapKeyStep k

267 deriving stock (Eq, Ord, Show)

268

269−iohmStructuralWith

269+iohmStructuralWith ::

270− :: (Ord k, Hashable k, Typeable k, Typeable v, Show k)

270+ (Ord k, Hashable k, Typeable k, Typeable v, Show k) =>

271− => (k -> ProdCons (Traced v) -> StructuralCompatFormula ())

271+ (k -> ProdCons (Traced v) -> StructuralCompatFormula ()) ->

272− -> ProdCons (Traced (IOHM.InsOrdHashMap k v))

272+ ProdCons (Traced (IOHM.InsOrdHashMap k v)) ->

273− -> StructuralCompatFormula ()

273+ StructuralCompatFormula ()

274iohmStructuralWith f pc = do

275 let ProdCons pEKeys cEKeys = S.fromList . IOHM.keys . extract <$> pc

276 if pEKeys == cEKeys

277 then

278 for_

279 pEKeys

280− (\eKey ->

280+ ( \eKey ->

281− f eKey $ stepTraced (InsOrdHashMapKeyStep eKey) . fmap (IOHM.lookupDefault (error "impossible") eKey) <$> pc)

281+ f eKey $ stepTraced (InsOrdHashMapKeyStep eKey) . fmap (IOHM.lookupDefault (error "impossible") eKey) <$> pc

282+ )

282 else structuralIssue

283 else structuralIssue

283{-# INLINE iohmStructuralWith #-}

284{-# INLINE iohmStructuralWith #-}

284

285

285−runCompatFormula

286+runCompatFormula ::

286− :: CompatFormula' q f r a

287+ CompatFormula' q f r a ->

287− -> Either (P.PathsPrefixTree q f r) a

288+ Either (P.PathsPrefixTree q f r) a

288runCompatFormula (Compose f) =

289runCompatFormula (Compose f) =

289 calculate . runIdentity . runMemo 0 . unCompatM $ f

290 calculate . runIdentity . runMemo 0 . unCompatM $ f

290{-# INLINE runCompatFormula #-}

291{-# INLINE runCompatFormula #-}

@@ -314,27 +315,27 @@ invertIssueOrientationP = P.map (\(AnIssue ori i) -> AnIssue (toggleOrientation

314structuralIssue :: StructuralCompatFormula a

315structuralIssue :: StructuralCompatFormula a

315structuralIssue = Compose $ pure $ anError $ AnItem Root Proxy

316structuralIssue = Compose $ pure $ anError $ AnItem Root Proxy

316

317

317−anyOfAt

318+anyOfAt ::

318− :: Issuable l

319+ Issuable l =>

319− => Paths q r l

320+ Paths q r l ->

320− -> Issue l

321+ Issue l ->

321− -> [CompatFormula' q AnIssue r a]

322+ [CompatFormula' q AnIssue r a] ->

322− -> CompatFormula' q AnIssue r a

323+ CompatFormula' q AnIssue r a

323anyOfAt _ _ [x] = x

324anyOfAt _ _ [x] = x

324anyOfAt xs issue fs =

325anyOfAt xs issue fs =

325 Compose $ (`eitherOf` AnItem xs (anIssue issue)) <$> traverse getCompose fs

326 Compose $ (`eitherOf` AnItem xs (anIssue issue)) <$> traverse getCompose fs

326

327

327-- | If the given formula contains any issues, add another issue on top. Otherwise succeed.

328-- | If the given formula contains any issues, add another issue on top. Otherwise succeed.

328−clarifyIssue

329+clarifyIssue ::

329− :: AnItem q AnIssue r

330+ AnItem q AnIssue r ->

330− -> CompatFormula' q AnIssue r a

331+ CompatFormula' q AnIssue r a ->

331− -> CompatFormula' q AnIssue r a

332+ CompatFormula' q AnIssue r a

332clarifyIssue item f =

333clarifyIssue item f =

333 Compose ((`eitherOf` item) <$> pure <$> getCompose f) *> f

334 Compose ((`eitherOf` item) <$> pure <$> getCompose f) *> f

334

335

335−fixpointKnot

336+fixpointKnot ::

336− :: MonadState (MemoState VarRef) m

337+ MonadState (MemoState VarRef) m =>

337− => KnotTier (FormulaF q f r ()) VarRef m

338+ KnotTier (FormulaF q f r ()) VarRef m

338fixpointKnot =

339fixpointKnot =

339 KnotTier

340 KnotTier

340 { onKnotFound = modifyMemoNonce succ

341 { onKnotFound = modifyMemoNonce succ

@@ -342,19 +343,20 @@ fixpointKnot =

342 , tieKnot = \i x -> pure $ maxFixpoint i x

343 , tieKnot = \i x -> pure $ maxFixpoint i x

343 }

344 }

344

345

345−memo

346+memo ::

346− :: (Typeable (l :: k), Typeable q, Typeable f, Typeable k, Typeable a)

347+ (Typeable (l :: k), Typeable q, Typeable f, Typeable k, Typeable a) =>

347− => Paths q r l

348+ Paths q r l ->

348− -> MemoKey

349+ MemoKey ->

349− -> (ProdCons (Traced a) -> CompatFormula' q f r ())

350+ (ProdCons (Traced a) -> CompatFormula' q f r ()) ->

350− -> (ProdCons (Traced a) -> CompatFormula' q f r ())

351+ (ProdCons (Traced a) -> CompatFormula' q f r ())

351memo bhv k f pc = Compose $ do

352memo bhv k f pc = Compose $ do

352 formula' <-

353 formula' <-

353 memoWithKnot

354 memoWithKnot

354 fixpointKnot

355 fixpointKnot

355− (do

356+ ( do

356− formula <- getCompose $ f pc

357+ formula <- getCompose $ f pc

357− pure $ mapErrors (P.takeSubtree bhv) formula)

358+ pure $ mapErrors (P.takeSubtree bhv) formula

359+ )

358 (k, ask <$> pc)

360 (k, ask <$> pc)

359 pure $ mapErrors (P.embed bhv) formula'

361 pure $ mapErrors (P.embed bhv) formula'

360

362

src/OpenAPI/Checker/Validate/Header.hs → src/Data/OpenApi/Compare/Validate/Header.hsrenamed+5−5

@@ -1,6 +1,6 @@

1{-# OPTIONS_GHC -Wno-orphans #-}

2

3−module OpenAPI.Checker.Validate.Header

3+module Data.OpenApi.Compare.Validate.Header

4 (

5 )

6where

@@ -9,10 +9,10 @@ import Data.Foldable

9import Data.Functor

10import Data.Maybe

11import Data.OpenApi

12−import OpenAPI.Checker.Behavior

12+import Data.OpenApi.Compare.Behavior

13−import OpenAPI.Checker.References ()

13+import Data.OpenApi.Compare.References ()

14−import OpenAPI.Checker.Subtree

14+import Data.OpenApi.Compare.Subtree

15−import OpenAPI.Checker.Validate.Schema ()

15+import Data.OpenApi.Compare.Validate.Schema ()

16import Text.Pandoc.Builder

17

18instance Subtree Header where

src/OpenAPI/Checker/Validate/Link.hs → src/Data/OpenApi/Compare/Validate/Link.hsrenamed+4−4

@@ -1,10 +1,10 @@

1{-# OPTIONS_GHC -Wno-orphans #-}

2

3−module OpenAPI.Checker.Validate.Link () where

3+module Data.OpenApi.Compare.Validate.Link () where

4

5import Data.OpenApi

6−import OpenAPI.Checker.Behavior

6+import Data.OpenApi.Compare.Behavior

7−import OpenAPI.Checker.Subtree

7+import Data.OpenApi.Compare.Subtree

8import Text.Pandoc.Builder

9

10instance Subtree Link where

@@ -19,4 +19,4 @@ instance Issuable 'LinkLevel where

19 deriving stock (Eq, Ord, Show)

20 issueKind = \case

21 LinksUnsupported -> Unsupported

22− describeIssue _ LinksUnsupported = para "OpenApi Diff does not currently support Link Objects."

22+ describeIssue _ LinksUnsupported = para "CompaREST does not currently support Link Objects."

src/OpenAPI/Checker/Validate/MediaTypeObject.hs → src/Data/OpenApi/Compare/Validate/MediaTypeObject.hsrenamed+10−10

@@ -1,8 +1,8 @@

1{-# OPTIONS_GHC -Wno-orphans #-}

2

3−module OpenAPI.Checker.Validate.MediaTypeObject

3+module Data.OpenApi.Compare.Validate.MediaTypeObject

4− ( Issue (..)

4+ ( Issue (..),

5− , Behave (..)

5+ Behave (..),

6 )

7where

8

@@ -12,15 +12,15 @@ import Data.HList

12import Data.HashMap.Strict.InsOrd as IOHM

13import Data.Map.Strict as M

14import Data.OpenApi

15+import Data.OpenApi.Compare.Behavior

16+import Data.OpenApi.Compare.Subtree

17+import Data.OpenApi.Compare.Validate.Header ()

18+import Data.OpenApi.Compare.Validate.Products

19+import Data.OpenApi.Compare.Validate.Schema ()

15import Data.String

20import Data.String

16import Data.Text (Text)

21import Data.Text (Text)

17import qualified Data.Text as T

22import qualified Data.Text as T

18import Network.HTTP.Media (MediaType, mainType, subType)

23import Network.HTTP.Media (MediaType, mainType, subType)

19−import OpenAPI.Checker.Behavior

20−import OpenAPI.Checker.Subtree

21−import OpenAPI.Checker.Validate.Header ()

22−import OpenAPI.Checker.Validate.Products

23−import OpenAPI.Checker.Validate.Schema ()

24import Text.Pandoc.Builder

25

26tracedSchema :: Traced MediaTypeObject -> Maybe (Traced (Referenced Schema))

@@ -45,7 +45,7 @@ instance Issuable 'PayloadLevel where

45 describeIssue _ MediaTypeSchemaRequired = para "Media type expected, but was not specified."

46 describeIssue Forward (MediaEncodingMissing enc) = para $ "Media encoding " <> str enc <> " has been removed."

47 describeIssue Backward (MediaEncodingMissing enc) = para $ "Media encoding " <> str enc <> " added."

48− describeIssue _ EncodingNotSupported = para "OpenApi Diff does not currently support media encodings other than JSON."

48+ describeIssue _ EncodingNotSupported = para "CompaREST does not currently support media encodings other than JSON."

49

50instance Behavable 'PayloadLevel 'SchemaLevel where

51 data Behave 'PayloadLevel 'SchemaLevel

@@ -119,7 +119,7 @@ instance Subtree Encoding where

119

120 -- FIXME: Support only JSON body for now. Then Encoding is checked only for

121 -- multipart/form-url-encoded

122− -- https://github.com/typeable/openapi-diff/issues/54

122+ -- #54

123 checkSemanticCompatibility _env beh _pc =

124 issueAt beh EncodingNotSupported

125

src/OpenAPI/Checker/Validate/OAuth2Flows.hs → src/Data/OpenApi/Compare/Validate/OAuth2Flows.hsrenamed+17−17

@@ -1,9 +1,9 @@

1{-# OPTIONS_GHC -Wno-orphans #-}

2

3−module OpenAPI.Checker.Validate.OAuth2Flows

3+module Data.OpenApi.Compare.Validate.OAuth2Flows

4− ( Step (..)

4+ ( Step (..),

5− , Issue (..)

5+ Issue (..),

6− , Behave (..)

6+ Behave (..),

7 )

8where

9

@@ -12,13 +12,13 @@ import Data.Function

12import Data.Functor

13import qualified Data.HashMap.Strict.InsOrd as IOHM

14import Data.OpenApi

15+import Data.OpenApi.Compare.Behavior

16+import Data.OpenApi.Compare.Orphans ()

17+import Data.OpenApi.Compare.Subtree

15import Data.Proxy

18import Data.Proxy

16import Data.Set (Set)

19import Data.Set (Set)

17import qualified Data.Set as S

20import qualified Data.Set as S

18import Data.Text (Text)

21import Data.Text (Text)

19−import OpenAPI.Checker.Behavior

20−import OpenAPI.Checker.Orphans ()

21−import OpenAPI.Checker.Subtree

22import Text.Pandoc.Builder

23

24instance Subtree OAuth2Flows where

@@ -26,11 +26,11 @@ instance Subtree OAuth2Flows where

26 type SubtreeLevel OAuth2Flows = 'SecuritySchemeLevel

27 checkStructuralCompatibility _ = structuralEq

28 checkSemanticCompatibility env bhv pc = do

29− let supportFlow

29+ let supportFlow ::

30− :: (Subtree t, SubtreeLevel t ~ SubtreeLevel OAuth2Flows, CheckEnv OAuth2Flows ~ CheckEnv t)

30+ (Subtree t, SubtreeLevel t ~ SubtreeLevel OAuth2Flows, CheckEnv OAuth2Flows ~ CheckEnv t) =>

31− => Issue 'SecuritySchemeLevel

31+ Issue 'SecuritySchemeLevel ->

32− -> ProdCons (Maybe (Traced t))

32+ ProdCons (Maybe (Traced t)) ->

33− -> SemanticCompatFormula ()

33+ SemanticCompatFormula ()

34 supportFlow i x = case x of

35 -- producer will not attempt this flow

36 (ProdCons Nothing _) -> pure ()

@@ -38,11 +38,11 @@ instance Subtree OAuth2Flows where

38 (ProdCons (Just _) Nothing) -> issueAt bhv i

39 (ProdCons (Just p) (Just c)) ->

40 checkCompatibility bhv env $ ProdCons p c

41− getFlow

41+ getFlow ::

42− :: Typeable x

42+ Typeable x =>

43− => (OAuth2Flows -> Maybe (OAuth2Flow x))

43+ (OAuth2Flows -> Maybe (OAuth2Flow x)) ->

44− -> Traced OAuth2Flows

44+ Traced OAuth2Flows ->

45− -> Maybe (Traced (OAuth2Flow x))

45+ Maybe (Traced (OAuth2Flow x))

46 getFlow f (Traced t a) = Traced (t >>> step (OAuth2FlowsFlow Proxy)) <$> f a

47 supportFlow ConsumerDoesNotSupportImplicitFlow $ getFlow _oAuth2FlowsImplicit <$> pc

48 supportFlow ConsumerDoesNotSupportPasswordFlow $ getFlow _oAuth2FlowsPassword <$> pc

src/OpenAPI/Checker/Validate/OpenApi.hs → src/Data/OpenApi/Compare/Validate/OpenApi.hsrenamed+18−17

@@ -2,19 +2,19 @@

2-- Does not compiles otherwise

3{-# OPTIONS_GHC -fconstraint-solver-iterations=0 #-}

4

5−module OpenAPI.Checker.Validate.OpenApi

5+module Data.OpenApi.Compare.Validate.OpenApi

6− ( Behave (..)

6+ ( Behave (..),

7− , Issue (..)

7+ Issue (..),

8 )

9where

10

11import Data.HList

12import qualified Data.HashMap.Strict.InsOrd as IOHM

13import Data.OpenApi

14−import OpenAPI.Checker.Behavior

14+import Data.OpenApi.Compare.Behavior

15−import OpenAPI.Checker.Paths

15+import Data.OpenApi.Compare.Paths

16−import OpenAPI.Checker.Subtree

16+import Data.OpenApi.Compare.Subtree

17−import OpenAPI.Checker.Validate.Operation

17+import Data.OpenApi.Compare.Validate.Operation

18

19tracedPaths :: Traced OpenApi -> Traced ProcessedPathItems

20tracedPaths oa =

@@ -79,16 +79,17 @@ instance Subtree OpenApi where

79 checkSemanticCompatibility _ beh prodCons = do

80 checkCompatibility @ProcessedPathItems

81 beh

82− ((tracedRequestBodies <$> prodCons)

82+ ( (tracedRequestBodies <$> prodCons)

83− `HCons` (tracedParameters <$> prodCons)

83+ `HCons` (tracedParameters <$> prodCons)

84− `HCons` (tracedSecuritySchemes <$> prodCons)

84+ `HCons` (tracedSecuritySchemes <$> prodCons)

85− `HCons` (tracedResponses <$> prodCons)

85+ `HCons` (tracedResponses <$> prodCons)

86− `HCons` (tracedHeaders <$> prodCons)

86+ `HCons` (tracedHeaders <$> prodCons)

87− `HCons` (tracedSchemas <$> prodCons)

87+ `HCons` (tracedSchemas <$> prodCons)

88− `HCons` (_openApiServers . extract <$> prodCons)

88+ `HCons` (_openApiServers . extract <$> prodCons)

89− `HCons` (tracedLinks <$> prodCons)

89+ `HCons` (tracedLinks <$> prodCons)

90− `HCons` (tracedCallbacks <$> prodCons)

90+ `HCons` (tracedCallbacks <$> prodCons)

91− `HCons` HNil)

91+ `HCons` HNil

92+ )

92 (tracedPaths <$> prodCons)

93 (tracedPaths <$> prodCons)

93

94

94instance Steppable OpenApi ProcessedPathItems where

95instance Steppable OpenApi ProcessedPathItems where

src/OpenAPI/Checker/Validate/Operation.hs → src/Data/OpenApi/Compare/Validate/Operation.hsrenamed+43−41

@@ -2,19 +2,19 @@

2{-# OPTIONS_GHC -Wno-orphans #-}

3{-# OPTIONS_GHC -fconstraint-solver-iterations=0 #-}

4

5−module OpenAPI.Checker.Validate.Operation

5+module Data.OpenApi.Compare.Validate.Operation

6 ( -- * Operation

7− MatchedOperation (..)

7+ MatchedOperation (..),

8− , OperationMethod (..)

8+ OperationMethod (..),

9− , pathItemMethod

9+ pathItemMethod,

10

11 -- * ProcessedPathItem

12− , ProcessedPathItem (..)

12+ ProcessedPathItem (..),

13− , ProcessedPathItems (..)

13+ ProcessedPathItems (..),

14− , processPathItems

14+ processPathItems,

15− , Step (..)

15+ Step (..),

16− , Behave (..)

16+ Behave (..),

17− , Issue (..)

17+ Issue (..),

18 )

19where

20

@@ -29,21 +29,21 @@ import qualified Data.List as L

29import Data.Map.Strict as M

30import Data.Maybe

31import Data.OpenApi

32+import Data.OpenApi.Compare.Behavior

33+import Data.OpenApi.Compare.References

34+import Data.OpenApi.Compare.Subtree

35+import Data.OpenApi.Compare.Validate.MediaTypeObject

36+import Data.OpenApi.Compare.Validate.OAuth2Flows

37+import Data.OpenApi.Compare.Validate.PathFragment

38+import Data.OpenApi.Compare.Validate.Products

39+import Data.OpenApi.Compare.Validate.RequestBody

40+import Data.OpenApi.Compare.Validate.Responses

41+import Data.OpenApi.Compare.Validate.SecurityRequirement ()

42+import Data.OpenApi.Compare.Validate.Server ()

43+import Data.OpenApi.Compare.Validate.Sums

32import Data.String

44import Data.String

33import Data.Text (Text)

45import Data.Text (Text)

34import qualified Data.Text as T

46import qualified Data.Text as T

35−import OpenAPI.Checker.Behavior

36−import OpenAPI.Checker.References

37−import OpenAPI.Checker.Subtree

38−import OpenAPI.Checker.Validate.MediaTypeObject

39−import OpenAPI.Checker.Validate.OAuth2Flows

40−import OpenAPI.Checker.Validate.PathFragment

41−import OpenAPI.Checker.Validate.Products

42−import OpenAPI.Checker.Validate.RequestBody

43−import OpenAPI.Checker.Validate.Responses

44−import OpenAPI.Checker.Validate.SecurityRequirement ()

45−import OpenAPI.Checker.Validate.Server ()

46−import OpenAPI.Checker.Validate.Sums

47import Text.Pandoc.Builder

48

49data MatchedOperation = MatchedOperation

@@ -86,11 +86,12 @@ tracedCallbacks (Traced t oper) =

86 | (k, v) <- IOHM.toList . _operationCallbacks . operation $ oper

87 ]

88

89−-- FIXME: https://github.com/typeable/openapi-diff/issues/28

89+-- FIXME: #28

90−getServers

90+getServers ::

91− :: [Server] -- ^ Servers from env

91+ -- | Servers from env

92+ [Server] ->

92− -> MatchedOperation

93+ MatchedOperation ->

93− -> [Server]

94+ [Server]

94getServers env oper =

95getServers env oper =

95 case _operationServers . operation $ oper of

96 case _operationServers . operation $ oper of

96 [] -> env

97 [] -> env

@@ -241,7 +242,7 @@ instance Subtree MatchedOperation where

241 checkProducts beh (const NoRequestBody) (const check) elements

242 checkProducts beh (const NoRequestBody) (const check) elements

242 checkResponses =

243 checkResponses =

243 swapProdCons (checkCompatibility beh) env $ tracedResponses <$> prodCons

244 swapProdCons (checkCompatibility beh) env $ tracedResponses <$> prodCons

244− -- FIXME: https://github.com/typeable/openapi-diff/issues/27

245+ -- FIXME: #27

245 checkCallbacks = do

246 checkCallbacks = do

246 let ProdCons pCallbacks cCallbacks = tracedCallbacks <$> prodCons

247 let ProdCons pCallbacks cCallbacks = tracedCallbacks <$> prodCons

247 for_ pCallbacks $ \(k, pCallback) -> do

248 for_ pCallbacks $ \(k, pCallback) -> do

@@ -250,7 +251,7 @@ instance Subtree MatchedOperation where

250 cCallbacks <&> \(_, cCallback) -> do

251 cCallbacks <&> \(_, cCallback) -> do

251 swapProdCons (checkCompatibility beh') env $ ProdCons pCallback cCallback

252 swapProdCons (checkCompatibility beh') env $ ProdCons pCallback cCallback

252 pure ()

253 pure ()

253− -- FIXME: https://github.com/typeable/openapi-diff/issues/28

254+ -- FIXME: #28

254 checkOperationSecurity = do

255 checkOperationSecurity = do

255 let ProdCons pSecs cSecs = tracedSecurity <$> prodCons

256 let ProdCons pSecs cSecs = tracedSecurity <$> prodCons

256 for_ pSecs $ \(i, pSec) -> do

257 for_ pSecs $ \(i, pSec) -> do

@@ -337,9 +338,10 @@ instance Issuable 'APILevel where

337 deriving stock (Eq, Ord, Show)

338 deriving stock (Eq, Ord, Show)

338 issueKind = \case

339 issueKind = \case

339 _ -> CertainIssue

340 _ -> CertainIssue

340− relatedIssues = (==) `withClass` \case

341+ relatedIssues =

342+ (==) `withClass` \case

341− NoPathsMatched fp -> Just fp

343+ NoPathsMatched fp -> Just fp

342− AllPathsFailed fp -> Just fp

344+ AllPathsFailed fp -> Just fp

343 describeIssue Forward (NoPathsMatched p) = para $ "The path " <> (code . T.pack) p <> " has been removed."

345 describeIssue Forward (NoPathsMatched p) = para $ "The path " <> (code . T.pack) p <> " has been removed."

344 describeIssue Backward (NoPathsMatched p) = para $ "The path " <> (code . T.pack) p <> " has been added."

346 describeIssue Backward (NoPathsMatched p) = para $ "The path " <> (code . T.pack) p <> " has been added."

345 describeIssue Forward (AllPathsFailed p) = para $ "The path " <> (code . T.pack) p <> " has been removed."

347 describeIssue Forward (AllPathsFailed p) = para $ "The path " <> (code . T.pack) p <> " has been removed."

@@ -434,10 +436,10 @@ tracedFragments mpi =

434 | (i, x) <- L.zip [0 ..] $ pathFragments $ extract mpi

436 | (i, x) <- L.zip [0 ..] $ pathFragments $ extract mpi

435 ]

437 ]

436

438

437−tracedMethod

439+tracedMethod ::

438− :: OperationMethod

440+ OperationMethod ->

439− -> Traced MatchedPathItem

441+ Traced MatchedPathItem ->

440− -> Maybe (Traced' MatchedOperation Operation)

442+ Maybe (Traced' MatchedOperation Operation)

441tracedMethod s mpi = env (ask mpi >>> step (OperationMethodStep s)) <$> (pathItemMethod s . pathItem . extract $ mpi)

443tracedMethod s mpi = env (ask mpi >>> step (OperationMethodStep s)) <$> (pathItemMethod s . pathItem . extract $ mpi)

442

444

443instance Issuable 'PathLevel where

445instance Issuable 'PathLevel where

@@ -485,10 +487,10 @@ instance Subtree MatchedPathItem where

485 checkSemanticCompatibility env beh prodCons = do

487 checkSemanticCompatibility env beh prodCons = do

486 let paramDefs = getH @(ProdCons (Traced (Definitions Param))) env

488 let paramDefs = getH @(ProdCons (Traced (Definitions Param))) env

487 pathTracedParams = getPathParams <$> paramDefs <*> prodCons

489 pathTracedParams = getPathParams <$> paramDefs <*> prodCons

488− getPathParams

490+ getPathParams ::

489− :: Traced (Definitions Param)

491+ Traced (Definitions Param) ->

490− -> Traced MatchedPathItem

492+ Traced MatchedPathItem ->

491− -> [Traced Param]

493+ [Traced Param]

492 getPathParams defs mpi = do

494 getPathParams defs mpi = do

493 paramRef <- tracedMatchedPathItemParameters mpi

495 paramRef <- tracedMatchedPathItemParameters mpi

494 pure $ dereference defs paramRef

496 pure $ dereference defs paramRef

@@ -564,7 +566,7 @@ instance Issuable 'CallbackLevel where

564 deriving stock (Eq, Ord, Show)

566 deriving stock (Eq, Ord, Show)

565 issueKind = \case

567 issueKind = \case

566 CallbacksUnsupported -> Unsupported

568 CallbacksUnsupported -> Unsupported

567− describeIssue _ CallbacksUnsupported = para "OpenApi Diff does not currently support callbacks."

569+ describeIssue _ CallbacksUnsupported = para "CompaREST does not currently support callbacks."

568

570

569tracedCallbackPathItems :: Traced Callback -> Traced ProcessedPathItems

571tracedCallbackPathItems :: Traced Callback -> Traced ProcessedPathItems

570tracedCallbackPathItems (Traced t (Callback x)) =

572tracedCallbackPathItems (Traced t (Callback x)) =

src/OpenAPI/Checker/Validate/Param.hs → src/Data/OpenApi/Compare/Validate/Param.hsrenamed+14−12

@@ -1,9 +1,9 @@

1{-# OPTIONS_GHC -Wno-orphans #-}

2{-# OPTIONS_GHC -fno-warn-name-shadowing #-}

3

4−module OpenAPI.Checker.Validate.Param

4+module Data.OpenApi.Compare.Validate.Param

5− ( Behave (..)

5+ ( Behave (..),

6− , Issue (..)

6+ Issue (..),

7 )

8where

9

@@ -11,11 +11,11 @@ import Control.Monad

11import Data.Functor

12import Data.Maybe

13import Data.OpenApi

14+import Data.OpenApi.Compare.Behavior

15+import Data.OpenApi.Compare.Orphans ()

16+import Data.OpenApi.Compare.Subtree

17+import Data.OpenApi.Compare.Validate.Schema ()

14import Data.Text as T

18import Data.Text as T

15−import OpenAPI.Checker.Behavior

16−import OpenAPI.Checker.Orphans ()

17−import OpenAPI.Checker.Subtree

18−import OpenAPI.Checker.Validate.Schema ()

19import Text.Pandoc.Builder

20

21-- | The type is normalized encoding style of the parameter. If two encoding

@@ -79,7 +79,7 @@ instance Issuable 'PathFragmentLevel where

79 describeIssue _ ParamPlaceIncompatible = para "Parameters in incompatible locations."

80 describeIssue _ ParamStyleMismatch = para "Different parameter styles (encodings)."

81 describeIssue _ ParamSchemaMismatch = para "Expected a schema, but didn't find one."

82− describeIssue ori (PathFragmentsDontMatch (orientProdCons ori -> ProdCons e a)) =

82+ describeIssue ori (PathFragmentsDontMatch (orientProdCons ori -> ProdCons e a)) =

83 para $ "Parameter changed from " <> code e <> " to " <> code a <> "."

84

85instance Behavable 'PathFragmentLevel 'SchemaLevel where

@@ -106,15 +106,17 @@ instance Subtree Param where

106 when (_paramName (extract p) /= _paramName (extract c)) $

107 issueAt beh ParamNameMismatch

108 when

109− ((fromMaybe False . _paramRequired . extract $ c)

109+ ( (fromMaybe False . _paramRequired . extract $ c)

110− && not (fromMaybe False . _paramRequired . extract $ p))

110+ && not (fromMaybe False . _paramRequired . extract $ p)

111+ )

111 $ issueAt beh ParamRequired

112 $ issueAt beh ParamRequired

112 case (_paramIn . extract $ p, _paramIn . extract $ c) of

113 case (_paramIn . extract $ p, _paramIn . extract $ c) of

113 (ParamQuery, ParamQuery) -> do

114 (ParamQuery, ParamQuery) -> do

114 -- Emptiness is only for query params

115 -- Emptiness is only for query params

115 when

116 when

116− ((fromMaybe False . _paramAllowEmptyValue . extract $ p)

117+ ( (fromMaybe False . _paramAllowEmptyValue . extract $ p)

117− && not (fromMaybe False . _paramAllowEmptyValue . extract $ c))

118+ && not (fromMaybe False . _paramAllowEmptyValue . extract $ c)

119+ )

118 $ issueAt beh ParamEmptinessIncompatible

120 $ issueAt beh ParamEmptinessIncompatible

119 (a, b) | a == b -> pure ()

121 (a, b) | a == b -> pure ()

120 _ -> issueAt beh ParamPlaceIncompatible

122 _ -> issueAt beh ParamPlaceIncompatible

src/OpenAPI/Checker/Validate/PathFragment.hs → src/Data/OpenApi/Compare/Validate/PathFragment.hsrenamed+8−9

@@ -1,21 +1,20 @@

1−module OpenAPI.Checker.Validate.PathFragment

1+module Data.OpenApi.Compare.Validate.PathFragment

2− ( parsePath

2+ ( parsePath,

3− , PathFragment (..)

3+ PathFragment (..),

4− , PathFragmentParam

4+ PathFragmentParam,

5 )

6where

7

8import qualified Data.Aeson as A

9import Data.OpenApi

10+import Data.OpenApi.Compare.Behavior

11+import Data.OpenApi.Compare.Subtree

12+import Data.OpenApi.Compare.Validate.Param

10import Data.Text (Text)

13import Data.Text (Text)

11import qualified Data.Text as T

14import qualified Data.Text as T

12−import Data.Typeable

13−import OpenAPI.Checker.Behavior

14−import OpenAPI.Checker.Subtree

15−import OpenAPI.Checker.Validate.Param

16

15

17-- TODO: templates can be only part of the PathFragment. Currently only supports templates as full PathFragment.

16-- TODO: templates can be only part of the PathFragment. Currently only supports templates as full PathFragment.

18−-- https://github.com/typeable/openapi-diff/issues/23

17+-- #23

19parsePath :: FilePath -> [PathFragment Text]

18parsePath :: FilePath -> [PathFragment Text]

20parsePath = fmap partition . T.splitOn "/" . T.pack

19parsePath = fmap partition . T.splitOn "/" . T.pack

21 where

20 where

src/Data/OpenApi/Compare/Validate/Products.hsnew file+48

@@ -0,0 +1,48 @@

1+-- | Checks product-like entities. The key is some identificator for the product

2+--element. Each element may be required or optional.

3+--

4+--One example of product is request parameters. There are optional and required

5+--parameters. The client and server have possibly different set of

6+--parameters. What we must check is if server requires some request parameter,

7+--then this parameter must be presented by client and their schemas must match.

8+--

9+--So when we checking products we are checking from the server's (consumer)

10+--perspective, ensuring that all parameters are provided by the client (producer)

11+--and their schemas match.

12+--

13+--This module abstracts this logic for arbitrary elements

14+module Data.OpenApi.Compare.Validate.Products

15+ ( checkProducts,

16+ ProductLike (..),

17+ )

18+where

19+

20+import Data.Foldable

21+import Data.Map.Strict (Map)

22+import qualified Data.Map.Strict as M

23+import Data.OpenApi.Compare.Behavior

24+import Data.OpenApi.Compare.Paths

25+import Data.OpenApi.Compare.Subtree

26+

27+-- | Some entity which is product-like

28+data ProductLike a = ProductLike

29+ { productValue :: a

30+ , required :: Bool

31+ }

32+

33+checkProducts ::

34+ (Ord k, Issuable l) =>

35+ Paths q r l ->

36+ -- | No required element found

37+ (k -> Issue l) ->

38+ (k -> ProdCons t -> CompatFormula' q AnIssue r ()) ->

39+ ProdCons (Map k (ProductLike t)) ->

40+ CompatFormula' q AnIssue r ()

41+checkProducts xs noElt check (ProdCons p c) = for_ (M.toList c) $ \(key, consElt) ->

42+ case M.lookup key p of

43+ Nothing -> case required consElt of

44+ True -> issueAt xs $ noElt key

45+ False -> pure ()

46+ Just prodElt -> do

47+ let elts = ProdCons prodElt consElt

48+ check key (productValue <$> elts)

src/OpenAPI/Checker/Validate/RequestBody.hs → src/Data/OpenApi/Compare/Validate/RequestBody.hsrenamed+7−7

@@ -1,8 +1,8 @@

1{-# OPTIONS_GHC -Wno-orphans #-}

2

3−module OpenAPI.Checker.Validate.RequestBody

3+module Data.OpenApi.Compare.Validate.RequestBody

4− ( Issue (..)

4+ ( Issue (..),

5− , Behave (..)

5+ Behave (..),

6 )

7where

8

@@ -11,12 +11,12 @@ import Data.HashMap.Strict.InsOrd as IOHM

11import Data.Map.Strict as M

12import Data.Maybe

13import Data.OpenApi

14+import Data.OpenApi.Compare.Behavior

15+import Data.OpenApi.Compare.Subtree

16+import Data.OpenApi.Compare.Validate.MediaTypeObject

17+import Data.OpenApi.Compare.Validate.Sums

14import qualified Data.Text as T

18import qualified Data.Text as T

15import Network.HTTP.Media (MediaType)

19import Network.HTTP.Media (MediaType)

16−import OpenAPI.Checker.Behavior

17−import OpenAPI.Checker.Subtree

18−import OpenAPI.Checker.Validate.MediaTypeObject

19−import OpenAPI.Checker.Validate.Sums

20import Text.Pandoc.Builder

21

22-- TODO: Use RequestMediaTypeObjectMapping

src/OpenAPI/Checker/Validate/Responses.hs → src/Data/OpenApi/Compare/Validate/Responses.hsrenamed+11−11

@@ -1,8 +1,8 @@

1{-# OPTIONS_GHC -Wno-orphans #-}

2{-# OPTIONS_GHC -fno-warn-name-shadowing #-}

3

4−module OpenAPI.Checker.Validate.Responses

4+module Data.OpenApi.Compare.Validate.Responses

5− ( Behave (..)

5+ ( Behave (..),

6 )

7where

8

@@ -11,17 +11,17 @@ import Data.HashMap.Strict.InsOrd as IOHM

11import Data.Map.Strict as M

12import Data.Maybe

13import Data.OpenApi

14+import Data.OpenApi.Compare.Behavior

15+import Data.OpenApi.Compare.References

16+import Data.OpenApi.Compare.Subtree

17+import Data.OpenApi.Compare.Validate.Header ()

18+import Data.OpenApi.Compare.Validate.Link ()

19+import Data.OpenApi.Compare.Validate.MediaTypeObject

20+import Data.OpenApi.Compare.Validate.Products

21+import Data.OpenApi.Compare.Validate.Schema ()

22+import Data.OpenApi.Compare.Validate.Sums

14import qualified Data.Text as T

23import qualified Data.Text as T

15import Network.HTTP.Media (MediaType)

24import Network.HTTP.Media (MediaType)

16−import OpenAPI.Checker.Behavior

17−import OpenAPI.Checker.References

18−import OpenAPI.Checker.Subtree

19−import OpenAPI.Checker.Validate.Header ()

20−import OpenAPI.Checker.Validate.Link ()

21−import OpenAPI.Checker.Validate.MediaTypeObject

22−import OpenAPI.Checker.Validate.Products

23−import OpenAPI.Checker.Validate.Schema ()

24−import OpenAPI.Checker.Validate.Sums

25import Text.Pandoc.Builder

26

27tracedResponses :: Traced Responses -> IOHM.InsOrdHashMap HttpStatusCode (Traced (Referenced Response))

src/OpenAPI/Checker/Validate/Schema.hs → src/Data/OpenApi/Compare/Validate/Schema.hsrenamed+86−107

@@ -1,5 +1,6 @@

1{-# OPTIONS_GHC -Wno-orphans #-}

2+

2−module OpenAPI.Checker.Validate.Schema

3+module Data.OpenApi.Compare.Validate.Schema

3 (

4 (

4 )

5 )

5where

6where

@@ -10,36 +11,36 @@ import Data.Coerce

10import Data.Foldable (for_, toList)

11import Data.Foldable (for_, toList)

11import Data.Functor

12import Data.Functor

12import Data.HList

13import Data.HList

14+import Data.List (genericIndex, genericLength, group)

13import qualified Data.List.NonEmpty as NE

15import qualified Data.List.NonEmpty as NE

14import qualified Data.Map as M

16import qualified Data.Map as M

15−import Data.List (group, genericLength, genericIndex)

16import Data.Maybe

17import Data.Maybe

17import Data.OpenApi

18import Data.OpenApi

19+import Data.OpenApi.Compare.Behavior

20+import Data.OpenApi.Compare.Paths

21+import qualified Data.OpenApi.Compare.PathsPrefixTree as P

22+import Data.OpenApi.Compare.Subtree

23+import Data.OpenApi.Compare.Validate.Schema.DNF

24+import Data.OpenApi.Compare.Validate.Schema.Issues

25+import Data.OpenApi.Compare.Validate.Schema.JsonFormula

26+import Data.OpenApi.Compare.Validate.Schema.Partition

27+import Data.OpenApi.Compare.Validate.Schema.Process

28+import Data.OpenApi.Compare.Validate.Schema.Traced

29+import Data.OpenApi.Compare.Validate.Schema.TypedJson

18import Data.Ord

30import Data.Ord

19import Data.Ratio

31import Data.Ratio

20import Data.Semigroup

32import Data.Semigroup

21import qualified Data.Set as S

33import qualified Data.Set as S

22import Data.Text (Text)

34import Data.Text (Text)

23−import OpenAPI.Checker.Behavior

24−import OpenAPI.Checker.Paths

25−import qualified OpenAPI.Checker.PathsPrefixTree as P

26−import OpenAPI.Checker.Subtree

27−import OpenAPI.Checker.Validate.Schema.DNF

28−import OpenAPI.Checker.Validate.Schema.Issues

29−import OpenAPI.Checker.Validate.Schema.JsonFormula

30−import OpenAPI.Checker.Validate.Schema.Traced

31−import OpenAPI.Checker.Validate.Schema.TypedJson

32−import OpenAPI.Checker.Validate.Schema.Partition

33−import OpenAPI.Checker.Validate.Schema.Process

34

35

35−checkFormulas

36+checkFormulas ::

36− :: (ReassembleHList xs (CheckEnv (Referenced Schema)))

37+ (ReassembleHList xs (CheckEnv (Referenced Schema))) =>

37− => HList xs

38+ HList xs ->

38− -> Behavior 'SchemaLevel

39+ Behavior 'SchemaLevel ->

39− -> ProdCons (Trace Schema)

40+ ProdCons (Trace Schema) ->

40− -> ProdCons (Traced (Definitions Schema))

41+ ProdCons (Traced (Definitions Schema)) ->

41− -> ProdCons (ForeachType JsonFormula, P.PathsPrefixTree Behave AnIssue 'SchemaLevel)

42+ ProdCons (ForeachType JsonFormula, P.PathsPrefixTree Behave AnIssue 'SchemaLevel) ->

42− -> SemanticCompatFormula ()

43+ SemanticCompatFormula ()

43checkFormulas env beh trs defs (ProdCons (fp, ep) (fc, ec)) =

44checkFormulas env beh trs defs (ProdCons (fp, ep) (fc, ec)) =

44 case P.toList ep ++ P.toList ec of

45 case P.toList ep ++ P.toList ec of

45 issues@(_ : _) -> for_ issues $ embedFormula beh . anItem

46 issues@(_ : _) -> for_ issues $ embedFormula beh . anItem

@@ -144,21 +145,21 @@ checkFormulas env beh trs defs (ProdCons (fp, ep) (fc, ec)) =

144 EnumDoesntSatisfy $ untypeValue e -- what does this look like when partitioned?

145 EnumDoesntSatisfy $ untypeValue e -- what does this look like when partitioned?

145 issueFromDisjunct mPart ps = NoMatchingCondition mPart $ SomeCondition <$> S.toList ps

146 issueFromDisjunct mPart ps = NoMatchingCondition mPart $ SomeCondition <$> S.toList ps

146

147

147−checkContradiction

148+checkContradiction ::

148− :: Behavior 'TypedSchemaLevel

149+ Behavior 'TypedSchemaLevel ->

149− -> Maybe Partition

150+ Maybe Partition ->

150− -> S.Set (Condition t)

151+ S.Set (Condition t) ->

151− -> SemanticCompatFormula ()

152+ SemanticCompatFormula ()

152checkContradiction beh mPart _ = issueAt beh $ maybe TypeBecomesEmpty PartitionBecomesEmpty mPart -- TODO #70

153checkContradiction beh mPart _ = issueAt beh $ maybe TypeBecomesEmpty PartitionBecomesEmpty mPart -- TODO #70

153

154

154−checkImplication

155+checkImplication ::

155− :: (ReassembleHList xs (CheckEnv (Referenced Schema)))

156+ (ReassembleHList xs (CheckEnv (Referenced Schema))) =>

156− => HList xs

157+ HList xs ->

157− -> Behavior 'TypedSchemaLevel

158+ Behavior 'TypedSchemaLevel ->

158− -> ProdCons (Trace Schema) -- the traces of the root schemas used in this comparison

159+ ProdCons (Trace Schema) -> -- the traces of the root schemas used in this comparison

159− -> S.Set (Condition t)

160+ S.Set (Condition t) ->

160− -> Condition t

161+ Condition t ->

161− -> SemanticCompatFormula ()

162+ SemanticCompatFormula ()

162checkImplication env beh trs prods cons = case findExactly prods of

163checkImplication env beh trs prods cons = case findExactly prods of

163 Just e

164 Just e

164 | all (satisfiesTyped e) prods ->

165 | all (satisfiesTyped e) prods ->

@@ -166,124 +167,104 @@ checkImplication env beh trs prods cons = case findExactly prods of

166 then pure ()

167 then pure ()

167 else issueAt beh (EnumDoesntSatisfy $ untypeValue e)

168 else issueAt beh (EnumDoesntSatisfy $ untypeValue e)

168 | otherwise -> pure () -- vacuously true

169 | otherwise -> pure () -- vacuously true

169−

170 Nothing -> case cons of

171 -- the above code didn't catch it, so there's no Exactly condition on the lhs

172 Exactly e -> issueAt beh (NoMatchingEnum $ untypeValue e)

173−

174 Maximum m -> foldCheck min m NoMatchingMaximum MatchingMaximumWeak $ \case

173 Maximum m -> foldCheck min m NoMatchingMaximum MatchingMaximumWeak $ \case

175 Maximum m' -> Just m'

174 Maximum m' -> Just m'

176 _ -> Nothing

175 _ -> Nothing

177−

178 Minimum m -> foldCheck max m (NoMatchingMinimum . coerce) (MatchingMinimumWeak . coerce) $ \case

176 Minimum m -> foldCheck max m (NoMatchingMinimum . coerce) (MatchingMinimumWeak . coerce) $ \case

179 Minimum m' -> Just m'

177 Minimum m' -> Just m'

180 _ -> Nothing

178 _ -> Nothing

181−

182 MultipleOf m -> foldCheck lcmScientific m NoMatchingMultipleOf MatchingMultipleOfWeak $ \case

179 MultipleOf m -> foldCheck lcmScientific m NoMatchingMultipleOf MatchingMultipleOfWeak $ \case

183 MultipleOf m' -> Just m'

180 MultipleOf m' -> Just m'

184 _ -> Nothing

181 _ -> Nothing

185−

186 NumberFormat f -> case flip any prods $ \case

182 NumberFormat f -> case flip any prods $ \case

187− NumberFormat f' -> f == f'

183+ NumberFormat f' -> f == f'

188− _ -> False

184+ _ -> False of

189− of

190 True -> pure ()

185 True -> pure ()

191 False -> issueAt beh (NoMatchingFormat f)

186 False -> issueAt beh (NoMatchingFormat f)

192−

193 MaxLength m -> foldCheck min m NoMatchingMaxLength MatchingMaxLengthWeak $ \case

187 MaxLength m -> foldCheck min m NoMatchingMaxLength MatchingMaxLengthWeak $ \case

194 MaxLength m' -> Just m'

188 MaxLength m' -> Just m'

195 _ -> Nothing

189 _ -> Nothing

196−

197 MinLength m -> foldCheck max m NoMatchingMinLength MatchingMinLengthWeak $ \case

190 MinLength m -> foldCheck max m NoMatchingMinLength MatchingMinLengthWeak $ \case

198 MinLength m' -> Just m'

191 MinLength m' -> Just m'

199 _ -> Nothing

192 _ -> Nothing

200−

201 Pattern p -> case flip any prods $ \case

193 Pattern p -> case flip any prods $ \case

202− Pattern p' -> p == p'

194+ Pattern p' -> p == p'

203− _ -> False

195+ _ -> False of

204− of

205 True -> pure ()

196 True -> pure ()

206 False -> issueAt beh (NoMatchingPattern p) -- TODO: regex comparison #32

197 False -> issueAt beh (NoMatchingPattern p) -- TODO: regex comparison #32

207−

208 StringFormat f -> case flip any prods $ \case

198 StringFormat f -> case flip any prods $ \case

209− StringFormat f' -> f == f'

199+ StringFormat f' -> f == f'

210− _ -> False

200+ _ -> False of

211− of

212 True -> pure ()

201 True -> pure ()

213 False -> issueAt beh (NoMatchingFormat f)

202 False -> issueAt beh (NoMatchingFormat f)

214−

215 Items _ cons' -> case foldSome (<>) prods $ \case

203 Items _ cons' -> case foldSome (<>) prods $ \case

216− Items _ rs -> Just (Just (rs NE.:| []), mempty)

204+ Items _ rs -> Just (Just (rs NE.:| []), mempty)

217− TupleItems (map snd -> fs) -> Just (mempty, Just (fs NE.:| []))

205+ TupleItems (map snd -> fs) -> Just (mempty, Just (fs NE.:| []))

218− _ -> Nothing

206+ _ -> Nothing of

219− of

220 Just (mItems, Just pfs)

207 Just (mItems, Just pfs)

221 | not $ allSame (length <$> pfs) -> pure () -- vacuously

208 | not $ allSame (length <$> pfs) -> pure () -- vacuously

222− | let plen = genericLength (NE.head pfs)

209+ | let plen = genericLength (NE.head pfs) ->

223− -> clarifyIssue (AnItem beh (anIssue TupleToArray)) $ for_ [0 .. plen - 1] $ \i -> do

210+ clarifyIssue (AnItem beh (anIssue TupleToArray)) $

211+ for_ [0 .. plen - 1] $ \i -> do

224− let prod' = tracedConjunct $ case mItems of

212+ let prod' = tracedConjunct $ case mItems of

225− Just prods' -> ((`genericIndex` i) <$> pfs) <> prods'

213+ Just prods' -> ((`genericIndex` i) <$> pfs) <> prods'

226− Nothing -> (`genericIndex` i) <$> pfs

214+ Nothing -> (`genericIndex` i) <$> pfs

227− checkCompatibility (beh >>> step (InItem i)) env $ ProdCons prod' cons'

215+ checkCompatibility (beh >>> step (InItem i)) env $ ProdCons prod' cons'

228 Just (Just prods', Nothing) -> do

216 Just (Just prods', Nothing) -> do

229 let prod' = tracedConjunct prods'

217 let prod' = tracedConjunct prods'

230 checkCompatibility (beh >>> step InItems) env $ ProdCons prod' cons'

218 checkCompatibility (beh >>> step InItems) env $ ProdCons prod' cons'

231 _ -> clarifyIssue (AnItem beh (anIssue NoMatchingItems)) $ do

219 _ -> clarifyIssue (AnItem beh (anIssue NoMatchingItems)) $ do

232 checkCompatibility (beh >>> step InItems) env $ ProdCons prodTopSchema cons'

220 checkCompatibility (beh >>> step InItems) env $ ProdCons prodTopSchema cons'

233−

234 TupleItems (map snd -> fs) -> case foldSome (<>) prods $ \case

221 TupleItems (map snd -> fs) -> case foldSome (<>) prods $ \case

235− TupleItems (map snd -> fs') -> Just (Just $ fs' NE.:| [], Just . Max $ genericLength fs', Just . Min $ genericLength fs', mempty)

222+ TupleItems (map snd -> fs') -> Just (Just $ fs' NE.:| [], Just . Max $ genericLength fs', Just . Min $ genericLength fs', mempty)

236− MinItems m' -> Just (mempty, Just . Max $ m', mempty, mempty)

223+ MinItems m' -> Just (mempty, Just . Max $ m', mempty, mempty)

237− MaxItems m' -> Just (mempty, mempty, Just . Min $ m', mempty)

224+ MaxItems m' -> Just (mempty, mempty, Just . Min $ m', mempty)

238− Items _ rs -> Just (mempty, mempty, mempty, Just (rs NE.:| []))

225+ Items _ rs -> Just (mempty, mempty, mempty, Just (rs NE.:| []))

239− _ -> Nothing

226+ _ -> Nothing of

240− of

241− -- if the length constraints in the producer are contradictory:

227+ -- if the length constraints in the producer are contradictory:

242− Just (_, Just (Max lowest), Just (Min highest), _) | lowest > highest -> pure ()

228+ Just (_, Just (Max lowest), Just (Min highest), _) | lowest > highest -> pure ()

243− -- We have an explicit tuple items clause...

229+ -- We have an explicit tuple items clause...

244− Just (Just pfs, Just (Max plen), _, _)

230+ Just (Just pfs, Just (Max plen), _, _)

245− | plen /= genericLength fs -- ...of wrong length

231+ | plen /= genericLength fs -> -- ...of wrong length

246− -> issueAt beh (TupleItemsLengthChanged ProdCons {producer = plen, consumer = genericLength fs})

232+ issueAt beh (TupleItemsLengthChanged ProdCons {producer = plen, consumer = genericLength fs})

247− | otherwise

233+ | otherwise ->

248− -> for_ [0 .. plen - 1] $ \i -> do

234+ for_ [0 .. plen - 1] $ \i -> do

249 checkCompatibility (beh >>> step (InItem i)) env $ ProdCons (tracedConjunct $ (`genericIndex` i) <$> pfs) (fs `genericIndex` i)

235 checkCompatibility (beh >>> step (InItem i)) env $ ProdCons (tracedConjunct $ (`genericIndex` i) <$> pfs) (fs `genericIndex` i)

250− -- We have a fixed length array in the producer...

236+ -- We have a fixed length array in the producer...

251− Just (Nothing, Just (Max plen), Just (Min plen'), mProd)

237+ Just (Nothing, Just (Max plen), Just (Min plen'), mProd)

252− | plen == plen'

238+ | plen == plen' ->

253− -> clarifyIssue (AnItem beh (anIssue ArrayToTuple)) $ case mProd of

239+ clarifyIssue (AnItem beh (anIssue ArrayToTuple)) $ case mProd of

240+ _

254− _ | plen /= genericLength fs -> -- ...of wrong length

241+ | plen /= genericLength fs -> -- ...of wrong length

255− issueAt beh (TupleItemsLengthChanged ProdCons {producer = plen, consumer = genericLength fs})

242+ issueAt beh (TupleItemsLengthChanged ProdCons {producer = plen, consumer = genericLength fs})

256 Just rs -> for_ [0 .. plen - 1] $ \i -> do

243 Just rs -> for_ [0 .. plen - 1] $ \i -> do

257 checkCompatibility (beh >>> step (InItem i)) env $ ProdCons (tracedConjunct rs) (fs `genericIndex` i)

244 checkCompatibility (beh >>> step (InItem i)) env $ ProdCons (tracedConjunct rs) (fs `genericIndex` i)

258 -- ...and no "items" schema

245 -- ...and no "items" schema

259 Nothing -> clarifyIssue (AnItem beh (anIssue NoMatchingTupleItems)) $ do

246 Nothing -> clarifyIssue (AnItem beh (anIssue NoMatchingTupleItems)) $ do

260 for_ [0 .. plen - 1] $ \i -> do

247 for_ [0 .. plen - 1] $ \i -> do

261 checkCompatibility (beh >>> step (InItem i)) env $ ProdCons prodTopSchema (fs `genericIndex` i)

248 checkCompatibility (beh >>> step (InItem i)) env $ ProdCons prodTopSchema (fs `genericIndex` i)

262− _ -> issueAt beh NoMatchingTupleItems

249+ _ -> issueAt beh NoMatchingTupleItems

263−

264 MaxItems m -> foldCheck min m NoMatchingMaxItems MatchingMaxItemsWeak $ \case

250 MaxItems m -> foldCheck min m NoMatchingMaxItems MatchingMaxItemsWeak $ \case

265 MaxItems m' -> Just m'

251 MaxItems m' -> Just m'

266 TupleItems fs -> Just $ toInteger $ length fs

252 TupleItems fs -> Just $ toInteger $ length fs

267 _ -> Nothing

253 _ -> Nothing

268−

269 MinItems m -> foldCheck max m NoMatchingMinItems MatchingMinItemsWeak $ \case

254 MinItems m -> foldCheck max m NoMatchingMinItems MatchingMinItemsWeak $ \case

270 MinItems m' -> Just m'

255 MinItems m' -> Just m'

271 TupleItems fs -> Just $ toInteger $ length fs

256 TupleItems fs -> Just $ toInteger $ length fs

272 _ -> Nothing

257 _ -> Nothing

273−

274 UniqueItems -> case flip any prods $ \case

258 UniqueItems -> case flip any prods $ \case

275− UniqueItems -> True

259+ UniqueItems -> True

276− MaxItems 1 -> True

260+ MaxItems 1 -> True

277− TupleItems fs | length fs == 1 -> True

261+ TupleItems fs | length fs == 1 -> True

278− _ -> False

262+ _ -> False of

279− of

280 True -> pure ()

263 True -> pure ()

281 False -> issueAt beh NoMatchingUniqueItems

264 False -> issueAt beh NoMatchingUniqueItems

282−

283 Properties props _ madd -> case foldSome (<>) prods $ \case

265 Properties props _ madd -> case foldSome (<>) prods $ \case

284− Properties props' _ madd' -> Just $ (props', madd') NE.:| []

266+ Properties props' _ madd' -> Just $ (props', madd') NE.:| []

285− _ -> Nothing

267+ _ -> Nothing of

286− of

287 Just pm ->

268 Just pm ->

288 anyOfAt beh NoMatchingProperties $ -- TODO: could first "concat" the lists

269 anyOfAt beh NoMatchingProperties $ -- TODO: could first "concat" the lists

289 NE.toList pm <&> \(props', madd') -> do

270 NE.toList pm <&> \(props', madd') -> do

@@ -314,11 +295,9 @@ checkImplication env beh trs prods cons = case findExactly prods of

314 (Just add', Just add) -> checkCompatibility (beh >>> step InAdditionalProperty) env (ProdCons add' add)

295 (Just add', Just add) -> checkCompatibility (beh >>> step InAdditionalProperty) env (ProdCons add' add)

315 pure ()

296 pure ()

316 Nothing -> issueAt beh NoMatchingProperties

297 Nothing -> issueAt beh NoMatchingProperties

317−

318 MaxProperties m -> foldCheck min m NoMatchingMaxProperties MatchingMaxPropertiesWeak $ \case

298 MaxProperties m -> foldCheck min m NoMatchingMaxProperties MatchingMaxPropertiesWeak $ \case

319 MaxProperties m' -> Just m'

299 MaxProperties m' -> Just m'

320 _ -> Nothing

300 _ -> Nothing

321−

322 MinProperties m -> foldCheck max m NoMatchingMinProperties MatchingMinPropertiesWeak $ \case

301 MinProperties m -> foldCheck max m NoMatchingMinProperties MatchingMinPropertiesWeak $ \case

323 MinProperties m' -> Just m'

302 MinProperties m' -> Just m'

324 _ -> Nothing

303 _ -> Nothing

@@ -326,14 +305,14 @@ checkImplication env beh trs prods cons = case findExactly prods of

326 lcmScientific (toRational -> a) (toRational -> b) =

305 lcmScientific (toRational -> a) (toRational -> b) =

327 fromRational $ lcm (numerator a) (numerator b) % gcd (denominator a) (denominator b)

306 fromRational $ lcm (numerator a) (numerator b) % gcd (denominator a) (denominator b)

328

307

329− foldCheck

308+ foldCheck ::

330− :: Eq a

309+ Eq a =>

331− => (a -> a -> a)

310+ (a -> a -> a) ->

332− -> a

311+ a ->

333− -> (a -> Issue 'TypedSchemaLevel)

312+ (a -> Issue 'TypedSchemaLevel) ->

334− -> (ProdCons a -> Issue 'TypedSchemaLevel)

313+ (ProdCons a -> Issue 'TypedSchemaLevel) ->

335− -> (forall t. Condition t -> Maybe a)

314+ (forall t. Condition t -> Maybe a) ->

336− -> SemanticCompatFormula ()

315+ SemanticCompatFormula ()

337 foldCheck f m missing weak extr = case foldSome f prods extr of

316 foldCheck f m missing weak extr = case foldSome f prods extr of

338 Just m'

317 Just m'

339 | f m' m == m' -> pure ()

318 | f m' m == m' -> pure ()

src/OpenAPI/Checker/Validate/Schema/DNF.hs → src/Data/OpenApi/Compare/Validate/Schema/DNF.hsrenamed+9−9

@@ -1,12 +1,12 @@

1−module OpenAPI.Checker.Validate.Schema.DNF

1+module Data.OpenApi.Compare.Validate.Schema.DNF

2− ( DNF (..)

2+ ( DNF (..),

3− , Disjunct (..)

3+ Disjunct (..),

4− , pattern SingleDisjunct

4+ pattern SingleDisjunct,

5− , pattern TopDNF

5+ pattern TopDNF,

6− , pattern BottomDNF

6+ pattern BottomDNF,

7− , pattern LiteralDNF

7+ pattern LiteralDNF,

8− , foldDNF

8+ foldDNF,

9− , forDNF

9+ forDNF,

10 )

11where

12

src/OpenAPI/Checker/Validate/Schema/Issues.hs → src/Data/OpenApi/Compare/Validate/Schema/Issues.hsrenamed+61−59

@@ -1,21 +1,21 @@

1{-# OPTIONS_GHC -Wno-orphans #-}

2

3−module OpenAPI.Checker.Validate.Schema.Issues

3+module Data.OpenApi.Compare.Validate.Schema.Issues

4− ( Issue (..)

4+ ( Issue (..),

5− , Behave (..)

5+ Behave (..),

6 )

7where

8

9import qualified Data.Aeson as A

10import Data.OpenApi

11+import Data.OpenApi.Compare.Behavior

12+import Data.OpenApi.Compare.Subtree

13+import Data.OpenApi.Compare.Validate.Schema.JsonFormula

14+import Data.OpenApi.Compare.Validate.Schema.Partition

15+import Data.OpenApi.Compare.Validate.Schema.TypedJson

11import Data.Scientific

16import Data.Scientific

12import Data.Text (Text)

17import Data.Text (Text)

13import qualified Data.Text as T

18import qualified Data.Text as T

14−import OpenAPI.Checker.Behavior

15−import OpenAPI.Checker.Subtree

16−import OpenAPI.Checker.Validate.Schema.JsonFormula

17−import OpenAPI.Checker.Validate.Schema.Partition

18−import OpenAPI.Checker.Validate.Schema.TypedJson

19import Text.Pandoc.Builder hiding (Format, Null)

20

21instance Issuable 'TypedSchemaLevel where

@@ -100,53 +100,54 @@ instance Issuable 'TypedSchemaLevel where

100 TypeBecomesEmpty -> ProbablyIssue -- TODO: #70

101 PartitionBecomesEmpty _ -> ProbablyIssue -- ditto

102 _ -> CertainIssue

103− relatedIssues = (==) `withClass` \case

103+ relatedIssues =

104+ (==) `withClass` \case

104 EnumDoesntSatisfy v -> Just v

105 EnumDoesntSatisfy v -> Just v

105 NoMatchingEnum v -> Just v

106 NoMatchingEnum v -> Just v

106 _ -> Nothing

107 _ -> Nothing

107− `withClass` \case

108+ `withClass` \case

108− NoMatchingMaximum _ -> Just ()

109+ NoMatchingMaximum _ -> Just ()

109− MatchingMaximumWeak _ -> Just ()

110+ MatchingMaximumWeak _ -> Just ()

110− _ -> Nothing

111+ _ -> Nothing

111− `withClass` \case

112+ `withClass` \case

112− NoMatchingMinimum _ -> Just ()

113+ NoMatchingMinimum _ -> Just ()

113− MatchingMinimumWeak _ -> Just ()

114+ MatchingMinimumWeak _ -> Just ()

114− _ -> Nothing

115+ _ -> Nothing

115− `withClass` \case

116+ `withClass` \case

116− NoMatchingMultipleOf _ -> Just ()

117+ NoMatchingMultipleOf _ -> Just ()

117− MatchingMultipleOfWeak _ -> Just ()

118+ MatchingMultipleOfWeak _ -> Just ()

118− _ -> Nothing

119+ _ -> Nothing

119− `withClass` \case

120+ `withClass` \case

120− NoMatchingMaxLength _ -> Just ()

121+ NoMatchingMaxLength _ -> Just ()

121− MatchingMaxLengthWeak _ -> Just ()

122+ MatchingMaxLengthWeak _ -> Just ()

122− _ -> Nothing

123+ _ -> Nothing

123− `withClass` \case

124+ `withClass` \case

124− NoMatchingMinLength _ -> Just ()

125+ NoMatchingMinLength _ -> Just ()

125− MatchingMinLengthWeak _ -> Just ()

126+ MatchingMinLengthWeak _ -> Just ()

126− _ -> Nothing

127+ _ -> Nothing

127− `withClass` \case

128+ `withClass` \case

128− NoMatchingItems -> Just ()

129+ NoMatchingItems -> Just ()

129− ArrayToTuple -> Just ()

130+ ArrayToTuple -> Just ()

130− TupleToArray -> Just ()

131+ TupleToArray -> Just ()

131− NoMatchingTupleItems -> Just ()

132+ NoMatchingTupleItems -> Just ()

132− TupleItemsLengthChanged _ -> Just ()

133+ TupleItemsLengthChanged _ -> Just ()

133− _ -> Nothing

134+ _ -> Nothing

134− `withClass` \case

135+ `withClass` \case

135− NoMatchingMaxItems _ -> Just ()

136+ NoMatchingMaxItems _ -> Just ()

136− MatchingMaxItemsWeak _ -> Just ()

137+ MatchingMaxItemsWeak _ -> Just ()

137− _ -> Nothing

138+ _ -> Nothing

138− `withClass` \case

139+ `withClass` \case

139− NoMatchingMinItems _ -> Just ()

140+ NoMatchingMinItems _ -> Just ()

140− MatchingMinItemsWeak _ -> Just ()

141+ MatchingMinItemsWeak _ -> Just ()

141− _ -> Nothing

142+ _ -> Nothing

142− `withClass` \case

143+ `withClass` \case

143− NoMatchingMaxProperties _ -> Just ()

144+ NoMatchingMaxProperties _ -> Just ()

144− MatchingMaxPropertiesWeak _ -> Just ()

145+ MatchingMaxPropertiesWeak _ -> Just ()

145− _ -> Nothing

146+ _ -> Nothing

146− `withClass` \case

147+ `withClass` \case

147− NoMatchingMinProperties _ -> Just ()

148+ NoMatchingMinProperties _ -> Just ()

148− MatchingMinPropertiesWeak _ -> Just ()

149+ MatchingMinPropertiesWeak _ -> Just ()

149− _ -> Nothing

150+ _ -> Nothing

150 describeIssue Forward (EnumDoesntSatisfy v) = para "The following enum value was removed:" <> showJSONValue v

151 describeIssue Forward (EnumDoesntSatisfy v) = para "The following enum value was removed:" <> showJSONValue v

151 describeIssue Backward (EnumDoesntSatisfy v) = para "The following enum value was added:" <> showJSONValue v

152 describeIssue Backward (EnumDoesntSatisfy v) = para "The following enum value was added:" <> showJSONValue v

152 describeIssue Forward (NoMatchingEnum v) = para "The following enum value has been added:" <> showJSONValue v

153 describeIssue Forward (NoMatchingEnum v) = para "The following enum value has been added:" <> showJSONValue v

@@ -254,16 +255,17 @@ instance Issuable 'SchemaLevel where

254 PropertyToAdditional -> Comment

255 PropertyToAdditional -> Comment

255 TypesRestricted _ -> ProbablyIssue -- TODO: #70

256 TypesRestricted _ -> ProbablyIssue -- TODO: #70

256 _ -> CertainIssue

257 _ -> CertainIssue

257− relatedIssues = (==) `withClass` \case

258+ relatedIssues =

259+ (==) `withClass` \case

258 AdditionalToProperty -> Just ()

260 AdditionalToProperty -> Just ()

259 PropertyToAdditional -> Just ()

261 PropertyToAdditional -> Just ()

260 _ -> Nothing

262 _ -> Nothing

261− `withClass` \case

263+ `withClass` \case

262− PropertyNowRequired -> Just ()

264+ PropertyNowRequired -> Just ()

263− UnexpectedProperty -> Just ()

265+ UnexpectedProperty -> Just ()

264− _ -> Nothing

266+ _ -> Nothing

265 describeIssue _ (NotSupported i) =

267 describeIssue _ (NotSupported i) =

266− para (emph "Encountered a feature that OpenApi Diff does not support: " <> text i <> ".")

268+ para (emph "Encountered a feature that CompaREST does not support: " <> text i <> ".")

267 describeIssue _ OneOfNotDisjoint =

269 describeIssue _ OneOfNotDisjoint =

268 para $

270 para $

269 "Could not deduce that " <> code "oneOf"

271 "Could not deduce that " <> code "oneOf"

@@ -275,7 +277,7 @@ instance Issuable 'SchemaLevel where

275 describeIssue _ (InvalidSchema i) =

277 describeIssue _ (InvalidSchema i) =

276 para (emph "The schema is invalid: " <> text i <> ".")

278 para (emph "The schema is invalid: " <> text i <> ".")

277 describeIssue _ UnguardedRecursion =

279 describeIssue _ UnguardedRecursion =

278− para "Encountered recursion that is too complex for OpenApi Diff to untangle."

280+ para "Encountered recursion that is too complex for CompaREST to untangle."

279 describeIssue Forward (TypesRestricted tys) = case tys of

281 describeIssue Forward (TypesRestricted tys) = case tys of

280 [] -> para "No longer has any valid values." -- weird

282 [] -> para "No longer has any valid values." -- weird

281 _ -> para "Values are now limited to the following types: " <> bulletList (para . describeJSONType <$> tys)

283 _ -> para "Values are now limited to the following types: " <> bulletList (para . describeJSONType <$> tys)

src/OpenAPI/Checker/Validate/Schema/JsonFormula.hs → src/Data/OpenApi/Compare/Validate/Schema/JsonFormula.hsrenamed+55−48

@@ -1,18 +1,18 @@

1−module OpenAPI.Checker.Validate.Schema.JsonFormula

1+module Data.OpenApi.Compare.Validate.Schema.JsonFormula

2− ( Bound (..)

2+ ( Bound (..),

3− , showBound

3+ showBound,

4− , Property (..)

4+ Property (..),

5− , Condition (..)

5+ Condition (..),

6− , showCondition

6+ showCondition,

7− , satisfiesTyped

7+ satisfiesTyped,

8− , checkStringFormat

8+ checkStringFormat,

9− , checkNumberFormat

9+ checkNumberFormat,

10− , SomeCondition (..)

10+ SomeCondition (..),

11− , JsonFormula (..)

11+ JsonFormula (..),

12− , satisfiesFormula

12+ satisfiesFormula,

13− , satisfies

13+ satisfies,

14− , showJSONValue

14+ showJSONValue,

15− , showJSONValueInline

15+ showJSONValueInline,

16 )

17where

18

@@ -20,13 +20,17 @@ import Algebra.Lattice

20import qualified Data.Aeson as A

21import qualified Data.ByteString.Lazy as BSL

22import qualified Data.Foldable as F

23−import qualified Data.HashMap.Strict as HM

24import Data.Functor

23import Data.Functor

24+import qualified Data.HashMap.Strict as HM

25import Data.Int

26import Data.Kind

27import qualified Data.Map as M

28import Data.Maybe

29import Data.OpenApi

30+import Data.OpenApi.Compare.Orphans ()

31+import Data.OpenApi.Compare.Subtree

32+import Data.OpenApi.Compare.Validate.Schema.DNF

33+import Data.OpenApi.Compare.Validate.Schema.TypedJson

30import Data.Ord

34import Data.Ord

31import Data.Ratio

35import Data.Ratio

32import Data.Scientific

36import Data.Scientific

@@ -35,10 +39,6 @@ import Data.Text (Text)

35import qualified Data.Text as T

39import qualified Data.Text as T

36import qualified Data.Text.Encoding as T

40import qualified Data.Text.Encoding as T

37import Data.Typeable

41import Data.Typeable

38−import OpenAPI.Checker.Orphans ()

39−import OpenAPI.Checker.Subtree

40−import OpenAPI.Checker.Validate.Schema.DNF

41−import OpenAPI.Checker.Validate.Schema.TypedJson

42import Text.Pandoc.Builder hiding (Format, Null)

43import Text.Regex.Pcre2

44

@@ -67,30 +67,33 @@ data Property = Property

67data Condition :: JsonType -> Type where

68 Exactly :: TypedValue t -> Condition t

69 Maximum :: !(Bound Scientific) -> Condition 'Number

70− Minimum

70+ Minimum ::

71− :: !(Down (Bound (Down Scientific)))

71+ !(Down (Bound (Down Scientific))) ->

72− -> Condition 'Number -- ^ this has the right Ord

72+ -- | this has the right Ord

73+ Condition 'Number

73 MultipleOf :: !Scientific -> Condition 'Number

74 MultipleOf :: !Scientific -> Condition 'Number

74 NumberFormat :: !Format -> Condition 'Number

75 NumberFormat :: !Format -> Condition 'Number

75 MaxLength :: !Integer -> Condition 'String

76 MaxLength :: !Integer -> Condition 'String

76 MinLength :: !Integer -> Condition 'String

77 MinLength :: !Integer -> Condition 'String

77 Pattern :: !Pattern -> Condition 'String

78 Pattern :: !Pattern -> Condition 'String

78 StringFormat :: !Format -> Condition 'String

79 StringFormat :: !Format -> Condition 'String

79− Items

80+ Items ::

80− :: !(ForeachType JsonFormula)

81+ !(ForeachType JsonFormula) ->

81− -> !(Traced (Referenced Schema))

82+ !(Traced (Referenced Schema)) ->

82− -> Condition 'Array

83+ Condition 'Array

83− TupleItems

84+ TupleItems ::

84− :: ![(ForeachType JsonFormula, Traced (Referenced Schema))]

85+ ![(ForeachType JsonFormula, Traced (Referenced Schema))] ->

85− -> Condition 'Array

86+ Condition 'Array

86 MaxItems :: !Integer -> Condition 'Array

87 MaxItems :: !Integer -> Condition 'Array

87 MinItems :: !Integer -> Condition 'Array

88 MinItems :: !Integer -> Condition 'Array

88 UniqueItems :: Condition 'Array

89 UniqueItems :: Condition 'Array

89− Properties

90+ Properties ::

90− :: !(M.Map Text Property)

91+ !(M.Map Text Property) ->

92+ -- | formula for additional properties

91− -> !(ForeachType JsonFormula) -- ^ formula for additional properties

93+ !(ForeachType JsonFormula) ->

92− -> !(Maybe (Traced (Referenced Schema))) -- ^ schema for additional properties, Nothing means bottom

94+ -- | schema for additional properties, Nothing means bottom

95+ !(Maybe (Traced (Referenced Schema))) ->

93− -> Condition 'Object

96+ Condition 'Object

94 MaxProperties :: !Integer -> Condition 'Object

97 MaxProperties :: !Integer -> Condition 'Object

95 MinProperties :: !Integer -> Condition 'Object

98 MinProperties :: !Integer -> Condition 'Object

96

99

@@ -118,13 +121,15 @@ showCondition = \case

118 UniqueItems -> para "The elements in the array should be unique."

121 UniqueItems -> para "The elements in the array should be unique."

119 (Properties props additional _) ->

122 (Properties props additional _) ->

120 bulletList $

123 bulletList $

121− (M.toList props

124+ ( M.toList props

122− <&> (\(k, p) ->

125+ <&> ( \(k, p) ->

123− para (code k)

126+ para (code k)

124− <> para (strong $ if propRequired p then "Required" else "Optional")

127+ <> para (strong $ if propRequired p then "Required" else "Optional")

125− <> showForEachJsonFormula (propFormula p)))

128+ <> showForEachJsonFormula (propFormula p)

129+ )

130+ )

126 <> [ para (emph "Additional properties")

131 <> [ para (emph "Additional properties")

127− <> showForEachJsonFormula additional

132+ <> showForEachJsonFormula additional

128 ]

133 ]

129 (MaxProperties n) -> para $ "The maximum number of fields should be " <> show' n <> "."

134 (MaxProperties n) -> para $ "The maximum number of fields should be " <> show' n <> "."

130 (MinProperties n) -> para $ "The minimum number of fields should be " <> show' n <> "."

135 (MinProperties n) -> para $ "The minimum number of fields should be " <> show' n <> "."

@@ -133,15 +138,17 @@ showCondition = \case

133 showForEachJsonFormula i =

138 showForEachJsonFormula i =

134 bulletList $

139 bulletList $

135 foldType

140 foldType

136− (\t f -> case getJsonFormula $ f i of

141+ ( \t f -> case getJsonFormula $ f i of

137− BottomDNF -> mempty

142+ BottomDNF -> mempty

138− (DNF conds) ->

143+ (DNF conds) ->

139 [ para (describeJSONType t)

144 [ para (describeJSONType t)

140 <> bulletList

145 <> bulletList

141− (S.toList conds <&> \case

146+ ( S.toList conds <&> \case

142− Disjunct (S.toList -> []) -> para "Empty"

147+ Disjunct (S.toList -> []) -> para "Empty"

143− Disjunct (S.toList -> cond) -> bulletList (showCondition <$> cond))

148+ Disjunct (S.toList -> cond) -> bulletList (showCondition <$> cond)

149+ )

144− ])

150+ ]

151+ )

145

152

146showJSONValue :: A.Value -> Blocks

153showJSONValue :: A.Value -> Blocks

147showJSONValue v = codeBlockWith ("", ["json"], mempty) (T.decodeUtf8 . BSL.toStrict . A.encode $ v)

154showJSONValue v = codeBlockWith ("", ["json"], mempty) (T.decodeUtf8 . BSL.toStrict . A.encode $ v)

src/OpenAPI/Checker/Validate/Schema/Partition.hs → src/Data/OpenApi/Compare/Validate/Schema/Partition.hsrenamed+38−37

@@ -1,15 +1,15 @@

1−module OpenAPI.Checker.Validate.Schema.Partition

1+module Data.OpenApi.Compare.Validate.Schema.Partition

2− ( partitionSchema

2+ ( partitionSchema,

3− , partitionRefSchema

3+ partitionRefSchema,

4− , selectPartition

4+ selectPartition,

5− , runPartitionM

5+ runPartitionM,

6− , tryPartition

6+ tryPartition,

7− , showPartition

7+ showPartition,

8− , intersectSchema

8+ intersectSchema,

9− , intersectRefSchema

9+ intersectRefSchema,

10− , IntersectionResult (..)

10+ IntersectionResult (..),

11− , runIntersectionM

11+ runIntersectionM,

12− , Partition

12+ Partition,

13 )

14where

15

@@ -32,17 +32,17 @@ import qualified Data.List.NonEmpty as NE

32import qualified Data.Map as M

33import Data.Maybe

34import Data.OpenApi

35+import Data.OpenApi.Compare.Memo

36+import Data.OpenApi.Compare.References

37+import Data.OpenApi.Compare.Subtree

38+import Data.OpenApi.Compare.Validate.Schema.DNF

39+import Data.OpenApi.Compare.Validate.Schema.JsonFormula

40+import Data.OpenApi.Compare.Validate.Schema.Traced

41+import Data.OpenApi.Compare.Validate.Schema.TypedJson

35import Data.Ord

42import Data.Ord

36import qualified Data.Set as S

43import qualified Data.Set as S

37import Data.Text (Text)

44import Data.Text (Text)

38import qualified Data.Text as T

45import qualified Data.Text as T

39−import OpenAPI.Checker.Memo

40−import OpenAPI.Checker.References

41−import OpenAPI.Checker.Subtree

42−import OpenAPI.Checker.Validate.Schema.DNF

43−import OpenAPI.Checker.Validate.Schema.JsonFormula

44−import OpenAPI.Checker.Validate.Schema.Traced

45−import OpenAPI.Checker.Validate.Schema.TypedJson

46import Text.Pandoc.Builder hiding (Format, Null)

47

48data PartitionData

@@ -143,10 +143,11 @@ partitionCondition = \case

143 Just _ -> top

144 Nothing ->

145 singletonPart $

146− DByProperties $ LiteralDNF

146+ DByProperties $

147+ LiteralDNF

147− ( M.keysSet $ M.filter (not . propRequired) props

148+ ( M.keysSet $ M.filter (not . propRequired) props

148− , M.keysSet $ M.filter propRequired props

149+ , M.keysSet $ M.filter propRequired props

149− )

150+ )

150 inProps <- forM (M.toList $ M.filter propRequired props) $ \(k, prop) -> do

151 inProps <- forM (M.toList $ M.filter propRequired props) $ \(k, prop) -> do

151 f <- partitionRefSchema $ propRefSchema prop

152 f <- partitionRefSchema $ propRefSchema prop

152 pure $ fmap (\(Partitions m) -> Partitions $ M.mapKeysMonotonic (PInProperty k) m) f

153 pure $ fmap (\(Partitions m) -> Partitions $ M.mapKeysMonotonic (PInProperty k) m) f

@@ -156,10 +157,10 @@ partitionCondition = \case

156runPartitionM :: Traced (Definitions Schema) -> PartitionM a -> a

157runPartitionM :: Traced (Definitions Schema) -> PartitionM a -> a

157runPartitionM defs = runIdentity . runMemo () . (`runReaderT` defs)

158runPartitionM defs = runIdentity . runMemo () . (`runReaderT` defs)

158

159

159−partitionJsonFormulas

160+partitionJsonFormulas ::

160− :: ProdCons (Traced (Definitions Schema))

161+ ProdCons (Traced (Definitions Schema)) ->

161− -> ProdCons (JsonFormula t)

162+ ProdCons (JsonFormula t) ->

162− -> Lifted Partitions

163+ Lifted Partitions

163partitionJsonFormulas defs pc = producer pcPart \/ consumer pcPart

164partitionJsonFormulas defs pc = producer pcPart \/ consumer pcPart

164 where

165 where

165 pcPart = partitionFormula <$> defs <*> pc

166 pcPart = partitionFormula <$> defs <*> pc

@@ -211,11 +212,11 @@ runIntersectionM defs act = case runWriterT $ runReaderT act defs of

211 Just (x, Any False) -> Same x

212 Just (x, Any False) -> Same x

212 Just (x, Any True) -> New x

213 Just (x, Any True) -> New x

213

214

214−intersectSchema

215+intersectSchema ::

215− :: PartitionLocation

216+ PartitionLocation ->

216− -> PartitionChoice

217+ PartitionChoice ->

217− -> Traced Schema

218+ Traced Schema ->

218− -> IntersectionM Schema

219+ IntersectionM Schema

219intersectSchema loc part sch = do

220intersectSchema loc part sch = do

220 allOf' <- forM (tracedAllOf sch) $ \rss ->

221 allOf' <- forM (tracedAllOf sch) $ \rss ->

221 -- Assuming i ranges over a nonempty set (checked in processSchema)

222 -- Assuming i ranges over a nonempty set (checked in processSchema)

@@ -258,11 +259,11 @@ intersectSchema loc part sch = do

258 pure $ sch' {_schemaEnum = Just enum'}

259 pure $ sch' {_schemaEnum = Just enum'}

259 CByProperties {} -> error "CByProperties not implemented"

260 CByProperties {} -> error "CByProperties not implemented"

260

261

261−intersectRefSchema

262+intersectRefSchema ::

262− :: PartitionLocation

263+ PartitionLocation ->

263− -> PartitionChoice

264+ PartitionChoice ->

264− -> Traced (Referenced Schema)

265+ Traced (Referenced Schema) ->

265− -> IntersectionM (Referenced Schema)

266+ IntersectionM (Referenced Schema)

266intersectRefSchema loc part rs = do

267intersectRefSchema loc part rs = do

267 defs <- R.ask

268 defs <- R.ask

268 Inline <$> intersectSchema loc part (dereference defs rs)

269 Inline <$> intersectSchema loc part (dereference defs rs)

src/OpenAPI/Checker/Validate/Schema/Process.hs → src/Data/OpenApi/Compare/Validate/Schema/Process.hsrenamed+48−47

@@ -1,11 +1,11 @@

1−module OpenAPI.Checker.Validate.Schema.Process

1+module Data.OpenApi.Compare.Validate.Schema.Process

2− ( schemaToFormula

2+ ( schemaToFormula,

3 )

4where

5

6import Algebra.Lattice

7−import qualified Control.Monad.Reader as R

8import Control.Monad.Reader hiding (ask)

7import Control.Monad.Reader hiding (ask)

8+import qualified Control.Monad.Reader as R

9import Control.Monad.State

10import Control.Monad.Writer

11import qualified Data.Aeson as A

@@ -14,20 +14,20 @@ import qualified Data.HashMap.Strict.InsOrd as IOHM

14import qualified Data.Map as M

15import Data.Maybe

16import Data.OpenApi hiding (get)

17+import Data.OpenApi.Compare.Behavior

18+import Data.OpenApi.Compare.Memo

19+import Data.OpenApi.Compare.Paths

20+import qualified Data.OpenApi.Compare.PathsPrefixTree as P

21+import Data.OpenApi.Compare.References

22+import Data.OpenApi.Compare.Subtree

23+import Data.OpenApi.Compare.Validate.Schema.DNF

24+import Data.OpenApi.Compare.Validate.Schema.Issues

25+import Data.OpenApi.Compare.Validate.Schema.JsonFormula

26+import Data.OpenApi.Compare.Validate.Schema.Partition

27+import Data.OpenApi.Compare.Validate.Schema.Traced

28+import Data.OpenApi.Compare.Validate.Schema.TypedJson

17import Data.Ord

29import Data.Ord

18import qualified Data.Set as S

30import qualified Data.Set as S

19−import OpenAPI.Checker.Behavior

20−import OpenAPI.Checker.Memo

21−import OpenAPI.Checker.Paths

22−import qualified OpenAPI.Checker.PathsPrefixTree as P

23−import OpenAPI.Checker.References

24−import OpenAPI.Checker.Subtree

25−import OpenAPI.Checker.Validate.Schema.DNF

26−import OpenAPI.Checker.Validate.Schema.Issues

27−import OpenAPI.Checker.Validate.Schema.JsonFormula

28−import OpenAPI.Checker.Validate.Schema.Partition

29−import OpenAPI.Checker.Validate.Schema.Traced

30−import OpenAPI.Checker.Validate.Schema.TypedJson

31

32-- | A fake writer monad that doesn't actually record anything and allows lazy recursion.

33newtype Silent w a = Silent {runSilent :: a}

@@ -71,10 +71,10 @@ warnKnot =

71 , tieKnot = \_ -> pure

72 }

73

74−processRefSchema

74+processRefSchema ::

75− :: MonadProcess m

75+ MonadProcess m =>

76− => Traced (Referenced Schema)

76+ Traced (Referenced Schema) ->

77− -> m (ForeachType JsonFormula)

77+ m (ForeachType JsonFormula)

78processRefSchema x = do

79 defs <- R.ask

80 memoWithKnot warnKnot (processSchema $ dereference defs x) (ask x)

@@ -82,10 +82,10 @@ processRefSchema x = do

82-- | Turn a schema into a tuple of 'JsonFormula's that describes the condition

83-- for every possible type of a JSON value. The conditions are independent, and

84-- are thus checked independently.

85−processSchema

85+processSchema ::

86− :: MonadProcess m

86+ MonadProcess m =>

87− => Traced Schema

87+ Traced Schema ->

88− -> m (ForeachType JsonFormula)

88+ m (ForeachType JsonFormula)

89processSchema sch@(extract -> Schema {..}) = do

90 let singletonFormula :: Condition t -> JsonFormula t

91 singletonFormula = JsonFormula . LiteralDNF

@@ -331,26 +331,27 @@ processSchema sch@(extract -> Schema {..}) = do

331 pure $

332 nullableClause

333 \/ meets

334− (allClauses

334+ ( allClauses

335− <> [ anyClause

335+ <> [ anyClause

336− , oneClause

336+ , oneClause

337− , typeClause

337+ , typeClause

338− , enumClause

338+ , enumClause

339− , maximumClause

339+ , maximumClause

340− , minimumClause

340+ , minimumClause

341− , multipleOfClause

341+ , multipleOfClause

342− , formatClause

342+ , formatClause

343− , maxLengthClause

343+ , maxLengthClause

344− , minLengthClause

344+ , minLengthClause

345− , patternClause

345+ , patternClause

346− , itemsClause

346+ , itemsClause

347− , maxItemsClause

347+ , maxItemsClause

348− , minItemsClause

348+ , minItemsClause

349− , uniqueItemsClause

349+ , uniqueItemsClause

350− , propertiesClause

350+ , propertiesClause

351− , maxPropertiesClause

351+ , maxPropertiesClause

352− , minPropertiesClause

352+ , minPropertiesClause

353− ])

353+ ]

354+ )

354

355

355{- TODO: ReadOnly/WriteOnly #68 -}

356{- TODO: ReadOnly/WriteOnly #68 -}

356

357

@@ -369,8 +370,8 @@ checkOneOfDisjoint schs = do

369runProcessM :: Traced (Definitions Schema) -> ProcessM a -> (a, P.PathsPrefixTree Behave AnIssue 'SchemaLevel)

370runProcessM :: Traced (Definitions Schema) -> ProcessM a -> (a, P.PathsPrefixTree Behave AnIssue 'SchemaLevel)

370runProcessM defs = runWriter . (`runReaderT` defs) . runMemo ()

371runProcessM defs = runWriter . (`runReaderT` defs) . runMemo ()

371

372

372−schemaToFormula

373+schemaToFormula ::

373− :: Traced (Definitions Schema)

374+ Traced (Definitions Schema) ->

374− -> Traced Schema

375+ Traced Schema ->

375− -> (ForeachType JsonFormula, P.PathsPrefixTree Behave AnIssue 'SchemaLevel)

376+ (ForeachType JsonFormula, P.PathsPrefixTree Behave AnIssue 'SchemaLevel)

376schemaToFormula defs rs = runProcessM defs $ processSchema rs

377schemaToFormula defs rs = runProcessM defs $ processSchema rs

src/OpenAPI/Checker/Validate/Schema/Traced.hs → src/Data/OpenApi/Compare/Validate/Schema/Traced.hsrenamed+14−14

@@ -1,18 +1,18 @@

1{-# OPTIONS_GHC -Wno-orphans #-}

2

3−module OpenAPI.Checker.Validate.Schema.Traced

3+module Data.OpenApi.Compare.Validate.Schema.Traced

4− ( Step (..)

4+ ( Step (..),

5− , tracedAllOf

5+ tracedAllOf,

6− , tracedAnyOf

6+ tracedAnyOf,

7− , tracedOneOf

7+ tracedOneOf,

8− , tracedItems

8+ tracedItems,

9− , tracedAdditionalProperties

9+ tracedAdditionalProperties,

10− , tracedDiscriminator

10+ tracedDiscriminator,

11− , tracedProperties

11+ tracedProperties,

12− , tracedConjunct

12+ tracedConjunct,

13− , PartitionLocation (..)

13+ PartitionLocation (..),

14− , PartitionChoice (..)

14+ PartitionChoice (..),

15− , Partition

15+ Partition,

16 )

17where

18

@@ -21,9 +21,9 @@ import Data.Functor

21import qualified Data.HashMap.Strict.InsOrd as IOHM

22import qualified Data.List.NonEmpty as NE

23import Data.OpenApi

24+import Data.OpenApi.Compare.Subtree

24import qualified Data.Set as S

25import qualified Data.Set as S

25import Data.Text (Text)

26import Data.Text (Text)

26−import OpenAPI.Checker.Subtree

27

28data PartitionChoice

29 = CByEnumValue (S.Set A.Value)

src/OpenAPI/Checker/Validate/Schema/TypedJson.hs → src/Data/OpenApi/Compare/Validate/Schema/TypedJson.hsrenamed+26−24

@@ -1,11 +1,11 @@

1−module OpenAPI.Checker.Validate.Schema.TypedJson

1+module Data.OpenApi.Compare.Validate.Schema.TypedJson

2− ( JsonType (..)

2+ ( JsonType (..),

3− , describeJSONType

3+ describeJSONType,

4− , TypedValue (..)

4+ TypedValue (..),

5− , untypeValue

5+ untypeValue,

6− , ForeachType (..)

6+ ForeachType (..),

7− , foldType

7+ foldType,

8− , forType_

8+ forType_,

9 )

10where

11

@@ -88,24 +88,26 @@ forType_ :: Applicative m => (forall x. Typeable x => JsonType -> (ForeachType f

88forType_ k = getAp $ foldType (\ty proj -> Ap $ k ty proj)

89

90broadcastType :: (forall x. Typeable x => f x) -> ForeachType f

91−broadcastType k = ForeachType

91+broadcastType k =

92+ ForeachType

92− { forNull = k

93+ { forNull = k

93− , forBoolean = k

94+ , forBoolean = k

94− , forNumber = k

95+ , forNumber = k

95− , forString = k

96+ , forString = k

96− , forArray = k

97+ , forArray = k

97− , forObject = k

98+ , forObject = k

98− }

99+ }

99

100

100zipType :: (forall x. Typeable x => f x -> g x -> h x) -> ForeachType f -> ForeachType g -> ForeachType h

101zipType :: (forall x. Typeable x => f x -> g x -> h x) -> ForeachType f -> ForeachType g -> ForeachType h

101−zipType k f1 f2 = ForeachType

102+zipType k f1 f2 =

103+ ForeachType

102− { forNull = k (forNull f1) (forNull f2)

104+ { forNull = k (forNull f1) (forNull f2)

103− , forBoolean = k (forBoolean f1) (forBoolean f2)

105+ , forBoolean = k (forBoolean f1) (forBoolean f2)

104− , forNumber = k (forNumber f1) (forNumber f2)

106+ , forNumber = k (forNumber f1) (forNumber f2)

105− , forString = k (forString f1) (forString f2)

107+ , forString = k (forString f1) (forString f2)

106− , forArray = k (forArray f1) (forArray f2)

108+ , forArray = k (forArray f1) (forArray f2)

107− , forObject = k (forObject f1) (forObject f2)

109+ , forObject = k (forObject f1) (forObject f2)

108− }

110+ }

109

111

110instance (forall x. Lattice (f x)) => Lattice (ForeachType f) where

112instance (forall x. Lattice (f x)) => Lattice (ForeachType f) where

111 (\/) = zipType (\/)

113 (\/) = zipType (\/)

src/OpenAPI/Checker/Validate/SecurityRequirement.hs → src/Data/OpenApi/Compare/Validate/SecurityRequirement.hsrenamed+14−13

@@ -1,8 +1,8 @@

1{-# LANGUAGE PartialTypeSignatures #-}

2{-# OPTIONS_GHC -Wno-orphans #-}

3

4−module OpenAPI.Checker.Validate.SecurityRequirement

4+module Data.OpenApi.Compare.Validate.SecurityRequirement

5− ( Issue (..)

5+ ( Issue (..),

6 )

7where

8

@@ -17,14 +17,14 @@ import Data.HList

17import qualified Data.HashMap.Strict.InsOrd as IOHM

18import qualified Data.List.NonEmpty as NE

19import Data.OpenApi

20+import Data.OpenApi.Compare.Behavior

21+import Data.OpenApi.Compare.Subtree

22+import Data.OpenApi.Compare.Validate.OAuth2Flows

23+import Data.OpenApi.Compare.Validate.SecurityScheme ()

20import Data.Set (Set)

24import Data.Set (Set)

21import qualified Data.Set as S

25import qualified Data.Set as S

22import Data.Text (Text)

26import Data.Text (Text)

23import Data.Traversable

27import Data.Traversable

24−import OpenAPI.Checker.Behavior

25−import OpenAPI.Checker.Subtree

26−import OpenAPI.Checker.Validate.OAuth2Flows

27−import OpenAPI.Checker.Validate.SecurityScheme ()

28

29instance Subtree SecurityRequirement where

30 type SubtreeLevel SecurityRequirement = 'SecurityRequirementLevel

@@ -41,18 +41,19 @@ instance Subtree SecurityRequirement where

41 for (IOHM.toList $ getSecurityRequirement sec) $ \(key, scopes) ->

42 (,scopes) <$> lookupScheme key defs

43 structuralMaybeWith

44− (\pc' -> do

44+ ( \pc' -> do

45− let ProdCons pScopes cScopes = fmap snd <$> pc'

45+ let ProdCons pScopes cScopes = fmap snd <$> pc'

46− unless (pScopes == cScopes) structuralIssue

46+ unless (pScopes == cScopes) structuralIssue

47− structuralList env $ fmap fst <$> pc'

47+ structuralList env $ fmap fst <$> pc'

48− pure ())

48+ pure ()

49+ )

49 normalized

50 normalized

50 pure ()

51 pure ()

51 checkSemanticCompatibility env bhv' pc = do

52 checkSemanticCompatibility env bhv' pc = do

52 let schemes = getH @(ProdCons (Traced (Definitions SecurityScheme))) env

53 let schemes = getH @(ProdCons (Traced (Definitions SecurityScheme))) env

53 ( ProdCons pErrs cErrs

54 ( ProdCons pErrs cErrs

54− , (ProdCons pSchemes cSchemes)

55+ , (ProdCons pSchemes cSchemes) ::

55− :: ProdCons [(Behavior 'SecuritySchemeLevel, Traced SecurityScheme, [Text])]

56+ ProdCons [(Behavior 'SecuritySchemeLevel, Traced SecurityScheme, [Text])]

56 ) =

57 ) =

57 NE.unzip $

58 NE.unzip $

58 partitionEithers <$> do

59 partitionEithers <$> do

src/OpenAPI/Checker/Validate/SecurityScheme.hs → src/Data/OpenApi/Compare/Validate/SecurityScheme.hsrenamed+5−5

@@ -1,16 +1,16 @@

1{-# OPTIONS_GHC -Wno-orphans #-}

2

3−module OpenAPI.Checker.Validate.SecurityScheme

3+module Data.OpenApi.Compare.Validate.SecurityScheme

4 (

5 )

6where

7

8import Control.Monad

9import Data.OpenApi

10−import OpenAPI.Checker.Behavior

10+import Data.OpenApi.Compare.Behavior

11−import OpenAPI.Checker.Orphans ()

11+import Data.OpenApi.Compare.Orphans ()

12−import OpenAPI.Checker.Subtree

12+import Data.OpenApi.Compare.Subtree

13−import OpenAPI.Checker.Validate.OAuth2Flows

13+import Data.OpenApi.Compare.Validate.OAuth2Flows

14

15instance Subtree SecurityScheme where

16 type CheckEnv SecurityScheme = '[]

src/OpenAPI/Checker/Validate/Server.hs → src/Data/OpenApi/Compare/Validate/Server.hsrenamed+17−16

@@ -1,7 +1,7 @@

1{-# OPTIONS_GHC -Wno-orphans #-}

2

3−module OpenAPI.Checker.Validate.Server

3+module Data.OpenApi.Compare.Validate.Server

4− ( Issue (..)

4+ ( Issue (..),

5 )

6where

7

@@ -19,21 +19,21 @@ import qualified Data.HashSet.InsOrd as IOHM

19import qualified Data.HashSet.InsOrd as IOHS

20import Data.Maybe

21import Data.OpenApi

22+import Data.OpenApi.Compare.Behavior

23+import Data.OpenApi.Compare.Common

24+import Data.OpenApi.Compare.Paths

25+import Data.OpenApi.Compare.Subtree

26+import Data.OpenApi.Compare.Validate.MediaTypeObject

22import qualified Data.Set as S

27import qualified Data.Set as S

23import Data.Text (Text)

28import Data.Text (Text)

24import qualified Data.Text as T

29import qualified Data.Text as T

25import Data.Traversable

30import Data.Traversable

26−import OpenAPI.Checker.Behavior

27−import OpenAPI.Checker.Common

28−import OpenAPI.Checker.Paths

29−import OpenAPI.Checker.Subtree

30−import OpenAPI.Checker.Validate.MediaTypeObject

31import Text.Pandoc.Builder

32import Prelude as P

33

34−tracedParsedServerUrlParts

34+tracedParsedServerUrlParts ::

35− :: Server

35+ Server ->

36− -> Either (Issue 'ServerLevel) ProcessedServer

36+ Either (Issue 'ServerLevel) ProcessedServer

37tracedParsedServerUrlParts s =

38 let parsedUrl = parseServerUrl $ _serverUrl s

39 lookupVar var = case IOHM.lookup var (_serverVariables s) of

@@ -63,11 +63,12 @@ instance Subtree [Server] where

63 pcServer

64 <&> partitionEithers

65 . fmap

66− (\(Traced t s) ->

66+ ( \(Traced t s) ->

67− let bhv = beh >>> step (InServer $ _serverUrl s)

67+ let bhv = beh >>> step (InServer $ _serverUrl s)

68− in case tracedParsedServerUrlParts s of

68+ in case tracedParsedServerUrlParts s of

69− Left e -> Left $ issueAt bhv e

69+ Left e -> Left $ issueAt bhv e

70− Right u -> Right (bhv, Traced (t >>> step (ServerStep $ _serverUrl s)) u))

70+ Right u -> Right (bhv, Traced (t >>> step (ServerStep $ _serverUrl s)) u)

71+ )

71 . sequence

72 . sequence

72 sequenceA_ pErrs

73 sequenceA_ pErrs

73 sequenceA_ cErrs

74 sequenceA_ cErrs

@@ -101,7 +102,7 @@ data ServerUrlPart var

101 deriving stock (Eq, Show, Functor, Foldable, Traversable)

102 deriving stock (Eq, Show, Functor, Foldable, Traversable)

102

103

103-- | This is super rough. Things like @{a|b}c@ will not match @ac@.

104-- | This is super rough. Things like @{a|b}c@ will not match @ac@.

104−-- FIXME: https://github.com/typeable/openapi-diff/issues/46

105+-- FIXME: #46

105--

106--

106-- NOTE: syntax is defined vaguely in the spec.

107-- NOTE: syntax is defined vaguely in the spec.

107parseServerUrl :: Text -> [ServerUrlPart Text]

108parseServerUrl :: Text -> [ServerUrlPart Text]

src/Data/OpenApi/Compare/Validate/Sums.hsnew file+25

@@ -0,0 +1,25 @@

1+module Data.OpenApi.Compare.Validate.Sums

2+ ( checkSums,

3+ )

4+where

5+

6+import Data.Foldable

7+import Data.Map.Strict (Map)

8+import qualified Data.Map.Strict as M

9+import Data.OpenApi.Compare.Behavior

10+import Data.OpenApi.Compare.Paths

11+import Data.OpenApi.Compare.Subtree

12+

13+checkSums ::

14+ (Ord k, Issuable l) =>

15+ Paths q r l ->

16+ (k -> Issue l) ->

17+ (k -> ProdCons t -> CompatFormula' q AnIssue r ()) ->

18+ ProdCons (Map k t) ->

19+ CompatFormula' q AnIssue r ()

20+checkSums xs noElt check (ProdCons p c) = for_ (M.toList p) $ \(key, prodElt) ->

21+ case M.lookup key c of

22+ Nothing -> issueAt xs $ noElt key

23+ Just consElt ->

24+ let sumElts = ProdCons prodElt consElt

25+ in check key sumElts

src/Data/OpenUnion/Extra.hs+5−5

@@ -1,7 +1,7 @@

1module Data.OpenUnion.Extra

2− ( (@@>)

2+ ( (@@>),

3− , TryLiftUnion (..)

3+ TryLiftUnion (..),

4− , pattern SingletonUnion

4+ pattern SingletonUnion,

5 )

6where

7

@@ -18,8 +18,8 @@ instance TryLiftUnion '[] where

18 tryLiftUnion _ = empty

19

20instance

21− (Typeable y, SubList ys (y : ys), TryLiftUnion ys)

21+ (Typeable y, SubList ys (y : ys), TryLiftUnion ys) =>

22− => TryLiftUnion (y ': ys)

22+ TryLiftUnion (y ': ys)

23 where

24 tryLiftUnion (x :: x) = case eqT @x @y of

25 Nothing -> reUnion <$> tryLiftUnion @ys x

src/OpenAPI/Checker/Memo.hsdeleted−126

@@ -1,126 +0,0 @@

1−{-# LANGUAGE AllowAmbiguousTypes #-}

2−-- | Utilities for effectfully memoizing other, more effectful functions.

3−module OpenAPI.Checker.Memo

4− ( MonadMemo

5− , MemoState

6− , runMemo

7− , modifyMemoNonce

8− , KnotTier(..)

9− , unknot

10− , memoWithKnot

11− , memoTaggedWithKnot

12− ) where

13−

14−import Control.Monad.State

15−import Data.Dynamic

16−import qualified Data.Map as M

17−import Data.Tagged

18−import Data.Void

19−import qualified Data.TypeRepMap as T

20−import Type.Reflection

21−

22−data Progress a = Finished a | Started | TyingKnot Dynamic

23−

24−data MemoMap a where

25− MemoMap :: !(M.Map k (Progress v)) -> MemoMap (k, v)

26−

27−data MemoState s = MemoState s (T.TypeRepMap MemoMap)

28−

29−-- | An effectful memoization monad.

30−type MonadMemo s m = MonadState (MemoState s) m

31−

32−memoStateLookup

33− :: forall k v s. (Typeable k, Typeable v, Ord k)

34− => k -> MemoState s -> Maybe (Progress v)

35−memoStateLookup k (MemoState _ t) = case T.lookup @(k, v) t of

36− Just (MemoMap m) -> M.lookup k m

37− Nothing -> Nothing

38−

39−memoStateInsert

40− :: forall k v s. (Typeable k, Typeable v, Ord k)

41− => k -> Progress v -> MemoState s -> MemoState s

42−memoStateInsert k x (MemoState s t) = MemoState s $ T.insert (MemoMap m'') t

43− where

44− m'' = M.insert k x m'

45− m' = case T.lookup @(k, v) t of

46− Just (MemoMap m) -> m

47− Nothing -> M.empty

48−

49−modifyMemoNonce :: MonadMemo s m => (s -> s) -> m s

50−modifyMemoNonce f = do

51− MemoState s t <- get

52− put $ MemoState (f s) t

53− pure s

54−

55−-- | Run a memoized computation.

56−runMemo :: Monad m => s -> StateT (MemoState s) m a -> m a

57−runMemo s = (`evalStateT` MemoState s T.empty)

58−

59−-- | A description of how to effectfully tie knots in type @v@, using the @m@

60−-- monad, and by sharing some @d@ data among the recursive instances.

61−data KnotTier v d m = KnotTier

62− { onKnotFound :: m d -- ^ Create some data that will be connected to this knot

63− , onKnotUsed :: d -> m v -- ^ This is what the knot will look like as a value

64− -- to the inner computations

65− , tieKnot :: d -> v -> m v -- ^ Once we're done and we're outside, tie the

66− -- knot using the datum

67− }

68−

69−unknot :: KnotTier v Void m

70−unknot = KnotTier

71− { onKnotFound = error "Recursion detected"

72− , onKnotUsed = absurd

73− , tieKnot = absurd

74− }

75−

76−-- | Run a potentially recursive computation. The provided key will be used to

77−-- refer to the result of this computation. If during the computation, another

78−-- attempt to run the computation with the same key is made, we run a

79−-- tying-the-knot procedure.

80−--

81−-- If another attempt to run the computation with the same key is made

82−-- *after we're done*, we will return the memoized value.

83−memoWithKnot

84− :: forall k v d m s.

85− (Typeable k, Typeable v, Typeable d, Ord k, MonadMemo s m)

86− => KnotTier v d m

87− -> m v -- ^ the computation to memoize

88− -> k -- ^ key for memoization

89− -> m v

90−memoWithKnot tier f k = memoStateLookup @k @v k <$> get >>= \case

91− Just (Finished v) -> pure v

92− Just Started -> do

93− d <- onKnotFound tier

94− modify $ memoStateInsert @k @v k (TyingKnot $ toDyn d)

95− onKnotUsed tier d

96− Just (TyingKnot dyn) -> case fromDynamic dyn of

97− Just d -> onKnotUsed tier d

98− Nothing -> error $ "Type mismatch when examining the knot of "

99− <> show (typeRep @(k -> v)) <> ": expected " <> show (typeRep @d)

100− <> ", got " <> show (dynTypeRep dyn)

101− Nothing -> do

102− modify $ memoStateInsert @k @v k Started

103− v <- f

104− v' <- memoStateLookup @k @v k <$> get >>= \case

105− Just Started -> pure v

106− Just (TyingKnot dyn) -> case fromDynamic dyn of

107− Just d -> tieKnot tier d v

108− Nothing -> error $ "Type mismatch when tying the knot of "

109− <> show (typeRep @(k -> v)) <> ": expected " <> show (typeRep @d)

110− <> ", got " <> show (dynTypeRep dyn)

111− Just (Finished _) -> error $ "Unexpected Finished when memoizing "

112− <> show (typeRep @(k -> v))

113− Nothing -> pure v

114− -- Normally this would be an error, but the underlying monad can refuse

115− -- to remember memoization state

116− modify $ memoStateInsert @k @v k (Finished v')

117− pure v'

118−

119−-- | Disambiguate memoized computations with an arbitrary tag.

120−memoTaggedWithKnot

121− :: forall t k v d m s.

122− ( Typeable t, Typeable k, Typeable v, Typeable d

123− , Ord k, MonadMemo s m )

124− => KnotTier v d m -> m v -> k -> m v

125−memoTaggedWithKnot tier f k = withTypeable (typeRepKind $ typeRep @t) $

126− memoWithKnot tier f (Tagged @t k)

src/OpenAPI/Checker/Validate/Products.hsdeleted−49

@@ -1,49 +0,0 @@

1−{- | Checks product-like entities. The key is some identificator for the product

2−element. Each element may be required or optional.

3−

4−One example of product is request parameters. There are optional and required

5−parameters. The client and server have possibly different set of

6−parameters. What we must check is if server requires some request parameter,

7−then this parameter must be presented by client and their schemas must match.

8−

9−So when we checking products we are checking from the server's (consumer)

10−perspective, ensuring that all parameters are provided by the client (producer)

11−and their schemas match.

12−

13−This module abstracts this logic for arbitrary elements -}

14−

15−module OpenAPI.Checker.Validate.Products

16− ( checkProducts

17− , ProductLike(..)

18− ) where

19−

20−import Data.Foldable

21−import Data.Map.Strict (Map)

22−import qualified Data.Map.Strict as M

23−import OpenAPI.Checker.Behavior

24−import OpenAPI.Checker.Paths

25−import OpenAPI.Checker.Subtree

26−

27−-- | Some entity which is product-like

28−data ProductLike a = ProductLike

29− { productValue :: a

30− , required :: Bool

31− }

32−

33−checkProducts

34− :: (Ord k, Issuable l)

35− => Paths q r l

36− -> (k -> Issue l)

37− -- ^ No required element found

38− -> (k -> ProdCons t -> CompatFormula' q AnIssue r ())

39− -> ProdCons (Map k (ProductLike t))

40− -> CompatFormula' q AnIssue r ()

41−checkProducts xs noElt check (ProdCons p c) = for_ (M.toList c) $ \(key, consElt) ->

42− case M.lookup key p of

43− Nothing -> case required consElt of

44− True -> issueAt xs $ noElt key

45− False -> pure ()

46− Just prodElt -> do

47− let

48− elts = ProdCons prodElt consElt

49− check key (productValue <$> elts)

src/OpenAPI/Checker/Validate/Sums.hsdeleted−24

@@ -1,24 +0,0 @@

1−module OpenAPI.Checker.Validate.Sums

2− ( checkSums

3− ) where

4−

5−import Data.Foldable

6−import Data.Map.Strict (Map)

7−import qualified Data.Map.Strict as M

8−import OpenAPI.Checker.Behavior

9−import OpenAPI.Checker.Subtree

10−import OpenAPI.Checker.Paths

11−

12−checkSums

13− :: (Ord k, Issuable l)

14− => Paths q r l

15− -> (k -> Issue l)

16− -> (k -> ProdCons t -> CompatFormula' q AnIssue r ())

17− -> ProdCons (Map k t)

18− -> CompatFormula' q AnIssue r ()

19−checkSums xs noElt check (ProdCons p c) = for_ (M.toList p) $ \(key, prodElt) ->

20− case M.lookup key c of

21− Nothing -> issueAt xs $ noElt key

22− Just consElt ->

23− let sumElts = ProdCons prodElt consElt

24− in check key sumElts

stack.yaml+7−4

@@ -1,8 +1,11 @@

1−resolver: lts-18.2

1+resolver: lts-18.16

2+

3+packages:

4+ - .

2

5

3extra-deps:

6extra-deps:

4 - open-union-0.4.0.0

7 - open-union-0.4.0.0

5 - type-fun-0.1.3

8 - type-fun-0.1.3

6−

9+ - github-0.26

7−apply-ghc-options: everything

10+ - base16-bytestring-0.1.1.7

8−rebuild-ghc-options: true

11+ - http-link-header-1.0.3.1

stack.yaml.lock+25−4

@@ -18,9 +18,30 @@ packages:

18 sha256: b977d42525f0b4223959918d18e7905085283e937493c395077b608cd19b42c1

19 original:

20 hackage: type-fun-0.1.3

21+- completed:

22+ hackage: github-0.26@sha256:a9d4046325c3eb28cdc7bef2c3f5bb213328caeae0b7dce6f51de655f0bffaa1,7162

23+ pantry-tree:

24+ size: 7511

25+ sha256: b71aab2984b268030c9e2617043575681134c1fe60dffbd5596e659c0a3e9aec

26+ original:

27+ hackage: github-0.26

28+- completed:

29+ hackage: base16-bytestring-0.1.1.7@sha256:0021256a9628971c08da95cb8f4d0d72192f3bb8a7b30b55c080562d17c43dd3,2231

30+ pantry-tree:

31+ size: 454

32+ sha256: 2dc99cd67293b09204098202d0bdcdcf89d2b8c69ce6c8f4e31deadbdab2a7f9

33+ original:

34+ hackage: base16-bytestring-0.1.1.7

35+- completed:

36+ hackage: http-link-header-1.0.3.1@sha256:9917c26635a46eff5d36c5344a4ae42fad2b5de79c0e300363bddd5eec66facd,1937

37+ pantry-tree:

38+ size: 990

39+ sha256: 155feaf856daf5b55491048c8c4726ba765a8fe79263ebdbfc82f6c385a15715

40+ original:

41+ hackage: http-link-header-1.0.3.1

21snapshots:

42snapshots:

22- completed:

43- completed:

23− size: 585392

44+ size: 586286

24− url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/18/2.yaml

45+ url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/18/16.yaml

25− sha256: 7abb45c0cc5eb349448b66d8753655542d45d387ad26970419282eab3d860724

46+ sha256: cdead65fca0323144b346c94286186f4969bf85594d649c49c7557295675d8a5

26− original: lts-18.2

47+ original: lts-18.16

test/README.md+1−1

@@ -30,7 +30,7 @@ This test would read the files `a.yaml` and `b.yaml` using the `Yaml.decodeFileT

30

31## Supported feature tests

32

33−If a test starts with either `x ` or `v `, the test is assumed to test the support of some OpenApi functionality. If the test begins `x ` it means that the feature is expected to be not supported, and the result will only be checked to have an "unsupported" flag set. If it starts with `v ` the test is expected to be supported and the result is compared to some file on disk.

33+If a test starts with either `x ` or `v `, the test is assumed to test the support of some OpenAPI functionality. If the test begins `x ` it means that the feature is expected to be not supported, and the result will only be checked to have an "unsupported" flag set. If it starts with `v ` the test is expected to be supported and the result is compared to some file on disk.

34

35The result will be reflected in the generated compatibility matrix.

36

test/Spec/Golden/Extra.hs+46−42

@@ -1,8 +1,8 @@

1module Spec.Golden.Extra

2− ( getGoldenInputs

2+ ( getGoldenInputs,

3− , getGoldenInputsUniform

3+ getGoldenInputsUniform,

4− , goldenInputsTree

4+ goldenInputsTree,

5− , goldenInputsTreeUniform

5+ goldenInputsTreeUniform,

6 )

7where

8

@@ -19,12 +19,12 @@ data TestInput t

19 | TestInputLeaf TestName t FilePath

20 deriving stock (Functor)

21

22−getGoldenInputs

22+getGoldenInputs ::

23− :: (Each s t (FilePath, FilePath -> IO a) a)

23+ (Each s t (FilePath, FilePath -> IO a) a) =>

24− => TestName

24+ TestName ->

25− -> FilePath

25+ FilePath ->

26− -> s

26+ s ->

27− -> IO (TestInput t)

27+ IO (TestInput t)

28getGoldenInputs name filepath inp = do

29 dirs' <- listDirectory filepath >>= filterM (doesDirectoryExist . (filepath </>))

30 case dirs' of

@@ -39,32 +39,34 @@ getGoldenInputs name filepath inp = do

39 TestInputNode name

40 <$> forM dirs (\dir -> getGoldenInputs dir (filepath </> dir) inp)

41

42−getGoldenInputsUniform

42+getGoldenInputsUniform ::

43− :: (Each t h (FilePath, FilePath -> IO a) a)

43+ (Each t h (FilePath, FilePath -> IO a) a) =>

44− => (Each s t FilePath (FilePath, FilePath -> IO a))

44+ (Each s t FilePath (FilePath, FilePath -> IO a)) =>

45− => TestName

45+ TestName ->

46− -> (FilePath -> IO a)

46+ (FilePath -> IO a) ->

47− -> FilePath

47+ FilePath ->

48− -> s

48+ s ->

49− -> IO (TestInput h)

49+ IO (TestInput h)

50getGoldenInputsUniform name f filepath inp = getGoldenInputs name filepath $ inp & each %~ (,f)

51

52−goldenInputsTree

52+goldenInputsTree ::

53− :: (Each s t (FilePath, FilePath -> IO a) a)

53+ (Each s t (FilePath, FilePath -> IO a) a) =>

54− => TestName

54+ TestName ->

55− -> FilePath -- ^ Root path

55+ -- | Root path

56+ FilePath ->

56− -> FilePath -- ^ Name of golden file

57+ -- | Name of golden file

57− -> s

58+ FilePath ->

59+ s ->

58− -> (t -> IO BSL.ByteString)

60+ (t -> IO BSL.ByteString) ->

59− -> IO TestTree

61+ IO TestTree

60goldenInputsTree name filepath golden inp f = do

62goldenInputsTree name filepath golden inp f = do

61 runTestInputTree golden f <$> getGoldenInputs name filepath inp

63 runTestInputTree golden f <$> getGoldenInputs name filepath inp

62

64

63−runTestInputTree

65+runTestInputTree ::

64− :: FilePath

66+ FilePath ->

65− -> (t -> IO BSL.ByteString)

67+ (t -> IO BSL.ByteString) ->

66− -> TestInput t

68+ TestInput t ->

67− -> TestTree

69+ TestTree

68runTestInputTree golden f (TestInputNode name rest) =

70runTestInputTree golden f (TestInputNode name rest) =

69 testGroup name (runTestInputTree golden f <$> rest)

71 testGroup name (runTestInputTree golden f <$> rest)

70runTestInputTree golden f (TestInputLeaf name t path) =

72runTestInputTree golden f (TestInputLeaf name t path) =

@@ -74,16 +76,18 @@ runTestInputTree golden f (TestInputLeaf name t path) =

74 (path </> golden)

76 (path </> golden)

75 (f t)

77 (f t)

76

78

77−goldenInputsTreeUniform

79+goldenInputsTreeUniform ::

78− :: ( Each t h (FilePath, FilePath -> IO a) a

80+ ( Each t h (FilePath, FilePath -> IO a) a

79− , Each s t FilePath (FilePath, FilePath -> IO a)

81+ , Each s t FilePath (FilePath, FilePath -> IO a)

80− )

82+ ) =>

81− => String

83+ String ->

82− -> FilePath -- ^ Root path

84+ -- | Root path

85+ FilePath ->

83− -> FilePath -- ^ Name of golden file

86+ -- | Name of golden file

84− -> s

87+ FilePath ->

88+ s ->

85− -> (FilePath -> IO a)

89+ (FilePath -> IO a) ->

86− -> (h -> IO BSL.ByteString)

90+ (h -> IO BSL.ByteString) ->

87− -> IO TestTree

91+ IO TestTree

88goldenInputsTreeUniform name filepath golden inp h =

92goldenInputsTreeUniform name filepath golden inp h =

89 goldenInputsTree name filepath golden (inp & each %~ (,h))

93 goldenInputsTree name filepath golden (inp & each %~ (,h))

test/Spec/Golden/TraceTree.hs+9−6

@@ -1,5 +1,5 @@

1module Spec.Golden.TraceTree

2− ( tests

2+ ( tests,

3 )

4where

5

@@ -7,13 +7,15 @@ import Control.Category

7import Control.Exception

8import qualified Data.ByteString.Lazy as BSL

9import Data.Default

10+import Data.OpenApi.Compare.Run

11+import Data.OpenApi.Compare.Validate.OpenApi ()

10import Data.Text (Text)

12import Data.Text (Text)

11import qualified Data.Text.Encoding as T

13import qualified Data.Text.Encoding as T

12import qualified Data.Yaml as Yaml

14import qualified Data.Yaml as Yaml

13−import OpenAPI.Checker.Run

15+import Paths_compaREST

14−import OpenAPI.Checker.Validate.OpenApi ()

15import Spec.Golden.Extra

16import Spec.Golden.Extra

16import Test.Tasty (TestTree, testGroup)

17import Test.Tasty (TestTree, testGroup)

18+import Text.Pandoc.Builder

17import Text.Pandoc.Class

19import Text.Pandoc.Class

18import Text.Pandoc.Options

20import Text.Pandoc.Options

19import Text.Pandoc.Writers

21import Text.Pandoc.Writers

@@ -21,10 +23,11 @@ import Prelude hiding (id, (.))

21

23

22tests :: IO TestTree

24tests :: IO TestTree

23tests = do

25tests = do

26+ dir <- getDataDir

24 traceTreeTests <-

27 traceTreeTests <-

25 goldenInputsTreeUniform

28 goldenInputsTreeUniform

26 "TraceTree"

29 "TraceTree"

27− "test/golden/common"

30+ dir

28 "trace-tree.yaml"

31 "trace-tree.yaml"

29 ("a.yaml", "b.yaml")

32 ("a.yaml", "b.yaml")

30 Yaml.decodeFileThrow

33 Yaml.decodeFileThrow

@@ -33,11 +36,11 @@ tests = do

33 reportTests <-

36 reportTests <-

34 goldenInputsTreeUniform

37 goldenInputsTreeUniform

35 "Report"

38 "Report"

36− "test/golden/common"

39+ dir

37 "report.md"

40 "report.md"

38 ("a.yaml", "b.yaml")

41 ("a.yaml", "b.yaml")

39 Yaml.decodeFileThrow

42 Yaml.decodeFileThrow

40− (runPandoc . writeMarkdown def {writerExtensions = githubMarkdownExtensions} . fst . runReport def)

43+ (runPandoc . writeMarkdown def {writerExtensions = githubMarkdownExtensions} . doc . fst . runReport def)

41

44

42 return $ testGroup "Golden tests" [traceTreeTests, reportTests]

45 return $ testGroup "Golden tests" [traceTreeTests, reportTests]

43

46

test/golden/common/bad-oneof-unchanged/report.md+6−6

@@ -1,19 +1,19 @@

1# Summary

2

3−| ⚠️ Breaking changes | 🙆 Non-breaking changes | [🤷 Unsupported feature changes](#unsupported-changes) |

3+| ❌ Breaking changes | ⚠️ Non-breaking changes | [❓ Unsupported feature changes](#unsupported-changes) |

4−|---------------------|------------------------|-------------------------------------------------------|

4+|---------------------|-------------------------|--------------------------------------------------------|

5−| 0 | 0 | 2 |

5+| 0 | 0 | 2 |

6

7−# 🤷 Unsupported feature changes

7+# ❓ Unsupported feature changes

8

9## **POST** /test

10

11−### 📱➡️ JSON Request

11+### ➡️☁️ JSON Request

12

13Could not deduce that `oneOf` cases don't overlap. Treating the `oneOf`

14as an `anyOf`. Reported errors might not be accurate.

15

16−### 📱⬅️ JSON Response – 200

16+### ⬅️☁️ JSON Response – 200

17

18Could not deduce that `oneOf` cases don't overlap. Treating the `oneOf`

19as an `anyOf`. Reported errors might not be accurate.

test/golden/common/enum-added/report.md+7−7

@@ -1,14 +1,14 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 1 | 1 | 0 |

5+| 1 | 1 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

11−### 📱⬅️ JSON Response – 200

11+### ⬅️☁️ JSON Response – 200

12

13#### `$(String)`

14

@@ -18,11 +18,11 @@ The following enum value was added:

18"C"

19```

20

21−# 🙆 Non-breaking changes

21+# ⚠️ Non-breaking changes

22

23## **POST** /test

24

25−### 📱➡️ JSON Request

25+### ➡️☁️ JSON Request

26

27#### `$(String)`

28

test/golden/common/enum-anyof/report.md+3−3

@@ -1,5 +1,5 @@

1# Summary

2

3−| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | ⚠️ Non-breaking changes |

4−|---------------------|------------------------|-------------------------------|

4+|---------------------|-------------------------|

5−| 0 | 0 | 0 |

5+| 0 | 0 |

test/golden/common/id/report.md+3−3

@@ -1,5 +1,5 @@

1# Summary

2

3−| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | ⚠️ Non-breaking changes |

4−|---------------------|------------------------|-------------------------------|

4+|---------------------|-------------------------|

5−| 0 | 0 | 0 |

5+| 0 | 0 |

test/golden/common/json/recursive/report.md+3−3

@@ -1,5 +1,5 @@

1# Summary

2

3−| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | ⚠️ Non-breaking changes |

4−|---------------------|------------------------|-------------------------------|

4+|---------------------|-------------------------|

5−| 0 | 0 | 0 |

5+| 0 | 0 |

test/golden/common/maximum-lowered/report.md+7−7

@@ -1,24 +1,24 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 1 | 1 | 0 |

5+| 1 | 1 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

11−### 📱➡️ JSON Request

11+### ➡️☁️ JSON Request

12

13#### `$(Number)`

14

15Upper bound changed from 3.0 inclusive to 2.0 inclusive.

16

17−# 🙆 Non-breaking changes

17+# ⚠️ Non-breaking changes

18

19## **POST** /test

20

21−### 📱⬅️ JSON Response – 200

21+### ⬅️☁️ JSON Response – 200

22

23#### `$(Number)`

24

test/golden/common/pathItem/operation/parameters/allowEmptyValue/reset/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | ⚠️ Non-breaking changes |

4−|------------------------------------------|------------------------|-------------------------------|

4+|------------------------------------------|-------------------------|

5−| 1 | 0 | 0 |

5+| 1 | 0 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

test/golden/common/pathItem/operation/parameters/allowEmptyValue/set/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|---------------------|-------------------------------------------------|-------------------------------|

4+|---------------------|--------------------------------------------------|

5−| 0 | 1 | 0 |

5+| 0 | 1 |

6

7−# 🙆 Non-breaking changes

7+# ⚠️ Non-breaking changes

8

9## **POST** /test

10

test/golden/common/pathItem/operation/parameters/change/report.md+5−5

@@ -1,10 +1,10 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 1 | 1 | 0 |

5+| 1 | 1 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

@@ -16,7 +16,7 @@

16

17The type has been removed.

18

19−# 🙆 Non-breaking changes

19+# ⚠️ Non-breaking changes

20

21## **POST** /test

22

test/golden/common/pathItem/operation/parameters/required/false/add/report.md+3−3

@@ -1,5 +1,5 @@

1# Summary

2

3−| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | ⚠️ Non-breaking changes |

4−|---------------------|------------------------|-------------------------------|

4+|---------------------|-------------------------|

5−| 0 | 0 | 0 |

5+| 0 | 0 |

test/golden/common/pathItem/operation/parameters/required/false/del/report.md+3−3

@@ -1,5 +1,5 @@

1# Summary

2

3−| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | ⚠️ Non-breaking changes |

4−|---------------------|------------------------|-------------------------------|

4+|---------------------|-------------------------|

5−| 0 | 0 | 0 |

5+| 0 | 0 |

test/golden/common/pathItem/operation/parameters/required/reset/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|---------------------|-------------------------------------------------|-------------------------------|

4+|---------------------|--------------------------------------------------|

5−| 0 | 1 | 0 |

5+| 0 | 1 |

6

7−# 🙆 Non-breaking changes

7+# ⚠️ Non-breaking changes

8

9## **POST** /test

10

test/golden/common/pathItem/operation/parameters/required/set/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | ⚠️ Non-breaking changes |

4−|------------------------------------------|------------------------|-------------------------------|

4+|------------------------------------------|-------------------------|

5−| 1 | 0 | 0 |

5+| 1 | 0 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

test/golden/common/pathItem/operation/parameters/required/true/add/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | ⚠️ Non-breaking changes |

4−|------------------------------------------|------------------------|-------------------------------|

4+|------------------------------------------|-------------------------|

5−| 1 | 0 | 0 |

5+| 1 | 0 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

test/golden/common/pathItem/operation/parameters/required/true/del/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|---------------------|-------------------------------------------------|-------------------------------|

4+|---------------------|--------------------------------------------------|

5−| 0 | 1 | 0 |

5+| 0 | 1 |

6

7−# 🙆 Non-breaking changes

7+# ⚠️ Non-breaking changes

8

9## **POST** /test

10

test/golden/common/pathItem/operation/requestBody/mediaTypeObject/add/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|---------------------|-------------------------------------------------|-------------------------------|

4+|---------------------|--------------------------------------------------|

5−| 0 | 1 | 0 |

5+| 0 | 1 |

6

7−# 🙆 Non-breaking changes

7+# ⚠️ Non-breaking changes

8

9## **POST** /test

10

test/golden/common/pathItem/operation/requestBody/mediaTypeObject/change/report.md+7−7

@@ -1,24 +1,24 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 1 | 1 | 0 |

5+| 1 | 1 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

11−### 📱➡️ JSON Request

11+### ➡️☁️ JSON Request

12

13#### `$(String)`

14

15The type has been removed.

16

17−# 🙆 Non-breaking changes

17+# ⚠️ Non-breaking changes

18

19## **POST** /test

20

21−### 📱➡️ JSON Request

21+### ➡️☁️ JSON Request

22

23#### `$(Number)`

24

test/golden/common/pathItem/operation/requestBody/mediaTypeObject/del/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | ⚠️ Non-breaking changes |

4−|------------------------------------------|------------------------|-------------------------------|

4+|------------------------------------------|-------------------------|

5−| 1 | 0 | 0 |

5+| 1 | 0 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

test/golden/common/pathItem/operation/requestBody/required/reset/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|---------------------|-------------------------------------------------|-------------------------------|

4+|---------------------|--------------------------------------------------|

5−| 0 | 1 | 0 |

5+| 0 | 1 |

6

7−# 🙆 Non-breaking changes

7+# ⚠️ Non-breaking changes

8

9## **POST** /test

10

test/golden/common/pathItem/operation/requestBody/required/set/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | ⚠️ Non-breaking changes |

4−|------------------------------------------|------------------------|-------------------------------|

4+|------------------------------------------|-------------------------|

5−| 1 | 0 | 0 |

5+| 1 | 0 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

test/golden/common/pathItem/operation/responses/add/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | ⚠️ Non-breaking changes |

4−|------------------------------------------|------------------------|-------------------------------|

4+|------------------------------------------|-------------------------|

5−| 1 | 0 | 0 |

5+| 1 | 0 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

test/golden/common/pathItem/operation/responses/change/headers/mandatory/add/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|---------------------|-------------------------------------------------|-------------------------------|

4+|---------------------|--------------------------------------------------|

5−| 0 | 1 | 0 |

5+| 0 | 1 |

6

7−# 🙆 Non-breaking changes

7+# ⚠️ Non-breaking changes

8

9## **POST** /test

10

test/golden/common/pathItem/operation/responses/change/headers/mandatory/del/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | ⚠️ Non-breaking changes |

4−|------------------------------------------|------------------------|-------------------------------|

4+|------------------------------------------|-------------------------|

5−| 1 | 0 | 0 |

5+| 1 | 0 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

test/golden/common/pathItem/operation/responses/change/headers/optional/add/report.md+3−3

@@ -1,5 +1,5 @@

1# Summary

2

3−| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | ⚠️ Non-breaking changes |

4−|---------------------|------------------------|-------------------------------|

4+|---------------------|-------------------------|

5−| 0 | 0 | 0 |

5+| 0 | 0 |

test/golden/common/pathItem/operation/responses/change/headers/optional/del/report.md+3−3

@@ -1,5 +1,5 @@

1# Summary

2

3−| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | ⚠️ Non-breaking changes |

4−|---------------------|------------------------|-------------------------------|

4+|---------------------|-------------------------|

5−| 0 | 0 | 0 |

5+| 0 | 0 |

test/golden/common/pathItem/operation/responses/change/mediaTypeObject/add/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | ⚠️ Non-breaking changes |

4−|------------------------------------------|------------------------|-------------------------------|

4+|------------------------------------------|-------------------------|

5−| 1 | 0 | 0 |

5+| 1 | 0 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

test/golden/common/pathItem/operation/responses/change/mediaTypeObject/change/report.md+7−7

@@ -1,24 +1,24 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 1 | 1 | 0 |

5+| 1 | 1 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

11−### 📱⬅️ JSON Response – 200

11+### ⬅️☁️ JSON Response – 200

12

13#### `$(Number)`

14

15The type has been added.

16

17−# 🙆 Non-breaking changes

17+# ⚠️ Non-breaking changes

18

19## **POST** /test

20

21−### 📱⬅️ JSON Response – 200

21+### ⬅️☁️ JSON Response – 200

22

23#### `$(String)`

24

test/golden/common/pathItem/operation/responses/change/mediaTypeObject/del/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|---------------------|-------------------------------------------------|-------------------------------|

4+|---------------------|--------------------------------------------------|

5−| 0 | 1 | 0 |

5+| 0 | 1 |

6

7−# 🙆 Non-breaking changes

7+# ⚠️ Non-breaking changes

8

9## **POST** /test

10

test/golden/common/pathItem/operation/responses/del/report.md+4−4

@@ -1,10 +1,10 @@

1# Summary

2

3−| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|---------------------|-------------------------------------------------|-------------------------------|

4+|---------------------|--------------------------------------------------|

5−| 0 | 1 | 0 |

5+| 0 | 1 |

6

7−# 🙆 Non-breaking changes

7+# ⚠️ Non-breaking changes

8

9## **POST** /test

10

test/golden/common/property-removed-additional/report.md+7−7

@@ -1,14 +1,14 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 3 | 3 | 0 |

5+| 3 | 3 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

11−### 📱⬅️ JSON Response – 200

11+### ⬅️☁️ JSON Response – 200

12

13#### `$.property2`

14

@@ -21,11 +21,11 @@

21

223. The property may not be present.

23

24−# 🙆 Non-breaking changes

24+# ⚠️ Non-breaking changes

25

26## **POST** /test

27

28−### 📱➡️ JSON Request

28+### ➡️☁️ JSON Request

29

30#### `$.property2`

31

test/golden/common/property-removed/report.md+6−6

@@ -1,20 +1,20 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | ⚠️ Non-breaking changes |

4−|------------------------------------------|------------------------|-------------------------------|

4+|------------------------------------------|-------------------------|

5−| 2 | 0 | 0 |

5+| 2 | 0 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

11−### 📱➡️ JSON Request

11+### ➡️☁️ JSON Request

12

13#### `$.property2`

14

15The property has been removed.

16

17−### 📱⬅️ JSON Response – 200

17+### ⬅️☁️ JSON Response – 200

18

19#### `$.property2`

20

test/golden/common/property-required/report.md+7−7

@@ -1,24 +1,24 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 1 | 1 | 0 |

5+| 1 | 1 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

11−### 📱➡️ JSON Request

11+### ➡️☁️ JSON Request

12

13#### `$.property2`

14

15The property has become required.

16

17−# 🙆 Non-breaking changes

17+# ⚠️ Non-breaking changes

18

19## **POST** /test

20

21−### 📱⬅️ JSON Response – 200

21+### ⬅️☁️ JSON Response – 200

22

23#### `$.property2`

24

test/golden/common/random-example/report.md+9−9

@@ -1,14 +1,14 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 5 | 6 | 0 |

5+| 5 | 6 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **GET** /pets

10

11−### 📱⬅️ JSON Response – 200

11+### ⬅️☁️ JSON Response – 200

12

13#### `$[*].name(String)`

14

@@ -18,7 +18,7 @@

18

19## **POST** /pets

20

21−### 📱➡️ JSON Request

21+### ➡️☁️ JSON Request

22

23#### `$.weight`

24

@@ -33,7 +33,7 @@

33

34Value is now a multiple of 1.0.

35

36−# 🙆 Non-breaking changes

36+# ⚠️ Non-breaking changes

37

38## **GET** /pets

39

@@ -45,7 +45,7 @@ Value is now a multiple of 1.0.

45

46Upper bound changed from 20.0 inclusive to 30.0 inclusive.

47

48−### 📱⬅️ JSON Response – 200

48+### ⬅️☁️ JSON Response – 200

49

50#### `$[*].weight`

51

@@ -62,7 +62,7 @@ Value is now a multiple of 1.0.

62

63## **POST** /pets

64

65−### 📱➡️ JSON Request

65+### ➡️☁️ JSON Request

66

67#### `$.name(String)`

68

test/golden/common/recursive/report.md+7−7

@@ -1,14 +1,14 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 1 | 1 | 0 |

5+| 1 | 1 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **GET** /api/foo

10

11−### 📱➡️ JSON Request

11+### ➡️☁️ JSON Request

12

13#### `$.leaf.value.foo(String)`

14

@@ -18,11 +18,11 @@ The following enum value has been added:

18"a"

19```

20

21−# 🙆 Non-breaking changes

21+# ⚠️ Non-breaking changes

22

23## **GET** /api/foo

24

25−### 📱⬅️ JSON Response – 200

25+### ⬅️☁️ JSON Response – 200

26

27#### `$.leaf.value.foo(String)`

28

test/golden/common/security-scheme/report.md+5−5

@@ -1,10 +1,10 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 2 | 1 | 0 |

5+| 2 | 1 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /oauth/check

10

@@ -22,7 +22,7 @@ Security scheme has been removed.

22

23Security scheme has been removed.

24

25−# 🙆 Non-breaking changes

25+# ⚠️ Non-breaking changes

26

27## **POST** /oauth/check

28

test/golden/common/servers/report.md+5−5

@@ -1,10 +1,10 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 3 | 1 | 0 |

5+| 3 | 1 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **GET** /pets

10

@@ -18,7 +18,7 @@ The server was removed.

18

192. A variable has been changed from being open to being closed.

20

21−# 🙆 Non-breaking changes

21+# ⚠️ Non-breaking changes

22

23## **GET** /pets

24

test/golden/common/tuple-items/heterogeneous-component-mismatch/report.md+9−9

@@ -1,36 +1,36 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 2 | 2 | 0 |

5+| 2 | 2 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

11−### 📱➡️ JSON Request

11+### ➡️☁️ JSON Request

12

13#### `$[1](String)`

14

15The type has been removed.

16

17−### 📱⬅️ JSON Response – 200

17+### ⬅️☁️ JSON Response – 200

18

19#### `$[1](Object)`

20

21The type has been added.

22

23−# 🙆 Non-breaking changes

23+# ⚠️ Non-breaking changes

24

25## **POST** /test

26

27−### 📱➡️ JSON Request

27+### ➡️☁️ JSON Request

28

29#### `$[1](Object)`

30

31The type has been added.

32

33−### 📱⬅️ JSON Response – 200

33+### ⬅️☁️ JSON Response – 200

34

35#### `$[1](String)`

36

test/golden/common/tuple-items/heterogeneous-length-mismatch/report.md+6−6

@@ -1,20 +1,20 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | ⚠️ Non-breaking changes |

4−|------------------------------------------|------------------------|-------------------------------|

4+|------------------------------------------|-------------------------|

5−| 2 | 0 | 0 |

5+| 2 | 0 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

11−### 📱➡️ JSON Request

11+### ➡️☁️ JSON Request

12

13#### `$(Array)`

14

15Tuple length changed from 3 to 2.

16

17−### 📱⬅️ JSON Response – 200

17+### ⬅️☁️ JSON Response – 200

18

19#### `$(Array)`

20

test/golden/common/tuple-items/homogeneous-component-mismatch/report.md+9−9

@@ -1,14 +1,14 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 4 | 2 | 0 |

5+| 4 | 2 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

11−### 📱➡️ JSON Request

11+### ➡️☁️ JSON Request

12

13#### `$(Array)`

14

@@ -18,7 +18,7 @@ The array is no longer explicitly defined as a tuple.

18

19The type has been removed.

20

21−### 📱⬅️ JSON Response – 200

21+### ⬅️☁️ JSON Response – 200

22

23#### `$(Array)`

24

@@ -28,17 +28,17 @@ The array is no longer explicitly defined as a tuple.

28

29The type has been added.

30

31−# 🙆 Non-breaking changes

31+# ⚠️ Non-breaking changes

32

33## **POST** /test

34

35−### 📱➡️ JSON Request

35+### ➡️☁️ JSON Request

36

37#### `$[0](Number)`

38

39The type has been added.

40

41−### 📱⬅️ JSON Response – 200

41+### ⬅️☁️ JSON Response – 200

42

43#### `$[0](String)`

44

test/golden/common/tuple-items/homogeneous-length-mismatch/report.md+13−13

@@ -1,14 +1,14 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 5 | 5 | 0 |

5+| 5 | 5 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test1

10

11−### 📱⬅️ JSON Response – 200

11+### ⬅️☁️ JSON Response – 200

12

13#### `$(Array)`

14

@@ -16,7 +16,7 @@ The array is no longer explicitly defined as a tuple.

16

17## **POST** /test2

18

19−### 📱⬅️ JSON Response – 200

19+### ⬅️☁️ JSON Response – 200

20

21#### `$(Array)`

22

@@ -24,13 +24,13 @@ The array is no longer explicitly defined as a tuple.

24

25## **POST** /test3

26

27−### 📱➡️ JSON Request

27+### ➡️☁️ JSON Request

28

29#### `$(Array)`

30

31Minimum length of the array changed from 2 to 3.

32

33−### 📱⬅️ JSON Response – 200

33+### ⬅️☁️ JSON Response – 200

34

35#### `$(Array)`

36

@@ -38,11 +38,11 @@ Minimum length of the array changed from 2 to 3.

38

392. The array is no longer explicitly defined as a tuple.

40

41−# 🙆 Non-breaking changes

41+# ⚠️ Non-breaking changes

42

43## **POST** /test1

44

45−### 📱➡️ JSON Request

45+### ➡️☁️ JSON Request

46

47#### `$(Array)`

48

@@ -50,7 +50,7 @@ The array is no longer explicitly defined as a tuple.

50

51## **POST** /test2

52

53−### 📱➡️ JSON Request

53+### ➡️☁️ JSON Request

54

55#### `$(Array)`

56

@@ -58,7 +58,7 @@ The array is no longer explicitly defined as a tuple.

58

59## **POST** /test3

60

61−### 📱➡️ JSON Request

61+### ➡️☁️ JSON Request

62

63#### `$(Array)`

64

@@ -66,7 +66,7 @@ The array is no longer explicitly defined as a tuple.

66

672. The array is no longer explicitly defined as a tuple.

68

69−### 📱⬅️ JSON Response – 200

69+### ⬅️☁️ JSON Response – 200

70

71#### `$(Array)`

72

test/golden/common/tuple-items/homogeneous-vector/report.md+3−3

@@ -1,5 +1,5 @@

1# Summary

2

3−| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

3+| ❌ Breaking changes | ⚠️ Non-breaking changes |

4−|---------------------|------------------------|-------------------------------|

4+|---------------------|-------------------------|

5−| 0 | 0 | 0 |

5+| 0 | 0 |

test/golden/common/type-changing/report.md+15−15

@@ -1,14 +1,14 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 6 | 6 | 0 |

5+| 6 | 6 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test1

10

11−### 📱➡️ JSON Request

11+### ➡️☁️ JSON Request

12

13Values are now limited to the following types:

14

@@ -16,7 +16,7 @@ Values are now limited to the following types:

16

17## **POST** /test2

18

19−### 📱➡️ JSON Request

19+### ➡️☁️ JSON Request

20

21Values are now limited to the following types:

22

@@ -28,7 +28,7 @@ Values are now limited to the following types:

28

29## **POST** /test3

30

31−### 📱➡️ JSON Request

31+### ➡️☁️ JSON Request

32

33#### `$(Array)`

34

@@ -36,7 +36,7 @@ The type has been removed.

36

37## **POST** /test4

38

39−### 📱➡️ JSON Request

39+### ➡️☁️ JSON Request

40

41#### `$(Object)`

42

@@ -44,7 +44,7 @@ The type has been removed.

44

45## **POST** /test5

46

47−### 📱➡️ JSON Request

47+### ➡️☁️ JSON Request

48

49Values are now limited to the following types:

50

@@ -54,11 +54,11 @@ Values are now limited to the following types:

54

55Value is now a multiple of 1.0.

56

57−# 🙆 Non-breaking changes

57+# ⚠️ Non-breaking changes

58

59## **POST** /test1

60

61−### 📱⬅️ JSON Response – 200

61+### ⬅️☁️ JSON Response – 200

62

63Values are now limited to the following types:

64

@@ -66,7 +66,7 @@ Values are now limited to the following types:

66

67## **POST** /test2

68

69−### 📱⬅️ JSON Response – 200

69+### ⬅️☁️ JSON Response – 200

70

71Values are now limited to the following types:

72

@@ -78,7 +78,7 @@ Values are now limited to the following types:

78

79## **POST** /test3

80

81−### 📱⬅️ JSON Response – 200

81+### ⬅️☁️ JSON Response – 200

82

83#### `$(Array)`

84

@@ -86,7 +86,7 @@ The type has been removed.

86

87## **POST** /test4

88

89−### 📱⬅️ JSON Response – 200

89+### ⬅️☁️ JSON Response – 200

90

91#### `$(Object)`

92

@@ -94,7 +94,7 @@ The type has been removed.

94

95## **POST** /test5

96

97−### 📱⬅️ JSON Response – 200

97+### ⬅️☁️ JSON Response – 200

98

99Values are now limited to the following types:

100

test/golden/common/unguarded-recursive/report.md+6−6

@@ -1,13 +1,13 @@

1# Summary

2

3−| ⚠️ Breaking changes | 🙆 Non-breaking changes | [🤷 Unsupported feature changes](#unsupported-changes) |

3+| ❌ Breaking changes | ⚠️ Non-breaking changes | [❓ Unsupported feature changes](#unsupported-changes) |

4−|---------------------|------------------------|-------------------------------------------------------|

4+|---------------------|-------------------------|--------------------------------------------------------|

5−| 0 | 0 | 1 |

5+| 0 | 0 | 1 |

6

7−# 🤷 Unsupported feature changes

7+# ❓ Unsupported feature changes

8

9## **GET** /api/foo

10

11−### 📱⬅️ JSON Response – 200

11+### ⬅️☁️ JSON Response – 200

12

13−Encountered recursion that is too complex for OpenApi Diff to untangle.

13+Encountered recursion that is too complex for CompaREST to untangle.

test/golden/common/variant-added/report.md+7−7

@@ -1,24 +1,24 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 1 | 1 | 0 |

5+| 1 | 1 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

11−### 📱⬅️ JSON Response – 200

11+### ⬅️☁️ JSON Response – 200

12

13#### `$(Object)`

14

15The case where `$.tag` is `"C"` – has been added.

16

17−# 🙆 Non-breaking changes

17+# ⚠️ Non-breaking changes

18

19## **POST** /test

20

21−### 📱➡️ JSON Request

21+### ➡️☁️ JSON Request

22

23#### `$(Object)`

24

test/golden/common/variant-changed/report.md+9−9

@@ -1,14 +1,14 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 2 | 2 | 0 |

5+| 2 | 2 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

11−### 📱➡️ JSON Request

11+### ➡️☁️ JSON Request

12

13#### In cases where `$.tag` is `"B"`

14

@@ -16,7 +16,7 @@

16

17The type has been removed.

18

19−### 📱⬅️ JSON Response – 200

19+### ⬅️☁️ JSON Response – 200

20

21#### In cases where `$.tag` is `"B"`

22

@@ -24,11 +24,11 @@ The type has been removed.

24

25The type has been added.

26

27−# 🙆 Non-breaking changes

27+# ⚠️ Non-breaking changes

28

29## **POST** /test

30

31−### 📱➡️ JSON Request

31+### ➡️☁️ JSON Request

32

33#### In cases where `$.tag` is `"B"`

34

@@ -36,7 +36,7 @@ The type has been added.

36

37The type has been added.

38

39−### 📱⬅️ JSON Response – 200

39+### ⬅️☁️ JSON Response – 200

40

41#### In cases where `$.tag` is `"B"`

42

test/golden/common/variant-deep-changed/report.md+9−9

@@ -1,14 +1,14 @@

1# Summary

2

3−| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

3+| [❌ Breaking changes](#breaking-changes) | [⚠️ Non-breaking changes](#non-breaking-changes) |

4−|------------------------------------------|-------------------------------------------------|-------------------------------|

4+|------------------------------------------|--------------------------------------------------|

5−| 2 | 2 | 0 |

5+| 2 | 2 |

6

7−# ⚠️ Breaking changes

7+# ❌ Breaking changes

8

9## **POST** /test

10

11−### 📱➡️ JSON Request

11+### ➡️☁️ JSON Request

12

13#### In cases where `$.desc.name` is `"B"`

14

@@ -16,7 +16,7 @@

16

17The type has been removed.

18

19−### 📱⬅️ JSON Response – 200

19+### ⬅️☁️ JSON Response – 200

20

21#### In cases where `$.desc.name` is `"B"`

22

@@ -24,11 +24,11 @@ The type has been removed.

24

25The type has been added.

26

27−# 🙆 Non-breaking changes

27+# ⚠️ Non-breaking changes

28

29## **POST** /test

30

31−### 📱➡️ JSON Request

31+### ➡️☁️ JSON Request

32

33#### In cases where `$.desc.name` is `"B"`

34

@@ -36,7 +36,7 @@ The type has been added.

36

37The type has been added.

38

39−### 📱⬅️ JSON Response – 200

39+### ⬅️☁️ JSON Response – 200

40

41#### In cases where `$.desc.name` is `"B"`

42