frameworks.yml

# Analyze frameworks. Note, these are just examples.
frameworks:
  rules:
    grav: # Grav CMS. See: https://github.com/getgrav/grav
      when: fs.depExists("php", "getgrav/grav")
      then: grav
      with:
        version: fs.depVersion("php", "getgrav/grav")
      groups: [php, symfony]

    bolt: # Bolt CMS. See: https://github.com/bolt/core
      when: fs.depExists("php", "bolt/core")
      then: bolt
      with:
        version: fs.depVersion("php", "bolt/core")
      groups: [php, symfony]

    kunstmaan-cms: # Kunstmaan CMS. See: https://github.com/Kunstmaan/KunstmaanBundlesCMS
      when: fs.depExists("php", "kunstmaan/*")
      then: kunstmaan-cms
      groups: [php, symfony]

    concrete-cms: # Concrete CMS. See: https://github.com/concretecms/concretecms
      when: fs.depExists("php", "concretecms/*")
      then: concrete-cms
      groups: [php, symfony]

    silverstripe-cms: # Silverstripe CMS. See: https://github.com/silverstripe/silverstripe-cms
      when: fs.depExists("php", "silverstripe/cms")
      then: silverstripe-cms
      with:
        version: fs.depVersion("php", "bolt/common")
      groups: [php, symfony]

    roadiz: # Roadiz CMS. See: https://github.com/roadiz
      when: fs.depExists("php", "roadiz/*")
      then: roadiz
      with:
        version: fs.depVersion("php", "roadiz/core-bundle")
      groups: [php, symfony]

    contao: # Contao CMS. See: https://github.com/contao/contao
      when: fs.depExists("php", "contao/contao")
      then: contao
      with:
        version: fs.depVersion("php", "contao/contao")
      groups: [php, symfony]

    picocms: # Pico CMS. See: https://github.com/picocms/Pico
      when: fs.depExists("php", "picocms/pico")
      then: picocms
      with:
        version: fs.depVersion("php", "picocms/pico")
      groups: [php, symfony]

    uvdesk: # UVDesk Community Helpdesk. See: https://github.com/uvdesk/core-framework
      when: fs.depExists("php", "uvdesk/core-framework")
      then: uvdesk
      with:
        version: fs.depVersion("php", "uvdesk/core-framework")
      groups: [php, symfony]

    craftcms: # Craft CMS. See: https://github.com/craftcms/cms
      when: fs.depExists("php", "craftcms/cms")
      then: craftcms
      with:
        version: fs.depVersion("php", "craftcms/cms")
      groups: [php, symfony]

    neos: # Neos CMS. See: https://docs.neos.io/
      when: fs.depExists("php", "neos/neos")
      then: neos
      with:
        version: fs.depVersion("php", "neos/neos")
      group: php

    typo3: # TYPO3 CMS. See: https://typo3.org/
      when: fs.depExists("php", "typo3/core") || fs.depExists("php", "typo3/cms*")
      then: typo3
      with:
        version: fs.depVersion("php", "typo3/core")
      groups: [php, symfony]

    joomla: # Joomla CMS. See: https://joomla.org
      when: fs.depExists("php", "joomla/application")
      then: joomla
      with:
        version: fs.depVersion("php", "joomla/application")
      groups: [php, symfony]

    sulu: # Sulu CMS. See: https://sulu.io
      when: fs.depExists("php", "sulu/sulu")
      then: sulu
      with:
        version: fs.depVersion("php", "sulu/sulu")
      groups: [php, symfony]

    pimcore: # Pimcore. See: https://pimcore.com/
      when: fs.depExists("php", "pimcore/pimcore")
      then: pimcore
      with:
        version: fs.depVersion("php", "pimcore/pimcore")
      groups: [php, symfony]

    ibexa: # Ibexa DXP. See: https://www.ibexa.co/
      when: fs.depExists("php", "ibexa/core") || fs.depExists("php", "ezsystems/*")
      then: ibexa
      with:
        version: fs.depVersion("php", "ibexa/core")
      groups: [php, symfony]

    mautic: # Mautic: Open Source Marketing Automation Software. See: https://mautic.org/
      when: fs.depExists("php", "mautic/mautic")
      then: mautic
      with:
        version: fs.depVersion("php", "mautic/mautic")
      groups: [php, symfony]

    woocommerce: # WooCommerce (WordPress-based eCommerce framework). See: https://woocommerce.com/
      when: fs.isDir("wp-content/plugins/woocommerce") || fs.depExists("php", "woocommerce/*")
      then: woocommerce
      group: php

    sylius: # Sylius: Open Source Headless eCommerce Platform. See: https://sylius.com/
      when: fs.depExists("php", "sylius/sylius")
      then: sylius
      with:
        version: fs.depVersion("php", "sylius/sylius")
      groups: [php, symfony]

    spryker: # Spryker: Digital Commerce Platform. See: https://spryker.com/
      when: fs.depExists("php", "spryker/*")
      then: sylius
      with:
        version: fs.depVersion("php", "spryker-feature/spryker-core")
      groups: [php, symfony]

    thelia: # Thelia eCommerce framework. See: https://thelia.net
      when: fs.depExists("php", "thelia/thelia")
      then: thelia
      with:
        version: fs.depVersion("php", "thelia/thelia")
      groups: [php, symfony]

    aimeos: # Aimeos eCommerce framework (based on Laravel). See: https://aimeos.org
      when: fs.depExists("php", "aimeos/aimeos-core")
      then: aimeos
      with:
        version: fs.depVersion("php", "aimeos/aimeos-core")
      groups: [php, laravel]

    oro-commerce: # OroCommerce. See: https://github.com/oroinc/orocommerce
      when: fs.depExists("php", "oro/commerce")
      then: oro-commerce
      with:
        version: fs.depVersion("php", "oro/commerce")
      groups: [php, symfony]

    shopware: # Shopware eCommerce platform. See: https://shopware.com
      when: fs.depExists("php", "shopware/core")
      then: shopware
      with:
        version: fs.depVersion("php", "shopware/core")
      groups: [php, symfony]

    prestashop: # PrestaShop eCommerce platform. See: https://github.com/PrestaShop/PrestaShop
      when: fs.depExists("php", "prestashop/prestashop")
      then: prestashop
      with:
        version: fs.depVersion("php", "prestashop/prestashop")
      groups: [php, symfony]

    akeneo: # Akeneo PIM. See: https://akeneo.com
      when: fs.depExists("php", "akeneo/*")
      then: akeneo
      with:
        version: fs.depVersion("php", "akeneo/pim-community-standard")
      groups: [php, symfony]

    api-platform: # API Platform. See: https://github.com/api-platform
      when: fs.depExists("php", "api-platform/core")
      then: api-platform
      with:
        version: fs.depVersion("php", "api-platform/core")
      groups: [php, symfony]

    yii2: # Yii 2. See: https://github.com/yiisoft/yii2
      when: fs.depExists("php", "yiisoft/yii2")
      then: yii2
      with:
        version: fs.depVersion("php", "yiisoft/yii2")
      group: php

    # Drupal (modern versions, installed via Composer).
    drupal:
      when: fs.depExists("php", "drupal/core") || fs.depExists("php", "drupal/core-recommended")
      then: drupal
      with:
        version: fs.depVersion("php", "drupal/core")
      groups: [php, symfony]
      ignore: # Drupal modules and themes themselves require Drupal via Composer.
        - modules/
        - themes/

    # Drupal 7 (legacy version 7, installed via Composer).
    drupal7-composer:
      when: fs.depExists("php", "drupal/drupal")
      then: drupal
      with:
        version: fs.depVersion("php", "drupal/drupal")
      group: php
      read_files: [ sites/default/settings.php ]

    # Drupal (detection when installed without Composer).
    drupal-direct:
      when: fs.fileExists("index.php") && fs.fileContains("index.php", "drupal_bootstrap(DRUPAL_BOOTSTRAP_FULL);")
      then: drupal
      group: php
      read_files: [ sites/default/settings.php ]

    # Any Composer "project" requiring a Symfony dependency.
    symfony-project:
      when: fs.depExists("php", "symfony/*") && jq(fs.read("composer.json"), ".type") == "project"
      maybe: symfony
      groups: [php, symfony]

    symfony-framework:
      when: fs.depExists("php", "symfony/framework-bundle")
      then: symfony
      with:
        version: fs.depVersion("php", "symfony/framework-bundle")
      groups: [php, symfony]
      read_files: [compose.yaml]

    laravel-framework:
      when: fs.depExists("php", "laravel/framework")
      then: laravel
      with:
        version: fs.depVersion("php", "laravel/framework")
      groups: [php, laravel]

    cakephp:
      when: fs.depExists("php", "cakephp/cakephp")
      then: cakephp
      with:
        version: fs.depVersion("php", "cakephp/cakephp")
      group: php

    laminas:
      when: fs.depExists("php", "laminas/laminas-mvc") && jq(fs.read("composer.json"), ".type") == "project"
      then: laminas
      with:
        version: fs.depVersion("php", "laminas/laminas-router")
      group: php

    codeigniter:
      when: fs.depExists("php", "codeigniter4/framework")
      then: codeigniter
      with:
        version: fs.depVersion("php", "codeigniter4/framework")
      group: php

    wordpress:
      when: fs.fileExists("wp-config.php") || fs.depExists("php", "wordpress/wordpress")
      then: wordpress
      with:
        version: fs.depVersion("php", "wordpress/wordpress")
      group: php
      read_files: [wp-config.php]

    matomo: # Matomo (formerly Piwik) analytics app. See: https://matomo.org/
      when: fs.fileExists("matomo.php") || (fs.fileExists("config/config.ini.php") && fs.fileContains("config/config.ini.php", "Matomo"))
      then: matomo
      group: php

    express:
      when: fs.depExists("js", "express")
      then: express
      with:
        version: fs.depVersion("js", "express")
      group: js

    gatsby:
      when: fs.fileExists("gatsby-config.js") || fs.depExists("js", "gatsby")
      then: gatsby
      with:
        version: fs.depVersion("js", "gatsby")
      group: js

    strapi:
      when: fs.fileExists("strapi-config.json") || fs.depExists("js", "@strapi/strapi")
      then: strapi
      with:
        version: fs.depVersion("js", "@strapi/strapi")
      group: js

    nestjs:
      when: fs.depExists("js", "@nestjs/core")
      then: nestjs
      with:
        version: fs.depVersion("js", "@nestjs/core")
      group: js

    # Next.js. See: https://nextjs.org/docs
    # Valid config files: next.config.js, next.config.ts, next.config.mjs
    nextjs:
      when: fs.glob("next.config.*s").size() > 0 || fs.depExists("js", "next")
      then: nextjs
      with:
        version: fs.depVersion("js", "next")
      group: js

    # Nuxt. See: https://nuxt.com/
    nuxt:
      when: fs.fileExists("nuxt.config.ts") || fs.depExists("js", "nuxt")
      then: nuxt
      with:
        version: fs.depVersion("js", "nuxt")
      group: js

    svelte-kit:
      when: fs.depExists("js", "@sveltejs/kit")
      then: svelte-kit
      with:
        version: fs.depVersion("js", "@sveltejs/kit")
      group: js

    reactjs:
      when: fs.depExists("js", "react")
      then: reactjs
      with:
        version: fs.depVersion("js", "react")
      group: js

    vuejs:
      when: fs.depExists("js", "vue")
      then: vuejs
      with:
        version: fs.depVersion("js", "vue")
      group: js

    shopsys: # Shopsys Platform (eCommerce framework). See: https://github.com/shopsys/shopsys
      when: fs.depExists("js", "shopsys")
      then: shopsys
      with:
        version: fs.depVersion("js", "shopsys")
      group: js

    directus: # Directus SQL API and dashboard. See: https://github.com/directus/directus
      when: fs.depExists("js", "directus")
      then: directus
      with:
        version: fs.depVersion("js", "directus")
      group: js

    hono:
      when: fs.depExists("js", "hono")
      then: hono
      with:
        version: fs.depVersion("js", "hono")
      group: js

    fastify:
      when: fs.depExists("js", "fastify")
      then: fastify
      with:
        version: fs.depVersion("js", "fastify")
      group: js

    ember:
      when: fs.depExists("js", "ember-source") || fs.fileExists(".ember-cli.js")
      then: ember
      with:
        version: fs.depVersion("js", "ember-source")
      group: js

    fresh: # Deno Fresh. See: https://fresh.deno.dev/
      when: fs.fileExists("fresh.config.ts") || fs.depExists("js", "https://deno.land/x/fresh")
      then: fresh
      with:
        version: fs.depVersion("js", "https://deno.land/x/fresh")
      group: js

    # Deno TypeScript/JavaScript runtime.
    # This is deliberately in all three rulesets.
    deno:
      when: fs.fileExists("deno.json") || fs.fileExists("deno.lock")
      then: deno
      group: js

    # Astro framework / SSG. See: https://github.com/withastro/astro
    # The config file is normally astro.config.mjs but could also have ts, js or cjs extensions.
    astro:
      when: fs.depExists("js", "astro") || fs.glob("astro.config.*s").size() > 0
      then: astro
      with:
        version: fs.depVersion("js", "astro")
      groups: [js, static]

    nue: # Nue. See: https://nuejs.org/
      when: fs.fileExists("site.yaml") && fs.fileContains("site.yaml", "https://json.schemastore.org/nuejs-site.json")
      then: nue
      groups: [js, static]

    magento:
      when: fs.depExists("php", "magento/*") && jq(fs.read("composer.json"), ".type") == "project"
      then: magento
      with:
        version: fs.depVersion("php", "magento/magento-composer-installer")
      group: php
      ignore:
        - Magento/

    gin:
      when: fs.depExists("go", "github.com/gin-gonic/gin")
      then: gin
      with:
        version: fs.depVersion("go", "github.com/gin-gonic/gin")
      group: go

    fiber:
      when: fs.depExists("go", "github.com/gofiber/fiber*")
      then: fiber
      with:
        version: fs.depVersion("go", "github.com/gofiber/fiber/v2")
      group: go

    echo:
      when: fs.depExists("go", "github.com/labstack/echo*")
      then: echo
      with:
        version: fs.depVersion("go", "github.com/labstack/echo/v4")
      group: go

    beego: # Beego framework. See: https://github.com/beego/beego
      when: fs.depExists("go", "github.com/beego/beego*")
      then: beego
      with:
        version: fs.depVersion("go", "github.com/beego/beego/v2")
      group: go

    flask:
      when: fs.depExists("python", "flask")
      then: flask
      group: python

    pyramid:
      when: fs.depExists("python", "pyramid")
      then: pyramid
      group: python

    fastapi:
      when: fs.depExists("python", "fastapi")
      then: fastapi
      group: python

    tornado:
      when: fs.depExists("python", "tornado")
      then: tornado
      group: python

    django:
      when: fs.depExists("python", "django")
      then: django
      with:
        version: fs.depVersion("python", "django")
      groups: [python, django]

    wagtail: # Wagtail CMS. See: https://wagtail.org
      when: fs.depExists("python", "wagtail")
      then: wagtail
      with:
        version: fs.depVersion("python", "wagtail")
      groups: [python, django]

    rails:
      when: fs.depExists("ruby", "rails")
      then: rails
      with:
        version: fs.depVersion("ruby", "rails")
      group: ruby
      read_files: [config/database.yml]

    jekyll:
      when: fs.depExists("ruby", "jekyll")
      then: jekyll
      with:
        version: fs.depVersion("ruby", "jekyll")
      groups: [ruby, static]

    sinatra:
      when: fs.depExists("ruby", "sinatra")
      then: sinatra
      with:
        version: fs.depVersion("ruby", "sinatra")
      group: ruby

    spring-boot:
      when: fs.depExists("java", "org.springframework.boot:*")
      then: spring-boot
      with:
        version: fs.depVersion("java", "org.springframework.boot:spring-boot-starter-parent")
      group: java

    grails:
      when: fs.depExists("java", "org.grails:*")
      then: grails
      with:
        version: fs.depVersion("java", "org.grails:grails-core")
      group: java

    quarkus:
      when: fs.depExists("java", "io.quarkus:*")
      then: quarkus
      with:
        version: fs.depVersion("java", "io.quarkus:quarkus-rest")
      group: java

    jfinal:
      when: fs.depExists("java", "com.jfinal:jfinal")
      then: jfinal
      with:
        version: fs.depVersion("java", "com.jfinal:jfinal")
      group: java

    jooby: # Jooby framework. See: https://jooby.io/
      when: fs.depExists("java", "io.jooby:jooby")
      then: jooby
      with:
        version: fs.depVersion("java", "io.jooby:jooby")
      group: java

    actix-web: # Actix Web. See: https://actix.rs/
      when: fs.depExists("rust", "actix-web")
      then: actix-web
      with:
        version: fs.depVersion("rust", "actix-web")
      group: rust

    rocket:
      when: fs.depExists("rust", "rocket")
      then: rocket
      with:
        version: fs.depVersion("rust", "rocket")
      group: rust

    warp: # Warp framework. See: https://github.com/seanmonstar/warp
      when: fs.depExists("rust", "warp")
      then: warp
      with:
        version: fs.depVersion("rust", "warp")
      group: rust

    dioxus: # Dioxus fullstack framework. See: https://dioxuslabs.com/
      when: fs.depExists("rust", "dioxus")
      then: dioxus
      with:
        version: fs.depVersion("rust", "dioxus")
      group: rust

    yew: # Yew WebAssembly framework. See: https://github.com/yewstack/yew
      when: fs.depExists("rust", "yew")
      then: yew
      with:
        version: fs.depVersion("rust", "yew")
      group: rust

    axum: # Axum framework. See: https://github.com/tokio-rs/axum
      when: fs.depExists("rust", "axum")
      then: axum
      with:
        version: fs.depVersion("rust", "axum")
      group: rust

    hugo:
      when: fs.fileExists("hugo.toml") || fs.fileExists("hugo.yaml") || fs.fileExists("hugo.json") || fs.fileExists(".hugo_build.lock")
      then: hugo
      groups: [go, static]

    redoc: # Redoc: Open source API documentation tool. See: https://redocly.com/docs/redoc
      when: fs.fileExists("redocly.yaml") || fs.fileExists(".redocly.yaml") || fs.fileExists("redoc-static.html")
      then: redoc
      groups: [js, static]

    # Eleventy static site generator. See: https://www.11ty.dev/
    # The config file, which is optional, could be any of .eleventy.js, eleventy.config.js, eleventy.config.mjs or eleventy.config.cjs.
    eleventy:
      when: fs.fileExists(".eleventy.js") || fs.glob("eleventy.config.*s").size() > 0 || fs.depExists("js", "@11ty/eleventy")
      then: eleventy
      with:
        version: fs.depVersion("js", "@11ty/eleventy")
      groups: [js, static]

    docusaurus: # Docusaurus static site generator. See: https://github.com/facebook/docusaurus
      when: fs.glob("docusaurus.config.*s").size() > 0 || fs.depExists("js", "@docusaurus/core")
      then: docusaurus
      with:
        version: fs.depVersion("js", "@docusaurus/core")
      groups: [js, static]

    # Meteor.js web framework (https://www.meteor.com/)
    meteor.js:
      when: fs.depExists("js", "meteor-base")
      then: meteor.js
      with:
        version: fs.depVersion("js", "meteor-base")
      group: js

    phoenix:
      when: fs.depExists("elixir", "phoenix")
      then: phoenix
      with:
        version: fs.depVersion("elixir", "phoenix")
      group: elixir

    # Play Framework (https://www.playframework.com/)
    play:
      when: fs.depExists("java", "com.typesafe.play:*")
      then: play
      groups: [java, scala]

    # Blazor WebAssembly (client-side Blazor)
    blazor-wasm:
      when: fs.depExists("dotnet", "Microsoft.AspNetCore.Components.WebAssembly")
      then: blazor-wasm
      with:
        version: fs.depVersion("dotnet", "Microsoft.AspNetCore.Components.WebAssembly")
      groups: [dotnet, blazor]

    # Blazor Server (server-side Blazor)
    blazor-server:
      when: fs.depExists("dotnet", "Microsoft.AspNetCore.Components.Server")
      then: blazor-server
      with:
        version: fs.depVersion("dotnet", "Microsoft.AspNetCore.Components.Server")
      groups: [dotnet, blazor]

    # Regular ASP.NET Core (non-Blazor web apps)
    aspnetcore:
      when: >
        fs.depExists("dotnet", "Microsoft.AspNetCore.*") && !fs.depExists("dotnet", "Microsoft.AspNetCore.Components.*")
      then: aspnetcore
      with:
        version: fs.depVersion("dotnet", "Microsoft.AspNetCore.App")
      groups: [dotnet]