master..df894c0 · compaREST

.github/actions/common_setup/action.yamldeleted−42

since splitsnapshots

unifiedsplit

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

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.yamldeleted−311

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

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.ymlnew file+54

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

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.yamlnew file+17

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

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−`comparest` uses [PVP Versioning][1].

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

4

5## 0.0.0.0

6

README.md+13−13

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

1−# CompaREST

1+# openapi-diff

2

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

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

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

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

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

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

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: comparest (-c|--client ARG) (-s|--server ARG)

244+Usage: openapi-diff (-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− comparest -c old.yaml -s new.yaml

255+ openapi-diff -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− comparest -c old.yaml -s new.yaml --only-breaking -o report

260+ openapi-diff -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− comparest -c old.json -s new.json --silent

264+ openapi-diff -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− comparest -c old.json -s new.json --folding-block-quotes-style -o report.html

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

270

271Available options:

272 -h,--help Show this help text

action.yamldeleted−47

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

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.hsdeleted−134

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

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

14import Data.Text (Text)

13import Data.Text (Text)

15import qualified Data.Text.Lazy as TL

14import qualified Data.Text.Lazy as TL

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

15import 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 ("CompaREST" :: Text))]

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

84 }

85 _ -> Nothing

86 where

app/Main.hs+3−4

@@ -6,15 +6,14 @@ 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

11import qualified Data.Text.IO as T

9import qualified Data.Text.IO as T

12import qualified Data.Yaml as Yaml

10import qualified Data.Yaml as Yaml

13import FormatHeuristic

11import 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

18

17

19main :: IO ()

18main :: IO ()

20main = do

19main = do

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

48 }

47 }

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

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

50 case mode opts of

49 case mode opts of

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

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

52 Nothing -> pure ()

51 Nothing -> pure ()

53 when (signalExitCode opts) $

52 when (signalExitCode opts) $

54 case status of

53 case status of

app/OpenAPI/Checker/Options.hsnew file+115

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

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 CompaREST](https://github.com/typeable/compaREST) | `typeable.md` |

15+| [Typeable OpenApi Diff](https://github.com/typeable/openapi-diff) | `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+12−8

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

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

2+, haskellNix ? import sources.haskellNix { }

2, gomod2nix ? sources.gomod2nix

3, 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,19 +8,23 @@

8 })

9 ];

10 })

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

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

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

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

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

14, bumpToken ? null

13, bumpToken ? null

15, bumpDocumentation ? null

14, bumpDocumentation ? null

16}:

15}:

17let

16let

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

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

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

19+ name = "openapi-diff";

20+ src = ./..;

21+ };

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

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

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

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

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

21 #!${pkgs.stdenv.shell}

25 #!${pkgs.stdenv.shell}

22 set +e

26 set +e

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

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

24 exit 0

28 exit 0

25 '';

29 '';

26

30

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

126 })

130 })

127 (getInputs root);

131 (getInputs root);

128 differs = [

132 differs = [

129− typeable-comparest-differ

133+ typeable-openapi-diff-differ

130 atlassian-openapi-diff-differ

134 atlassian-openapi-diff-differ

131 openapitools-openapi-diff-differ

135 openapitools-openapi-diff-differ

132 oasdiff-differ

136 oasdiff-differ

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

160 tools = [

164 tools = [

161 "Typeable"

165 "Typeable"

162 "Atlassian"

166 "Atlassian"

163− "OpenAPI Tools"

167+ "OpenApi Tools"

164 "oasdiff"

168 "oasdiff"

165 "Bump.sh"

169 "Bump.sh"

166 ];

170 ];

ci/policeman.nixdeleted−4

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

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

2−, pkgs ? import sources.nixpkgs { }

3−}:

4−pkgs.haskellPackages.policeman

default.nix+10−91

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

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

6}:

5}:

7let

6let

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

9−

10 hsPkgs = pkgs.haskell-nix.stackProject {

7 hsPkgs = pkgs.haskell-nix.stackProject {

11− src = nix-filter {

8+ src = ./.;

12− root = ./.;

13− name = "compaREST";

14− include = [

15− ./stack.yaml

16− ./stack.yaml.lock

17− ./compaREST.cabal

18− ];

19− };

20

9

21 modules = [

10 modules = [

22 {

11 {

23 dontStrip = false;

12 dontStrip = false;

24 dontPatchELF = false;

13 dontPatchELF = false;

25 enableDeadCodeElimination = true;

14 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− };

45 }

15 }

46 ];

16 ];

47 };

17 };

48

18

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

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

50− mkdir -p $out/bin

20+ mkdir $out

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

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

52

22

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

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

54 '';

24 '';

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−

63− compaRESTImage = pkgs.dockerTools.buildImage {

25+ compaREST = pkgs.dockerTools.buildImage {

64 name = "compaREST";

26 name = "compaREST";

65− contents = [ compaRESTStaticBin ];

27+ contents = [compaREST-static];

66 config = {

28 config = {

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

29+ Entrypoint = [ "/compaREST" ];

68 };

30 };

69 };

31 };

70

32

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

33+in compaREST

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.mddeleted−149

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

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.mddeleted−51

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

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.mddeleted−51

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

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.pngdeleted

Binary file not shown.

github-action/CompaREST/GitHub/API.hsdeleted−86

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

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.hsdeleted−43

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

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.hsdeleted−27

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

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.hsdeleted−173

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

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.hsdeleted−12

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

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.hsdeleted−66

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

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.nixdeleted−6

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

1−{ sources ? import ./sources.nix

2−, pkgs ? import sources.nixpkgs { }

3−}:

4−pkgs.mkShell {

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

6−}

nix/sources.json+6−30

@@ -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": "c8a8f57de3c14fcf1c5cda045ed885fb6d06a00e",

8+ "rev": "8c587f90d2986f87a8212c3469521db512bc7ed9",

9− "sha256": "0frzmvz8rhb4vgx20qms9xxqbkmg5pwivis4qis63ny5wxclzb34",

9+ "sha256": "0a4mz47ccvl1nl2p08zbn33i1vmak4bjr4z6wqzzflnq90hg5a0s",

10 "type": "tarball",

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

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

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

13 },

14 "niv": {

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

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

18 "owner": "nmattia",

19 "repo": "niv",

20− "rev": "5830a4dd348d77e39a0f3c4c762ff2663b602d4c",

20+ "rev": "e0ca65c81a2d7a4d82a189f1e23a48d59ad42070",

21− "sha256": "1d3lsrqvci4qz2hwjrcnd8h5vfkg8aypq3sjd4g3izbc8frwz5sm",

21+ "sha256": "1pq9nh1d8nn3xvbdny8fafzw87mj7gsmp6pxkdl65w2g18rmcmzx",

22 "type": "tarball",

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

23+ "url": "https://github.com/nmattia/niv/archive/e0ca65c81a2d7a4d82a189f1e23a48d59ad42070.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",

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

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

49 }

25 }

50}

26}

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

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

1cabal-version: 2.4

2−name: compaREST

2+name: openapi-diff

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: Typeable

8+author: Aleksey Uymanov

9−maintainer: compaREST@typeable.io

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

10−copyright: 2021 Typeable

10+copyright: 2021 Aleksey Uymanov

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−data-files:

17+

18− test/golden/**/*.yaml

18+Flag static

19− test/golden/**/*.md

19+ Default: False

20+ Manual: True

20

21

21common common-options

22common common-options

23+ if flag(static)

24+ cc-options: -static

25+ ld-options: -static -pthread

26+ ghc-options: -static

22 ghc-options:

27 ghc-options:

23 -Weverything

28 -Weverything

24 -Wno-implicit-prelude

29 -Wno-implicit-prelude

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

33 -fconstraint-solver-iterations=0

38 -fconstraint-solver-iterations=0

34 default-language: Haskell2010

39 default-language: Haskell2010

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

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

41+ , bytestring

36 , text

42 , text

37

43

38−

39 default-extensions: ApplicativeDo

44 default-extensions: ApplicativeDo

40 , BangPatterns

45 , BangPatterns

41 , ConstraintKinds

46 , ConstraintKinds

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

77 , QuantifiedConstraints

82 , QuantifiedConstraints

78 , DefaultSignatures

83 , DefaultSignatures

79

84

80−

81library

85library

82 import: common-options

86 import: common-options

83 build-depends:

87 build-depends:

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

107 , file-embed

111 , file-embed

108 , data-default

112 , data-default

109 , ordered-containers

113 , ordered-containers

110− , bytestring

111 hs-source-dirs: src

114 hs-source-dirs: src

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

115+ exposed-modules: Data.HList

113− , Data.OpenApi.Compare.Common

116+ , OpenAPI.Checker.Behavior

114− , Data.OpenApi.Compare.Formula

117+ , OpenAPI.Checker.Formula

115− , Data.OpenApi.Compare.Memo

118+ , OpenAPI.Checker.Memo

116− , Data.OpenApi.Compare.Orphans

119+ , OpenAPI.Checker.Orphans

117− , Data.OpenApi.Compare.Paths

120+ , OpenAPI.Checker.Paths

118− , Data.OpenApi.Compare.PathsPrefixTree

121+ , OpenAPI.Checker.PathsPrefixTree

119− , Data.OpenApi.Compare.References

122+ , OpenAPI.Checker.References

120− , Data.OpenApi.Compare.Report

123+ , OpenAPI.Checker.Subtree

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

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

124+ , OpenAPI.Checker.Validate.MediaTypeObject

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

129− , Data.OpenApi.Compare.Validate.OpenApi

125+ , OpenAPI.Checker.Validate.OpenApi

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

126+ , OpenAPI.Checker.Validate.Operation

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

127+ , OpenAPI.Checker.Validate.Param

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

128+ , OpenAPI.Checker.Validate.PathFragment

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

129+ , OpenAPI.Checker.Validate.Products

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

130+ , OpenAPI.Checker.Validate.RequestBody

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

131+ , OpenAPI.Checker.Validate.Responses

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

132+ , OpenAPI.Checker.Validate.Schema

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

140+ , OpenAPI.Checker.Validate.SecurityRequirement

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

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

141+ , OpenAPI.Checker.Validate.Server

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

142+ , OpenAPI.Checker.Validate.Sums

148− other-modules: Data.HList

143+ , OpenAPI.Checker.Validate.Header

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

150

153

151−executable compaREST

154+executable openapi-diff

152 import: common-options

155 import: common-options

153 hs-source-dirs: app

156 hs-source-dirs: app

154 main-is: Main.hs

157 main-is: Main.hs

155 build-depends:

158 build-depends:

156− compaREST

159+ openapi-diff

157 , pandoc

160 , pandoc

158 , data-default

161 , data-default

159 , bytestring

162 , bytestring

@@ -164,41 +167,14 @@ executable compaREST

164 , aeson

167 , aeson

165 , containers

168 , containers

166 , doctemplates

169 , doctemplates

167− , pandoc-types

168 ghc-options: -threaded

170 ghc-options: -threaded

169 -rtsopts

171 -rtsopts

170 -with-rtsopts=-N

172 -with-rtsopts=-N

171 other-modules:

173 other-modules:

172 FormatHeuristic

174 FormatHeuristic

173− Data.OpenApi.Compare.Options

175+ OpenAPI.Checker.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

200

176

201−test-suite compaREST-tests

177+test-suite openapi-diff-test

202 import: common-options

178 import: common-options

203 type: exitcode-stdio-1.0

179 type: exitcode-stdio-1.0

204 hs-source-dirs: test

180 hs-source-dirs: test

@@ -206,10 +182,8 @@ test-suite compaREST-tests

206 other-modules:

182 other-modules:

207 Spec.Golden.Extra

183 Spec.Golden.Extra

208 Spec.Golden.TraceTree

184 Spec.Golden.TraceTree

209− Paths_compaREST

210− autogen-modules: Paths_compaREST

211 build-depends:

185 build-depends:

212− , compaREST

186+ , openapi-diff

213 , tasty-golden

187 , tasty-golden

214 , tasty

188 , tasty

215 , bytestring

189 , bytestring

@@ -219,7 +193,6 @@ test-suite compaREST-tests

219 , pandoc

193 , pandoc

220 , data-default

194 , data-default

221 , lens

195 , lens

222− , pandoc-types

223 ghc-options: -threaded

196 ghc-options: -threaded

224 -rtsopts

197 -rtsopts

225 -with-rtsopts=-N

198 -with-rtsopts=-N

policeman.jsondeleted−6

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

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/Data/OpenApi/Compare/Memo.hsdeleted−164

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

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/Data/OpenApi/Compare/Validate/Products.hsdeleted−48

@@ -1,48 +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−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/Data/OpenApi/Compare/Validate/Sums.hsdeleted−25

@@ -1,25 +0,0 @@

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/Data/OpenApi/Compare/Behavior.hs → src/OpenAPI/Checker/Behavior.hsrenamed+13−13

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

1−module Data.OpenApi.Compare.Behavior

1+module OpenAPI.Checker.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

19import Data.Typeable

18import Data.Typeable

19+import OpenAPI.Checker.Paths

20import Text.Pandoc.Builder

21

22-- | Kind

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

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

1−module Data.OpenApi.Compare.Common

1+module OpenAPI.Checker.Common

2− ( zipAll,

2+ ( zipAll

3 )

4where

5

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

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

1−module Data.OpenApi.Compare.Formula

1+module OpenAPI.Checker.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− )

12−where

11+ ) where

13

12

14import Data.Kind

13import Data.Kind

15−import qualified Data.List.NonEmpty as NE

16import Data.Monoid

14import Data.Monoid

17−import Data.OpenApi.Compare.Paths

15+import qualified Data.List.NonEmpty as NE

16+import OpenAPI.Checker.Paths

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

17+import qualified OpenAPI.Checker.PathsPrefixTree as P

19

18

20type VarRef = Int

19type VarRef = Int

21

20

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

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

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

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

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

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

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

28− Errors ::

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

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

30− -- | invariant: never empty

28+ -- ^ invariant: never empty

31− FormulaF q f r a

32− Apply ::

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

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

34− FormulaF q f r b ->

35− (c -> a) ->

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

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

37 -- both not 'Result'

31 -- both not 'Result'

38− FormulaF q f r a

39− SelectFirst ::

40− NE.NonEmpty (SomeFormulaF b) ->

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

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

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

42− (b -> a) ->

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

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

44 -- 'SelectFirst'

35 -- 'SelectFirst'

45− FormulaF q f r a

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

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

47

37

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

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

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

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

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

55mkSelectFirst fs allE h = case foldMap check fs of

45mkSelectFirst fs allE h = case foldMap check fs of

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

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

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

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

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

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

59 where

49 where

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

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

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

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

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

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

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

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

