DSL для конфигурации приложения

Пару лет назад мне довелось писать приложение для учета посещений в танцевальном клубе. Бизнес-логики в нем практически никакой не было, но зато была необходимость прилично настраивать программу. В клубе -- множество групп, они разные по стоимости; оплату можно произвести за фиксированное число занятий, но этих чисел несколько (1, 4, 8, 12); разные типы скидок должны были относиться к разным по стоимости группам и т.д. Ничего сложного, просто нужно вносить много данных. Тогда возможность настройки приложения я сделал целиком через оконный интерфейс. Теперь я бы предпочел конфигурационный файл как наименее затратный вариант.
Поскольку этот конфиг очень сильно заточен на одну задачу (описание танцевального клуба), то он представляет собой классический язык предметной области (DSL). Каким образом проще всего его реализовать?
Вкратце, для тех, кто не до конца представляет собой концепцию языков предметной области, опишу подробнее. В [1] указана главная характеристика языка предметной области: его ограниченность. В отличие от языков общего назначения, DSL, как правило, содержит очень мало синтаксиса. С его помощью нельзя написать любую программу, зато можно очень легко и кратко решить задачу, для которой DSL предназначен. Так, например, в DSL может не быть даже таких простых операторов, как if, for или объявления процедур.
Там же, (в [1]), указано, что суть языка предметной области -- это его семантическая модель, т.е. набор функционала, который DSL реализует. В паттерне MVC семантическая модель занимала бы нишу модели и контроллера, а синтаксис -- представления.
Синтаксис DSL может быть реализован несколькими способами, начиная от оконного интерфейса и заканчивая прямым вызовом функционала семантической модели. Ниже я покажу внешний DSL, реализованный при помощи XML-файла, и внутренний DSL, реализованный при помощи Clojure.
Семантическая модель очень проста. Она содержит в себе классы CardType, Payment, Group и Discount. Тип карты (абонемент) представляет собой отдельную ценовую категорию, в пределах которой пользователь может посещать занятия в разных группах. Владелец более дешевой карты не может посещать занятия в группах более дорогой ценовой категории.
CardType содержит несколько видов оплаты (Payment), каждая оплата -- это объект с двумя свойствами: стоимость и количество оплаченных занятий.
В пределах этой же ценовой категории должны быть описаны группы (Group) и скидки (Discount).
Вот фрагмент класса-парсера DSL-а, реализованного в XML:

        public void startElement(String uri, String localName, String qName, Attributes atts) 

        throws SAXException {
            if (localName.equals("card-type")) {
                CardType cardType = new CardType();
                cardTypeTitle = atts.getValue(0);
                cardType.setTitle(cardTypeTitle);
            }
            
            if (localName.equals("payment")) {
                Payment payment = new Payment();
                try { 
                    payment.setCardTypeTitle(cardTypeTitle);
                } catch (Exception ex) { System.out.println(ex); }
                
                for (int i = 0; i < atts.getLength(); i++) {
                    if (atts.getQName(i).contains("cost")) {
                        int cost = Integer.parseInt(atts.getValue(i));
                        payment.setCost(cost);
                    }
                    if (atts.getQName(i).contains("number")) {
                        int number = Integer.parseInt(atts.getValue(i));
                        payment.setNumber(number);
                    }
                }
            }
            
            if (localName.equals("discount-for")) {
                Discount discount = new Discount();
                
                for (int i = 0; i < atts.getLength(); i++) {
                    if (atts.getQName(i).contains("cost")) {
                        int cost = Integer.parseInt(atts.getValue(i));
                        discount.setCost(cost);
                    }
                    if (atts.getQName(i).contains("percent")) {
                        int percent = Integer.parseInt(atts.getValue(i));
                        discount.setPercent(percent);
                    }
                    if (atts.getQName(i).contains("condition")) {
                        discount.setCondition(atts.getValue(i));
                    }
                    if (atts.getQName(i).contains("cardTypes")) {
                        String[] cardTypes = atts.getValue(i).split(" ");
                        
                        for (String ct: cardTypes) {
                            if (ct.isEmpty()) continue;
                            try {
                                discount.addToCardType(ct);
                            } catch (Exception ex) { System.out.println(ex);}                    
                        }
                    }
                    }
                }
            
            if (localName.equals("group")) {
                Group group = new Group();
                
                for (int i = 0; i < atts.getLength(); i++) {
                    if (atts.getQName(i).contains("title")) {
                        group.setTitle(atts.getValue(i));
                    }
                    if (atts.getQName(i).contains("instructor")) {
                        group.setInstructor(atts.getValue(i));
                    }
                    if (atts.getQName(i).contains("style")) {
                        group.setStyle(atts.getValue(i));
                    }
                    if (atts.getQName(i).contains("cardType")) {
                        try {
                            group.setCardTypeTitle(atts.getValue(i));
                        } catch (Exception ex) { System.out.println(ex);}                    
                    }
                }
            }
        }

Пример описания на этом DSL выглядит так:

