nora_mark 0.2beta3 → 0.2beta4

data/lib/nora_mark/parser.kpeg

@@ -1,123 +1,177 @@
 %% name = NoraMark::Parser
 
-# literals
-eof = !.
-space = ' ' | '\t' 
-eof_comment = lh space* "#" (!eof .)*
-comment =   lh space* "#" (!nl .)* nl empty_line*
-- =  ( space | comment )*
-empty_line = lh - nl
-nl = /\r?\n/
-lh = /^/
-le = nl | eof
-word  = < /[\w0-9]/ ( '-' | /[\w0-9]/ )* >  { text }
-num = < [0-9]+ > { text.to_i }
+%% ast-location = ::NoraMark
+%% text = ast Text(content)
+%% paragraph = ast Paragraph(ids, classes, parameters, content)
+%% paragraph_group = ast ParagraphGroup(ids, classes, parameters, content)
+%% br = ast Breakline()
+%% line_command = ast LineCommand(name, ids, classes, parameters, content)
+%% block = ast Block(name, ids, classes, parameters, content)
+%% newpage = ast Newpage(ids, classes, parameters, content)
+%% inline = ast Inline(name, ids, classes, parameters, content)
+%% ul_item = ast UlItem(ids, classes, parameters, content)
+%% unordered_list = ast UnorderedList(ids, classes, parameters, content)
+%% ol_item = ast OlItem(ids, classes, parameters, content)
+%% ordered_list = ast OrderedList(ids, classes, parameters, content)
+%% dl_item = ast DLItem(ids, classes, parameters, content)
+%% definition_list = ast DefinitionList(ids, classes, parameters, content)
+%% preformatted_block = ast PreformattedBlock(name, ids, classes, parameters, codelanguage, content)
+%% frontmatter = ast Frontmatter(content)
+%% h_section = ast HeadedSection(level, heading, content)
+%% page = ast Page(content)
 
+# literals
+Eof = !. 
+Space = ' ' | '\t' 
+EofComment = Space* "#" (!Eof .)* 
+Comment =   Space* "#" (!Nl .)* Nl EmptyLine*
+- =  ( Space )* 
+EmptyLine = /^/ - (Nl | Comment | EofComment)
+Nl = /\r?\n/
+Le = Nl | Eof
+Word  = < /[\w0-9]/ ( '-' | /[\w0-9]/ )* >  { text }
+Num = < [0-9]+ > { text.to_i }
 
 #common syntax