64 check x = (mempty, [x])

54 check x = (mempty, [x])

65

55

66data SomeFormulaF (a :: Type) where

56data SomeFormulaF (a :: Type) where

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

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

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

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

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

108 where

98 where

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

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

110 Left _ -> go rs

100 Left _ -> go rs

111 Right x -> Right (h x)

101 Right x -> Right (h x)

112 go [] = Left e

102 go [] = Left e

src/OpenAPI/Checker/Memo.hsnew file+126

@@ -0,0 +1,126 @@

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/Data/OpenApi/Compare/Orphans.hs → src/OpenAPI/Checker/Orphans.hsrenamed+1−1

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

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

2

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

3+module OpenAPI.Checker.Orphans () where

4

5import Control.Comonad.Env

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

src/Data/OpenApi/Compare/Paths.hs → src/OpenAPI/Checker/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 Data.OpenApi.Compare.Paths

4+module OpenAPI.Checker.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/Data/OpenApi/Compare/PathsPrefixTree.hs → src/OpenAPI/Checker/PathsPrefixTree.hsrenamed+39−39

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

1{-# LANGUAGE QuantifiedConstraints #-}

2

3−module Data.OpenApi.Compare.PathsPrefixTree

3+module OpenAPI.Checker.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

31import qualified Data.Set as S

30import qualified Data.Set as S

32import qualified Data.Text as T

31import qualified Data.Text as T

33import Data.Type.Equality

32import Data.Type.Equality

34import qualified Data.TypeRepMap as TRM

33import qualified Data.TypeRepMap as TRM

35import qualified Data.Vector as V

34import qualified Data.Vector as V

36import qualified GHC.Exts as Exts

35import qualified GHC.Exts as Exts

36+import OpenAPI.Checker.Paths

37import Type.Reflection

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

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

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/Data/OpenApi/Compare/References.hs → src/OpenAPI/Checker/References.hsrenamed+12−11

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

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

2

3−module Data.OpenApi.Compare.References

3+module OpenAPI.Checker.References

4− ( Step (..),

4+ ( Step (..)

5− dereference,

5+ , dereference

6− Typeable,

6+ , Typeable

7 )

8where

9

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

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

12import Data.Maybe

13import Data.OpenApi

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

14+import Data.Typeable

15+import OpenAPI.Checker.Orphans ()

15−import Data.OpenApi.Compare.Subtree

16+import OpenAPI.Checker.Subtree

16

17

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

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

18 data Step (Referenced a) a = InlineStep

19 data Step (Referenced a) a = InlineStep

19 deriving stock (Eq, Ord, Show)

20 deriving stock (Eq, Ord, Show)

20

21

21−dereference ::

22+dereference

22− Typeable a =>

23+ :: Typeable a

23− Traced (Definitions a) ->

24+ => Traced (Definitions a)

24− Traced (Referenced a) ->

25+ -> Traced (Referenced a)

25− Traced a

26+ -> Traced a

26dereference defs x = case extract x of

27dereference defs x = case extract x of

27 Inline a ->

28 Inline a ->

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

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

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

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

1−module Data.OpenApi.Compare.Report

1+module OpenAPI.Checker.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,15 +23,6 @@ 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

35import Data.OpenUnion

26import Data.OpenUnion

36import Data.OpenUnion.Extra

27import Data.OpenUnion.Extra

37import Data.Set

28import Data.Set

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

41import Data.TypeRepMap hiding (empty)

32import Data.TypeRepMap hiding (empty)

42import Data.Typeable

33import Data.Typeable

43import Generic.Data

34import 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,27 +54,22 @@ data CheckerOutput = CheckerOutput

54 deriving anyclass (ToJSON)

55

56data ReportInput = ReportInput

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

58− breakingChanges :: Changes

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

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

58+ , nonBreakingChanges :: Changes -- ^ 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

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

64− schemaIssues :: Changes

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

65 }

61 }

66 deriving stock (Generic)

62 deriving stock (Generic)

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

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

68 deriving anyclass (ToJSON)

64 deriving anyclass (ToJSON)

69

65

70segregateIssues :: CheckerOutput -> ReportInput

66segregateIssues :: CheckerOutput -> ReportInput

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

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

72− ReportInput

73− { breakingChanges = P.filter isBreaking fwd

68+ { breakingChanges = P.filter isBreaking fwd

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

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

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

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

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

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

77− }

72+ }

78 where

73 where

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

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

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

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

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

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

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

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

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

111

106

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

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

113generateReport cfg inp =

108generateReport cfg inp =

109+ let

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

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

115 breakingChangesPresent = not $ P.null $ breakingChanges inp

111 breakingChangesPresent = not $ P.null $ breakingChanges inp

116 nonBreakingChangesPresent = not $ P.null $ nonBreakingChanges inp

112 nonBreakingChangesPresent = not $ P.null $ nonBreakingChanges inp

117 unsupportedChangesPresent = not $ P.null $ unsupportedChanges inp

113 unsupportedChangesPresent = not $ P.null $ unsupportedChanges inp

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

120 OnlyErrors -> False

116 OnlyErrors -> False

121 builder = buildReport cfg

117 builder = buildReport cfg

122 report =

118 report =

119+ doc $

123− header 1 "Summary"

120+ header 1 "Summary"

124− <> twoRowTable

121+ <> twoRowTable

125− ( when'

122+ (when'

126− schemaIssuesPresent

123+ schemaIssuesPresent

127− [

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

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

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

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

130− )

126+ )

131− ]

127+ ]

132− ++ [

128+ ++

133− ( refOpt breakingChangesPresent breakingChangesId "❌ Breaking changes"

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

134 , show' $ P.size $ breakingChanges inp

130 , show' $ P.size $ breakingChanges inp

135 )

131 )

136 ]

132 ]

137− ++ when'

133+ ++ when'

138− nonBreakingChangesShown

134+ nonBreakingChangesShown

139− [

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

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

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

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

142− )

137+ )

143− ]

138+ ]

144− ++ when'

145− unsupportedChangesPresent

146− [

147− ( refOpt unsupportedChangesPresent unsupportedChangesId "❓ Unsupported feature changes"

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

148− , show' $ P.size $ unsupportedChanges inp

140+ , show' $ P.size $ unsupportedChanges inp

149− )

141+ )

150− ]

142+ ])

151− )

152− <> when'

143+ <> when'

153− schemaIssuesPresent

144+ schemaIssuesPresent

154− ( header 1 (anchor schemaIssuesId <> "‼️ Schema issues")

145+ (header 1 (anchor schemaIssuesId <> "❌ Schema issues")

155− <> builder (showErrs $ schemaIssues inp)

146+ <> builder (showErrs $ schemaIssues inp))

156− )

157− <> when'

147+ <> when'

158− breakingChangesPresent

148+ breakingChangesPresent

159− ( header 1 (anchor breakingChangesId <> "❌ Breaking changes")

149+ (header 1 (anchor breakingChangesId <> "⚠️ Breaking changes")

160− <> builder (showErrs $ breakingChanges inp)

150+ <> builder (showErrs $ breakingChanges inp))

161− )

162− <> when'

151+ <> when'

163− (nonBreakingChangesPresent && nonBreakingChangesShown)

152+ (nonBreakingChangesPresent && nonBreakingChangesShown)

164− ( header 1 (anchor nonBreakingChangesId <> "⚠️ Non-breaking changes")

153+ (header 1 (anchor nonBreakingChangesId <> "🙆 Non-breaking changes")

165− <> builder (showErrs $ nonBreakingChanges inp)

154+ <> builder (showErrs $ nonBreakingChanges inp))

166− )

167− <> when'

155+ <> when'

168− unsupportedChangesPresent

156+ unsupportedChangesPresent

169− ( header 1 (anchor unsupportedChangesId <> "❓ Unsupported feature changes")

157+ (header 1 (anchor unsupportedChangesId <> "🤷 Unsupported feature changes")

170− <> builder (showErrs $ unsupportedChanges inp)

158+ <> builder (showErrs $ unsupportedChanges inp))

171− )

172 status =

159 status =

173 if

160 if

174 | breakingChangesPresent -> BreakingChanges

161 | breakingChangesPresent -> BreakingChanges

@@ -198,14 +185,13 @@ showErrs x@(P.PathsPrefixNode currentIssues _) =

198 let -- Extract this pattern if more cases like this arise

185 let -- Extract this pattern if more cases like this arise

