Գնահատել նախագիծը
← Բոլոր հրապարակումները

Ktor-ի templating. Pebble-ի համեմատությունը HTML DSL-ի հետ

Հայացք այն բանին, թե ինչ եք շահում և կորցնում դասական HTML-ի վրա հիմնված կաղապարներով՝ Kotlin-ի տիպային անվտանգ DSL-ի համեմատ սերվերի կողմից ռենդերինգի ժամանակ, կենտրոնանալով յուրաքանչյուր մոտեցման ընթեռնելիության, ընդլայնելիության և առօրյա օգտագործելիության վրա։

5 րոպե
KotlinHTMLKtorKotlinServerSide

Վերջին ամիսներին Server Side Rendering-ը (SSR) մեծ թափով վերադարձել է։ Front-end-ի հետ խոսելու միջոց JSON-ից մի քայլ հետ գնալը իսկապես թարմացնող է զգացվել։ Կարող եք ընտրել շատ տարբեր templating լեզուներից, և երբ դրանցից մեկը գիտեք, մյուսին անցնելը սովորաբար հեշտ է։ Ոչ վաղ անցյալում հանդիպեցի մեկի, որը ուզում էի փորձել՝ HTML DSL, kotlinx.html ինտեգրացիա, որը գալիս է Ktor-ի հետ. Kotlin ֆրեյմվորք ասինխրոն կլիենտ և սերվեր հավելվածներ ստեղծելու համար։ Այն templating-ին մոտենում է այլ տեսանկյունից. դուք գրում եք սովորական HTML Kotlin-ով, փոփոխականներ ինտերպոլացնում դիտումների (views) մեջ և հավաքում բարդ layout-ներ։ Կարծում եմ՝ ընդլայնելիությունը HTML-ի ամենամեծ ուժեղ կողմերից է, և կասկածներ ունեմ, թե արդյոք տիպային անվտանգությունը դրա հետ կհամերաշխվի, ուստի եկեք խորանանք և համեմատենք HTML DSL-ը Pebble templates-ի՝ ավելի սովորական templating լեզվի հետ։

Հիմնական էջը Pebble-ով

Իմ գաղափարն էր երկուսը համեմատել կոնտակտների կառավարման rolodex հավելվածի օրինակով, թեթևակի ոճավորված Pico-ով։ Սակայն գնանք քայլ առ քայլ և սկսենք <body>.-ի մեջ բովանդակալից ոչինչ չդնելով։ Այստեղ pebble կաղապարը ճիշտ նույնն է, ինչ սովորական HTML-ը.

<!DOCTYPE html>
<html lang="en" data-theme="light">
<head>
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.min.css">
  <link rel="stylesheet" href="/static/css/main.css">
  <meta charset="UTF-8"/>
  <title>Pebble vs HTML DSL</title>
</head>
<body>
<main class="container">
  <h1>It works 🚀!</h1>
</main>
</body>
</html>

Այստեղ ոչ մի անսովոր բան չկա, բացի Pico-ի data-themeargument-ից <html> թեգում։

Հաջորդը հիմնական էջը առանձնացնելն է։ Ժառանգման կամ կոմպոզիցիայի որևէ ձև պարտադիր է, երբ HTML էջ եք գեներացնում սերվերի վրա. այն թույլ է տալիս էջի մի մասը դուրս բերել և հետագայում դրա մեջ ներարկել իրական բովանդակությունը։ Pebble-ում դա արվում է թեգերով (չշփոթել սովորական HTML թեգերի հետ).