-classname = '.' word:classname { classname }
-classnames = (classname)*:classnames { classnames }
-idname = '#' word:idname { idname }
-idnames = (idname)*:idnames { idnames }
-
-commandname = word:name idnames?:idnames classnames?:classes  { {:name => name, :ids => idnames, :classes => classes} }
-parameter = < ( /[^,)]/* | '"' /[^"]/* '"' | "'" /[^']/* "'" ) > { text }
-parameters = < parameter (',' parameter)* > { text }
-command = commandname:cn ('(' - parameters:arg - ')')? { arg ||= ''; cn.merge({ :args => arg.split(',') }) }
+ClassName = '.' Word:classname { classname }
+ClassNames = (ClassName)*:classnames { classnames }
+IdName = '#' Word:idname { idname }
+IdNames = (IdName)*:idnames { idnames }
+
+CommandName = Word:name IdNames?:idnames ClassNames?:classes  { {name: name, ids: idnames, classes: classes} }
+ParameterNormal = < /[^,)]/* > { text }
+ParameterQuoted = '"' < /[^"]/* > '"' - &/[,)]/  { text }
+ParameterSingleQuoted = "'" < /[^']/* > "'" - &/[,)]/ { text }
+Parameter = (ParameterQuoted | ParameterSingleQuoted | ParameterNormal ):value { value }
+Parameters = Parameter:parameter (',' - Parameter)*:rest_parameters { [parameter] + rest_parameters }
+Command = CommandName:cn ('(' - Parameters:args - ')')? { args ||= []; cn.merge({ args: args }) }
 
 # paragraph
-implicit_paragraph = < (!paragraph_delimiter - documentline:p -) > { create_item(:paragraph, nil, p, raw: text) }
-paragraph = explicit_paragraph | implicit_paragraph 
+ImplicitParagraph = - !ParagraphDelimiter Comment* DocumentLine:content  Comment* EofComment? ~paragraph([],[], [], content)
+Paragraph = ExplicitParagraph | ImplicitParagraph 
 
 # paragraph_group
-paragraph_group = < paragraph+:p empty_line* > { create_item(:paragraph_group, nil, p, raw: text) }
+ParagraphGroup = Paragraph+:p EmptyLine* ~paragraph_group([],[],[],p)
 
 # explicit block 
-blockhead = lh - command:command - '{' - nl empty_line* { command }
-blockend = lh - '}' - le empty_line*
-blockbody = (!blockend block)+:body { body } 
-explicit_block = < blockhead:head - blockbody:body - blockend > { create_item(:block, head, body, raw: text) }
+BlockHead = - Command:command - '{' - Nl EmptyLine* { command }
+BlockEnd =  - '}' - Le EmptyLine*
+BlockBody = (!BlockEnd Block)+:body { body } 
+ExplicitBlock = BlockHead:c - BlockBody:content - BlockEnd ~block(c[:name], c[:ids], c[:classes], c[:args], content)
 
 # preformatted block
-preformatted_command = command:command &{ ['pre', 'precode'].include? command[:name] }
-preformatted_command_head = lh - preformatted_command:command - '<<' &/[\w0-9]/ { command }
-preformat_end(start) = lh word:delimiter &{ delimiter == start }
-preformatted_block = < lh - preformatted_command_head:command !nl word:delimiter nl (!preformat_end(delimiter) (lh charstring nl))+:content preformat_end(delimiter) > { create_item(:preformatted, command, content, raw: text) }
+PreformattedCommand = Command:command &{ ['pre', 'code'].include? command[:name] }
+PreformattedCommandHeadSimple = - PreformattedCommand:command - '{' - Nl { command }
+PreformattedCommandHeadComplex = - PreformattedCommand:command - '{//' Word?:codelanguage - Nl { command.merge({codelanguage: codelanguage}) }
+PreformattedCommandHead = PreformattedCommandHeadComplex | PreformattedCommandHeadSimple
+PreformatEndSimple = - '}' - Le EmptyLine*
+PreformatEndComplex = - '//}' - Le EmptyLine*
+
+PreformattedBlockSimple = PreformattedCommandHeadSimple:c (!PreformatEndSimple (CharString Nl))+:content PreformatEndSimple
+                        ~preformatted_block(c[:name], c[:ids], c[:classes], c[:args], c[:codelanguage], content)
+
+PreformattedBlockComplex = PreformattedCommandHeadComplex:c (!PreformatEndComplex (CharString Nl))+:content PreformatEndComplex
+                        ~preformatted_block(c[:name], c[:ids], c[:classes], c[:args], c[:codelanguage], content)
+
+PreformattedBlock = PreformattedBlockComplex | PreformattedBlockSimple
 
 # inline command
-inline = img_inline | common_inline
-common_inline = < '[' command:c '{' documentcontent_except('}'):content '}' ']' > { create_item(:inline, c, content, raw: text) }
-img_command = command:c &{ c[:name] == 'img' && c[:args].size == 2}
-img_inline = < '[' img_command:c  ']' > { create_item(:inline, c, nil, raw: text) } 
+Inline = ImgInline | CommonInline
+CommonInline = '[' Command:c '{' - DocumentContentExcept('}'):content '}' ']' ~inline(c[:name], c[:ids], c[:classes], c[:args], content)
+ImgCommand = Command:c &{ c[:name] == 'img' && c[:args].size == 2}
+ImgInline = '[' ImgCommand:c  ']' ~inline(c[:name], c[:ids], c[:classes], c[:args], nil)
 
 # special line commands
-commandname_for_special_line_command = newpage_command | explicit_paragraph_command
+CommandNameForSpecialLineCommand = NewpageCommand | ExplicitParagraphCommand
 
 # newpage
-newpage_command = command:command &{ command[:name] == 'newpage' }
-newpage = < lh - newpage_command:c ':' documentcontent?:content - nl > { create_item(:newpage, c, content, raw:text) }
+NewpageCommand = Command:command &{ command[:name] == 'newpage' }
+Newpage = - NewpageCommand:c ':' - DocumentContent?:content - Nl ~newpage(c[:ids],c[:classes],c[:args], content)
 
 # explicit paragraph
-explicit_paragraph_command = command:c &{ c[:name] == 'p' }
-explicit_paragraph = < lh - explicit_paragraph_command:c ':' documentcontent?:content le empty_line*> { create_item(:paragraph, c, content, raw:text) }
+ExplicitParagraphCommand = Command:c &{ c[:name] == 'p' }
+ExplicitParagraph = - ExplicitParagraphCommand:c ':' - DocumentContent?:content Le EmptyLine* ~paragraph(c[:ids], c[:classes], c[:args], content)
 
 
 # unordered list
-unordered_list = < unordered_item+:items > { create_item(:ul, nil, items, raw: text) }
-unordered_item = < lh '*:' documentcontent:content le > { create_item(:li, nil, content, raw: text) }
+UnorderedList = UnorderedItem+:items ~unordered_list([],[],[], items)
+UnorderedItem = '*:' - DocumentContent:content Le ~ul_item([], [], [], content)
 
 # ordered list
-ordered_list = < ordered_item+:items > { create_item(:ol, nil, items, raw: text) }
-ordered_item = < lh num ':' documentcontent:content le > { create_item(:li, nil, content, raw: text) }
+OrderedList = OrderedItem+:items ~ordered_list([],[],[], items)
+OrderedItem = Num ':' - DocumentContent:content Le ~ol_item([], [], [], content)
 
 # definition list
-definition_list = < definition_item+:items > { create_item(:dl, nil, items, raw: text) }
-definition_item = < lh ';:' - documentcontent_except(':'):term ':' - documentcontent:definition le > { create_item(:dtdd, {:args => [term, definition]}, nil, raw: text) }
+DefinitionList = DefinitionItem+:items ~definition_list([], [], [], items)
+DefinitionItem = - ';:' - DocumentContentExcept(':'):term ':' - DocumentContent:definition Le ~dl_item([], [], [term], definition)
 
-items_list = unordered_list | ordered_list | definition_list
+# long definition list
+LongDefinitionList = LongDefinitionItem+:items ~definition_list([], [], [], items)
+LongDefinitionItem = - ';:' - DocumentContentExcept('{'):term '{' - Nl - BlockBody:definition - BlockEnd ~dl_item([], [], [term], definition)
+
+ItemsList = UnorderedList
+          | OrderedList
+          | DefinitionList
+          | LongDefinitionList
 
 
 # generic line command
-line_command = < lh - !commandname_for_special_line_command command:c ':' documentcontent?:content - le empty_line* > { create_item(:line_command, c, content, raw: text) }
+LineCommand = - !CommandNameForSpecialLineCommand Command:c ':' - DocumentContent?:content - Le EmptyLine*  ~line_command(c[:name], c[:ids], c[:classes], c[:args], content)
 
 # blocks
-line_block =  items_list | line_command 
-block = (preformatted_block | headed_section | line_block  | explicit_block | paragraph_group ):block empty_line* {block}
-block_delimiter = blockhead | blockend 
-paragraph_delimiter = block_delimiter | preformatted_command_head | line_block | newpage | headed_start
+LineBlock =  ItemsList | LineCommand 
+Block = EmptyLine*
+       (PreformattedBlock
+       | HeadedSection
+       | LineBlock 
+       | ExplicitBlock
+       | ParagraphGroup ):block
+         EmptyLine* {block}
+
+BlockDelimiter = BlockHead | BlockEnd 
+ParagraphDelimiter = BlockDelimiter | PreformattedCommandHead | LineBlock | Newpage | HeadedStart
 
 # markdown-style headings
-h_start_mark(n) = < '='+ ':' > &{ text.length - 1 == n }
-h_markup_terminator(n) = lh - < '='+ ':' > &{ text.length - 1 <= n }
-
-h_start(n) = lh - h_start_mark(n) charstring:s le { { level: n, heading: s } }
-h_section(n) = < h_start(n):h (!h_markup_terminator(n) !eof block)+:content > { create_item(:h_section, h, content, raw: text) }
-
-headed_start = h_start(1) | h_start(2) | h_start(3) | h_start(4) | h_start(5) | h_start(6)
-headed_section = h_section(1) | h_section(2)| h_section(3)| h_section(4)| h_section(5) | h_section(6)
-
-#header
-stylesheets = < lh - 'stylesheets:' !le charstring:s nl  > { create_item(:stylesheets, {:stylesheets => s.split(',').map(&:strip)}, nil, raw:text) }
-title = < lh - 'title:' !le charstring:t nl  > { create_item(:title, {:title => t }, nil, raw:text) }
-lang = < lh - 'lang:' !le charstring:l nl  > { create_item(:lang, {:lang => l }, nil, raw:text) }
-paragraph_style = < lh - 'paragraph-style:' !le charstring:l nl  > { create_item(:paragraph_style, {:paragraph_style => l }, nil, raw:text) }
-header = (stylesheets | title | lang | paragraph_style ) empty_line*
+HStartMark(n) = < '='+ ':' > &{ text.length - 1 == n }
+HMarkupTerminator(n) = - < '='+ ':' > &{ text.length - 1 <= n }
+
+HStart(n) = - HStartMark(n) - DocumentContent:s Le { { level: n, heading: s } }
+HSection(n) = HStart(n):h (!HMarkupTerminator(n) !Eof Block)*:content ~h_section(h[:level], h[:heading], content)
+
+HeadedStart = HStart(1)
+            | HStart(2)
+            | HStart(3)
+            | HStart(4)
+            | HStart(5)
+            | HStart(6)
+
+HeadedSection = HSection(1)
+              | HSection(2)
+              | HSection(3)
+              | HSection(4)
+              | HSection(5)
+              | HSection(6)
+
+# frontmatter
+FrontmatterSeparator =  - '---' - Nl
+Frontmatter = FrontmatterSeparator (!FrontmatterSeparator ( CharString Nl))+:yaml FrontmatterSeparator EmptyLine* ~frontmatter(yaml)
 
 # texts
-char = < /[[:print:]]/ > { text }
-charstring = < char* > { text }
-char_except(e) = char:c &{ c != e }
-charstring_except(e) = < char_except(e)* > { text }
-documentcontent_except(e) = (inline | !inline char_except(e))+:content ~parse_text(content)
-documentcontent = (inline | !inline char)+:content  ~parse_text(content)
-documentline = lh documentcontent:content le { content }
+Char = < /[[:print:]]/ > { text }
+CharString = < Char* > { text }
+CharExcept(e) = Char:c &{ c != e }
+DocumentTextExcept(e) = < (!Inline CharExcept(e))+ > ~text(text)
+DocumentContentExcept(e) = (Inline | DocumentTextExcept(e))+:content { content } 
+DocumentText = < (!Inline Char)+ > ~text(text)
+DocumentContent = (Inline | DocumentText)+:content  { content }
+DocumentLine = DocumentContent:content Le { content }
 
 #page
-headers = header*:headers { create_item(:headers, nil, headers) }
-page = headers:headers - (!newpage block)*:blocks { create_item(:page, nil, [headers] + blocks.select{ |x| !x.nil?}) }
-newpaged_page = newpage:newpage page:page { page[:children] = page[:children].unshift newpage; page }
+Page = Frontmatter?:frontmatter - (!Newpage Block)*:blocks ~page(([frontmatter] +  blocks).select{ |x| !x.nil?})
+NewpagedPage = Newpage:newpage Page:page { page.content = page.content.unshift newpage; page }
+
 #root
-root = page:page newpaged_page*:pages - eof_comment? eof { [ page ] + pages }
+root = Page:page NewpagedPage*:pages - EofComment? Eof { [ page ] + pages }