199 ( removedPaths :: Maybe (Orientation, [Issue 'APILevel])

186 ( removedPaths :: Maybe (Orientation, [Issue 'APILevel])

200 , otherIssues :: Set (AnIssue a)

187 , otherIssues :: Set (AnIssue a)

201− ) = case eqT @a @ 'APILevel of

188+ ) = case eqT @a @'APILevel of

202 Just Refl

189 Just Refl

203 | (S.toList -> p@((AnIssue ori _) : _), o) <-

190 | (S.toList -> p@((AnIssue ori _) : _), o) <-

204 S.partition

191 S.partition

205− ( \((AnIssue _ u)) -> case u of

192+ (\((AnIssue _ u)) -> case u of

206− NoPathsMatched {} -> True

193+ NoPathsMatched {} -> True

207− AllPathsFailed {} -> True

194+ AllPathsFailed {} -> True)

208− )

209 currentIssues ->

195 currentIssues ->

210 let p' = p <&> (\(AnIssue _ i) -> i)

196 let p' = p <&> (\(AnIssue _ i) -> i)

211 in (Just (ori, p'), o)

197 in (Just (ori, p'), o)

@@ -216,10 +202,9 @@ showErrs x@(P.PathsPrefixNode currentIssues _) =

216 paths = case removedPaths of

202 paths = case removedPaths of

217 Just (ori, ps) -> do

203 Just (ori, ps) -> do

218 singletonHeader

204 singletonHeader

219− ( case ori of

205+ (case ori of

220− Forward -> "Removed paths"

206+ Forward -> "Removed paths"

221− Backward -> "Added paths"

207+ Backward -> "Added paths")

222− )

223 $ singletonBody $

208 $ singletonBody $

224 bulletList $

209 bulletList $

225 ps <&> \case

210 ps <&> \case

@@ -255,62 +240,60 @@ jets =

255 , constructReportJet $ \p@(AtPath _) op@(InOperation _) ->

240 , constructReportJet $ \p@(AtPath _) op@(InOperation _) ->

256 strong (describeBehavior op) <> " " <> describeBehavior p :: Inlines

241 strong (describeBehavior op) <> " " <> describeBehavior p :: Inlines

257 , constructReportJet $ \(WithStatusCode c) ResponsePayload PayloadSchema ->

242 , constructReportJet $ \(WithStatusCode c) ResponsePayload PayloadSchema ->

258− "⬅️☁️ JSON Response – " <> str (T.pack . show $ c) :: Inlines

243+ "📱⬅️ JSON Response – " <> str (T.pack . show $ c) :: Inlines

259− , constructReportJet $ \InRequest InPayload PayloadSchema -> "➡️☁️ JSON Request" :: Inlines

244+ , constructReportJet $ \InRequest InPayload PayloadSchema -> "📱➡️ JSON Request" :: Inlines

260 ]

245 ]

261 where

246 where

262 unwrapReportJetResult :: ReportJetResult Behave x -> ReportJet' Behave x

247 unwrapReportJetResult :: ReportJetResult Behave x -> ReportJet' Behave x

263 unwrapReportJetResult (Pure _) = error "There really shouldn't be any results here."

248 unwrapReportJetResult (Pure _) = error "There really shouldn't be any results here."

264 unwrapReportJetResult (Free f) = f

249 unwrapReportJetResult (Free f) = f

265

250

266− jsonPathJet ::

251+ jsonPathJet

267− NonEmpty

252+ :: NonEmpty

268− ( Union

253+ ( Union

269− '[ Behave 'SchemaLevel 'TypedSchemaLevel

254+ '[ Behave 'SchemaLevel 'TypedSchemaLevel

270− , Behave 'TypedSchemaLevel 'SchemaLevel

255+ , Behave 'TypedSchemaLevel 'SchemaLevel

271− ]

256+ ]

272− ) ->

257+ )

273− Inlines

258+ -> Inlines

274 jsonPathJet x = code $ "$" <> showParts (NE.toList x)

259 jsonPathJet x = code $ "$" <> showParts (NE.toList x)

275 where

260 where

276− showParts ::

261+ showParts

277− [ Union

262+ :: [ Union

278− '[ Behave 'SchemaLevel 'TypedSchemaLevel

263+ '[ Behave 'SchemaLevel 'TypedSchemaLevel

279− , Behave 'TypedSchemaLevel 'SchemaLevel

264+ , Behave 'TypedSchemaLevel 'SchemaLevel

280− ]

265+ ]

281− ] ->

266+ ]

282− Text

267+ -> Text

283 showParts [] = mempty

268 showParts [] = mempty

284 showParts (SingletonUnion (OfType Object) : xs@((SingletonUnion (InProperty _)) : _)) = showParts xs

269 showParts (SingletonUnion (OfType Object) : xs@((SingletonUnion (InProperty _)) : _)) = showParts xs

285 showParts (SingletonUnion (OfType Object) : xs@((SingletonUnion InAdditionalProperty) : _)) = showParts xs

270 showParts (SingletonUnion (OfType Object) : xs@((SingletonUnion InAdditionalProperty) : _)) = showParts xs

286 showParts (SingletonUnion (OfType Array) : xs@(SingletonUnion InItems : _)) = showParts xs

271 showParts (SingletonUnion (OfType Array) : xs@(SingletonUnion InItems : _)) = showParts xs

287 showParts (SingletonUnion (OfType Array) : xs@(SingletonUnion (InItem _) : _)) = showParts xs

272 showParts (SingletonUnion (OfType Array) : xs@(SingletonUnion (InItem _) : _)) = showParts xs

288 showParts (y : ys) =

273 showParts (y : ys) =

289− ( (\(OfType t) -> "(" <> describeJSONType t <> ")")

274+ ((\(OfType t) -> "(" <> describeJSONType t <> ")")

290− @@> ( \case

275+ @@> (\case

291− InItems -> "[*]"

276+ InItems -> "[*]"

292− InItem i -> "[" <> T.pack (show i) <> "]"

277+ InItem i -> "[" <> T.pack (show i) <> "]"

293− InProperty p -> "." <> p

278+ InProperty p -> "." <> p

294− InAdditionalProperty -> ".*"

279+ InAdditionalProperty -> ".*")

295− )

296− @@> typesExhausted

280+ @@> typesExhausted)

297− )

298 y

281 y

299 <> showParts ys

282 <> showParts ys

300

283

301−observeJetShowErrs ::

284+observeJetShowErrs

302− ReportJet' Behave (Maybe Inlines) ->

285+ :: ReportJet' Behave (Maybe Inlines)

303− P.PathsPrefixTree Behave AnIssue a ->

286+ -> P.PathsPrefixTree Behave AnIssue a

304− (Report, P.PathsPrefixTree Behave AnIssue a)

287+ -> (Report, P.PathsPrefixTree Behave AnIssue a)

305observeJetShowErrs jet p = case observeJetShowErrs' jet p of

288observeJetShowErrs jet p = case observeJetShowErrs' jet p of

306 Just m -> m

289 Just m -> m

307 Nothing -> (mempty, p)

290 Nothing -> (mempty, p)

308

291

309−observeJetShowErrs' ::

292+observeJetShowErrs'

310− forall a.

293+ :: forall a.

311− ReportJet' Behave (Maybe Inlines) ->

294+ ReportJet' Behave (Maybe Inlines)

312− P.PathsPrefixTree Behave AnIssue a ->

295+ -> P.PathsPrefixTree Behave AnIssue a

313− Maybe (Report, P.PathsPrefixTree Behave AnIssue a)

296+ -> Maybe (Report, P.PathsPrefixTree Behave AnIssue a)

314observeJetShowErrs' (ReportJet jet) (P.PathsPrefixNode currentIssues subIssues) =

297observeJetShowErrs' (ReportJet jet) (P.PathsPrefixNode currentIssues subIssues) =

315 let results =

298 let results =

316 subIssues >>= \(WrapTypeable (AStep m)) ->

299 subIssues >>= \(WrapTypeable (AStep m)) ->

@@ -318,23 +301,21 @@ observeJetShowErrs' (ReportJet jet) (P.PathsPrefixNode currentIssues subIssues)

318 maybe (Left $ embed (step bhv) subErrs) Right . listToMaybe $

301 maybe (Left $ embed (step bhv) subErrs) Right . listToMaybe $

319 jet @_ @_ @[] bhv

302 jet @_ @_ @[] bhv

320 & mapMaybe

303 & mapMaybe

321− ( \case

304+ (\case

322− Free jet' -> fmap (embed $ step bhv) <$> observeJetShowErrs' jet' subErrs

305+ Free jet' -> fmap (embed $ step bhv) <$> observeJetShowErrs' jet' subErrs

323− Pure (Just h) ->

306+ Pure (Just h) ->

324− if P.null subErrs

307+ if P.null subErrs

325− then Just mempty

308+ then Just mempty

326− else Just (singletonHeader h (showErrs subErrs), mempty)

309+ else Just (singletonHeader h (showErrs subErrs), mempty)

327− Pure Nothing -> Nothing

310+ Pure Nothing -> Nothing)

328− )

329 in (fmap . fmap) (PathsPrefixNode currentIssues mempty <>) $

311 in (fmap . fmap) (PathsPrefixNode currentIssues mempty <>) $

330 if any isRight results

312 if any isRight results

331 then

313 then

332 Just $

314 Just $

333 foldMap

315 foldMap

334− ( \case

316+ (\case

335− Left e -> (mempty, e)

317+ Left e -> (mempty, e)

336− Right m -> m

318+ Right m -> m)

337− )

338 results

319 results

339 else Nothing

320 else Nothing

340

321

@@ -357,9 +338,8 @@ buildReport cfg = case treeStyle cfg of

357 body rprt

338 body rprt

358 <> foldOMapWithKey

339 <> foldOMapWithKey

359 (headers rprt)

340 (headers rprt)

360− ( \k v ->

341+ (\k v ->

361− header level k <> subBuilder v

342+ header level k <> subBuilder v)

362− )

363 where

343 where

364 subBuilder = headerStyleBuilder (level + 1)

344 subBuilder = headerStyleBuilder (level + 1)

365

345

@@ -368,17 +348,16 @@ buildReport cfg = case treeStyle cfg of

368 body rprt

348 body rprt

369 <> foldOMapWithKey

349 <> foldOMapWithKey

370 (headers rprt)

350 (headers rprt)

371− ( \k v ->

351+ (\k v ->

372− if (OM.size . headers $ rprt) < 2

352+ if (OM.size . headers $ rprt) < 2

373− then para k <> blockQuote (subBuilder v)

353+ then para k <> blockQuote (subBuilder v)

374− else

354+ else

375− rawHtml "<details>"

355+ rawHtml "<details>"

376− <> rawHtml "<summary>"

356+ <> rawHtml "<summary>"

377− <> plain k

357+ <> plain k

378− <> rawHtml "</summary>"

358+ <> rawHtml "</summary>"

379− <> blockQuote (subBuilder v)

359+ <> blockQuote (subBuilder v)

380− <> rawHtml "</details>"

360+ <> rawHtml "</details>")

381− )

382 where

361 where

383 subBuilder = foldingStyleBuilder

362 subBuilder = foldingStyleBuilder

384

363

src/Data/OpenApi/Compare/Report/Html/Template.hs → src/OpenAPI/Checker/Report/Html/Template.hsrenamed+4−4

@@ -1,7 +1,7 @@

1{-# LANGUAGE TemplateHaskell #-}

2

3−module Data.OpenApi.Compare.Report.Html.Template

3+module OpenAPI.Checker.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=\"CompaREST\" />\

27+ \<meta name=\"generator\" content=\"OpenApi Diff\" />\

28 \<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0, user-scalable=yes\" />\

29 \</head>\

30 \<body>\

31− \<header><h1>CompaREST</h1></header>\

31+ \<header><h1>⛄ OpenApi Diff</h1></header>\

32 \<main>\

33 \$body$\

34 \</main>\

src/Data/OpenApi/Compare/Report/Jet.hs → src/OpenAPI/Checker/Report/Jet.hsrenamed+5−5

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

1−module Data.OpenApi.Compare.Report.Jet

1+module OpenAPI.Checker.Report.Jet

2− ( ReportJet (..),

2+ ( ReportJet (..)

3− ReportJet',

3+ , ReportJet'

4− ConstructReportJet (..),

4+ , ConstructReportJet (..)

5− ReportJetResult,

5+ , ReportJetResult

6 )

7where

8

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

@@ -1,17 +1,16 @@

1−module Data.OpenApi.Compare.Run

1+module OpenAPI.Checker.Run

2− ( runChecker,

2+ ( runChecker

3− runReport,

3+ , runReport

4− module Data.OpenApi.Compare.Report,

4+ , module OpenAPI.Checker.Report

5 )

6where

7

8import Data.HList

9import Data.OpenApi (OpenApi)

10−import Data.OpenApi.Compare.Paths

10+import OpenAPI.Checker.Paths

11−import Data.OpenApi.Compare.Report

11+import OpenAPI.Checker.Report

12−import Data.OpenApi.Compare.Subtree

12+import OpenAPI.Checker.Subtree

13−import Data.OpenApi.Compare.Validate.OpenApi ()

13+import OpenAPI.Checker.Validate.OpenApi ()

14−import Text.Pandoc.Builder

15

14

16runChecker :: (OpenApi, OpenApi) -> CheckerOutput

15runChecker :: (OpenApi, OpenApi) -> CheckerOutput

17runChecker (client, server) =

16runChecker (client, server) =

@@ -27,5 +26,5 @@ runChecker (client, server) =

27 }

26 }

28 run p c = either id mempty . runCompatFormula . checkCompatibility Root HNil $ toPC p c

27 run p c = either id mempty . runCompatFormula . checkCompatibility Root HNil $ toPC p c

29

28

30−runReport :: ReportConfig -> (OpenApi, OpenApi) -> (Blocks, ReportStatus)

29+runReport :: ReportConfig -> (OpenApi, OpenApi) -> (Pandoc, ReportStatus)

31runReport cfg = generateReport cfg . segregateIssues . runChecker

30runReport cfg = generateReport cfg . segregateIssues . runChecker

src/Data/OpenApi/Compare/Subtree.hs → src/OpenAPI/Checker/Subtree.hsrenamed+126−128

@@ -1,52 +1,52 @@

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

2

3−module Data.OpenApi.Compare.Subtree

3+module OpenAPI.Checker.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

68import qualified Data.Set as S

63import qualified Data.Set as S

69import Data.Typeable

64import 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,26 +266,25 @@ 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− )

283 else structuralIssue

282 else structuralIssue

284{-# INLINE iohmStructuralWith #-}

283{-# INLINE iohmStructuralWith #-}

285

284

286−runCompatFormula ::

285+runCompatFormula

287− CompatFormula' q f r a ->

286+ :: CompatFormula' q f r a

288− Either (P.PathsPrefixTree q f r) a

287+ -> Either (P.PathsPrefixTree q f r) a

289runCompatFormula (Compose f) =

288runCompatFormula (Compose f) =

290 calculate . runIdentity . runMemo 0 . unCompatM $ f

289 calculate . runIdentity . runMemo 0 . unCompatM $ f

291{-# INLINE runCompatFormula #-}

290{-# INLINE runCompatFormula #-}

@@ -315,27 +314,27 @@ invertIssueOrientationP = P.map (\(AnIssue ori i) -> AnIssue (toggleOrientation

315structuralIssue :: StructuralCompatFormula a

314structuralIssue :: StructuralCompatFormula a

316structuralIssue = Compose $ pure $ anError $ AnItem Root Proxy

315structuralIssue = Compose $ pure $ anError $ AnItem Root Proxy

317

316

318−anyOfAt ::

317+anyOfAt

319− Issuable l =>

318+ :: Issuable l

320− Paths q r l ->

319+ => Paths q r l

321− Issue l ->

320+ -> Issue l

322− [CompatFormula' q AnIssue r a] ->

321+ -> [CompatFormula' q AnIssue r a]

323− CompatFormula' q AnIssue r a

322+ -> CompatFormula' q AnIssue r a

324anyOfAt _ _ [x] = x

323anyOfAt _ _ [x] = x

325anyOfAt xs issue fs =

324anyOfAt xs issue fs =

326 Compose $ (`eitherOf` AnItem xs (anIssue issue)) <$> traverse getCompose fs

325 Compose $ (`eitherOf` AnItem xs (anIssue issue)) <$> traverse getCompose fs

327

326

328-- | If the given formula contains any issues, add another issue on top. Otherwise succeed.

327-- | If the given formula contains any issues, add another issue on top. Otherwise succeed.

329−clarifyIssue ::

328+clarifyIssue

330− AnItem q AnIssue r ->

329+ :: AnItem q AnIssue r

331− CompatFormula' q AnIssue r a ->

330+ -> CompatFormula' q AnIssue r a

332− CompatFormula' q AnIssue r a

331+ -> CompatFormula' q AnIssue r a

333clarifyIssue item f =

332clarifyIssue item f =

334 Compose ((`eitherOf` item) <$> pure <$> getCompose f) *> f

333 Compose ((`eitherOf` item) <$> pure <$> getCompose f) *> f

335

334

336−fixpointKnot ::

335+fixpointKnot

337− MonadState (MemoState VarRef) m =>

336+ :: MonadState (MemoState VarRef) m

338− KnotTier (FormulaF q f r ()) VarRef m

337+ => KnotTier (FormulaF q f r ()) VarRef m

339fixpointKnot =

338fixpointKnot =

340 KnotTier

339 KnotTier

341 { onKnotFound = modifyMemoNonce succ

340 { onKnotFound = modifyMemoNonce succ

@@ -343,20 +342,19 @@ fixpointKnot =

343 , tieKnot = \i x -> pure $ maxFixpoint i x

342 , tieKnot = \i x -> pure $ maxFixpoint i x

344 }

343 }

345

344

346−memo ::

345+memo

347− (Typeable (l :: k), Typeable q, Typeable f, Typeable k, Typeable a) =>

346+ :: (Typeable (l :: k), Typeable q, Typeable f, Typeable k, Typeable a)

348− Paths q r l ->

347+ => Paths q r l

349− MemoKey ->

348+ -> MemoKey

350− (ProdCons (Traced a) -> CompatFormula' q f r ()) ->

349+ -> (ProdCons (Traced a) -> CompatFormula' q f r ())

351− (ProdCons (Traced a) -> CompatFormula' q f r ())

350+ -> (ProdCons (Traced a) -> CompatFormula' q f r ())

352memo bhv k f pc = Compose $ do

351memo bhv k f pc = Compose $ do

353 formula' <-

352 formula' <-

354 memoWithKnot

353 memoWithKnot

355 fixpointKnot

354 fixpointKnot

356− ( do

355+ (do

357− formula <- getCompose $ f pc

356+ formula <- getCompose $ f pc

358− pure $ mapErrors (P.takeSubtree bhv) formula

357+ pure $ mapErrors (P.takeSubtree bhv) formula)

359− )

360 (k, ask <$> pc)

358 (k, ask <$> pc)

361 pure $ mapErrors (P.embed bhv) formula'

359 pure $ mapErrors (P.embed bhv) formula'

362

360

src/Data/OpenApi/Compare/Validate/Header.hs → src/OpenAPI/Checker/Validate/Header.hsrenamed+5−5

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

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

2

3−module Data.OpenApi.Compare.Validate.Header

3+module OpenAPI.Checker.Validate.Header

4 (

5 )

6where

@@ -9,10 +9,10 @@ import Data.Foldable

9import Data.Functor

10import Data.Maybe

11import Data.OpenApi

12−import Data.OpenApi.Compare.Behavior

12+import OpenAPI.Checker.Behavior

13−import Data.OpenApi.Compare.References ()

13+import OpenAPI.Checker.References ()

14−import Data.OpenApi.Compare.Subtree

14+import OpenAPI.Checker.Subtree

15−import Data.OpenApi.Compare.Validate.Schema ()

15+import OpenAPI.Checker.Validate.Schema ()

16import Text.Pandoc.Builder

17

18instance Subtree Header where

src/Data/OpenApi/Compare/Validate/Link.hs → src/OpenAPI/Checker/Validate/Link.hsrenamed+4−4

@@ -1,10 +1,10 @@

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

2

3−module Data.OpenApi.Compare.Validate.Link () where

3+module OpenAPI.Checker.Validate.Link () where

4

5import Data.OpenApi

6−import Data.OpenApi.Compare.Behavior

6+import OpenAPI.Checker.Behavior

7−import Data.OpenApi.Compare.Subtree

7+import OpenAPI.Checker.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 "CompaREST does not currently support Link Objects."

22+ describeIssue _ LinksUnsupported = para "OpenApi Diff does not currently support Link Objects."

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

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

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

2

3−module Data.OpenApi.Compare.Validate.MediaTypeObject

3+module OpenAPI.Checker.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 ()

20import Data.String

15import Data.String

21import Data.Text (Text)

16import Data.Text (Text)

22import qualified Data.Text as T

17import qualified Data.Text as T

23import Network.HTTP.Media (MediaType, mainType, subType)

18import 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 "CompaREST does not currently support media encodings other than JSON."

48+ describeIssue _ EncodingNotSupported = para "OpenApi Diff 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− -- #54

122+ -- https://github.com/typeable/openapi-diff/issues/54

123 checkSemanticCompatibility _env beh _pc =

124 issueAt beh EncodingNotSupported

125

src/Data/OpenApi/Compare/Validate/OAuth2Flows.hs → src/OpenAPI/Checker/Validate/OAuth2Flows.hsrenamed+17−17

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

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

2

3−module Data.OpenApi.Compare.Validate.OAuth2Flows

3+module OpenAPI.Checker.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

18import Data.Proxy

15import Data.Proxy

19import Data.Set (Set)

16import Data.Set (Set)

20import qualified Data.Set as S

17import qualified Data.Set as S

21import Data.Text (Text)

18import 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/Data/OpenApi/Compare/Validate/OpenApi.hs → src/OpenAPI/Checker/Validate/OpenApi.hsrenamed+17−18

@@ -2,19 +2,19 @@

2-- Does not compiles otherwise

3{-# OPTIONS_GHC -fconstraint-solver-iterations=0 #-}

4

5−module Data.OpenApi.Compare.Validate.OpenApi

5+module OpenAPI.Checker.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 Data.OpenApi.Compare.Behavior

14+import OpenAPI.Checker.Behavior

15−import Data.OpenApi.Compare.Paths

15+import OpenAPI.Checker.Paths

16−import Data.OpenApi.Compare.Subtree

16+import OpenAPI.Checker.Subtree

17−import Data.OpenApi.Compare.Validate.Operation

17+import OpenAPI.Checker.Validate.Operation

18

19tracedPaths :: Traced OpenApi -> Traced ProcessedPathItems

20tracedPaths oa =

@@ -79,17 +79,16 @@ 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− )

93 (tracedPaths <$> prodCons)

92 (tracedPaths <$> prodCons)

94

93

95instance Steppable OpenApi ProcessedPathItems where

94instance Steppable OpenApi ProcessedPathItems where

src/Data/OpenApi/Compare/Validate/Operation.hs → src/OpenAPI/Checker/Validate/Operation.hsrenamed+41−43

@@ -2,19 +2,19 @@

2{-# OPTIONS_GHC -Wno-orphans #-}

3{-# OPTIONS_GHC -fconstraint-solver-iterations=0 #-}

4

5−module Data.OpenApi.Compare.Validate.Operation

5+module OpenAPI.Checker.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

44import Data.String

32import Data.String

45import Data.Text (Text)

33import Data.Text (Text)

46import qualified Data.Text as T

34import 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,12 +86,11 @@ tracedCallbacks (Traced t oper) =

86 | (k, v) <- IOHM.toList . _operationCallbacks . operation $ oper

87 ]

88

89−-- FIXME: #28

89+-- FIXME: https://github.com/typeable/openapi-diff/issues/28

90−getServers ::

90+getServers

91− -- | Servers from env

91+ :: [Server] -- ^ Servers from env

92− [Server] ->

93− MatchedOperation ->

92+ -> MatchedOperation

94− [Server]

93+ -> [Server]

95getServers env oper =

94getServers env oper =

96 case _operationServers . operation $ oper of

95 case _operationServers . operation $ oper of

97 [] -> env

96 [] -> env

@@ -242,7 +241,7 @@ instance Subtree MatchedOperation where

242 checkProducts beh (const NoRequestBody) (const check) elements

241 checkProducts beh (const NoRequestBody) (const check) elements

243 checkResponses =

242 checkResponses =

244 swapProdCons (checkCompatibility beh) env $ tracedResponses <$> prodCons

243 swapProdCons (checkCompatibility beh) env $ tracedResponses <$> prodCons

245− -- FIXME: #27

244+ -- FIXME: https://github.com/typeable/openapi-diff/issues/27

246 checkCallbacks = do

245 checkCallbacks = do

247 let ProdCons pCallbacks cCallbacks = tracedCallbacks <$> prodCons

246 let ProdCons pCallbacks cCallbacks = tracedCallbacks <$> prodCons

248 for_ pCallbacks $ \(k, pCallback) -> do

247 for_ pCallbacks $ \(k, pCallback) -> do

@@ -251,7 +250,7 @@ instance Subtree MatchedOperation where

251 cCallbacks <&> \(_, cCallback) -> do

250 cCallbacks <&> \(_, cCallback) -> do

252 swapProdCons (checkCompatibility beh') env $ ProdCons pCallback cCallback

251 swapProdCons (checkCompatibility beh') env $ ProdCons pCallback cCallback

253 pure ()

252 pure ()

254− -- FIXME: #28

253+ -- FIXME: https://github.com/typeable/openapi-diff/issues/28

255 checkOperationSecurity = do

254 checkOperationSecurity = do

256 let ProdCons pSecs cSecs = tracedSecurity <$> prodCons

255 let ProdCons pSecs cSecs = tracedSecurity <$> prodCons

257 for_ pSecs $ \(i, pSec) -> do

256 for_ pSecs $ \(i, pSec) -> do

@@ -338,10 +337,9 @@ instance Issuable 'APILevel where

338 deriving stock (Eq, Ord, Show)

337 deriving stock (Eq, Ord, Show)

339 issueKind = \case

338 issueKind = \case

340 _ -> CertainIssue

339 _ -> CertainIssue

341− relatedIssues =

340+ relatedIssues = (==) `withClass` \case

342− (==) `withClass` \case

343− NoPathsMatched fp -> Just fp

341+ NoPathsMatched fp -> Just fp

344− AllPathsFailed fp -> Just fp

342+ AllPathsFailed fp -> Just fp

345 describeIssue Forward (NoPathsMatched p) = para $ "The path " <> (code . T.pack) p <> " has been removed."

343 describeIssue Forward (NoPathsMatched p) = para $ "The path " <> (code . T.pack) p <> " has been removed."

346 describeIssue Backward (NoPathsMatched p) = para $ "The path " <> (code . T.pack) p <> " has been added."

344 describeIssue Backward (NoPathsMatched p) = para $ "The path " <> (code . T.pack) p <> " has been added."

347 describeIssue Forward (AllPathsFailed p) = para $ "The path " <> (code . T.pack) p <> " has been removed."

345 describeIssue Forward (AllPathsFailed p) = para $ "The path " <> (code . T.pack) p <> " has been removed."

@@ -436,10 +434,10 @@ tracedFragments mpi =

436 | (i, x) <- L.zip [0 ..] $ pathFragments $ extract mpi

434 | (i, x) <- L.zip [0 ..] $ pathFragments $ extract mpi

437 ]

435 ]

438

436

439−tracedMethod ::

437+tracedMethod

440− OperationMethod ->

438+ :: OperationMethod

441− Traced MatchedPathItem ->

439+ -> Traced MatchedPathItem

442− Maybe (Traced' MatchedOperation Operation)

440+ -> Maybe (Traced' MatchedOperation Operation)

443tracedMethod s mpi = env (ask mpi >>> step (OperationMethodStep s)) <$> (pathItemMethod s . pathItem . extract $ mpi)

441tracedMethod s mpi = env (ask mpi >>> step (OperationMethodStep s)) <$> (pathItemMethod s . pathItem . extract $ mpi)

444

442

445instance Issuable 'PathLevel where

443instance Issuable 'PathLevel where

@@ -487,10 +485,10 @@ instance Subtree MatchedPathItem where

487 checkSemanticCompatibility env beh prodCons = do

485 checkSemanticCompatibility env beh prodCons = do

488 let paramDefs = getH @(ProdCons (Traced (Definitions Param))) env

486 let paramDefs = getH @(ProdCons (Traced (Definitions Param))) env

489 pathTracedParams = getPathParams <$> paramDefs <*> prodCons

487 pathTracedParams = getPathParams <$> paramDefs <*> prodCons

490− getPathParams ::

488+ getPathParams

491− Traced (Definitions Param) ->

489+ :: Traced (Definitions Param)

492− Traced MatchedPathItem ->

490+ -> Traced MatchedPathItem

493− [Traced Param]

491+ -> [Traced Param]

494 getPathParams defs mpi = do

492 getPathParams defs mpi = do

495 paramRef <- tracedMatchedPathItemParameters mpi

493 paramRef <- tracedMatchedPathItemParameters mpi

496 pure $ dereference defs paramRef

494 pure $ dereference defs paramRef

@@ -566,7 +564,7 @@ instance Issuable 'CallbackLevel where

566 deriving stock (Eq, Ord, Show)

564 deriving stock (Eq, Ord, Show)

567 issueKind = \case

565 issueKind = \case

568 CallbacksUnsupported -> Unsupported

566 CallbacksUnsupported -> Unsupported

569− describeIssue _ CallbacksUnsupported = para "CompaREST does not currently support callbacks."

567+ describeIssue _ CallbacksUnsupported = para "OpenApi Diff does not currently support callbacks."

570

568

571tracedCallbackPathItems :: Traced Callback -> Traced ProcessedPathItems

569tracedCallbackPathItems :: Traced Callback -> Traced ProcessedPathItems

572tracedCallbackPathItems (Traced t (Callback x)) =

570tracedCallbackPathItems (Traced t (Callback x)) =

src/Data/OpenApi/Compare/Validate/Param.hs → src/OpenAPI/Checker/Validate/Param.hsrenamed+12−14

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

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

2{-# OPTIONS_GHC -fno-warn-name-shadowing #-}

3

4−module Data.OpenApi.Compare.Validate.Param

4+module OpenAPI.Checker.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 ()

18import Data.Text as T

14import 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,17 +106,15 @@ 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− )

112 $ issueAt beh ParamRequired

111 $ issueAt beh ParamRequired

113 case (_paramIn . extract $ p, _paramIn . extract $ c) of

112 case (_paramIn . extract $ p, _paramIn . extract $ c) of

114 (ParamQuery, ParamQuery) -> do

113 (ParamQuery, ParamQuery) -> do

115 -- Emptiness is only for query params

114 -- Emptiness is only for query params

116 when

115 when

117− ( (fromMaybe False . _paramAllowEmptyValue . extract $ p)

116+ ((fromMaybe False . _paramAllowEmptyValue . extract $ p)

118− && not (fromMaybe False . _paramAllowEmptyValue . extract $ c)

117+ && not (fromMaybe False . _paramAllowEmptyValue . extract $ c))

119− )

120 $ issueAt beh ParamEmptinessIncompatible

118 $ issueAt beh ParamEmptinessIncompatible

121 (a, b) | a == b -> pure ()

119 (a, b) | a == b -> pure ()

122 _ -> issueAt beh ParamPlaceIncompatible

120 _ -> issueAt beh ParamPlaceIncompatible

src/Data/OpenApi/Compare/Validate/PathFragment.hs → src/OpenAPI/Checker/Validate/PathFragment.hsrenamed+9−8

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

1−module Data.OpenApi.Compare.Validate.PathFragment

1+module OpenAPI.Checker.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

13import Data.Text (Text)

10import Data.Text (Text)

14import qualified Data.Text as T

11import 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

15

16

16-- TODO: templates can be only part of the PathFragment. Currently only supports templates as full PathFragment.

17-- TODO: templates can be only part of the PathFragment. Currently only supports templates as full PathFragment.

17−-- #23

18+-- https://github.com/typeable/openapi-diff/issues/23

18parsePath :: FilePath -> [PathFragment Text]

19parsePath :: FilePath -> [PathFragment Text]

19parsePath = fmap partition . T.splitOn "/" . T.pack

20parsePath = fmap partition . T.splitOn "/" . T.pack

20 where

21 where

src/OpenAPI/Checker/Validate/Products.hsnew file+49

@@ -0,0 +1,49 @@

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/Data/OpenApi/Compare/Validate/RequestBody.hs → src/OpenAPI/Checker/Validate/RequestBody.hsrenamed+7−7

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

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

2

3−module Data.OpenApi.Compare.Validate.RequestBody

3+module OpenAPI.Checker.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

18import qualified Data.Text as T

14import qualified Data.Text as T

19import Network.HTTP.Media (MediaType)

15import 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/Data/OpenApi/Compare/Validate/Responses.hs → src/OpenAPI/Checker/Validate/Responses.hsrenamed+11−11

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

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

2{-# OPTIONS_GHC -fno-warn-name-shadowing #-}

3

4−module Data.OpenApi.Compare.Validate.Responses

4+module OpenAPI.Checker.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

23import qualified Data.Text as T

14import qualified Data.Text as T

24import Network.HTTP.Media (MediaType)

15import 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/Data/OpenApi/Compare/Validate/Schema.hs → src/OpenAPI/Checker/Validate/Schema.hsrenamed+107−86

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

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

2−

3−module Data.OpenApi.Compare.Validate.Schema

2+module OpenAPI.Checker.Validate.Schema

4 (

3 (

5 )

4 )

6where

5where

@@ -11,36 +10,36 @@ import Data.Coerce

11import Data.Foldable (for_, toList)

10import Data.Foldable (for_, toList)

12import Data.Functor

11import Data.Functor

13import Data.HList

12import Data.HList

14−import Data.List (genericIndex, genericLength, group)

15import qualified Data.List.NonEmpty as NE

13import qualified Data.List.NonEmpty as NE

16import qualified Data.Map as M

14import qualified Data.Map as M

15+import Data.List (group, genericLength, genericIndex)

17import Data.Maybe

16import Data.Maybe

18import Data.OpenApi

17import 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

30import Data.Ord

18import Data.Ord

31import Data.Ratio

19import Data.Ratio

32import Data.Semigroup

20import Data.Semigroup

33import qualified Data.Set as S

21import qualified Data.Set as S

34import Data.Text (Text)

22import 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

35

34

36−checkFormulas ::

35+checkFormulas

37− (ReassembleHList xs (CheckEnv (Referenced Schema))) =>

36+ :: (ReassembleHList xs (CheckEnv (Referenced Schema)))

38− HList xs ->

37+ => HList xs

39− Behavior 'SchemaLevel ->

38+ -> Behavior 'SchemaLevel

40− ProdCons (Trace Schema) ->

39+ -> ProdCons (Trace Schema)

41− ProdCons (Traced (Definitions Schema)) ->

40+ -> ProdCons (Traced (Definitions Schema))

42− ProdCons (ForeachType JsonFormula, P.PathsPrefixTree Behave AnIssue 'SchemaLevel) ->

41+ -> ProdCons (ForeachType JsonFormula, P.PathsPrefixTree Behave AnIssue 'SchemaLevel)

43− SemanticCompatFormula ()

42+ -> SemanticCompatFormula ()

44checkFormulas env beh trs defs (ProdCons (fp, ep) (fc, ec)) =

43checkFormulas env beh trs defs (ProdCons (fp, ep) (fc, ec)) =

45 case P.toList ep ++ P.toList ec of

44 case P.toList ep ++ P.toList ec of

46 issues@(_ : _) -> for_ issues $ embedFormula beh . anItem

45 issues@(_ : _) -> for_ issues $ embedFormula beh . anItem

@@ -145,21 +144,21 @@ checkFormulas env beh trs defs (ProdCons (fp, ep) (fc, ec)) =

145 EnumDoesntSatisfy $ untypeValue e -- what does this look like when partitioned?

144 EnumDoesntSatisfy $ untypeValue e -- what does this look like when partitioned?

146 issueFromDisjunct mPart ps = NoMatchingCondition mPart $ SomeCondition <$> S.toList ps

145 issueFromDisjunct mPart ps = NoMatchingCondition mPart $ SomeCondition <$> S.toList ps

147

146

148−checkContradiction ::

147+checkContradiction

149− Behavior 'TypedSchemaLevel ->

148+ :: Behavior 'TypedSchemaLevel

150− Maybe Partition ->

149+ -> Maybe Partition

151− S.Set (Condition t) ->

150+ -> S.Set (Condition t)

152− SemanticCompatFormula ()

151+ -> SemanticCompatFormula ()

153checkContradiction beh mPart _ = issueAt beh $ maybe TypeBecomesEmpty PartitionBecomesEmpty mPart -- TODO #70

152checkContradiction beh mPart _ = issueAt beh $ maybe TypeBecomesEmpty PartitionBecomesEmpty mPart -- TODO #70

154

153

155−checkImplication ::

154+checkImplication

156− (ReassembleHList xs (CheckEnv (Referenced Schema))) =>

155+ :: (ReassembleHList xs (CheckEnv (Referenced Schema)))

157− HList xs ->

156+ => HList xs

158− Behavior 'TypedSchemaLevel ->

157+ -> Behavior 'TypedSchemaLevel

159− ProdCons (Trace Schema) -> -- the traces of the root schemas used in this comparison

158+ -> ProdCons (Trace Schema) -- the traces of the root schemas used in this comparison

160− S.Set (Condition t) ->

159+ -> S.Set (Condition t)

161− Condition t ->

160+ -> Condition t

162− SemanticCompatFormula ()

161+ -> SemanticCompatFormula ()

163checkImplication env beh trs prods cons = case findExactly prods of

162checkImplication env beh trs prods cons = case findExactly prods of

164 Just e

163 Just e

165 | all (satisfiesTyped e) prods ->

164 | all (satisfiesTyped e) prods ->

@@ -167,104 +166,124 @@ checkImplication env beh trs prods cons = case findExactly prods of

167 then pure ()

166 then pure ()

168 else issueAt beh (EnumDoesntSatisfy $ untypeValue e)

167 else issueAt beh (EnumDoesntSatisfy $ untypeValue e)

169 | otherwise -> pure () -- vacuously true

168 | 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+

173 Maximum m -> foldCheck min m NoMatchingMaximum MatchingMaximumWeak $ \case

174 Maximum m -> foldCheck min m NoMatchingMaximum MatchingMaximumWeak $ \case

174 Maximum m' -> Just m'

175 Maximum m' -> Just m'

175 _ -> Nothing

176 _ -> Nothing

177+

176 Minimum m -> foldCheck max m (NoMatchingMinimum . coerce) (MatchingMinimumWeak . coerce) $ \case

178 Minimum m -> foldCheck max m (NoMatchingMinimum . coerce) (MatchingMinimumWeak . coerce) $ \case

177 Minimum m' -> Just m'

179 Minimum m' -> Just m'

178 _ -> Nothing

180 _ -> Nothing

181+

179 MultipleOf m -> foldCheck lcmScientific m NoMatchingMultipleOf MatchingMultipleOfWeak $ \case

182 MultipleOf m -> foldCheck lcmScientific m NoMatchingMultipleOf MatchingMultipleOfWeak $ \case

180 MultipleOf m' -> Just m'

183 MultipleOf m' -> Just m'

181 _ -> Nothing

184 _ -> Nothing

185+

182 NumberFormat f -> case flip any prods $ \case

186 NumberFormat f -> case flip any prods $ \case

183− NumberFormat f' -> f == f'

187+ NumberFormat f' -> f == f'

184− _ -> False of

188+ _ -> False

189+ of

185 True -> pure ()

190 True -> pure ()

186 False -> issueAt beh (NoMatchingFormat f)

191 False -> issueAt beh (NoMatchingFormat f)

192+

187 MaxLength m -> foldCheck min m NoMatchingMaxLength MatchingMaxLengthWeak $ \case

193 MaxLength m -> foldCheck min m NoMatchingMaxLength MatchingMaxLengthWeak $ \case

188 MaxLength m' -> Just m'

194 MaxLength m' -> Just m'

189 _ -> Nothing

195 _ -> Nothing

196+

190 MinLength m -> foldCheck max m NoMatchingMinLength MatchingMinLengthWeak $ \case

197 MinLength m -> foldCheck max m NoMatchingMinLength MatchingMinLengthWeak $ \case

191 MinLength m' -> Just m'

198 MinLength m' -> Just m'

192 _ -> Nothing

199 _ -> Nothing

200+

193 Pattern p -> case flip any prods $ \case

201 Pattern p -> case flip any prods $ \case

194− Pattern p' -> p == p'

202+ Pattern p' -> p == p'

195− _ -> False of

203+ _ -> False

204+ of

196 True -> pure ()

205 True -> pure ()

197 False -> issueAt beh (NoMatchingPattern p) -- TODO: regex comparison #32

206 False -> issueAt beh (NoMatchingPattern p) -- TODO: regex comparison #32

207+

198 StringFormat f -> case flip any prods $ \case

208 StringFormat f -> case flip any prods $ \case

199− StringFormat f' -> f == f'

209+ StringFormat f' -> f == f'

200− _ -> False of

210+ _ -> False

211+ of

201 True -> pure ()

212 True -> pure ()

202 False -> issueAt beh (NoMatchingFormat f)

213 False -> issueAt beh (NoMatchingFormat f)

214+

203 Items _ cons' -> case foldSome (<>) prods $ \case

215 Items _ cons' -> case foldSome (<>) prods $ \case

204− Items _ rs -> Just (Just (rs NE.:| []), mempty)

216+ Items _ rs -> Just (Just (rs NE.:| []), mempty)

205− TupleItems (map snd -> fs) -> Just (mempty, Just (fs NE.:| []))

217+ TupleItems (map snd -> fs) -> Just (mempty, Just (fs NE.:| []))

206− _ -> Nothing of

218+ _ -> Nothing

219+ of

207 Just (mItems, Just pfs)

220 Just (mItems, Just pfs)

208 | not $ allSame (length <$> pfs) -> pure () -- vacuously

221 | not $ allSame (length <$> pfs) -> pure () -- vacuously

209− | let plen = genericLength (NE.head pfs) ->

222+ | let plen = genericLength (NE.head pfs)

210− clarifyIssue (AnItem beh (anIssue TupleToArray)) $

223+ -> clarifyIssue (AnItem beh (anIssue TupleToArray)) $ for_ [0 .. plen - 1] $ \i -> do

211− for_ [0 .. plen - 1] $ \i -> do

212− let prod' = tracedConjunct $ case mItems of

224+ let prod' = tracedConjunct $ case mItems of

213− Just prods' -> ((`genericIndex` i) <$> pfs) <> prods'

225+ Just prods' -> ((`genericIndex` i) <$> pfs) <> prods'

214− Nothing -> (`genericIndex` i) <$> pfs

226+ Nothing -> (`genericIndex` i) <$> pfs

215− checkCompatibility (beh >>> step (InItem i)) env $ ProdCons prod' cons'

227+ checkCompatibility (beh >>> step (InItem i)) env $ ProdCons prod' cons'

216 Just (Just prods', Nothing) -> do

228 Just (Just prods', Nothing) -> do

217 let prod' = tracedConjunct prods'

229 let prod' = tracedConjunct prods'

218 checkCompatibility (beh >>> step InItems) env $ ProdCons prod' cons'

230 checkCompatibility (beh >>> step InItems) env $ ProdCons prod' cons'

219 _ -> clarifyIssue (AnItem beh (anIssue NoMatchingItems)) $ do

231 _ -> clarifyIssue (AnItem beh (anIssue NoMatchingItems)) $ do

220 checkCompatibility (beh >>> step InItems) env $ ProdCons prodTopSchema cons'

232 checkCompatibility (beh >>> step InItems) env $ ProdCons prodTopSchema cons'

233+

221 TupleItems (map snd -> fs) -> case foldSome (<>) prods $ \case

234 TupleItems (map snd -> fs) -> case foldSome (<>) prods $ \case

222− TupleItems (map snd -> fs') -> Just (Just $ fs' NE.:| [], Just . Max $ genericLength fs', Just . Min $ genericLength fs', mempty)

235+ TupleItems (map snd -> fs') -> Just (Just $ fs' NE.:| [], Just . Max $ genericLength fs', Just . Min $ genericLength fs', mempty)

223− MinItems m' -> Just (mempty, Just . Max $ m', mempty, mempty)

236+ MinItems m' -> Just (mempty, Just . Max $ m', mempty, mempty)

224− MaxItems m' -> Just (mempty, mempty, Just . Min $ m', mempty)

237+ MaxItems m' -> Just (mempty, mempty, Just . Min $ m', mempty)

225− Items _ rs -> Just (mempty, mempty, mempty, Just (rs NE.:| []))

238+ Items _ rs -> Just (mempty, mempty, mempty, Just (rs NE.:| []))

226− _ -> Nothing of

239+ _ -> Nothing

240+ of

227− -- if the length constraints in the producer are contradictory:

241+ -- if the length constraints in the producer are contradictory:

228− Just (_, Just (Max lowest), Just (Min highest), _) | lowest > highest -> pure ()

242+ Just (_, Just (Max lowest), Just (Min highest), _) | lowest > highest -> pure ()

229− -- We have an explicit tuple items clause...

243+ -- We have an explicit tuple items clause...

230− Just (Just pfs, Just (Max plen), _, _)

244+ Just (Just pfs, Just (Max plen), _, _)

231− | plen /= genericLength fs -> -- ...of wrong length

245+ | plen /= genericLength fs -- ...of wrong length

232− issueAt beh (TupleItemsLengthChanged ProdCons {producer = plen, consumer = genericLength fs})

246+ -> issueAt beh (TupleItemsLengthChanged ProdCons {producer = plen, consumer = genericLength fs})

233− | otherwise ->

247+ | otherwise

234− for_ [0 .. plen - 1] $ \i -> do

248+ -> for_ [0 .. plen - 1] $ \i -> do

235 checkCompatibility (beh >>> step (InItem i)) env $ ProdCons (tracedConjunct $ (`genericIndex` i) <$> pfs) (fs `genericIndex` i)

249 checkCompatibility (beh >>> step (InItem i)) env $ ProdCons (tracedConjunct $ (`genericIndex` i) <$> pfs) (fs `genericIndex` i)

236− -- We have a fixed length array in the producer...

250+ -- We have a fixed length array in the producer...

237− Just (Nothing, Just (Max plen), Just (Min plen'), mProd)

251+ Just (Nothing, Just (Max plen), Just (Min plen'), mProd)

238− | plen == plen' ->

252+ | plen == plen'

239− clarifyIssue (AnItem beh (anIssue ArrayToTuple)) $ case mProd of

253+ -> clarifyIssue (AnItem beh (anIssue ArrayToTuple)) $ case mProd of

240− _

241− | plen /= genericLength fs -> -- ...of wrong length

254+ _ | plen /= genericLength fs -> -- ...of wrong length

242− issueAt beh (TupleItemsLengthChanged ProdCons {producer = plen, consumer = genericLength fs})

255+ issueAt beh (TupleItemsLengthChanged ProdCons {producer = plen, consumer = genericLength fs})

243 Just rs -> for_ [0 .. plen - 1] $ \i -> do

256 Just rs -> for_ [0 .. plen - 1] $ \i -> do

244 checkCompatibility (beh >>> step (InItem i)) env $ ProdCons (tracedConjunct rs) (fs `genericIndex` i)

257 checkCompatibility (beh >>> step (InItem i)) env $ ProdCons (tracedConjunct rs) (fs `genericIndex` i)

245 -- ...and no "items" schema

258 -- ...and no "items" schema

246 Nothing -> clarifyIssue (AnItem beh (anIssue NoMatchingTupleItems)) $ do

259 Nothing -> clarifyIssue (AnItem beh (anIssue NoMatchingTupleItems)) $ do

247 for_ [0 .. plen - 1] $ \i -> do

260 for_ [0 .. plen - 1] $ \i -> do

248 checkCompatibility (beh >>> step (InItem i)) env $ ProdCons prodTopSchema (fs `genericIndex` i)

261 checkCompatibility (beh >>> step (InItem i)) env $ ProdCons prodTopSchema (fs `genericIndex` i)

249− _ -> issueAt beh NoMatchingTupleItems

262+ _ -> issueAt beh NoMatchingTupleItems

263+

250 MaxItems m -> foldCheck min m NoMatchingMaxItems MatchingMaxItemsWeak $ \case

264 MaxItems m -> foldCheck min m NoMatchingMaxItems MatchingMaxItemsWeak $ \case

251 MaxItems m' -> Just m'

265 MaxItems m' -> Just m'

252 TupleItems fs -> Just $ toInteger $ length fs

266 TupleItems fs -> Just $ toInteger $ length fs

253 _ -> Nothing

267 _ -> Nothing

268+

254 MinItems m -> foldCheck max m NoMatchingMinItems MatchingMinItemsWeak $ \case

269 MinItems m -> foldCheck max m NoMatchingMinItems MatchingMinItemsWeak $ \case

255 MinItems m' -> Just m'

270 MinItems m' -> Just m'

256 TupleItems fs -> Just $ toInteger $ length fs

271 TupleItems fs -> Just $ toInteger $ length fs

257 _ -> Nothing

272 _ -> Nothing

273+

258 UniqueItems -> case flip any prods $ \case

274 UniqueItems -> case flip any prods $ \case

259− UniqueItems -> True

275+ UniqueItems -> True

260− MaxItems 1 -> True

276+ MaxItems 1 -> True

261− TupleItems fs | length fs == 1 -> True

277+ TupleItems fs | length fs == 1 -> True

262− _ -> False of

278+ _ -> False

279+ of

263 True -> pure ()

280 True -> pure ()

264 False -> issueAt beh NoMatchingUniqueItems

281 False -> issueAt beh NoMatchingUniqueItems

282+

265 Properties props _ madd -> case foldSome (<>) prods $ \case

283 Properties props _ madd -> case foldSome (<>) prods $ \case

266− Properties props' _ madd' -> Just $ (props', madd') NE.:| []

284+ Properties props' _ madd' -> Just $ (props', madd') NE.:| []

267− _ -> Nothing of

285+ _ -> Nothing

286+ of

268 Just pm ->

287 Just pm ->

269 anyOfAt beh NoMatchingProperties $ -- TODO: could first "concat" the lists

288 anyOfAt beh NoMatchingProperties $ -- TODO: could first "concat" the lists

270 NE.toList pm <&> \(props', madd') -> do

289 NE.toList pm <&> \(props', madd') -> do

@@ -295,9 +314,11 @@ checkImplication env beh trs prods cons = case findExactly prods of

295 (Just add', Just add) -> checkCompatibility (beh >>> step InAdditionalProperty) env (ProdCons add' add)

314 (Just add', Just add) -> checkCompatibility (beh >>> step InAdditionalProperty) env (ProdCons add' add)

296 pure ()

315 pure ()

297 Nothing -> issueAt beh NoMatchingProperties

316 Nothing -> issueAt beh NoMatchingProperties

317+

298 MaxProperties m -> foldCheck min m NoMatchingMaxProperties MatchingMaxPropertiesWeak $ \case

318 MaxProperties m -> foldCheck min m NoMatchingMaxProperties MatchingMaxPropertiesWeak $ \case

299 MaxProperties m' -> Just m'

319 MaxProperties m' -> Just m'

300 _ -> Nothing

320 _ -> Nothing

321+

301 MinProperties m -> foldCheck max m NoMatchingMinProperties MatchingMinPropertiesWeak $ \case

322 MinProperties m -> foldCheck max m NoMatchingMinProperties MatchingMinPropertiesWeak $ \case

302 MinProperties m' -> Just m'

323 MinProperties m' -> Just m'

303 _ -> Nothing

324 _ -> Nothing

@@ -305,14 +326,14 @@ checkImplication env beh trs prods cons = case findExactly prods of

305 lcmScientific (toRational -> a) (toRational -> b) =

326 lcmScientific (toRational -> a) (toRational -> b) =

306 fromRational $ lcm (numerator a) (numerator b) % gcd (denominator a) (denominator b)

327 fromRational $ lcm (numerator a) (numerator b) % gcd (denominator a) (denominator b)

307

328

308− foldCheck ::

329+ foldCheck

309− Eq a =>

330+ :: Eq a

310− (a -> a -> a) ->

331+ => (a -> a -> a)

311− a ->

332+ -> a

312− (a -> Issue 'TypedSchemaLevel) ->

333+ -> (a -> Issue 'TypedSchemaLevel)

313− (ProdCons a -> Issue 'TypedSchemaLevel) ->

334+ -> (ProdCons a -> Issue 'TypedSchemaLevel)

314− (forall t. Condition t -> Maybe a) ->

335+ -> (forall t. Condition t -> Maybe a)

315− SemanticCompatFormula ()

336+ -> SemanticCompatFormula ()

316 foldCheck f m missing weak extr = case foldSome f prods extr of

337 foldCheck f m missing weak extr = case foldSome f prods extr of

317 Just m'

338 Just m'

318 | f m' m == m' -> pure ()

339 | f m' m == m' -> pure ()

src/Data/OpenApi/Compare/Validate/Schema/DNF.hs → src/OpenAPI/Checker/Validate/Schema/DNF.hsrenamed+9−9

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

1−module Data.OpenApi.Compare.Validate.Schema.DNF

1+module OpenAPI.Checker.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/Data/OpenApi/Compare/Validate/Schema/Issues.hs → src/OpenAPI/Checker/Validate/Schema/Issues.hsrenamed+59−61

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

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

2

3−module Data.OpenApi.Compare.Validate.Schema.Issues

3+module OpenAPI.Checker.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

16import Data.Scientific

11import Data.Scientific

17import Data.Text (Text)

12import Data.Text (Text)

18import qualified Data.Text as T

13import 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,54 +100,53 @@ instance Issuable 'TypedSchemaLevel where

100 TypeBecomesEmpty -> ProbablyIssue -- TODO: #70

101 PartitionBecomesEmpty _ -> ProbablyIssue -- ditto

102 _ -> CertainIssue

103− relatedIssues =

103+ relatedIssues = (==) `withClass` \case

104− (==) `withClass` \case

105 EnumDoesntSatisfy v -> Just v

104 EnumDoesntSatisfy v -> Just v

106 NoMatchingEnum v -> Just v

105 NoMatchingEnum v -> Just v

107 _ -> Nothing

106 _ -> Nothing

108− `withClass` \case

107+ `withClass` \case

109− NoMatchingMaximum _ -> Just ()

108+ NoMatchingMaximum _ -> Just ()

110− MatchingMaximumWeak _ -> Just ()

109+ MatchingMaximumWeak _ -> Just ()

111− _ -> Nothing

110+ _ -> Nothing

112− `withClass` \case

111+ `withClass` \case

113− NoMatchingMinimum _ -> Just ()

112+ NoMatchingMinimum _ -> Just ()

114− MatchingMinimumWeak _ -> Just ()

113+ MatchingMinimumWeak _ -> Just ()

115− _ -> Nothing

114+ _ -> Nothing

116− `withClass` \case

115+ `withClass` \case

117− NoMatchingMultipleOf _ -> Just ()

116+ NoMatchingMultipleOf _ -> Just ()

118− MatchingMultipleOfWeak _ -> Just ()

117+ MatchingMultipleOfWeak _ -> Just ()

119− _ -> Nothing

118+ _ -> Nothing

120− `withClass` \case

119+ `withClass` \case

121− NoMatchingMaxLength _ -> Just ()

120+ NoMatchingMaxLength _ -> Just ()

122− MatchingMaxLengthWeak _ -> Just ()

121+ MatchingMaxLengthWeak _ -> Just ()

123− _ -> Nothing

122+ _ -> Nothing

124− `withClass` \case

123+ `withClass` \case

125− NoMatchingMinLength _ -> Just ()

124+ NoMatchingMinLength _ -> Just ()

126− MatchingMinLengthWeak _ -> Just ()

125+ MatchingMinLengthWeak _ -> Just ()

127− _ -> Nothing

126+ _ -> Nothing

128− `withClass` \case

127+ `withClass` \case

129− NoMatchingItems -> Just ()

128+ NoMatchingItems -> Just ()

130− ArrayToTuple -> Just ()

129+ ArrayToTuple -> Just ()

131− TupleToArray -> Just ()

130+ TupleToArray -> Just ()

132− NoMatchingTupleItems -> Just ()

131+ NoMatchingTupleItems -> Just ()

133− TupleItemsLengthChanged _ -> Just ()

132+ TupleItemsLengthChanged _ -> Just ()

134− _ -> Nothing

133+ _ -> Nothing

135− `withClass` \case

134+ `withClass` \case

136− NoMatchingMaxItems _ -> Just ()

135+ NoMatchingMaxItems _ -> Just ()

137− MatchingMaxItemsWeak _ -> Just ()

136+ MatchingMaxItemsWeak _ -> Just ()

138− _ -> Nothing

137+ _ -> Nothing

139− `withClass` \case

138+ `withClass` \case

140− NoMatchingMinItems _ -> Just ()

139+ NoMatchingMinItems _ -> Just ()

141− MatchingMinItemsWeak _ -> Just ()

140+ MatchingMinItemsWeak _ -> Just ()

142− _ -> Nothing

141+ _ -> Nothing

143− `withClass` \case

142+ `withClass` \case

144− NoMatchingMaxProperties _ -> Just ()

143+ NoMatchingMaxProperties _ -> Just ()

145− MatchingMaxPropertiesWeak _ -> Just ()

144+ MatchingMaxPropertiesWeak _ -> Just ()

146− _ -> Nothing

145+ _ -> Nothing

147− `withClass` \case

146+ `withClass` \case

148− NoMatchingMinProperties _ -> Just ()

147+ NoMatchingMinProperties _ -> Just ()

149− MatchingMinPropertiesWeak _ -> Just ()

148+ MatchingMinPropertiesWeak _ -> Just ()

150− _ -> Nothing

149+ _ -> Nothing

151 describeIssue Forward (EnumDoesntSatisfy v) = para "The following enum value was removed:" <> showJSONValue v

150 describeIssue Forward (EnumDoesntSatisfy v) = para "The following enum value was removed:" <> showJSONValue v

152 describeIssue Backward (EnumDoesntSatisfy v) = para "The following enum value was added:" <> showJSONValue v

151 describeIssue Backward (EnumDoesntSatisfy v) = para "The following enum value was added:" <> showJSONValue v

153 describeIssue Forward (NoMatchingEnum v) = para "The following enum value has been added:" <> showJSONValue v

152 describeIssue Forward (NoMatchingEnum v) = para "The following enum value has been added:" <> showJSONValue v

@@ -255,17 +254,16 @@ instance Issuable 'SchemaLevel where

255 PropertyToAdditional -> Comment

254 PropertyToAdditional -> Comment

256 TypesRestricted _ -> ProbablyIssue -- TODO: #70

255 TypesRestricted _ -> ProbablyIssue -- TODO: #70

257 _ -> CertainIssue

256 _ -> CertainIssue

258− relatedIssues =

257+ relatedIssues = (==) `withClass` \case

259− (==) `withClass` \case

260 AdditionalToProperty -> Just ()

258 AdditionalToProperty -> Just ()

261 PropertyToAdditional -> Just ()

259 PropertyToAdditional -> Just ()

262 _ -> Nothing

260 _ -> Nothing

263− `withClass` \case

261+ `withClass` \case

264− PropertyNowRequired -> Just ()

262+ PropertyNowRequired -> Just ()

265− UnexpectedProperty -> Just ()

263+ UnexpectedProperty -> Just ()

266− _ -> Nothing

264+ _ -> Nothing

267 describeIssue _ (NotSupported i) =

265 describeIssue _ (NotSupported i) =

268− para (emph "Encountered a feature that CompaREST does not support: " <> text i <> ".")

266+ para (emph "Encountered a feature that OpenApi Diff does not support: " <> text i <> ".")

269 describeIssue _ OneOfNotDisjoint =

267 describeIssue _ OneOfNotDisjoint =

270 para $

268 para $

271 "Could not deduce that " <> code "oneOf"

269 "Could not deduce that " <> code "oneOf"

@@ -277,7 +275,7 @@ instance Issuable 'SchemaLevel where

277 describeIssue _ (InvalidSchema i) =

275 describeIssue _ (InvalidSchema i) =

278 para (emph "The schema is invalid: " <> text i <> ".")

276 para (emph "The schema is invalid: " <> text i <> ".")

279 describeIssue _ UnguardedRecursion =

277 describeIssue _ UnguardedRecursion =

280− para "Encountered recursion that is too complex for CompaREST to untangle."

278+ para "Encountered recursion that is too complex for OpenApi Diff to untangle."

281 describeIssue Forward (TypesRestricted tys) = case tys of

279 describeIssue Forward (TypesRestricted tys) = case tys of

282 [] -> para "No longer has any valid values." -- weird

280 [] -> para "No longer has any valid values." -- weird

283 _ -> para "Values are now limited to the following types: " <> bulletList (para . describeJSONType <$> tys)

281 _ -> para "Values are now limited to the following types: " <> bulletList (para . describeJSONType <$> tys)

src/Data/OpenApi/Compare/Validate/Schema/JsonFormula.hs → src/OpenAPI/Checker/Validate/Schema/JsonFormula.hsrenamed+48−55

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

1−module Data.OpenApi.Compare.Validate.Schema.JsonFormula

1+module OpenAPI.Checker.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,17 +20,13 @@ import Algebra.Lattice

20import qualified Data.Aeson as A

21import qualified Data.ByteString.Lazy as BSL

22import qualified Data.Foldable as F

23−import Data.Functor

24import qualified Data.HashMap.Strict as HM

23import qualified Data.HashMap.Strict as HM

24+import Data.Functor

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

34import Data.Ord

30import Data.Ord

35import Data.Ratio

31import Data.Ratio

36import Data.Scientific

32import Data.Scientific

@@ -39,6 +35,10 @@ import Data.Text (Text)

39import qualified Data.Text as T

35import qualified Data.Text as T

40import qualified Data.Text.Encoding as T

36import qualified Data.Text.Encoding as T

41import Data.Typeable

37import 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,33 +67,30 @@ 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− -- | this has the right Ord

72+ -> Condition 'Number -- ^ this has the right Ord

73− Condition 'Number

74 MultipleOf :: !Scientific -> Condition 'Number

73 MultipleOf :: !Scientific -> Condition 'Number

75 NumberFormat :: !Format -> Condition 'Number

74 NumberFormat :: !Format -> Condition 'Number

76 MaxLength :: !Integer -> Condition 'String

75 MaxLength :: !Integer -> Condition 'String

77 MinLength :: !Integer -> Condition 'String

76 MinLength :: !Integer -> Condition 'String

78 Pattern :: !Pattern -> Condition 'String

77 Pattern :: !Pattern -> Condition 'String

79 StringFormat :: !Format -> Condition 'String

78 StringFormat :: !Format -> Condition 'String

80− Items ::

79+ Items

81− !(ForeachType JsonFormula) ->

80+ :: !(ForeachType JsonFormula)

82− !(Traced (Referenced Schema)) ->

81+ -> !(Traced (Referenced Schema))

83− Condition 'Array

82+ -> Condition 'Array

84− TupleItems ::

83+ TupleItems

85− ![(ForeachType JsonFormula, Traced (Referenced Schema))] ->

84+ :: ![(ForeachType JsonFormula, Traced (Referenced Schema))]

86− Condition 'Array

85+ -> Condition 'Array

87 MaxItems :: !Integer -> Condition 'Array

86 MaxItems :: !Integer -> Condition 'Array

88 MinItems :: !Integer -> Condition 'Array

87 MinItems :: !Integer -> Condition 'Array

89 UniqueItems :: Condition 'Array

88 UniqueItems :: Condition 'Array

90− Properties ::

89+ Properties

91− !(M.Map Text Property) ->

90+ :: !(M.Map Text Property)

92− -- | formula for additional properties

93− !(ForeachType JsonFormula) ->

91+ -> !(ForeachType JsonFormula) -- ^ formula for additional properties

94− -- | schema for additional properties, Nothing means bottom

92+ -> !(Maybe (Traced (Referenced Schema))) -- ^ schema for additional properties, Nothing means bottom

95− !(Maybe (Traced (Referenced Schema))) ->

96− Condition 'Object

93+ -> Condition 'Object

97 MaxProperties :: !Integer -> Condition 'Object

94 MaxProperties :: !Integer -> Condition 'Object

98 MinProperties :: !Integer -> Condition 'Object

95 MinProperties :: !Integer -> Condition 'Object

99

96

@@ -121,15 +118,13 @@ showCondition = \case

121 UniqueItems -> para "The elements in the array should be unique."

118 UniqueItems -> para "The elements in the array should be unique."

122 (Properties props additional _) ->

119 (Properties props additional _) ->

123 bulletList $

120 bulletList $

124− ( M.toList props

121+ (M.toList props

125− <&> ( \(k, p) ->

122+ <&> (\(k, p) ->

126− para (code k)

123+ para (code k)

127− <> para (strong $ if propRequired p then "Required" else "Optional")

124+ <> para (strong $ if propRequired p then "Required" else "Optional")

128− <> showForEachJsonFormula (propFormula p)

125+ <> showForEachJsonFormula (propFormula p)))

129− )

130− )

131 <> [ para (emph "Additional properties")

126 <> [ para (emph "Additional properties")

132− <> showForEachJsonFormula additional

127+ <> showForEachJsonFormula additional

133 ]

128 ]

134 (MaxProperties n) -> para $ "The maximum number of fields should be " <> show' n <> "."

129 (MaxProperties n) -> para $ "The maximum number of fields should be " <> show' n <> "."

135 (MinProperties n) -> para $ "The minimum number of fields should be " <> show' n <> "."

130 (MinProperties n) -> para $ "The minimum number of fields should be " <> show' n <> "."

@@ -138,17 +133,15 @@ showCondition = \case

138 showForEachJsonFormula i =

133 showForEachJsonFormula i =

139 bulletList $

134 bulletList $

140 foldType

135 foldType

141− ( \t f -> case getJsonFormula $ f i of

136+ (\t f -> case getJsonFormula $ f i of

142− BottomDNF -> mempty

137+ BottomDNF -> mempty

143− (DNF conds) ->

138+ (DNF conds) ->

144 [ para (describeJSONType t)

139 [ para (describeJSONType t)

145 <> bulletList

140 <> bulletList

146− ( S.toList conds <&> \case

141+ (S.toList conds <&> \case

147− Disjunct (S.toList -> []) -> para "Empty"

142+ Disjunct (S.toList -> []) -> para "Empty"

148− Disjunct (S.toList -> cond) -> bulletList (showCondition <$> cond)

143+ Disjunct (S.toList -> cond) -> bulletList (showCondition <$> cond))

149− )

150− ]

144+ ])

151− )

152

145

153showJSONValue :: A.Value -> Blocks

146showJSONValue :: A.Value -> Blocks

154showJSONValue v = codeBlockWith ("", ["json"], mempty) (T.decodeUtf8 . BSL.toStrict . A.encode $ v)

147showJSONValue v = codeBlockWith ("", ["json"], mempty) (T.decodeUtf8 . BSL.toStrict . A.encode $ v)

src/Data/OpenApi/Compare/Validate/Schema/Partition.hs → src/OpenAPI/Checker/Validate/Schema/Partition.hsrenamed+37−38

@@ -1,15 +1,15 @@

1−module Data.OpenApi.Compare.Validate.Schema.Partition

1+module OpenAPI.Checker.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

42import Data.Ord

35import Data.Ord

43import qualified Data.Set as S

36import qualified Data.Set as S

44import Data.Text (Text)

37import Data.Text (Text)

45import qualified Data.Text as T

38import 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,11 +143,10 @@ partitionCondition = \case

143 Just _ -> top

144 Nothing ->

145 singletonPart $

146− DByProperties $

146+ DByProperties $ LiteralDNF

147− LiteralDNF

148− ( M.keysSet $ M.filter (not . propRequired) props

147+ ( M.keysSet $ M.filter (not . propRequired) props

149− , M.keysSet $ M.filter propRequired props

148+ , M.keysSet $ M.filter propRequired props

150− )

149+ )

151 inProps <- forM (M.toList $ M.filter propRequired props) $ \(k, prop) -> do

150 inProps <- forM (M.toList $ M.filter propRequired props) $ \(k, prop) -> do

152 f <- partitionRefSchema $ propRefSchema prop

151 f <- partitionRefSchema $ propRefSchema prop

153 pure $ fmap (\(Partitions m) -> Partitions $ M.mapKeysMonotonic (PInProperty k) m) f

152 pure $ fmap (\(Partitions m) -> Partitions $ M.mapKeysMonotonic (PInProperty k) m) f

@@ -157,10 +156,10 @@ partitionCondition = \case

157runPartitionM :: Traced (Definitions Schema) -> PartitionM a -> a

156runPartitionM :: Traced (Definitions Schema) -> PartitionM a -> a

158runPartitionM defs = runIdentity . runMemo () . (`runReaderT` defs)

157runPartitionM defs = runIdentity . runMemo () . (`runReaderT` defs)

159

158

160−partitionJsonFormulas ::

159+partitionJsonFormulas

161− ProdCons (Traced (Definitions Schema)) ->

160+ :: ProdCons (Traced (Definitions Schema))

162− ProdCons (JsonFormula t) ->

161+ -> ProdCons (JsonFormula t)

163− Lifted Partitions

162+ -> Lifted Partitions

164partitionJsonFormulas defs pc = producer pcPart \/ consumer pcPart

163partitionJsonFormulas defs pc = producer pcPart \/ consumer pcPart

165 where

164 where

166 pcPart = partitionFormula <$> defs <*> pc

165 pcPart = partitionFormula <$> defs <*> pc

@@ -212,11 +211,11 @@ runIntersectionM defs act = case runWriterT $ runReaderT act defs of

212 Just (x, Any False) -> Same x

211 Just (x, Any False) -> Same x

213 Just (x, Any True) -> New x

212 Just (x, Any True) -> New x

214

213

215−intersectSchema ::

214+intersectSchema

216− PartitionLocation ->

215+ :: PartitionLocation

217− PartitionChoice ->

216+ -> PartitionChoice

218− Traced Schema ->

217+ -> Traced Schema

219− IntersectionM Schema

218+ -> IntersectionM Schema

220intersectSchema loc part sch = do

219intersectSchema loc part sch = do

221 allOf' <- forM (tracedAllOf sch) $ \rss ->

220 allOf' <- forM (tracedAllOf sch) $ \rss ->

222 -- Assuming i ranges over a nonempty set (checked in processSchema)

221 -- Assuming i ranges over a nonempty set (checked in processSchema)

@@ -259,11 +258,11 @@ intersectSchema loc part sch = do

259 pure $ sch' {_schemaEnum = Just enum'}

258 pure $ sch' {_schemaEnum = Just enum'}

260 CByProperties {} -> error "CByProperties not implemented"

259 CByProperties {} -> error "CByProperties not implemented"

261

260

262−intersectRefSchema ::

261+intersectRefSchema

263− PartitionLocation ->

262+ :: PartitionLocation

264− PartitionChoice ->

263+ -> PartitionChoice

265− Traced (Referenced Schema) ->

264+ -> Traced (Referenced Schema)

266− IntersectionM (Referenced Schema)

265+ -> IntersectionM (Referenced Schema)

267intersectRefSchema loc part rs = do

266intersectRefSchema loc part rs = do

268 defs <- R.ask

267 defs <- R.ask

269 Inline <$> intersectSchema loc part (dereference defs rs)

268 Inline <$> intersectSchema loc part (dereference defs rs)

src/Data/OpenApi/Compare/Validate/Schema/Process.hs → src/OpenAPI/Checker/Validate/Schema/Process.hsrenamed+47−48

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

1−module Data.OpenApi.Compare.Validate.Schema.Process

1+module OpenAPI.Checker.Validate.Schema.Process

2− ( schemaToFormula,

2+ ( schemaToFormula

3 )

4where

5

6import Algebra.Lattice

7−import Control.Monad.Reader hiding (ask)

8import qualified Control.Monad.Reader as R

7import qualified Control.Monad.Reader as R

8+import Control.Monad.Reader hiding (ask)

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

29import Data.Ord

17import Data.Ord

30import qualified Data.Set as S

18import 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,27 +331,26 @@ 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− )

355

354

356{- TODO: ReadOnly/WriteOnly #68 -}

355{- TODO: ReadOnly/WriteOnly #68 -}

357

356

@@ -370,8 +369,8 @@ checkOneOfDisjoint schs = do

370runProcessM :: Traced (Definitions Schema) -> ProcessM a -> (a, P.PathsPrefixTree Behave AnIssue 'SchemaLevel)

369runProcessM :: Traced (Definitions Schema) -> ProcessM a -> (a, P.PathsPrefixTree Behave AnIssue 'SchemaLevel)

371runProcessM defs = runWriter . (`runReaderT` defs) . runMemo ()

370runProcessM defs = runWriter . (`runReaderT` defs) . runMemo ()

372

371

373−schemaToFormula ::

372+schemaToFormula

374− Traced (Definitions Schema) ->

373+ :: Traced (Definitions Schema)

375− Traced Schema ->

374+ -> Traced Schema

376− (ForeachType JsonFormula, P.PathsPrefixTree Behave AnIssue 'SchemaLevel)

375+ -> (ForeachType JsonFormula, P.PathsPrefixTree Behave AnIssue 'SchemaLevel)

377schemaToFormula defs rs = runProcessM defs $ processSchema rs

376schemaToFormula defs rs = runProcessM defs $ processSchema rs

src/Data/OpenApi/Compare/Validate/Schema/Traced.hs → src/OpenAPI/Checker/Validate/Schema/Traced.hsrenamed+14−14

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

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

2

3−module Data.OpenApi.Compare.Validate.Schema.Traced

3+module OpenAPI.Checker.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

25import qualified Data.Set as S

24import qualified Data.Set as S

26import Data.Text (Text)

25import Data.Text (Text)

26+import OpenAPI.Checker.Subtree

27

28data PartitionChoice

29 = CByEnumValue (S.Set A.Value)

src/Data/OpenApi/Compare/Validate/Schema/TypedJson.hs → src/OpenAPI/Checker/Validate/Schema/TypedJson.hsrenamed+24−26

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

1−module Data.OpenApi.Compare.Validate.Schema.TypedJson

1+module OpenAPI.Checker.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,26 +88,24 @@ 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 =

91+broadcastType k = ForeachType

92− ForeachType

93− { forNull = k

92+ { forNull = k

94− , forBoolean = k

93+ , forBoolean = k

95− , forNumber = k

94+ , forNumber = k

96− , forString = k

95+ , forString = k

97− , forArray = k

96+ , forArray = k

98− , forObject = k

97+ , forObject = k

99− }

98+ }

100

99

101zipType :: (forall x. Typeable x => f x -> g x -> h x) -> ForeachType f -> ForeachType g -> ForeachType h

100zipType :: (forall x. Typeable x => f x -> g x -> h x) -> ForeachType f -> ForeachType g -> ForeachType h

102−zipType k f1 f2 =

101+zipType k f1 f2 = ForeachType

103− ForeachType

104− { forNull = k (forNull f1) (forNull f2)

102+ { forNull = k (forNull f1) (forNull f2)

105− , forBoolean = k (forBoolean f1) (forBoolean f2)

103+ , forBoolean = k (forBoolean f1) (forBoolean f2)

106− , forNumber = k (forNumber f1) (forNumber f2)

104+ , forNumber = k (forNumber f1) (forNumber f2)

107− , forString = k (forString f1) (forString f2)

105+ , forString = k (forString f1) (forString f2)

108− , forArray = k (forArray f1) (forArray f2)

106+ , forArray = k (forArray f1) (forArray f2)

109− , forObject = k (forObject f1) (forObject f2)

107+ , forObject = k (forObject f1) (forObject f2)

110− }

108+ }

111

109

112instance (forall x. Lattice (f x)) => Lattice (ForeachType f) where

110instance (forall x. Lattice (f x)) => Lattice (ForeachType f) where

113 (\/) = zipType (\/)

111 (\/) = zipType (\/)

src/Data/OpenApi/Compare/Validate/SecurityRequirement.hs → src/OpenAPI/Checker/Validate/SecurityRequirement.hsrenamed+13−14

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

1{-# LANGUAGE PartialTypeSignatures #-}

2{-# OPTIONS_GHC -Wno-orphans #-}

3

4−module Data.OpenApi.Compare.Validate.SecurityRequirement

4+module OpenAPI.Checker.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 ()

24import Data.Set (Set)

20import Data.Set (Set)

25import qualified Data.Set as S

21import qualified Data.Set as S

26import Data.Text (Text)

22import Data.Text (Text)

27import Data.Traversable

23import 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,19 +41,18 @@ 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− )

50 normalized

49 normalized

51 pure ()

50 pure ()

52 checkSemanticCompatibility env bhv' pc = do

51 checkSemanticCompatibility env bhv' pc = do

53 let schemes = getH @(ProdCons (Traced (Definitions SecurityScheme))) env

52 let schemes = getH @(ProdCons (Traced (Definitions SecurityScheme))) env

54 ( ProdCons pErrs cErrs

53 ( ProdCons pErrs cErrs

55− , (ProdCons pSchemes cSchemes) ::

54+ , (ProdCons pSchemes cSchemes)

56− ProdCons [(Behavior 'SecuritySchemeLevel, Traced SecurityScheme, [Text])]

55+ :: ProdCons [(Behavior 'SecuritySchemeLevel, Traced SecurityScheme, [Text])]

57 ) =

56 ) =

58 NE.unzip $

57 NE.unzip $

59 partitionEithers <$> do

58 partitionEithers <$> do

src/Data/OpenApi/Compare/Validate/SecurityScheme.hs → src/OpenAPI/Checker/Validate/SecurityScheme.hsrenamed+5−5

@@ -1,16 +1,16 @@

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

2

3−module Data.OpenApi.Compare.Validate.SecurityScheme

3+module OpenAPI.Checker.Validate.SecurityScheme

4 (

5 )

6where

7

8import Control.Monad

9import Data.OpenApi

10−import Data.OpenApi.Compare.Behavior

10+import OpenAPI.Checker.Behavior

11−import Data.OpenApi.Compare.Orphans ()

11+import OpenAPI.Checker.Orphans ()

12−import Data.OpenApi.Compare.Subtree

12+import OpenAPI.Checker.Subtree

13−import Data.OpenApi.Compare.Validate.OAuth2Flows

13+import OpenAPI.Checker.Validate.OAuth2Flows

14

15instance Subtree SecurityScheme where

16 type CheckEnv SecurityScheme = '[]

src/Data/OpenApi/Compare/Validate/Server.hs → src/OpenAPI/Checker/Validate/Server.hsrenamed+16−17

@@ -1,7 +1,7 @@

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

2

3−module Data.OpenApi.Compare.Validate.Server

3+module OpenAPI.Checker.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

27import qualified Data.Set as S

22import qualified Data.Set as S

28import Data.Text (Text)

23import Data.Text (Text)

29import qualified Data.Text as T

24import qualified Data.Text as T

30import Data.Traversable

25import 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,12 +63,11 @@ 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− )

72 . sequence

71 . sequence

73 sequenceA_ pErrs

72 sequenceA_ pErrs

74 sequenceA_ cErrs

73 sequenceA_ cErrs

@@ -102,7 +101,7 @@ data ServerUrlPart var

102 deriving stock (Eq, Show, Functor, Foldable, Traversable)

101 deriving stock (Eq, Show, Functor, Foldable, Traversable)

103

102

104-- | This is super rough. Things like @{a|b}c@ will not match @ac@.

103-- | This is super rough. Things like @{a|b}c@ will not match @ac@.

105−-- FIXME: #46

104+-- FIXME: https://github.com/typeable/openapi-diff/issues/46

106--

105--

107-- NOTE: syntax is defined vaguely in the spec.

106-- NOTE: syntax is defined vaguely in the spec.

108parseServerUrl :: Text -> [ServerUrlPart Text]

107parseServerUrl :: Text -> [ServerUrlPart Text]

src/OpenAPI/Checker/Validate/Sums.hsnew file+24

@@ -0,0 +1,24 @@

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+4−7

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

1−resolver: lts-18.16

1+resolver: lts-18.2

2−

3−packages:

4− - .

5

2

6extra-deps:

3extra-deps:

7 - open-union-0.4.0.0

4 - open-union-0.4.0.0

8 - type-fun-0.1.3

5 - type-fun-0.1.3

9− - github-0.26

6+

10− - base16-bytestring-0.1.1.7

7+apply-ghc-options: everything

11− - http-link-header-1.0.3.1

8+rebuild-ghc-options: true

stack.yaml.lock+4−25

@@ -18,30 +18,9 @@ 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

42snapshots:

21snapshots:

43- completed:

22- completed:

44− size: 586286

23+ size: 585392

45− url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/18/16.yaml

24+ url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/18/2.yaml

46− sha256: cdead65fca0323144b346c94286186f4969bf85594d649c49c7557295675d8a5

25+ sha256: 7abb45c0cc5eb349448b66d8753655542d45d387ad26970419282eab3d860724

47− original: lts-18.16

26+ original: lts-18.2

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+42−46

@@ -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,34 +39,32 @@ 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− -- | Root path

55+ -> FilePath -- ^ Root path

56− FilePath ->

57− -- | Name of golden file

56+ -> FilePath -- ^ Name of golden file

58− FilePath ->

57+ -> s

59− s ->

60− (t -> IO BSL.ByteString) ->

58+ -> (t -> IO BSL.ByteString)

61− IO TestTree

59+ -> IO TestTree

62goldenInputsTree name filepath golden inp f = do

60goldenInputsTree name filepath golden inp f = do

63 runTestInputTree golden f <$> getGoldenInputs name filepath inp

61 runTestInputTree golden f <$> getGoldenInputs name filepath inp

64

62

65−runTestInputTree ::

63+runTestInputTree

66− FilePath ->

64+ :: FilePath

67− (t -> IO BSL.ByteString) ->

65+ -> (t -> IO BSL.ByteString)

68− TestInput t ->

66+ -> TestInput t

69− TestTree

67+ -> TestTree

70runTestInputTree golden f (TestInputNode name rest) =

68runTestInputTree golden f (TestInputNode name rest) =

71 testGroup name (runTestInputTree golden f <$> rest)

69 testGroup name (runTestInputTree golden f <$> rest)

72runTestInputTree golden f (TestInputLeaf name t path) =

70runTestInputTree golden f (TestInputLeaf name t path) =

@@ -76,18 +74,16 @@ runTestInputTree golden f (TestInputLeaf name t path) =

76 (path </> golden)

74 (path </> golden)

77 (f t)

75 (f t)

78

76

79−goldenInputsTreeUniform ::

77+goldenInputsTreeUniform

80− ( Each t h (FilePath, FilePath -> IO a) a

78+ :: ( Each t h (FilePath, FilePath -> IO a) a

81− , Each s t FilePath (FilePath, FilePath -> IO a)

79+ , Each s t FilePath (FilePath, FilePath -> IO a)

82− ) =>

80+ )

83− String ->

81+ => String

84− -- | Root path

82+ -> FilePath -- ^ Root path

85− FilePath ->

86− -- | Name of golden file

83+ -> FilePath -- ^ Name of golden file

87− FilePath ->

84+ -> s

88− s ->

89− (FilePath -> IO a) ->

85+ -> (FilePath -> IO a)

90− (h -> IO BSL.ByteString) ->

86+ -> (h -> IO BSL.ByteString)

91− IO TestTree

87+ -> IO TestTree

92goldenInputsTreeUniform name filepath golden inp h =

88goldenInputsTreeUniform name filepath golden inp h =

93 goldenInputsTree name filepath golden (inp & each %~ (,h))

89 goldenInputsTree name filepath golden (inp & each %~ (,h))

test/Spec/Golden/TraceTree.hs+6−9

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

1module Spec.Golden.TraceTree

2− ( tests,

2+ ( tests

3 )

4where

5

@@ -7,15 +7,13 @@ 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 ()

12import Data.Text (Text)

10import Data.Text (Text)

13import qualified Data.Text.Encoding as T

11import qualified Data.Text.Encoding as T

14import qualified Data.Yaml as Yaml

12import qualified Data.Yaml as Yaml

15−import Paths_compaREST

13+import OpenAPI.Checker.Run

14+import OpenAPI.Checker.Validate.OpenApi ()

16import Spec.Golden.Extra

15import Spec.Golden.Extra

17import Test.Tasty (TestTree, testGroup)

16import Test.Tasty (TestTree, testGroup)

18−import Text.Pandoc.Builder

19import Text.Pandoc.Class

17import Text.Pandoc.Class

20import Text.Pandoc.Options

18import Text.Pandoc.Options

21import Text.Pandoc.Writers

19import Text.Pandoc.Writers

@@ -23,11 +21,10 @@ import Prelude hiding (id, (.))

23

21

24tests :: IO TestTree

22tests :: IO TestTree

25tests = do

23tests = do

26− dir <- getDataDir

27 traceTreeTests <-

24 traceTreeTests <-

28 goldenInputsTreeUniform

25 goldenInputsTreeUniform

29 "TraceTree"

26 "TraceTree"

30− dir

27+ "test/golden/common"

31 "trace-tree.yaml"

28 "trace-tree.yaml"

32 ("a.yaml", "b.yaml")

29 ("a.yaml", "b.yaml")

33 Yaml.decodeFileThrow

30 Yaml.decodeFileThrow

@@ -36,11 +33,11 @@ tests = do

36 reportTests <-

33 reportTests <-

37 goldenInputsTreeUniform

34 goldenInputsTreeUniform

38 "Report"

35 "Report"

39− dir

36+ "test/golden/common"

40 "report.md"

37 "report.md"

41 ("a.yaml", "b.yaml")

38 ("a.yaml", "b.yaml")

42 Yaml.decodeFileThrow

39 Yaml.decodeFileThrow

43− (runPandoc . writeMarkdown def {writerExtensions = githubMarkdownExtensions} . doc . fst . runReport def)

40+ (runPandoc . writeMarkdown def {writerExtensions = githubMarkdownExtensions} . fst . runReport def)

44

41

45 return $ testGroup "Golden tests" [traceTreeTests, reportTests]

42 return $ testGroup "Golden tests" [traceTreeTests, reportTests]

46

43

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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 1 | 1 |

5+| 1 | 1 | 0 |

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 |

3+| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|---------------------|-------------------------|

4+|---------------------|------------------------|-------------------------------|

5−| 0 | 0 |

5+| 0 | 0 | 0 |

test/golden/common/id/report.md+3−3

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

1# Summary

2

3−| ❌ Breaking changes | ⚠️ Non-breaking changes |

3+| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|---------------------|-------------------------|

4+|---------------------|------------------------|-------------------------------|

5−| 0 | 0 |

5+| 0 | 0 | 0 |

test/golden/common/json/recursive/report.md+3−3

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

1# Summary

2

3−| ❌ Breaking changes | ⚠️ Non-breaking changes |

3+| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|---------------------|-------------------------|

4+|---------------------|------------------------|-------------------------------|

5−| 0 | 0 |

5+| 0 | 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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 1 | 1 |

5+| 1 | 1 | 0 |

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 |

3+| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|------------------------------------------|-------------------------|

4+|------------------------------------------|------------------------|-------------------------------|

5−| 1 | 0 |

5+| 1 | 0 | 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) |

3+| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|---------------------|--------------------------------------------------|

4+|---------------------|-------------------------------------------------|-------------------------------|

5−| 0 | 1 |

5+| 0 | 1 | 0 |

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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 1 | 1 |

5+| 1 | 1 | 0 |

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 |

3+| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|---------------------|-------------------------|

4+|---------------------|------------------------|-------------------------------|

5−| 0 | 0 |

5+| 0 | 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 |

3+| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|---------------------|-------------------------|

4+|---------------------|------------------------|-------------------------------|

5−| 0 | 0 |

5+| 0 | 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) |

3+| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|---------------------|--------------------------------------------------|

4+|---------------------|-------------------------------------------------|-------------------------------|

5−| 0 | 1 |

5+| 0 | 1 | 0 |

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 |

3+| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|------------------------------------------|-------------------------|

4+|------------------------------------------|------------------------|-------------------------------|

5−| 1 | 0 |

5+| 1 | 0 | 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 |

3+| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|------------------------------------------|-------------------------|

4+|------------------------------------------|------------------------|-------------------------------|

5−| 1 | 0 |

5+| 1 | 0 | 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) |

3+| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|---------------------|--------------------------------------------------|

4+|---------------------|-------------------------------------------------|-------------------------------|

5−| 0 | 1 |

5+| 0 | 1 | 0 |

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) |

3+| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|---------------------|--------------------------------------------------|

4+|---------------------|-------------------------------------------------|-------------------------------|

5−| 0 | 1 |

5+| 0 | 1 | 0 |

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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 1 | 1 |

5+| 1 | 1 | 0 |

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 |

3+| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|------------------------------------------|-------------------------|

4+|------------------------------------------|------------------------|-------------------------------|

5−| 1 | 0 |

5+| 1 | 0 | 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) |

3+| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|---------------------|--------------------------------------------------|

4+|---------------------|-------------------------------------------------|-------------------------------|

5−| 0 | 1 |

5+| 0 | 1 | 0 |

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 |

3+| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|------------------------------------------|-------------------------|

4+|------------------------------------------|------------------------|-------------------------------|

5−| 1 | 0 |

5+| 1 | 0 | 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 |

3+| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|------------------------------------------|-------------------------|

4+|------------------------------------------|------------------------|-------------------------------|

5−| 1 | 0 |

5+| 1 | 0 | 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) |

3+| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|---------------------|--------------------------------------------------|

4+|---------------------|-------------------------------------------------|-------------------------------|

5−| 0 | 1 |

5+| 0 | 1 | 0 |

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 |

3+| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|------------------------------------------|-------------------------|

4+|------------------------------------------|------------------------|-------------------------------|

5−| 1 | 0 |

5+| 1 | 0 | 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 |

3+| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|---------------------|-------------------------|

4+|---------------------|------------------------|-------------------------------|

5−| 0 | 0 |

5+| 0 | 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 |

3+| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|---------------------|-------------------------|

4+|---------------------|------------------------|-------------------------------|

5−| 0 | 0 |

5+| 0 | 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 |

3+| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|------------------------------------------|-------------------------|

4+|------------------------------------------|------------------------|-------------------------------|

5−| 1 | 0 |

5+| 1 | 0 | 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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 1 | 1 |

5+| 1 | 1 | 0 |

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) |

3+| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|---------------------|--------------------------------------------------|

4+|---------------------|-------------------------------------------------|-------------------------------|

5−| 0 | 1 |

5+| 0 | 1 | 0 |

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) |

3+| ⚠️ Breaking changes | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|---------------------|--------------------------------------------------|

4+|---------------------|-------------------------------------------------|-------------------------------|

5−| 0 | 1 |

5+| 0 | 1 | 0 |

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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 3 | 3 |

5+| 3 | 3 | 0 |

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 |

3+| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|------------------------------------------|-------------------------|

4+|------------------------------------------|------------------------|-------------------------------|

5−| 2 | 0 |

5+| 2 | 0 | 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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 1 | 1 |

5+| 1 | 1 | 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 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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 5 | 6 |

5+| 5 | 6 | 0 |

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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 1 | 1 |

5+| 1 | 1 | 0 |

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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 2 | 1 |

5+| 2 | 1 | 0 |

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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 3 | 1 |

5+| 3 | 1 | 0 |

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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 2 | 2 |

5+| 2 | 2 | 0 |

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 |

3+| [⚠️ Breaking changes](#breaking-changes) | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|------------------------------------------|-------------------------|

4+|------------------------------------------|------------------------|-------------------------------|

5−| 2 | 0 |

5+| 2 | 0 | 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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 4 | 2 |

5+| 4 | 2 | 0 |

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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 5 | 5 |

5+| 5 | 5 | 0 |

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 |

3+| ⚠️ Breaking changes | 🙆 Non-breaking changes | 🤷 Unsupported feature changes |

4−|---------------------|-------------------------|

4+|---------------------|------------------------|-------------------------------|

5−| 0 | 0 |

5+| 0 | 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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 6 | 6 |

5+| 6 | 6 | 0 |

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 CompaREST to untangle.

13+Encountered recursion that is too complex for OpenApi Diff 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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 1 | 1 |

5+| 1 | 1 | 0 |

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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 2 | 2 |

5+| 2 | 2 | 0 |

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) |

3+| [⚠️ Breaking changes](#breaking-changes) | [🙆 Non-breaking changes](#non-breaking-changes) | 🤷 Unsupported feature changes |

4−|------------------------------------------|--------------------------------------------------|

4+|------------------------------------------|-------------------------------------------------|-------------------------------|

5−| 2 | 2 |

5+| 2 | 2 | 0 |

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