nora_mark 0.2beta3 → 0.2beta4

data/lib/nora_mark/html/generator.rb

@@ -3,10 +3,10 @@ require 'nora_mark/html/util'
 require 'nora_mark/html/pages'
 require 'nora_mark/html/context'
 require 'nora_mark/html/tag_writer'
-require 'nora_mark/html/header_writer'
+require 'nora_mark/html/frontmatter_writer'
 require 'nora_mark/html/paragraph_writer'
 require 'nora_mark/html/writer_selector'
-require 'nora_mark/html/abstract_item_writer'
+require 'nora_mark/html/abstract_node_writer'
 module NoraMark
   module Html
     class Generator
@@ -17,56 +17,75 @@ module NoraMark
         article_writer = TagWriter.create('article', self)
         section_writer = TagWriter.create('section', self)
         link_writer = TagWriter.create('a', self, trailer: '', 
-                                       item_preprocessor: proc do |item|
-                                         (item[:attrs] ||= {}).merge!({:href => [ item[:args][0] ]})
-                                         item
+                                       node_preprocessor: proc do |node|
+                                         (node.attrs ||= {}).merge!({href: [node.parameters[0]]})
+                                         node
                                        end)
 
-        header_writer = HeaderWriter.new self
+        frontmatter_writer = FrontmatterWriter.new self
         paragraph_writer = ParagraphWriter.new self
