nora_mark 0.2beta3

data/lib/nora_mark/html/paragraph_writer.rb

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+module NoraMark
+  module Html
+    class ParagraphWriter
+      def initialize(generator)
+        @generator = generator
+        @context = generator.context
+        @writer_set = { use_paragraph_group: {
+          :paragraph =>
+          TagWriter.create('p', @generator, chop_last_space: true,
+                           item_preprocessor: proc do |item|
+                             add_class(item, 'noindent') if item[:children][0] =~/^(「|『|（)/  # TODO: should be plaggable}
+                             item
+                           end
+                           ),
+          :paragraph_group =>
+          TagWriter.create("div", @generator,
+                           item_preprocessor: proc do |item|
+                             add_class item, 'pgroup'
+                             item[:no_tag] = true unless @context.enable_pgroup
+                             item
+                           end
+                           )
+          },
+          default: {
+          :paragraph => 
+          TagWriter.create(nil, @generator, chop_last_space: true,
+                           item_preprocessor: proc do |item|
+                             item[:no_tag] = true
+                             item
+                           end),
+          :paragraph_group =>
+          TagWriter.create("p", @generator,
+                           item_preprocessor: proc do |item|
+                             item[:children] = item[:children].inject([]) do |memo, item|
+                               memo << { :type => :br, :args => [] } if !memo.last.nil? && memo.last[:type] == :paragraph && item[:type] == :paragraph
+                               memo << item
+                             end
+                             item
+                           end
+                           )
+          }
+        }
+      end
+      def write(item)
+        writer_set = @writer_set[@context.paragraph_style]
+        writer_set = @writer_set['default'] if writer_set.nil?
+        writer_set[item[:type]].write(item)
+      end
+    end
+  end
+end

data/lib/nora_mark/html/tag_writer.rb

@@ -0,0 +1,110 @@
+module NoraMark
+  module Html
+    class TagWriter
+      include Util
+      attr_accessor :trailer, :item_preprocessors, :write_body_preprocessors
+
+      def self.create(tag_name, generator, item_preprocessor: nil, write_body_preprocessor: nil, trailer: "\n", chop_last_space: false)
+        instance = TagWriter.new(tag_name, generator, chop_last_space: chop_last_space)
+        instance.item_preprocessors << item_preprocessor unless item_preprocessor.nil?
+        instance.write_body_preprocessors << write_body_preprocessor unless write_body_preprocessor.nil?
+        instance.trailer = trailer 
+        yield instance if block_given?
+        instance
+      end
+
+      def initialize(tag_name, generator, **param)
+        @tag_name = tag_name
+        @generator = generator
+        @context = generator.context
+        @trailer = trailer
+        @item_preprocessors = []
+        @write_body_preprocessors = []
+        @param = param
+      end
+
+      def attr_string(attrs)
+        attrs.map do
+          |name, vals|
+          if vals.size == 0
+            ''
+          else
+            " #{name}='#{vals.join(' ')}'"            
+          end
+        end.join('')
+      end
+
+      def class_string(cls_array)
+        attr_string({'class' => cls_array})
+      end
+
+      def ids_string(ids_array)
+        attr_string({'id' => ids_array})
+      end
+
+      def add_class(item, cls)
+        (item[:classes] ||= []) << cls
+      end
+
+      def add_class_if_empty(item, cls)
+        add_class(item, cls) if item[:classes].nil? || item[:classes].size == 0 
+      end
+
+      def tag_start(item)
+        return if item[:no_tag] 
+        ids = item[:ids] || []
+        classes = item[:classes] || []
+        attr = item[:attrs] || {}
+        tag_name = @tag_name || item[:name]
+        @context << "<#{tag_name}#{ids_string(ids)}#{class_string(classes)}#{attr_string(attr)}"
+        if item[:no_body]
+          @context << " />"
+        else
+          @context << ">"
+        end
+      end
+
+      def output(string)
+        @context << string
+      end
+      
+      def tag_end(item)
+        return if item[:no_tag] 
+        tag_name = @tag_name || item[:name]
+        @context << "</#{tag_name}>#{@trailer}"
+      end
+
+      def write(item)
+        @item_preprocessors.each { |x| item = instance_exec item.dup, &x }
+        @context.enable_pgroup, saved_ep = !(item[:args].include?('wo-pgroup') || !@context.enable_pgroup), @context.enable_pgroup
+        tag_start item
+        write_body item if !item[:no_body]
+        tag_end item if !item[:no_body]
+        @context.enable_pgroup = saved_ep
+      end
+
+      def write_body(item)
+        @write_body_preprocessors.each {
+          |x|
+          return if instance_exec(item, &x) == :done
+        }
+        write_children item
+      end
+
+      def write_children(item)
+        write_array(item[:children])
+      end
+
+      def write_array(array)
+        return if array.nil? || array.size == 0
+        array.each { |x| @generator.to_html x }
+        @generator.context.chop_last_space if (@param[:chop_last_space]) 
+      end
+      
+      def children_not_empty(item)
+        !item[:children].nil? && item[:children].size > 0 && item[:children].select { |x| (x.is_a? String) ? x.size >0 : !x.nil? }.size > 0
+      end
+
+    end
+  end
+end

data/lib/nora_mark/html/util.rb

@@ -0,0 +1,12 @@
+module NoraMark
+  module Html
+    module Util
+      def escape_html(string)
+        string.to_s.gsub("&", "&").
+          gsub("<", "&lt;").
+          gsub(">", "&gt;").
+          gsub('"', "&quot;")
+      end
+    end
+  end
+end

data/lib/nora_mark/html/writer_selector.rb

@@ -0,0 +1,24 @@
+module NoraMark
+  module Html
+    class WriterSelector
+      def initialize(generator, tag_writers = {}, trailer_default: "\n" )
+        @generator = generator
+        @common_tag_writer = TagWriter.create(nil, @generator, trailer: trailer_default)
+        @tag_writers = tag_writers
+        if !trailer_default.nil?
+          @tag_writers.each { |k, t|
+            if t.is_a? TagWriter
+              t.trailer = trailer_default
+            end
+          }
+        end
+
+      end
+
+      def write(item)
+        writer = @tag_writers[item[:name]] || @common_tag_writer
+        writer.write(item)
+      end
+    end
+  end
+end

data/lib/nora_mark/parser.kpeg

@@ -0,0 +1,123 @@
+%% 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 }
+
+
+#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(',') }) }
+
+# paragraph
+implicit_paragraph = < (!paragraph_delimiter - documentline:p -) > { create_item(:paragraph, nil, p, raw: text) }
+paragraph = explicit_paragraph | implicit_paragraph 
+
+# paragraph_group
+paragraph_group = < paragraph+:p empty_line* > { create_item(:paragraph_group, nil, p, raw: text) }
+
+# 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) }
+
+# 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) }
+
+# 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) } 
+
+# special line commands
+commandname_for_special_line_command = newpage_command | explicit_paragraph_command
+
+# newpage
+newpage_command = command:command &{ command[:name] == 'newpage' }
+newpage = < lh - newpage_command:c ':' documentcontent?:content - nl > { create_item(:newpage, c, content, raw:text) }
+
+# 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) }
+
+
+# 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) }
+
+# 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) }
+
+# 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) }
+
+items_list = unordered_list | ordered_list | definition_list
+
+
+# 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) }
+
+# 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
+
+# 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*
+
+# 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 }
+
+#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 }
+#root
+root = page:page newpaged_page*:pages - eof_comment? eof { [ page ] + pages }
+
+
+