Показаны сообщения с ярлыком DSL. Показать все сообщения
Показаны сообщения с ярлыком DSL. Показать все сообщения

вторник, 12 июня 2012 г.

Мой DSL для проектов на Android


Пару месяцев назад перепала мне задачка пилить в одиночку довольно объемный проект на Android. Сам по себе проект был несложный, но количество повторяющегося кода зашкаливало. При том самое обидное, что стандартными средствами как-то избавиться от повторений не представляется возможным. Тогда я и наваял первоначальную версию небольшой генерилки андроид-кода.

Больше всего, конечно, в андроиде меня раздражает xml. Логично, что формочки лучше описывать в декларативном стиле; понятно, что java для этого не годится; разумеется, xml здесь уместен. Но, блин, как же отстойно все это выглядит! Элементарного цикла в нем не сделать, а уж про реюзабельность вообще молчу. Она там, конечно, есть в виде подключаемых пользовательских компонентов. Но все эти механизмы страшно сосут даже по сравнению с инструментами разработки под iPhone!

Самое главное, чего я хотел добиться созданием своего DSL, – это избавиться от богомерзкого xml. Я хотел описывать UI в декларативном стиле на языке общего назначения. Оказалось, что на Clojure – это очень даже просто, достаточно воспользоваться библиотекой hiccup.

Например, вместо этого
<Button android:id="@+id/helloWorldBtn" 
    android:background="@drawable/blue_button_slt"    
    android:layout_height="wrap_content"
    android:layout_width="wrap_content"
    android:text="Push me!"
    android:textColor="#fff"
    android:textSize="10dp"
    android:textStyle="bold"/>

писать такой код:

(Button "helloWorldBtn" wc wc
 [:text "Push me!"
  :textColor "#fff"
  :textSize "10dp"
  :textStyle "bold"
  :background (drawable "blue_button_slt")])

На данном этапе выигрыша в коде почти никакого нет. Зато уже можно сделать, например, так:

(defn large-button [id attributes image & [ txt]]
  (VLayout nil wc wc (conj attributes :gravity "center")
           (ImageButton id "60dp" "70dp"
                        [:background (drawable image)])
           (if-not (empty? txt)
             (TextView nil "125dp" "18dp" 
                        [:text txt
                         :textSize "16dp"
                         :gravity "center"
                         :textColor "#0096c1"]))))

Как видите, введение языка общего назначения вместо xml позволяет легко создавать функции. Напротив, создание реюзабельного компонента под андроид – процедура более долгая и трудоемкая. Еще очень удобно использовать if-ы, loop-ы и прочие возможности языка. Кроме того, код на Clojure писать проще, ведь можно заранее задать для компонентов сокращенные варианты атрибутов либо рациональные настройки. Например, в приведенном выше исходнике wc означает "wrap_content".

Кроме генерации xml на основе приведенного выше примере, можно сгенерировать и код на java. Это позволит автоматизировать многие, часто повторяемые операции.

Рассмотрим пример формы с текстовой строкой и двумя кнопками.

(defn layout []
  (html
   (VLayoutFP nil [:background (drawable "home_bgr")]
    (HLayoutFP nil []
     (VLayoutFP nil []
      (TextView nil wc wc [:text "Demo text"
                 :textColor "#09bbaa"])
      (Button "helloWorldBtn" wc wc [:text "Push me!"
                       :textColor "#fff"
                       :textSize "10dp"
                       :textStyle "bold"
                       :background (drawable "blue_button_slt")
                       :code (->java {}
                                (def ^:String hello "Hello")
                                (def world "world")
                                (System.out.println (+ hello " " world)))])
      (Button "demoBtn" wc wc [:text "Push me!"
                     :textColor "#fff"
                     :textSize "10dp"
                     :textStyle "bold"
                     :background (drawable "blue_button_slt")
                     :code (->java {}  
                              (startActivity
                                (new android.content.Intent this OrderScreen.class)))])
      )))))

(generate-activity layout "com.adsl.demo" "MyDemoActivity")
 
Будет создана связка файлов MVC. Генерятся классы MyDemoActivityModel, MyDemoActivityView, MyDemoActivityController и связываются таким образом, что они сразу готовы к использованию как единая сущность. Будет создана заготовка метода, который вызывается во вьюхе при изменении модели.

public void update(Observable modelObj, Object arg) {
    initialize();
    MyDemoActivityModel model = (MyDemoActivityModel)modelObj;
}
 
В классе MyDemoActivityView будут созданы атрибуты:

private Button _helloWorldBtn;
private Button _demoBtn;

Позже они инициализируются таким образом:

_helloWorldBtn = (Button) findViewById(R.id.helloWorldBtn);
_demoBtn = (Button) findViewById(R.id.demoBtn);


Кнопкам назначается листенер, который вызывает соответствующий метод контроллера:

View.OnClickListener listener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if (v.equals(_helloWorldBtn)) {
            controller.helloWorldBtnActionPerformed(MyDemoActivityView.this);
            return;
            }
            if (v.equals(_demoBtn)) {
            controller.demoBtnActionPerformed(MyDemoActivityView.this);
            return;
            }
        }
        };

