udon 0.0.3 → 0.0.4

data/Gemfile

@@ -12,5 +12,5 @@ group :development do
   gem "rcov", ">= 0"
   gem "reek", "~> 1.2.8"
   gem "roodi", "~> 2.1.0"
-  gem "genmachine", "~> 0.2.2"
+  gem "genmachine", "~> 0.2.4"
 end

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/lib/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/lib/udon/udon_parser.rb

@@ -22,18 +22,18 @@ class String
   def reset; d=dup;d.reset!;d end
 end
 
+class Array
+  def into(v); into!(v) unless size == 0 end
+  def into!(v); v << self end
+  def reset!; self.clear end
+  def reset; d=dup;d.reset!;d end
+end
 
 module UdonParser
   def self.parse(str) Parser.new(str).parse end
   def self.parse_file(fname) Parser.new(IO.read(fname)).parse end
 
 
-  class UArray < Array
-    def into(v); into!(v) unless size == 0 end
-    def into!(v); v << self end
-    def reset!; self.clear end
-    def reset; d=dup;d.reset!;d end
-  end
 
   class UHash < Hash
     def into!(v) v << self end
@@ -158,7 +158,7 @@ module UdonParser
 
     def document(p=nil,name='document')
       __state=':data_or_child'
-      s = UArray.new
+      s = []
       a ||= ''
       b ||= ''
       loop do
@@ -252,12 +252,14 @@ module UdonParser
             when nl?; __i.into(a); a.into(s.c.last); __state=':ident:nl'; next
             when !eof?; __i.into(a); __state=':ident:child'; next
             end
+        when ':ident:idret'
+            @fwd=true; id=['id',s.c.pop]; id.into(s.a); __state=':ident:nxt'; next
         when ':ident'
             case
             when (eof?); @fwd=true; error('er1'); return(retstate)
             when __i==9,space?; __state=':ident:nxt'; next
             when nl?; __state=':ident:nl'; next
-            when (__i>45&&__i<48),__i==123; @fwd=true; __state=':ident:nxt'; next
+            when __i==46,__i==91,__i==123; @fwd=true; __state=':ident:nxt'; next
             when !eof?; @fwd=true; __state=cstr(':ident:nameret',s); next
             end
         when ':ident:attr:val'
@@ -267,7 +269,8 @@ module UdonParser
         when ':ident:nxt'
             case
             when (eof?); @fwd=true; s.into(p); return(retstate)
-            when (__i>45&&__i<48),__i==123; error('nyi'); return(retstate)
+            when __i==91; __state=idstr(':ident:idret',s); next
+            when __i==46; error('nyi'); return(retstate)
             when nl?; __state=':ident:nl'; next
             when __i==9,space?; next
             when !eof?; @fwd=true; __state=cstr(':ident:a_or_c',s); next
@@ -290,63 +293,96 @@ module UdonParser
     end
 
     def cstr(retstate,p=nil,name='cstr')
+      nst=0
       __state=':first'
-      s = UArray.new
+      s = []
       a ||= ''
       b ||= ''
       loop do
         __i = nextchar
         case __state
-        when ':bt-dat'
+        when ':delimited:donecheck'
+            case
+            when (nst==0); @fwd=true; a.into!(p); return(retstate)
+            when !eof?; @fwd=true; ')'.into(a); __state=':delimited'; next
+            end
+        when ':delimited'
             case
-            when __i==96; a.into!(p); return(retstate)
+            when __i==92; __i.into(b); __state=':delimited:esc'; next
+            when __i==40; __i.into(a); nst+=1; next
+            when __i==41; nst-=1; __state=':delimited:donecheck'; next
             when !eof?; __i.into(a); next
             end
         when ':first'
             case
             when (eof?); @fwd=true; a.into!(p); return(retstate)
