"""
    This is all valid syntax in my shiny new 
    domain specific language, implemented in Python.

    >>> put("jason").into.element.named("username")
    >>> put("jason").into.element.labeled("username")      
    >>> put("jason").into.element.identified.by("username")

    ...or...    
    >>> put("jason").into.element(name="username")
    >>> put("jason").into.element(label="username")
    >>> put("jason").into.element(id="username")

    ...and don't forget...
    >>> get.button.named("submit")
    >>> click.it()


    For "advanced stuff", you could do this, too:
    >>> xpath_expr = "//table[@id='table1']//tr[4]/td[2]"
    >>> put("1234").into.element.identified.by(xpath_expr)

"""

# Here's the implementation:

# Built-in commands:
def put        (*args, **kwargs): return put
def get        (*args, **kwargs): return get
def click      (*args, **kwargs): return click

# Built-in page objects:
def element    (*args, **kwargs): pass
def field      (*args, **kwargs): pass   
def button     (*args, **kwargs): pass

# Properties of a page object:
def named      (*args, **kwargs): pass
def labeled    (*args, **kwargs): pass
def identified (*args, **kwargs): pass
def by         (*args, **kwargs): pass

# Prepositions treated as whitespace
def into       ()               : pass

# "Helper" nouns:
def it         ()               : pass


# Now let's define the "grammar"!
# Command grammar
put.__dict__        = { 'into'    :into,
                        'element' :element, 
                        'field'   :field,
                        'button'  :button}

get.__dict__        = put.__dict__                

click.__dict__      = { 'it':it } 


# Object grammar
element.__dict__    = { 'named'      :named,
                        'labeled'    :labeled,
                        'identified' :identified }
button.__dict__ = element.__dict__ 

identified.__dict__ = { 'by': by}

# Preposition grammar                            
into.__dict__       = { 'element': element}  

What does all this code mean?

I just defined a new domain specific language for scripting and testing web pages (like we need another one, I know!). And I did this without having to write a new parser or learning Backus Naur Form. If you step way back and squint your eyes, though, all that “dict = * ” business does look like BNF notation a little.

Separating tokens by dots instead of whitespace makes this pretty easy to define and parse. Also, by using dots, IDE’s are already tuned to give you a list of valid tokens in a drop-down menu when you type each “dot”. The big down side though is tripping on reserved words. For example, I would get a syntax error if I tried to write “my.dsl.is.the.coolest.in.the.world” because “is” and “in” are reserved words in Python. I don’t know if that will become a show-stopper down the road.

A slightly cool thing about my little DSL is that it is valid syntax in C#, C++, Java, Ruby, Python, JavaScript, Groovy, and Lua. (Dear LazyWeb, call me out here if I’m wrong on this point! And feel free to add to my list, too.) My DSL can now become a library for those other languages. When it comes time to add the “hard stuff” to my DSL, though, (e.g. loops, conditionals, objects, functions, etc.), I won’t have to because I automatically inherit the capabilities of the “parent” language.

The current code is just a shell, of course. Now I have to figure out how to translate it into stuff that actually does something. A simple matter of programming, right? :-)

I figured I’d post this, though, ’cause these days, Ruby fans are going ga-ga for DSLs. And they love to go on and on about how Ruby is just about the most wonderful and amazing language for creating DSLs that ever walked (or ever will walk) the face of the earth. As a Python (and not ashamed to admit it–JavaScript) developer, you can understand my knee-jerk reaction to say “But, But!!! Python can do that, too!” And with my fancy “Dot Notational Domain Specific Language Toolkit”, I now have some ammunition with which to fight back the onslaught of a million rabid Ruby/DSL fans. (Throw Lisp and Tcl in there, too, since those dudes throw around the phrase “DSL” alot, as well.)

Actually, I give major props to the Rails and Ruby communities for pushing DSLs mainstream. I didn’t really “get” LISP, Scheme, Tcl, and Rexx, etc. until recently when I realized that those languages were really tuned for creating DSLs. I also finally “got” that those languages sucked, too, because there’s an inherent “glass ceiling” to doing non-DSL development in those languages. By writing a DSL inside a general purpose language (like Python or Ruby), there’s no glass ceiling, only sky’s-the-limit goodness. At this point, I should stop, because Martin Fowler explains this aspect of DSLs way better in this post on his blog.

Now that we’re living in a post Ajax world, I need a catchy acronym for this technique. I’m tempted to call this “DDD” or “Triple D” as in — “DDD is all about using Dots for DSLs”. What do you think? Have you “Triple D’d” your app today?

• Jason

P.S. After a little googling around, it looks like these guys “Do the ‘D’” quite well.