-        abstract_item_writer = AbstractItemWriter.new self
+        abstract_node_writer = AbstractNodeWriter.new self
         @writers = {
-          :page => abstract_item_writer,
-          :headers => abstract_item_writer,
-          :paragraph => paragraph_writer,
-          :paragraph_group => paragraph_writer,
-          :block =>
-          WriterSelector.new(self,
-                             {
-                               'd' => TagWriter.create('div', self),
-                               'art' => article_writer,
-                               'arti' => article_writer,
-                               'article' => article_writer,
-                               'sec' => section_writer,
-                               'sect' => section_writer,
-                               'section' => section_writer,
-                             }),
-          :line_command =>
+          Paragraph => paragraph_writer,
+          ParagraphGroup => paragraph_writer,
+          Breakline => 
+          TagWriter.create('br', self, node_preprocessor: proc do |node|
+                             node.body_empty = true
+                             node
+                           end),
+          LineCommand =>
           WriterSelector.new(self,
                              {
                                'image' =>
                                TagWriter.create('div', self,
-                                                item_preprocessor: proc do |item|
-                                                  add_class_if_empty item, 'img-wrap'
-                                                  item
+                                                node_preprocessor: proc do |node|
+                                                  add_class_if_empty node, 'img-wrap'
+                                                  node
                                                 end,
-                                                write_body_preprocessor: proc do |item|
-                                                  src = item[:args][0].strip
-                                                  alt = (item[:args][1] || '').strip
-                                                  caption_before = item[:named_args][:caption_before]
-                                                  if caption_before && children_not_empty(item)
-                                                    output "<p>"; write_children item; output "</p>"
+                                                write_body_preprocessor: proc do |node|
+                                                  src = node.parameters[0].strip
+                                                  alt = (node.parameters[1] || '').strip
+                                                  caption_before = node.named_parameters[:caption_before]
+                                                  if caption_before && children_not_empty(node)
+                                                    output "<p>"; write_children node; output "</p>"
                                                   end
                                                   output "<img src='#{src}' alt='#{escape_html alt}' />"
-                                                  if !caption_before && children_not_empty(item)
-                                                    output "<p>"; write_children item; output "</p>"
+                                                  if !caption_before && children_not_empty(node)
+                                                    output "<p>"; write_children node; output "</p>"
                                                   end
                                                   :done
                                                 end
                                                 ),
 
                                }),
-          :inline =>
+          Block =>
+          WriterSelector.new(self,
+                             {
+                               'd' => TagWriter.create('div', self),
+                               'art' => article_writer,
+                               'arti' => article_writer,
+                               'article' => article_writer,
+                               'sec' => section_writer,
+                               'sect' => section_writer,
+                               'section' => section_writer,
+                             }),
+          Newpage =>
+          TagWriter.create('div', self,
+                           node_preprocessor: proc do |node|
+                             node.no_tag = true
+                             node
+                           end,
+                           write_body_preprocessor: proc do |node|
+                             title = nil
+                             if node.parameters.size > 0 && node.parameters[0].size > 0
+                               title = escape_html node.parameters.first
+                             end
+                             @context.title = title unless title.nil?
+                             @context.end_html
+                             :done
+                           end
+                           ),
+          Inline =>
           WriterSelector.new(self, 
                              {
                                'link' => link_writer,
@@ -74,101 +93,104 @@ module NoraMark
                                's' => TagWriter.create('span', self),
                                'img' =>
                                TagWriter.create('img', self,
-                                                item_preprocessor: proc do |item|
-                                                  item[:no_body] = true #TODO : it is not just an item's attribute, 'img_inline' has no body. maybe should specify in parser.{rb|kpeg}
-                                                  (item[:attrs] ||= {}).merge!({:src => [item[:args][0] ]})
-                                                  item[:attrs].merge!({:alt => [ escape_html(item[:args][1].strip)]}) if (item[:args].size > 1 && item[:args][1].size > 0)
-                                                  item
+                                                node_preprocessor: proc do |node|
+                                                  node.body_empty = true #TODO : it is not just an item's attribute, 'img_inline' has no body. maybe should specify in parser.{rb|kpeg}
+                                                  (node.attrs ||= {}).merge!({src: [node.parameters[0] ]})
+                                                  node.attrs.merge!({alt: [ escape_html(node.parameters[1].strip)]}) if (node.parameters.size > 1 && node.parameters[1].size > 0)
+                                                  node
                                                 end)  ,
                                'tcy' =>
                                TagWriter.create('span', self,
-                                                item_preprocessor: proc do |item|
-                                                  add_class item, 'tcy'
-                                                  item
+                                                node_preprocessor: proc do |node|
+                                                  add_class node, 'tcy'
+                                                  node
                                                 end),
                                'ruby' =>
                                TagWriter.create('ruby', self,
-                                                write_body_preprocessor: proc do |item|
-                                                  write_children item
-                                                  output "<rp>(</rp><rt>#{escape_html item[:args][0].strip}</rt><rp>)</rp>"
+                                                write_body_preprocessor: proc do |node|
+                                                  write_children node
+                                                  output "<rp>(</rp><rt>#{escape_html node.parameters[0].strip}</rt><rp>)</rp>"
                                                   :done
                                                 end),
                                
                              },
                              trailer_default:''
                              ),
-          :ol => TagWriter.create('ol', self),
-          :ul => TagWriter.create('ul', self),
-          :li => TagWriter.create('li', self),
-          :dl => TagWriter.create('dl', self),
-          :dtdd =>
-          TagWriter.create('', self, chop_last_space: true, item_preprocessor: proc do |item| item[:no_tag] = true; item end,
-                           write_body_preprocessor: proc do |item|
-                             output "<dt>"; write_array item[:args][0]; output "</dt>"
-                             output "<dd>"; write_array item[:args][1]; output "</dd>"
+          OrderedList => TagWriter.create('ol', self),
+          UnorderedList => TagWriter.create('ul', self),
+          UlItem => TagWriter.create('li', self),
+          OlItem => TagWriter.create('li', self),
+          DefinitionList => TagWriter.create('dl', self),
+          DLItem => 
+          TagWriter.create('', self, chop_last_space: true, node_preprocessor: proc do |node| node.no_tag = true; node end,
+                           write_body_preprocessor: proc do |node|
+                             output "<dt>"; write_array node.parameters[0]; output "</dt>\n"
+                             output "<dd>"; write_children node; output "</dd>\n"
                              :done
                            end),
-          :newpage =>
-          TagWriter.create('div', self,
-                           item_preprocessor: proc do |item|
-                             item[:no_tag] = true
-                             item
-                           end,
-                           write_body_preprocessor: proc do |item|
-                             title = nil
-                             if item[:args].size > 0 && item[:args][0].size > 0
-                               title = escape_html item[:args].first
-                             end
-                             @context.title = title unless title.nil?
-                             @context.end_html
-                             :done
-                           end
-                           ),
+
+          Document =>  abstract_node_writer,
+          Page =>  abstract_node_writer,
+
           #headed-section
-          :h_section =>
-          TagWriter.create('section', self, write_body_preprocessor: proc do |item|
-                             output "<h#{item[:level]}>#{item[:heading].strip}</h#{item[:level]}>\n"
+          HeadedSection => 
+          TagWriter.create('section', self, write_body_preprocessor: proc do |node|
+                             output "<h#{node.level}>"
+                             write_array node.heading
+                             @generator.context.chop_last_space
+                             output "</h#{node.level}>\n"
                              :continue
                            end),
-          # headers
-          :stylesheets => header_writer,
-          :title => header_writer,
-          :lang => header_writer,
-          :paragraph_style => header_writer,
+          # frontmatter
+          Frontmatter =>  frontmatter_writer,
           # pre-formatted
-          :preformatted =>
-          TagWriter.create('pre', self,write_body_preprocessor: proc do |item|
-                             output "<code>" if item[:name] == 'precode'
-                             output item[:children].join "\n"
-                             output "</code>" if item[:name] == 'precode'
+          PreformattedBlock => 
+          TagWriter.create('pre', self,
+                           node_preprocessor: proc do |node|
+                             if node.codelanguage
+                               (node.attrs ||= {}).merge!({'data-code-language' => [node.codelanguage]})
+                               add_class node, "code-#{node.codelanguage}"
+                             end
+                             node
+                           end,
+                           write_body_preprocessor: proc do |node|
+                             output "<code>" if node.name == 'code'
+                             output escape_html(node.content.join "\n")
+                             output "</code>" if node.name == 'code'
                              :done
                            end),
-          #break
-          :br =>
-            TagWriter.create('br', self, item_preprocessor: proc do |item|
-                               item[:no_body] = true
-                               item
-                             end),
           }
       end
 
       def convert(parsed_result)
-        parsed_result.each {
-          |item|
-          to_html(item)
+        children = parsed_result.content
+        @context.file_basename = parsed_result.document_name
+        children.each {
+          |node|
+          to_html(node)
         }
         @context.result
       end
-      def to_html(item)
-        if item.is_a? String
-          @context << escape_html(item)
+
+      def to_html(node)
+        if node.is_a? String
+          @context << escape_html(node)
+        elsif node.is_a? Hash
+          writer = @writers[node[:type]]
+          if writer.nil?
+            warn "can't find html generator for \"#{node}\""
+            @context << escape_html(node[:raw_text])
+          else
+            writer.write(node)
+          end
+        elsif node.kind_of? Text
+          @context << escape_html(node.content)
         else
-          writer = @writers[item[:type]]
+          writer = @writers[node.class]
           if writer.nil?
-            warn "can't find html generator for \"#{item}\""
-            @context << escape_html(item[:raw_text])
+            warn "can't find html generator for \"#{node.class}\""
           else
-            writer.write(item)
+            writer.write(node)
           end
         end
       end

data/lib/nora_mark/html/pages.rb

@@ -4,8 +4,8 @@ module NoraMark
     class Context
       class Pages
         attr_reader :created_files
-        def initialize(filename_base = nil, sequence_format='%05d')
-          @filename_base = filename_base || "noramark_#{SecureRandom.uuid}"
+        attr_accessor :file_basename
+        def initialize(sequence_format='%05d')
           @sequence_format = sequence_format || '%05d'
           @result = []
         end
@@ -20,7 +20,7 @@ module NoraMark
         
         def <<(page)
           seq = @result.size + 1
-          @result << { content: page, filename: "#{@filename_base}_#{@sequence_format%(seq)}.xhtml" }
+          @result << { content: page, filename: "#{@file_basename}_#{@sequence_format%(seq)}.xhtml" }
         end
 
         def [](num)
@@ -44,12 +44,6 @@ module NoraMark
             end
           end
         end 
-        def write_as_single_file(filename)
-          File.open(filename, 'w+') {
-            |file|
-            file << @result[0][:content]
-          }
-        end
       end
     end
   end

data/lib/nora_mark/html/paragraph_writer.rb

@@ -6,46 +6,50 @@ module NoraMark
         @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
+          Paragraph =>
+          TagWriter.create('p', @generator, chop_last_space: true, 
+                           node_preprocessor: proc do |node|
+                             first = node.content[0]
+                             if first.kind_of? Text
+                               first.content.sub!(/^[[:space:]]+/, '')
+                               add_class(node, 'noindent') if first.content =~/^(「|『|（)/  # TODO: should be plaggable
+                             end
+                             node
                            end
                            ),
-          :paragraph_group =>
+          ParagraphGroup =>
           TagWriter.create("div", @generator,
-                           item_preprocessor: proc do |item|
-                             add_class item, 'pgroup'
-                             item[:no_tag] = true unless @context.enable_pgroup
-                             item
+                           node_preprocessor: proc do |node|
+                             add_class node, 'pgroup'
+                             node.no_tag = true unless @context.enable_pgroup
+                             node
                            end
                            )
           },
           default: {
-          :paragraph => 
+            Paragraph =>
           TagWriter.create(nil, @generator, chop_last_space: true,
-                           item_preprocessor: proc do |item|
-                             item[:no_tag] = true
-                             item
+                           node_preprocessor: proc do |node|
+                             node.no_tag = true
+                             node
                            end),
-          :paragraph_group =>
+            ParagraphGroup =>
           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
+                           node_preprocessor: proc do |node|
+                             node.content = node.content.inject([]) do |memo, node|
+                               memo << Breakline.new if !memo.last.nil? && memo.last.kind_of?(Paragraph) && node.kind_of?(Paragraph)
+                               memo << node
                              end
-                             item
+                             node
                            end
                            )
           }
         }
       end
-      def write(item)
-        writer_set = @writer_set[@context.paragraph_style]
+      def write(node)
+        writer_set = @writer_set[@context.paragraph_style] 
         writer_set = @writer_set['default'] if writer_set.nil?
-        writer_set[item[:type]].write(item)
+        writer_set[node.class].write(node)
       end
     end
   end

data/lib/nora_mark/html/tag_writer.rb

@@ -2,11 +2,11 @@ module NoraMark
   module Html
     class TagWriter
       include Util
-      attr_accessor :trailer, :item_preprocessors, :write_body_preprocessors
+      attr_accessor :trailer, :node_preprocessors, :write_body_preprocessors
 
-      def self.create(tag_name, generator, item_preprocessor: nil, write_body_preprocessor: nil, trailer: "\n", chop_last_space: false)
+      def self.create(tag_name, generator, node_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.node_preprocessors << node_preprocessor unless node_preprocessor.nil?
         instance.write_body_preprocessors << write_body_preprocessor unless write_body_preprocessor.nil?
         instance.trailer = trailer 
         yield instance if block_given?
@@ -18,7 +18,7 @@ module NoraMark
         @generator = generator
         @context = generator.context
         @trailer = trailer
-        @item_preprocessors = []
+        @node_preprocessors = []
         @write_body_preprocessors = []
         @param = param
       end
@@ -35,29 +35,29 @@ module NoraMark
       end
 
       def class_string(cls_array)
-        attr_string({'class' => cls_array})
+        attr_string({class: cls_array})
       end
 
       def ids_string(ids_array)
-        attr_string({'id' => ids_array})
+        attr_string({id: ids_array})
       end
 
-      def add_class(item, cls)
-        (item[:classes] ||= []) << cls
+      def add_class(node, cls)
+        (node.classes ||= []) << cls
       end
 
-      def add_class_if_empty(item, cls)
-        add_class(item, cls) if item[:classes].nil? || item[:classes].size == 0 
+      def add_class_if_empty(node, cls)
+        add_class(node, cls) if node.classes.nil? || node.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]
+      def tag_start(node)
+        return if node.no_tag
+        ids = node.ids || []
+        classes = node.classes || []
+        attr = node.attrs || {}
+        tag_name = @tag_name || node.name
         @context << "<#{tag_name}#{ids_string(ids)}#{class_string(classes)}#{attr_string(attr)}"
-        if item[:no_body]
+        if node.body_empty
           @context << " />"
         else
           @context << ">"
@@ -68,31 +68,31 @@ module NoraMark
         @context << string
       end
       
-      def tag_end(item)
-        return if item[:no_tag] 
-        tag_name = @tag_name || item[:name]
+      def tag_end(node)
+        return if node.no_tag
+        tag_name = @tag_name || node.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]
+      def write(node)
+        @node_preprocessors.each { |x| node = instance_exec node.dup, &x }
+        @context.enable_pgroup, saved_ep = !(node.parameters.include?('wo-pgroup') || !@context.enable_pgroup), @context.enable_pgroup
+        tag_start node
+        write_body node unless node.body_empty
+        tag_end node unless node.body_empty
         @context.enable_pgroup = saved_ep
       end
 