-            when __i==34; __state=':dq-dat'; next
-            when __i==39; __state=':sq-dat'; next
-            when __i==96; __state=':bt-dat'; next
+            when __i==40; nst=1; __state=':delimited'; next
             when nl?,(__i>8&&__i<11),space?; @fwd=true; a.into!(p); return(retstate)
-            when !eof?; __i.into(a); __state=':dat'; next
+            when !eof?; __i.into(a); __state=':normal'; next
             end
-        when ':dq-dat:esc'
+        when ':normal'
             case
-            when __i==116; "\t".into(a); __state=':dq-dat'; next
-            when __i==110; "\n".into(a); __state=':dq-dat'; next
-            when __i==114; "\r".into(a); __state=':dq-dat'; next
-            when __i==102; "\f".into(a); __state=':dq-dat'; next
-            when __i==98; "\b".into(a); __state=':dq-dat'; next
-            when __i==97; "\a".into(a); __state=':dq-dat'; next
-            when __i==101; "\e".into(a); __state=':dq-dat'; next
-            when __i==115; "\s".into(a); __state=':dq-dat'; next
-            when !eof?; __i.into(a); __state=':dq-dat'; next
+            when (eof?); @fwd=true; a.into!(p); return(retstate)
+            when __i==92; __i.into(b); __state=':normal:esc'; next
+            when nl?,(__i>8&&__i<11),space?,__i==46,__i==91; @fwd=true; a.into!(p); return(retstate)
+            when !eof?; __i.into(a); next
             end
-        when ':sq-dat'
+        when ':normal:esc'
             case
-            when __i==92; __state=':sq-dat:esc'; next
-            when __i==39; a.into!(p); return(retstate)
-            when !eof?; __i.into(a); next
+            when (eof?); @fwd=true; b.into(a); a.into!(p); return(retstate)
+            when __i==9,space?,__i==46,__i==91; __i.into(a); __state=':normal'; next
+            when !eof?; __i.into(b); b.into(a); __state=':normal'; next
             end
-        when ':dq-dat'
+        when ':delimited:esc'
             case
-            when __i==92; __state=':dq-dat:esc'; next
-            when __i==34; a.into!(p); return(retstate)
-            when !eof?; __i.into(a); next
+            when __i==92; __state=':delimited:esc:2'; next
+            when (__i>39&&__i<42); __i.into(a); __state=':delimited'; next
+            when !eof?; __i.into(b); b.into(a); __state=':delimited'; next
             end
-        when ':sq-dat:esc'
+        when ':delimited:esc:2'
             case
-            when __i==92; __i.into(a); __state=':sq-dat'; next
-            when __i==39; __i.into(a); __state=':sq-dat'; next
-            when !eof?; __i.into(b); '\\'.into(a); b.into(a); __state=':sq-dat'; next
+            when (__i>39&&__i<42); @fwd=true; b.into(a); __state=':delimited'; next
+            when !eof?; __i.into(b); '\\'.into(a); b.into(a); __state=':delimited'; next
             end
-        when ':dat'
+        end
+        error("Unexpected \"#{[__i].pack("U*")}\"")
+        @fwd = true
+        return
+      end
+    end
+
+    def idstr(retstate,p=nil,name='idstr')
+      nst=1
+      __state=':delimited'
+      s = []
+      a ||= ''
+      b ||= ''
+      loop do
+        __i = nextchar
+        case __state
+        when ':delimited:donecheck'
             case
-            when (eof?); @fwd=true; a.into!(p); return(retstate)
-            when nl?,(__i>8&&__i<11),space?; @fwd=true; a.into!(p); return(retstate)
+            when (nst==0); @fwd=true; a.into!(p); return(retstate)
+            when !eof?; @fwd=true; ']'.into(a); __state=':delimited'; next
+            end
+        when ':delimited'
+            case
+            when __i==92; __i.into(b); __state=':delimited:esc'; next
+            when __i==91; __i.into(a); nst+=1; next
+            when __i==93; nst-=1; __state=':delimited:donecheck'; next
             when !eof?; __i.into(a); next
             end
