* Introduction

Diagram Make Language for Common Lisp.You can look DML as Domain Specific Language for drawing UML. 

我国同学，请参考一个更详细的[[file:README.zh.org][中文说明]]

* Install

DML is added to quicklisp, quicklisp automatically download it to local disk on the first loading.

#+BEGIN_SRC lisp
(ql:quickload :dml)
#+END_SRC 

* Quick start by examples

To run examples, load dml system and change current package to 'dml'. 

#+BEGIN_SRC lisp
(ql:quickload :dml)
(use-package :dml) ;; or (in-package :dml)
#+END_src 

** Quick Start for Sequence Diagram
 Call macro dml-create-sequence to create a sequnce diagram:
 #+BEGIN_EXAMPLE
 (dml-create-sequence "<diagram name>" (<attribute>...) <messages>
 #+END_EXAMPLE

 A synchronous message & retrun in a formated string :
 #+BEGIN_EXAMPLE 
 "==><object name>.<message label>/<return label>"
 #+END_EXAMPLE

 A asynchronous message in a formated string:
 #+BEGIN_EXAMPLE 
 "--><object name>.<message label>"
 #+END_EXAMPLE

 A new message in a fromated string :
 #+BEGIN_EXAMPLE 
 "n-><object name>.<mesasge label>"
 #+END_EXAMPLE

 Any object name begin with '!' is a active object, that has a active bar at beginning.
 
 A sequence list of messages in macro '&prog'
 #+BEGIN_EXAMPLE
 (&prog <message 1> <message 2> <message 3> ...)
 #+END_EXAMPLE
   
 A message with follwing sub-messages in mcaro '&chain'
 #+BEGIN_EXAMPLE
 (&chain <message> <sub-message> <sub-sub-message> ...)
 #+END_EXAMPLE

 A optional/alternative frame with guard condtion and  messages in macro  '&if'
 #+BEGIN_EXAMPLE
 (&if "<guard label(condtion)>" <then-message> [<else-message>]) 
 #+END_EXAMPLE

 A loop frame with guard and message in macro '&loop'
 #+BEGIN_EXAMPLE
 (&loop "<gurad label(conditon)>" <message in loop> )
 #+END_EXAMPLE

 Any macro ('&prog' ,'&chain', '&opt', '&if' and '&loop') return a messages, so it can be nested in each other

 Evaluate follwing expression:

#+BEGIN_SRC lisp
(dml-create-sequence "legend" ()
  (&prog "==>ObjectA.SyncMsg1()/ret1" 
         (&chain "==>ObjectA.SyncMsg2()/ret2"
                 "==>ObjectB.SyncMsg2.1()/ret2.1"
                 "-->!ActiveObjectC.AsyMesg2.2()")))
#+END_SRC

Wil output image(legend.ps and legend.png):

[[file:demo/legend.png]] 


Evaluate Expression:

#+BEGIN_SRC lisp
(dml-create-sequence "nested" ()
  (&chain "==>aComputer.play()/"
          (&prog (&chain "==>emacs.run()/"
                         "==>slime.load()/")
                 (&chain "==>slime.Hacking()/"
                         (&chain "==>slime.LookupHyperSpec()"
                                 (&prog "==>chrome:Explorer.Start()/"
                                        "==>chrome:Explorer.OpenSpec()/"))))))
#+END_SRC

Output image:

[[file:demo/nested.png]] 

Evalate Expression:

#+BEGIN_SRC lisp
(dml-create-sequence "control" ()
  (&chain "==>:PersonFile.LoadAllGoodMan()/"
          (&loop "[ hasNext ]"
                 (&prog "==>:PersonFile.readNext()/"
                        (&if "[ Is Good Man ]"
                             (&prog "n=>aManObj.new"
                                    "==>manPool.register()/"))))))
#+END_SRC

Output image:

[[file:demo/control.png]] 

** Quick Start for Graph Diargam
   Call macro dml-create-graph to create a graph diagram:
   #+BEGIN_EXAMPLE
   (dml-create-graph "<diagram name>" (<attribute>...) <node or edge>
   #+END_EXAMPLE

   Define nodes by call functions (node type as function name).:'full-class', 'simp-class', 'actor', 'pack', 'ucas', 'comp' 
   #+BEGIN_EXAMPLE
   (<node type>  <node name>  [options])
   #+END_EXAMPLE

1. Define Graph by edges that linked nodes, define edges by functions (edge type as function name): '-dep-', '-com-', '-agg-', '-gen-by-'.
   #+BEGIN_EXAMPLE
   (-<edge type>- <src node> <dest node>) ; link one-to-one
   (-<edge type>-* <src node> <dest node 1> <dest node 2> ...); link one-to-manny
   (-<edge type>-- <1st node> <2nd node> <3rd node> ...); link one-by-one
   #+END_EXAMPLE 
3. Reference Predefined node by name '@name'.
   #+BEGIN_EXAMPLE
   (@name <node name>)
   #+END_EXAMPLE

Evaluate expression:

#+BEGIN_SRC lisp
(dml-create-graph "dml-component" (:rankdir :LR)
  (-dep-- "use"
          (comp "DML")
          (comp "donuts")
          (comp "Graphviz")))
#+END_SRC


Output image:

[[file:demo/dml-component.png]] 



Evalate expression:
#+BEGIN_SRC lisp
(dml-create-graph "os-class" ()
  (with-method ("+ play () : Love" "+ work () : Hate")
    (-genby-*
     (full-class "OS"
                 "abstract"
                 (attributes "- name : String"
                             "- born : Date"))
     (full-class "Linux")
     (full-class "Android")
     (full-class "Apple")
     (full-class "Windows"))
    (-dep- "from"
           (@name "Android")
           (@name"Linux"))))
#+END_SRC

Output Image:

[[file:demo/os-class.png]] 

Evaluate expression:

#+BEGIN_SRC lisp
(dml-create-graph "coder-case" (:rankdir :LR)
  (-point-* 
       (actor "coder")
       (ucas "Use Emacs")
       (ucas "Programing")
       (ucas "Play game"))
  (-dep- "extend"
         (@name "Programing")
         (@name "Use Emacs")))
#+END_SRC lisp

Output image:

[[file:demo/coder-case.png]] 

Evaluate expression:
#+BEGIN_SRC lisp
(dml-create-graph "dom" ()
  (with-method ("+ calcPrice(): BigDecimal"
                "+ toJson(): String"
                "+ getValue(name:String) : Object")
    (-genby-* (full-class "TreeNode"
                          "Abstract"
                          nil
                          (methods "+ getParent(): TreeNode"
                                   "+ addChild(:TreeNode)"))
              (full-class "PriceCache" "Decorator"
                          (attributes "- theNode : TreeNode"))
              (full-class "Case")
              (full-class "Plan")
              (full-class "Categorization"
                          nil
                          (attributes "- fromAge : integer"
                                      "- toAge : integer"
                                      "- isSheBao : boolean"
                                      "- count : integer"))))
  (-dep- "Create"
         (full-class "CaseBuilder"
                     "Factory"
                     nil (methods "+ parseJson(: String) : Case"))                                  
         (@name "Case"))
  (-agg- (@name "TreeNode")
         (@name "TreeNode"))
  (-com- (@name "PriceCache")
         (@name "TreeNode"))
  (-com- (@name "Case")
         (@name "Plan"))
  (-com- (@name "Plan")
         (@name "Categorization"))  
  (-dep- "Usage"
         (@name "Categorization")
         (full-class "Calculator"
                     "Utility"
                     nil
                     (methods "+ calc(arg : TreeNode) : BigDecimal"
                              "- log2db() :")))
  
  (with-method ("+ loadFromdb()"
                "+ lookUp()")
    (-com- (@name "Calculator")
           (full-class "ArgumentTable"))
    (-dep- "Call"
           (@name "Calculator")
           (@name "TreeNode"))  
    (-genby-* (@name "ArgumentTable")
              (full-class "ByAgeScope")
              (full-class "ByAge")
              (full-class "ByID"))
    (-dep- "Usage" (@name "ArgumentTable")
           (pack "JDBC"))))
#+END_SRC 

Output image:
  [[file:demo/dom.png]] 

* Reference 

** Symbol for Sequence Diagram

| Symbol name        | Type  | Description                                         |
|--------------------+-------+-----------------------------------------------------|
| dml-create-sequnce | Macro | Dump sequnce diagram to ps and png file             |
| &prog              | Macro | Define sequnce calls                                |
| &chain             | Macro | Define a call with sub calls                        |
| &if                | Macro | Define two alternative calls with a guard condition |
| &loop              | Macro | Defile a call in a loop with a guard condition      |



** Symbol for Graph Diagram

 | Symbol name           | Type                 | Description                                        |
 |-----------------------+----------------------+----------------------------------------------------|
 | dml-create-graph      | Macro                | Dump graph diagram to ps and png file.             |
 | full-class            | Function (node type) | Create a class node whih attributes and methods.   |
 | attributes, methods   | Function             | Define attribute/method list for the full-calss    |
 | simp-class            | Function (node type) | Return a class node with a simple name in the box. |
 | with-method           | Macro                | Create to define share methods for classes.        |
 | actor                 | Function (node type) | Create a stick man as actor.                       |
 | pack                  | Function (node type) | Create a package node.                             |
 | ucas                  | Function (node type) | Create use case node.                              |
 | comp                  | Function (node type) | Create component node                              |
 | @name                 | Function             | Reference pre-defined node by name                 |
 | -point-, -point-*     | Function (edge type) | Define a arrow edge: 1-to-1, 1-to-n                |
 | -dep-, -dep-*, -dep-- | Function (edge type) | Define dependcy edge: 1-to-1, 1-to-n, 1-by-1       |
 | -com-, com-*          | Function (edge type) | Define composition edge: 1-to-1, 1-to-n            |
 | -agg-, -agg-*         | Function (edge type) | Define a aggregation edge: 1-to-1, 1-to-n          |
 | -genby-,genby-*       | Function (edge type) | Define generalize edge: 1-to-1, 1-to-n             |



dml

Upstream URL

Author

License

dml

Version:

License:

Authors:

Dependencies:

Dependencies (4)

Dependents (0)