-      def write_body(item)
+      def write_body(node)
         @write_body_preprocessors.each {
           |x|
-          return if instance_exec(item, &x) == :done
+          return if instance_exec(node, &x) == :done
         }
-        write_children item
+        write_children node
       end
 
-      def write_children(item)
-        write_array(item[:children])
+      def write_children(node)
+        write_array(node.content)
       end
 
       def write_array(array)
@@ -101,10 +101,9 @@ module NoraMark
         @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
+      def children_not_empty(node)
+        !node.content.nil? && node.content.size > 0 && node.content.reject { |x| x.nil? }.size > 0
       end
-
     end
   end
 end

data/lib/nora_mark/html/writer_selector.rb

@@ -15,9 +15,9 @@ module NoraMark
 
       end
 
-      def write(item)
-        writer = @tag_writers[item[:name]] || @common_tag_writer
-        writer.write(item)
+      def write(node)
+        writer = @tag_writers[node.name] || @common_tag_writer
+        writer.write(node)
       end
     end
   end

data/lib/nora_mark/node.rb

@@ -0,0 +1,31 @@
+require 'yaml'
+
+module NoraMark
+  class Node
+    attr_accessor :content, :ids, :classes, :no_tag, :attrs, :name, :body_empty
+
+    def named_parameters=(named_parameters)
+      @named_parameters = named_parameters
+    end
+
+    def named_parameters
+      @named_parameters = Hash[*(parameters.select { |x| x.include?(':') }.map { |x| v = x.split(':', 2); [v[0].strip.to_sym, v[1]]}.flatten)] if !@parameters.nil?
+      @named_parameters ||= {}
+    end
+
+    def parameters=(parameters)
+      @parameters = parameters
+    end
+    
+    def parameters
+      @parameters ||= []
+    end
+  end
+
+  class Frontmatter < Node
+    def yaml
+      @yaml ||= YAML.load(@content.join("\n"))
+      @yaml
+    end
+  end
+end