{# base.peb #}

<!DOCTYPE html>
<html lang="en" data-theme="light">
<head>
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.min.css">
  <link rel="stylesheet" href="/static/css/main.css">
  <meta charset="UTF-8"/>
  <title>Pebble vs HTML DSL</title>
  <style>
  </style>
</head>
<body>
<main class="container">
    {% block content %}{% endblock %}
</main>
</body>
</html>

Այնուհետև կարող ենք այն կրկին օգտագործել index էջը ռենդերելու համար այսպես.

{# index.peb #}
{% extends "base.peb" %}

{% block content %}
<h1>It works 🚀!</h1>
{% endblock %}

Հիմնական էջը HTML DSL-ով և descoping

Ստանդարտ templating լեզվում հիմնական էջի աշխատանքի զգացողություն ունենալուց հետո կարող ենք անցնել HTML DSL-ին։ Փաստաթղթերը անցնելուց և custom պարամետրերը ուսումնասիրելուց հետո, հիմնական index.peb-ին համարժեք Kotlin routing կոդը այսպիսի տեսք ունի.

fun Application.configureRouting() {
  routing { 
    staticResources("/static", "static") {
      extensions("css")
      preCompressed(CompressedFileType.GZIP)
    }
    get("/") {
      call.respondHtml(HttpStatusCode.OK) {
        lang = "en"
        attributes["data-theme"] = "light"
        head {
          link {
            href = "https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.min.css"
            rel = "stylesheet"
          }
          link {
            href = "/static/css/main.css"
            rel = "stylesheet"
          }
          meta {
            charset = "UTF-8"
          }
          title {
            +"Pebble vs HTML DSL"
          }
        }
        body {
          main {
            classes = linkedSetOf("container")
            h1 {
              +"It works 🚀!"
            }
          }
        }
      }
    }
  }
}

Սա բոլորովին նման չէ սովորական HTML-ին։ Բայց արդյո՞ք սա առավելություն է։ Անկեղծ ասած՝ չեմ կարծում, և ահա DSL մոտեցման հետ կապված իմ խնդիրները.

  • Նույնիսկ այսքան պարզ էջի համար միանգամից պարզ չէ, թե կոդի որ մասերն են համապատասխանում HTML-ի որ մասերին։ Դա կարող է JavaScript կոդի դեբագը անհարկի դժվարացնել։
  • Քանի որ կոդը HTML-ի նման չէ, Kotlin-ին անծանոթ մարդիկ դժվարանալու են նախագծի front-end մասի վրա աշխատել։
  • Այդ տարբերությունը ունի ևս մեկ թերություն. HTML բաղադրիչների գրադարանները չեն կարող օգտագործվել այս մոտեցմամբ, եթե չծախսվի աննշան չլինող ջանք դրանք DSL-ի թարգմանելու վրա
  • class ատրիբուտի համար Set օգտագործելը կարող է թվալ կրկնությունները խուսափելու հարմար եղանակ, բայց այն կարող է անսպասելի կողմնակի էֆեկտներ ունենալ, քանի որ կարող է կոտրել ձեր attribute selectors-ը. օրինակ՝ [class="class1 class2"]-ը տարբերվում է [class="class2 class1"]-ից։ Որպես կանոն՝ պետք է օգտագործել linkedSetOf
  • Ինչպես նշեցի սկզբում, ընդլայնելիությունը HTML-ի նախագծման սկզբունքներից մեկն է։ Ես կասկածում էի, որ խիստ տիպային անվտանգությունը կդիմանա ամեն դեպքում, և իսկապես, այն կոտրվեց հենց առաջին թեգում, երբ ուզեցինք Pico-ի theme-ը սահմանել data attribute-ով։ Գրադարանները նաև հաճախ ապավինում են այլ custom attributes-ի։

Հաջորդիվ այս կոդի հիմնական մասը առանձնացնենք HTML դասի առանձին մեթոդի մեջ, որպեսզի այն դառնա մեր DSL-ի մաս։

object Templates {
    fun HTML.base(content: FlowContent.() -> Unit) {
        lang = "en"
        attributes["data-theme"] = "light"

        ...

        body {
            main {
                classes = setOf("container")
                content()
            }
        }
    }
}

//Application.configureRouting
get("/") {
  call.respondHtml(HttpStatusCode.OK) {
    base {
      h1 {
        +"It works 🚀!"
      }
    }
  }
}

Այս ռեֆակտորինգը պահանջեց մի քիչ ավելի Kotlin գիտելիք, բայց ջանքը մի դեպքից մյուսը շատ չպետք է տարբերվի։

Երբ սկսեցի գրել այս հոդվածը, ամբիցիոզ պլան ունեի՝ համեմատել Pebble-ը և HTML DSL-ը պարզ rolodex հավելվածով։ Ցավոք, DSL-ը նույնիսկ միայն կարդալու հավելվածը դարձրեց դժվար ընթեռնելի, ուստի որոշեցի այս գրառման մեջ մնացածը չընդգրկել։ Միայն կարդալու պատրաստի տարբերակում տողերի քանակը կազմում է 75 ընդդեմ 128-ի, Pebble-ը ավելի կարճն է։

Եզրակացություն

Կարող եմ տեսնել HTML DSL-ի մի քանի առավելություն.

  • Լիարժեք աջակցություն IDEA-ում, քանի որ դա պարզապես Kotlin կոդ է
  • Սա Ktor-ի միակ templating տարբերակն է, որն աշխատում է native server-ի հետ
  • Այն աշխատում է անմիջապես, հենց dependency-ն ավելացվում է build-ին
  • Այն խուսափում է template թեգերի նյարդայնացնող սահմանափակումից, որոնք սովորաբար պետք է տեղավորվեն մեկ տողում

Սակայն անձամբ ես շուտով նորից դրան չեմ դիմի. գտնում եմ, որ հաստատված template լեզուների համեմատ այն վեբ հավելվածների կառուցումը դարձնում է ավելի բարդ, քան անհրաժեշտ է։