+        when ':delimited:esc'
+            case
+            when __i==92; __state=':delimited:esc:2'; next
+            when __i==91,__i==93; __i.into(a); __state=':delimited'; next
+            when !eof?; __i.into(b); b.into(a); __state=':delimited'; next
+            end
+        when ':delimited:esc:2'
+            case
+            when __i==91,__i==93; @fwd=true; b.into(a); __state=':delimited'; next
+            when !eof?; __i.into(b); '\\'.into(a); b.into(a); __state=':delimited'; next
+            end
         end
         error("Unexpected \"#{[__i].pack("U*")}\"")
         @fwd = true

data/machines/udon.machine

@@ -18,7 +18,7 @@
 
  Block comments
 +-----------------+-----------------+-----+-----------------+------------------------+
-| comment(retstate)::U |           |     | ibase=$indent+1 | :first:ws              |
+| comment(retstate)::U |            |     | ibase=$indent+1 | :first:ws              |
 :                 :                 :     : ipar=$indent    :                        :
 +-----------------+-----------------+-----+-----------------+------------------------+
 | :first:ws       | [ \t]           | >>  | ibase += 1      | :first:ws              |
@@ -45,16 +45,19 @@
 | :ident          | {eof?}          |     | error('er1')    | <retstate>             |
 | :ident          | [ \t]           | >>  |                 | :ident:nxt             |
 | :ident          | [\n]            | >>  |                 | :ident:nl              |