<root>
  <card-type title="Regular">
    <payment
        cost="120000"
        number="8" />
    <payment
        cost="150000"
        number="12" />
  </card-type>

  <card-type title="Early">
    <payment
        cost="100000"
        number="8" />
  </card-type>

  <card-type title="Kid">
    <payment
        cost="80000"
        number="8" />
  </card-type>

  <group title="K9"
         cardType="Regular"
         instructor="V.Pupkin"
         style="Hip-hop"/>

  <group title="H7"
         cardType="Early" 
         instructor="I.Sidorov"
         style="Hip-hop R-n-B" />
  
  <discount-for cardTypes="Regular Early"
                percent="15"
                condition="Comes with two friends."/>

  <discount-for cardTypes="Regular Early"
                cost="20000"
                condition="Pays for three months."/>

</root>

При реализации языка программирования последовательно проходят стадии (приблизительно и неформально): парсер, построитель синтаксического дерева, семантическая модель. В данном случае, парсером был парсер XML Apache Xerses. Но обход дерева пришлось реализовывать уже на java. В данном случае, максимальный уровень вложенности структур равен двум, поэтому обход дерева здесь очень простой и негибкий. Если бы нужно было реализовать чуть более мощное средство, то абстрактное синтаксческое дерево построить было бы значительно сложнее.
Самый существенный минус внешних предметно-ориентированных языков в том, что они не могут обращаться к функциональности других языков. Даже организация элементарного цикла, или вызова процедуры с рекурсией потребует значительных затрат сил и времени. Поэтому, если представляется возможность, предпочтительнее пользоваться внутренними DSL-ами, синтаксис которых базируется на хостовом языке.
В [2] даны примеры реализации внутренних DSL-ов на разных языках (Ruby, Scals, Groovy, Clojure). Наибольшие преимущества мы можем извлечь, реализуя DSL на Clojure. Связано это с тем, что на любом лиспе исключается шаг построения синтаксического дерева. Исходник на лиспе и есть дерево разбора выражений, достаточно просто им воспользоваться. В моем DSL нет сложных конструкций, из которых были бы видны все преимущества лиспа. Но если хотите их ощутить -- просто попробуйте расширить приведенный здесь DSL хотя бы операторами if и for(;;), а также определения и вызова процедур при неограниченной языком вложенности конструкций.
Реализация DSL на Clojure выглядит так:

(ns CMDSL.core
  (:import [entities CardType Payment Discount Group])
  (:use [clojure.contrib.repl-utils :only (show)]))

;;; Utility functions ;;;

(defn capitalize [word]
  (let [big-letter (.toUpperCase (.toString (get word 0)))
        rest-word (.substring word 1)]
    (str big-letter rest-word)))

(defn make-setter [property]
  (str ".set" (capitalize property)))

(defn make-getter [property]
  (str ".get" (capitalize property)))

(defmacro props->setters [props object]
  `(do ~@(map
          (fn [k] `(~(symbol (str (make-setter (.substring (str k) 1))))
                   ~object
                   ~(k props)))
          (keys props))))

;;; DSL ;;;

(defmacro card-type [title & payments]
  `(let [cardType# (CardType.)]
     (.setTitle cardType# ~(str title))
     ~@(map (fn [payment] `(.setCardTypeTitle ~payment ~(str title))) payments)
     cardType#))

(defmacro dsl-entity [class args]
  (let [props (apply hash-map args)
         instance (gensym "instance")]
    `(let [~instance (new ~class)]
       (props->setters ~props ~instance)
       ~instance)))

(defmacro payment [& args]
  `(dsl-entity ~Payment ~args))

(defmacro discount [args]
  `(dsl-entity ~Discount ~args))

(defmacro discount-for [card-types & args]
  (let [d (gensym "discount")]
  `(let [~d (discount ~args)]
     ~@(map (fn [ct] `(.addToCardType ~d ~(str ct))) card-types)
     ~d)))

(defmacro group-m [args]
    `(dsl-entity ~Group ~args))

(defmacro group [title card-type & args]
  (if (not= (str (first card-type)) "card-type")
    nil
    (let [t (str title)
          ct (str (second card-type))
          g (gensym "group")]
      `(let [~g (group-m ~args)]
         (.setTitle ~g ~t)
         (.setCardTypeTitle ~g ~ct)
         ~g))))

Использование DSL:

(use 'CMDSL.core)

(card-type Regular
  (payment
    :cost 120000
    :number 8)
  (payment
    :cost 150000
    :number 12))

(card-type Early
  (payment
    :cost 100000
    :number 8))

(card-type Kid
  (payment
    :cost 80000
    :number 8))

(group K9 (card-type Regular)
    :instructor "V.Pupkin"
    :style "Hip-hop")

(group H7 (card-type Early)
    :instructor "I.Sidorov"
    :style "Hip-hop, R&B"
    :level "Medium")

(discount-for [Regular, Early]
    :percent 15
    :condition "Comes with two friends.")

(discount-for [Regular, Early]
    :cost 20000
    :condition "Pays for three months.")

Выводы.
DSL, реализованный на Clojure, позволяет легко конфигурировать Java-приложение. Язык предметной области реализуется очень просто, при этом позволяет пропустить шаги разбора и построения абстрактного синтаксического дерева. Полученный язык обладает преимуществами внутренних DSL, т.к. может обращаться к функционалу хостового языка. Благодаря свойствам хостового языка (Clojure), описываемый DSL легко расширять как другими доменными сущностями, так и более сложными конструкциями.

Литература:
1. Domain-Specific Languages, Martin Fowler, Addison-Wesley, 2010.
2. DSLs in Action, Debasish Ghosh, Manning, 2011.