_helloWorldBtn.setOnClickListener(listener);
_demoBtn.setOnClickListener(listener); 
 
Еще одна забавная штука, которую я добавил скорее по приколу, – это компиляция из моего псевдо-лиспа в java. Кнопке можно задать атрибут :code и прописать туда такое выражение:

(->java {}
         (def ^:String hello "Hello")                  ; Объявить стринговую переменную
         (def world "world")                           ; Объявить нетипизированную переменную
         (System.out.println (+ hello " " world)))   ; Вызвать функцию с параметрами

Генератор преобразует эти выражения в java-код и вставит его в тело метода:

public void helloWorldBtnActionPerformed(MyDemoActivityView view) {
       String hello = "Hello";
       Object world = "world";
       System.out.println(hello + " " + world);
}
 
Вообще, такой транслятор с псевдо-лиспа в java мне понадобился в основном затем, чтобы можно было по нажатию кнопки сделать простую инициализацию объекта либо показать другой активити.

Например:

(->java {} (startActivity (new android.content.Intent this OrderScreen.class)))
 
На выходе будет:

public void demoBtnActionPerformed(MyDemoActivityView view) {
       startActivity(new android.content.Intent(this, OrderScreen.class));
} 

Сам транслятор содержится в файле clj2java.clj, а главная функция выглядит так:
(defn process
  ([data raw-code]
     (let [code (enrich-with-data data raw-code)]
       (if (list? code)
         (let [elem1 (first code)]
           (cond
            (= elem1 'def) (process-definition code)
            (= elem1 'defn) (process-func-definition code)
            (= elem1 'do) (process-command-sequence (next code))
            (= elem1 'set!) (process-assignment (next code))
            (= elem1 'if) (process-if (next code))
            (= elem1 'return) (process-return (next code))
            (= elem1 '->) (process-method-call (next code))
            (= elem1 'lambda-interface) (process-lambda-interface)
            (= elem1 'lambda) (process-lambda code)
            (= elem1 'call) (process-call (next code))
            (= elem1 'loop) (process-loop (next code))
            (= elem1 'new) (process-new (next code))
            :else (process-function-call code)))
         (process-single-value code))))
  ([raw-code] (process {} raw-code)))

Как видите, транслятор умеет не так уж и мало и позволяет писать более краткий, по сравнению с java, код.

Сам же язык описания интерфейсов построен с применением барьеров абстракции, как об этом рассказывается в SICP и On Lisp. Весь код содержится в файле util.clj.

На нижнем уровне абстракции находятся различные служебные функции и ядро всех будущих компонентов – функция виджет:
(defn widget [type id width height params-raw & more] . . . )  

Все прочие виджеты создаются на основе этой функции, например, так:

(defn Button [id width height & [params]]
  (widget "Button" id width height (apply android params)))

(defn HLayoutWC [id & [params & more]]
  (widget "LinearLayout" id "wrap_content" "wrap_content" 
          (merge {"xmlns:android" "http://schemas.android.com/apk/res/android"
                  (andr-attr "orientation") "horizontal"}
                 (apply android params))
          more))

Верхний уровень абстракции – кастомные виджеты и хелперы, которые создаются на основе стандартных виджетов. Например, синяя кнопка выглядит так: 
 
(defn BlueButton [id width height & [params]]
  (Button id width height (flatten (conj params [:background (drawable "blue_button_slt")
                                                   :textColor "#fff"
                                                   :textSize "10dp"
                                                   :textStyle "bold"]))))  

А хелперы для отступа выглядят так:

(defn padding-top [top & more]
  (HLayout nil wc wc [:paddingTop top]
           more))

(defn padding-left [left & more]
  (HLayout nil wc wc [:paddingLeft left]
           more))
  
Саму генерилку описывать особо нет смысла, т.к. она достаточно простая.

Плюсы подхода:
  1. Сокращение кода описания активити в три-четыре раза. Чем больше и сложнее описываемая форма – тем больше выигрыш.
  2. Гораздо более простой способ создания абстракций при помощи обыкновенных функций. В результате значительно повышается реюзабельность кода.
  3. Значительно облегчается чтение и модификация кода UI по сравнению с использованием xml.

Минусы:
  1. Сгенеренный код выглядит, порой, написанным copy-paste-ом.
  2. При перегенерации кода теряется код, написанный вручную в сгенеренных ранее файлах.

Вообще, я с минусами придумал бороться следующим образом. Во-первых, не лазить в сгенеренные файлы вообще. Если нужно добавить тело метода или еще какую функциональность, то нужно наследоваться от сгенеренных классов. Это избавляет от необходимости переносить вручную набитый код в новую версию нагенеренных классов. Кроме того, раз не нужно больше лазить в сгенеренные классы, то отпадает требование о красоте их кода, и автоматический copy-paste становится допустимым. Главное, чтобы его не было на уровне самого DSL.

четверг, 14 июля 2011 г.

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.