-| :ident          | [./{]           |     |                 | :ident:nxt             |
+| :ident          | [.{\[]          |     |                 | :ident:nxt             |
 | :ident          | .               |     |                 | cstr(:ident:nameret)   |
 | :ident:nameret  |                 |     | s.name>>        | :ident:nxt             |
 :                 :                 :     : s.c.pop>>s.name :                        :
 +-----------------+-----------------+-----+-----------------+------------------------+
 | :ident:nxt      | {eof?}          |     | s>>p            | <retstate>             |
-| :ident:nxt      | [./{]           | >>  | error('nyi')    | <retstate>             |
+| :ident:nxt      | [\[]            | >>  |                 | idstr(:ident:idret)    |
+| :ident:nxt      | [.]             | >>  | error('nyi')    | <retstate>             |
 | :ident:nxt      | [\n]            | >>  |                 | :ident:nl              |
 | :ident:nxt      | [ \t]           | >>  |                 | :ident:nxt             |
 | :ident:nxt      | .               |     |                 | cstr(:ident:a_or_c)    |
+| :ident:idret    |                 |     | id=['id',s.c.pop] | :ident:nxt           |
+:                 :                 :     : id>>s.a         :                        : # two lines here because of genmachine defect
 +-----------------+-----------------+-----+-----------------+------------------------+
 | :ident:nl       | {eof?}          |     | error('er3')    | <retstate>             |
 | :ident:nl       | [ \t]           | >>  |                 | :ident:nl              |
@@ -81,41 +84,52 @@
 
  Basic Control Strings
 +-----------------+-----------------+-----+-----------------+------------------------+
-| cstr(retstate)  |                 |     |                 | :first                 |
+| cstr(retstate)  |                 |     | nst=0           | :first                 |
 | :first          | {eof?}          |     | a>>>p           | <retstate>             |
-| :first          | ["]             | >>  |                 | :dq-dat                |
-| :first          | [']             | >>  |                 | :sq-dat                |
-| :first          | [`]             | >>  |                 | :bt-dat                |
+| :first          | [(]             | >>  | nst=1           | :delimited             |
 | :first          | [ \t\n]         |     | a>>>p           | <retstate>             |
-| :first          | .               | >>a |                 | :dat                   |
-+-----------------+-----------------+-----+-----------------+------------------------+
-| :dat            | {eof?}          |     | a>>>p           | <retstate>             |
-| :dat            | [ \t\n]         |     | a>>>p           | <retstate>             |
-| :dat            | .               | >>a |                 | :dat                   |
-+-----------------+-----------------+-----+-----------------+------------------------+
-| :dq-dat         | [\\]            | >>  |                 | :dq-dat:esc            |
-| :dq-dat         | ["]             | >>  | a>>>p           | <retstate>             |
-| :dq-dat         | .               | >>a |                 | :dq-dat                |
-+-----------------+-----------------+-----+-----------------+------------------------+
-# TODO: move these to a separate metachar function?
-| :dq-dat:esc     | [t]             | >>  | "\t">>a         | :dq-dat                |
-| :dq-dat:esc     | [n]             | >>  | "\n">>a         | :dq-dat                |
-| :dq-dat:esc     | [r]             | >>  | "\r">>a         | :dq-dat                |
-| :dq-dat:esc     | [f]             | >>  | "\f">>a         | :dq-dat                |
-| :dq-dat:esc     | [b]             | >>  | "\b">>a         | :dq-dat                |
-| :dq-dat:esc     | [a]             | >>  | "\a">>a         | :dq-dat                |
-| :dq-dat:esc     | [e]             | >>  | "\e">>a         | :dq-dat                |
-| :dq-dat:esc     | [s]             | >>  | "\s">>a         | :dq-dat                |
-| :dq-dat:esc     | .               | >>a |                 | :dq-dat                |
-+-----------------+-----------------+-----+-----------------+------------------------+
-| :sq-dat         | [\\]            | >>  |                 | :sq-dat:esc            |
-| :sq-dat         | [']             | >>  | a>>>p           | <retstate>             |
-| :sq-dat         | .               | >>a |                 | :sq-dat                |
-+-----------------+-----------------+-----+-----------------+------------------------+
-| :sq-dat:esc     | [\\]            | >>a |                 | :sq-dat                |
-| :sq-dat:esc     | [']             | >>a |                 | :sq-dat                |
-| :sq-dat:esc     | .               | >>b | '\\'>>a; b>>a   | :sq-dat                |
-+-----------------+-----------------+-----+-----------------+------------------------+
-| :bt-dat         | [`]             | >>  | a>>>p           | <retstate>             |
-| :bt-dat         | .               | >>a |                 | :bt-dat                |
+| :first          | .               | >>a |                 | :normal                |
++-----------------+-----------------+-----+-----------------+------------------------+
+| :delimited      | [\\]            | >>b |                 | :delimited:esc         |
+| :delimited      | [(]             | >>a | nst+=1          | :delimited             |
+| :delimited      | [)]             | >>  | nst-=1          | :delimited:donecheck   |
+| :delimited      | .               | >>a |                 | :delimited             |
++-----------------+-----------------+-----+-----------------+------------------------+
+| :delimited:donecheck | {nst==0}   |     | a>>>p           | <retstate>             |
+| :delimited:donecheck | .          |     | ')'>>a          | :delimited             |
++-----------------+-----------------+-----+-----------------+------------------------+
+| :delimited:esc  | [\\]            | >>  |                 | :delimited:esc:2       |
+| :delimited:esc  | [()]            | >>a |                 | :delimited             | # Escaped parenths
+| :delimited:esc  | .               | >>b | b>>a            | :delimited             |
++-----------------+-----------------+-----+-----------------+------------------------+
+| :delimited:esc:2 | [()]           |     | b>>a            | :delimited             | # Escaped backslash before parenths -> \ and actual (
+| :delimited:esc:2 | .              | >>b | '\\'>>a; b>>a   | :delimited             | # Just two backslashes, moving on
++-----------------+-----------------+-----+-----------------+------------------------+
+| :normal         | {eof?}          |     | a>>>p           | <retstate>             |
+| :normal         | [\\]            | >>b |                 | :normal:esc            |
+| :normal         | [\[\s\n\t.]     |     | a>>>p           | <retstate>             |
+| :normal         | .               | >>a |                 | :normal                |
++-----------------+-----------------+-----+-----------------+------------------------+
+| :normal:esc     | {eof?}          |     | b>>a; a>>>p     | <retstate>             |
+| :normal:esc     | [\[\s\t.]       | >>a |                 | :normal                |
+| :normal:esc     | .               | >>b | b>>a            | :normal                |
++-----------------+-----------------+-----+-----------------+------------------------+
+
+ ID Strings - like cstr but with square brackets
++-----------------+-----------------+-----+-----------------+------------------------+
+| idstr(retstate) |                 |     | nst=1           | :delimited             |
+| :delimited      | [\\]            | >>b |                 | :delimited:esc         |
+| :delimited      | [\[]            | >>a | nst+=1          | :delimited             |
+| :delimited      | [\]]            | >>  | nst-=1          | :delimited:donecheck   |
+| :delimited      | .               | >>a |                 | :delimited             |
++-----------------+-----------------+-----+-----------------+------------------------+
+| :delimited:donecheck | {nst==0}   |     | a>>>p           | <retstate>             |
+| :delimited:donecheck | .          |     | ']'>>a          | :delimited             |
++-----------------+-----------------+-----+-----------------+------------------------+
+| :delimited:esc  | [\\]            | >>  |                 | :delimited:esc:2       |
+| :delimited:esc  | [\[\]]          | >>a |                 | :delimited             | # Escaped parenths
+| :delimited:esc  | .               | >>b | b>>a            | :delimited             |
++-----------------+-----------------+-----+-----------------+------------------------+
+| :delimited:esc:2 | [\[\]]         |     | b>>a            | :delimited             | # Escaped backslash before parenths -> \ and actual [
+| :delimited:esc:2 | .              | >>b | '\\'>>a; b>>a   | :delimited             | # Just two backslashes, moving on
 +-----------------+-----------------+-----+-----------------+------------------------+

data/test/helper.rb

@@ -86,10 +86,20 @@ def randstr(avg_length, char_dists = nil)
       end
     end
   end
+  return fix_utf8(ret)
+end
+
+def fix_utf8(str)
   # (To fix iconv bug: cr http://po-ru.com/diary/fixing-invalid-utf-8-in-ruby-revisited/ )
-  ret = ret + ' '
-  Iconv.iconv('UTF-8//IGNORE', 'UTF-8', ret)
-  return ret[0..-2]
+  str = str + ' '
+  Iconv.iconv('UTF-8//IGNORE', 'UTF-8', str)
+  return str[0..-2]
+end
+
+def udon_safe(str)
+  str.gsub! /^(\s*)(#|\|)/u, '\\1\\\\\2'
+  str.gsub! /(\||!)\{/u, '\\1{{'
+  str + "\n"
 end
 
 class MiniTest::Unit::TestCase

data/test/test_udon.rb

@@ -2,7 +2,6 @@ require 'helper'
 $KCODE='U'
 
 class TestUdon < MiniTest::Unit::TestCase
-  TRIGGER_UDON = /(^\s*(#|\||<).*$|<\||<:)/u
   WHITESPACE   = "      \t\n\r"
 
   def test_blank_documents
@@ -19,7 +18,7 @@ class TestUdon < MiniTest::Unit::TestCase
 
   def test_passthru_documents
     (0..3).each do
-      s = randstr(100).gsub(TRIGGER_UDON,'')
+      s = udon_safe(randstr(100))
       ##############
       assert_equal       s,                     s.udon.join('')
       ##############
@@ -62,8 +61,8 @@ class TestUdon < MiniTest::Unit::TestCase
   end
 
   def test_block_comment_in_passthru
-    leading = randstr(200).gsub(TRIGGER_UDON,'') + "\n"
-    following = randstr(200).gsub(TRIGGER_UDON,'')
+    leading = udon_safe(randstr(200))
+    following = udon_safe(randstr(200))
     comment = <<-COMMENT
       # the-comment
       and back to normal
@@ -92,55 +91,241 @@ class TestUdon < MiniTest::Unit::TestCase
     ##############
   end
 
-  def test_node_name
-    ##############
-    assert_equal         'hello-there!',        '|hello-there!'.udon[0].name
-    assert_equal         "hello there!\t",      '|"hello there!\t"'.udon[0].name
-    assert_equal         'hello there!\t',      "|'hello there!\\t'".udon[0].name
-    assert_equal         'hello there!\t',      '|`hello there!\t`'.udon[0].name
-    ##############
+  def test_node_name_undelimited_cstring
+    (0..20).each do
+      name = randstr(50).unpack("U*")
+      name = name - [0x0b, 0x0c, 0x85, 0x2028, 0x2029, 0x0a, 0x0d] # No newlines
+      name = name - [0x20, 0x09]                                   # No spaces
+      name = name - '[|.'.unpack("U*")                             # No [ or |
+      name << '-'[0] if name.last == '\\'[0]                       # Make sure it doesn't end with a \
+      name.unshift('-'[0]) if name.first == '{'[0]                 # Make sure it doesn't start with a {
+      name.unshift('-'[0]) if name.first == '('[0]                 # Make sure it doesn't start with a (
+      name = name.pack("U*")
+      name = 'node' if name.length == 0                            # Make sure it is not blank
+      assert_equal name, "|#{name} a".udon[0].name
+    end
   end
 
-  def test_node_name_with_inline_children
-    ##############
-    assert_equal         'hello-there!',        '|hello-there! c'.udon[0].name
-    assert_equal         "hello there!\t",      '|"hello there!\t" c'.udon[0].name
-    assert_equal         'hello there!\t',      "|'hello there!\\t' c".udon[0].name
-    assert_equal         'hello there!\t',      '|`hello there!\t` c'.udon[0].name
-    ##############
+  def test_node_name_delimited_cstring
+    (0..20).each do
+      name = randstr(50).gsub(/\(|\)/u,'').scan(/./u)
+      # Inject some balanced parenthases
+      (0..rand(10)).each do
+        pos1 = rand(name.size)
+        pos2 = rand(name.size - pos1) + pos1 + 1
+        unless name[pos1-1]=="\\" || name[pos2-1]=="\\"
+          name = name.insert(pos2,')').insert(pos1,'(')
+        end
+      end
+      name << ' ' if name.last=='\\'
+      name = name.join('')
+      assert_equal name, "|(#{name}) a".udon[0].name
+    end
   end
 
-  def test_node_name_with_nextline_children
-    ##############
-    assert_equal         'hello-there!',        "|hello-there!\nc".udon[0].name
-    assert_equal         "hello there!\t",      "|\"hello there!\\t\"\nc".udon[0].name
-    assert_equal         'hello there!\t',      "|'hello there!\\t'\nc".udon[0].name
-    assert_equal         'hello there!\t',      "|`hello there!\\t`\nc".udon[0].name
-    ##############
+  def test_node_id_after_name
+    assert_equal 'my id!', "|this-node[my id!]".udon[0].a['id']
   end
 
-SCRATCH=<<-SCRATCH
+=begin
 
-|one         # Sets ipar
- a:b         # no base
-   c:d       # no base
-  e:f        # no base
-      g h i  # sets base to indent
+--------------------------- TODO
+---- MISC
+ [ ] - Change passthru tests so they replace udon triggers w/ escaped triggers
+       instead of removing the line.
 
-|one blah    # Sets ipar to indent
-  asdf       # sets base to indent
+---- TOP LEVEL DATA
+ [ ] - Lines beginning with `|` or `#` must be escaped
+ [ ] - Any internal `|{...` or `!{...` must be escaped by doubling the { to
+       pass it through literally
 
-# SO: first non-ident non-inline child sets base (or its own ipar)
+---- BLOCK-COMMENTS
+
+---- BASIC DATA (children)
+ [ ] - Rules for top level data apply
+ [ ] - Started with a `| `
+ [ ] - Leading whitespace for first node is not retained and sets base
+ [ ] - If the data is on the same line as the node began, any isolated hash
+       marks it wants to retain also need to be escaped or they become EOL
+       comments.
+ [ ] - Full embeds
+
+---- SPECIAL DATA children
+ [ ] - Special Basic `|'` -- Same as basic but no EOL comments and can have
+       leading space.
+ [ ] - Special String `|"`
+   [ ] - Metachars
+   [ ] - Full embeds
+
+---- DATA NODES
+ [d] - Triggered with '|'
+ [d] - (Inline) Name (control-string)
+ [ ] - Inline ID (bracketed-string - like control-string but w/ required square delims)
+ [ ] - Nextline ID
+ [ ] - Inline Tags (control-strings starting with '.')
+ [ ] - Nextline Tags
+ [ ] - Inline attributes no whitespace values
+ [ ] - Inline attributes w/ values w/ whitespaces
+ [ ] - Inline EOL comments
+ [ ] - 
+
+--------------------------- NOTES
+---- EOL COMMENTS
+     * Only available on lines that begin w/ `|` or `:` unless it's an
+       anonymous (!') pipe.
+     * The hash mark must have a space before it
+
+---- BUILT-IN 
+
+
+
+---------------------------- SCRATCH
+# Normal udon-level comment
+|# Application-defined block comment (such as html comments)
+!# 
+
+First class data; only embeds allowed, no inline comments, no metacharacters
+First class => (document text) == `!'` == `| `
+CString => (...) in ident == `!"` well, `!{"  "}`
+
+|something :one two| three
+  four
+
+*** Attribute values must escape their pipes if not delimited
+*** Allow parenthasese to delimit values w/ whitespaces
+*** Attribute values extend to next `\s:`, `|`, or newline, or are delimited by () (balanced inner)
+*** To start child text w/ whitespace, escape the first whitespace:
+    |blah \   I'm indented quite a bit
+
+
+ * Make sure attributes can easily be ruby symbols - start with :
+   -     ::blahspace:url http://example.com:80:
+
+|node :a1 v1
+  :'a 2' v 2
+  
+
+|node >|another asdf:2 > bcdg:2
+
+
+|node normal children
+  blah blah blah
+
+|(another-node kajsdf jewifowe) asdf
+  normal children blah blah blah
 
+|yet-another-node
+  !"child with some metachars \n \t to think about
+    but no need to have an ending quote, because that's determined by the
+    indent
+  !'and another child !{`with an embedded string`}
 
 
-|asdf
-  `howdy fejw ioafj weifj <:oawj:> fa weoi`: kvjjfejiwo
-  `howdy fejw ioafj weifj <:oawj:> fa weoi` kvjjfejiwo
+first class text
+|node also first class text
+  just with a different baseline
+  (at least once it gets to the line above this one)
+  and when I want something special I just do an
+  embedded !{'something or other'}
 
 
+!'blah blah blah'
 
+|div.red.ugly.blah[leftcol]
+|.blah[heya].torn.(fejwio fjeiwo).jfeiwo.(j fjeiwo fejiofjwe f)
+|[geo].trans
+
+|===[hm jfeiwo fei]
+
+|(t > fjeio:[blah=feio], fjeiwo)[13th of id]
+  :(something this way) (george the carpenter)
+
+--OR--
+
+
+|my-awesome-node (The blah and blah)   # Comments allowed because child is inline
+
+command-string:
+  NAME, (.)TAGS, (*)ID, ATTRIBUTE-NAMES(:), & (sometimes) ATTRIBUTE-VALUES
+  - NOT available for children... children that start with a paren need to escape it(?)
+  - no whitespace if no delimiter or escaped spaces (usually single word)
+  - value embeds available; must evaluate to a string
+  - delimited by () - can contain them also as long as they're balanced
+  - preserves whitespace(?)
+
+value-string:
+  VALUE-EMBEDS, 
+
+
+|  -> node (values accumulate)
+:  -> attribute (values override)
+!  -> directive - inject result
+!- -> directive, ignore result
+(.)-> text (or, if inline, possibly simple-value)
+
+|{...}
+!{...}
+!{-...} ignore result
+!{'...'}
+!{"..."}
+!{`...`}
+
+|name[id].tag.tag2
+
+|hello
+  I hope this message finds you well, Mr. !{$blah}
+  !urlencode
+
+INLINE
+|asdf |bcal
+  |child of bcal always
+
+|asdf |bcal this
+  sentence continues here below
+
+|asdf |bcal but
+this is now a sibling (obviously) of |asdf
+
+|house
+  :fixtures
+    :south 12
+    :north 14
+  :color
+    :summer green  # Comment allowed
+    :winter
+      white # Comment not allowed - this is part of the text
+    :something\ else blah
+  simple value
+  and some more
+  muahaha
+  |something
+    :strange
+      |good[1]
+      |good[2]
+
+|house 
+
+
+
+INLINES
+  * Goes depth-wise  `|a |b |c d` == `<|a <|b <|c d|>|>|>`
+  * Carries over to the next line (indented children of `|a |b |c` are children of `|c`
+
+
+
+----------------------------
+
+|one         # Sets ipar
+ a: b        # no base
+   c: d      # no base
+  e: f       # no base
+      g h i  # sets base to indent
+
+|one blah    # Sets ipar to indent
+  asdf       # sets base to indent
+
+# SO: first non-ident non-inline child sets base (or its own ipar)
 
-SCRATCH
+=end
 
 end

data/udon.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{udon}
-  s.version = "0.0.3"
+  s.version = "0.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Joseph Wecker"]
-  s.date = %q{2011-08-20}
+  s.date = %q{2011-08-23}
   s.description = %q{Parse and generate udon, inspired by zml, haml, json, and more.}
   s.email = %q{joseph.wecker@gmail.com}
   s.extra_rdoc_files = [
@@ -47,7 +47,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<rcov>, [">= 0"])
       s.add_development_dependency(%q<reek>, ["~> 1.2.8"])
       s.add_development_dependency(%q<roodi>, ["~> 2.1.0"])
-      s.add_development_dependency(%q<genmachine>, ["~> 0.2.2"])
+      s.add_development_dependency(%q<genmachine>, ["~> 0.2.4"])
     else
       s.add_dependency(%q<minitest>, [">= 0"])
       s.add_dependency(%q<bundler>, ["~> 1.0.0"])
@@ -55,7 +55,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<rcov>, [">= 0"])
       s.add_dependency(%q<reek>, ["~> 1.2.8"])
       s.add_dependency(%q<roodi>, ["~> 2.1.0"])
-      s.add_dependency(%q<genmachine>, ["~> 0.2.2"])
+      s.add_dependency(%q<genmachine>, ["~> 0.2.4"])
     end
   else
     s.add_dependency(%q<minitest>, [">= 0"])
@@ -64,7 +64,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<rcov>, [">= 0"])
     s.add_dependency(%q<reek>, ["~> 1.2.8"])
     s.add_dependency(%q<roodi>, ["~> 2.1.0"])
-    s.add_dependency(%q<genmachine>, ["~> 0.2.2"])
+    s.add_dependency(%q<genmachine>, ["~> 0.2.4"])
   end
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: udon
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: 
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Joseph Wecker
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-20 00:00:00 -07:00
+date: 2011-08-23 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -116,12 +116,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 19
+        hash: 31
         segments: 
         - 0
         - 2
-        - 2
-        version: 0.2.2
+        - 4
+        version: 0.2.4
   name: genmachine
   version_requirements: *id007
   prerelease: false