nora_mark 0.2beta7 → 0.2beta8

data/lib/nora_mark.rb

@@ -1,74 +1,12 @@
 require "nora_mark/version"
-require 'nora_mark/html/generator'
-require 'nora_mark/parser'
 require 'nora_mark/node_util'
-require 'nora_mark/node'
-require 'nora_mark/node_set'
 require 'nora_mark/transformer'
-require 'nora_mark/node_builder'
-require 'securerandom'
-
-module NoraMark
-  class Document 
-    attr_accessor :document_name, :root
-    private_class_method :new 
-
-    def self.parse(string_or_io, param = {})
-      instance = new param
-      src = (string_or_io.respond_to?(:read) ? string_or_io.read : string_or_io).encode 'utf-8'
-      yield instance if block_given?
-      instance.instance_eval do 
-        @preprocessors.each do
-          |pr|
-          src = pr.call(src)
-        end
-        parser = Parser.new(src)
-        if (!parser.parse)
-          raise parser.raise_error
-        end
-        @root = parser.result
-        @root.document_name ||= @document_name
-        @root.reparent
-        @root.first_child.inject(1) do |page_no, node|
-          if node.kind_of? Page
-            node.page_no = page_no
-            page_no = page_no + 1
-          end
-          page_no
-        end
-      end
-      instance
-    end
+require 'nora_mark/parser'
+require 'nora_mark/node_set'
+require 'nora_mark/html/generator'
+require 'nora_mark/document'
+require 'nora_mark/extensions'
 
-    def preprocessor(&block)
-      @preprocessors << block
-    end
 
-    def html
-      if @html.nil?
-        @transformers[:html].each { |t| t.transform @root }
-        @html = Html::Generator.new(@param).convert(@root.clone, @render_parameter)
-      end
-      @html
-    end
 
-    def render_parameter(param = {})
-      @render_parameter.merge! param
-      self
-    end
 
-    def add_transformer(generator: :html, text: nil, &block)
-      (@transformers[generator] ||= []) << TransformerFactory.create(text: text, &block)
-    end
-    
-    def initialize(param = {})
-      @param = param
-      @preprocessors = [
-                        Proc.new { |text| text.gsub(/\r?\n(\r?\n)+/, "\n\n") },
-                       ]
-      @document_name = param[:document_name] || "noramark_#{SecureRandom.uuid}"
-      @render_parameter = {}
-      @transformers = { html: []}
-    end 
-  end
-end

data/lib/nora_mark/document.rb

@@ -0,0 +1,89 @@
+require 'securerandom'
+
+module NoraMark
+  class Document 
+    attr_accessor :document_name, :root
+    private_class_method :new 
+
+    def self.generators
+      @generators ||= {}
+    end
+    
+    def self.register_generator(generator)
+      @generators ||= {}
+      generator_name = generator.name
+      @generators[generator_name] = generator
+      generator.activate self if generator.respond_to? :activate
+      class_eval do
+        define_method(generator_name) do
+          generate(generator_name)
+        end
+      end
+    end
+
+    register_generator(::NoraMark::Html::Generator)
+
+    def self.parse(string_or_io, param = {})
+      instance = new param
+      src = (string_or_io.respond_to?(:read) ? string_or_io.read : string_or_io).encode 'utf-8'
+      yield instance if block_given?
+      instance.instance_eval do 
+        @preprocessors.each do
+          |pr|
+          src = pr.call(src)
+        end
+        parser = Parser.new(src)
+        if (!parser.parse)
+          raise parser.raise_error
+        end
+        @root = parser.result
+        @root.document_name ||= @document_name
+        @root.reparent
+        @root.first_child.inject(1) do |page_no, node|
+          if node.kind_of? Page
+            node.page_no = page_no
+            page_no = page_no + 1
+          end
+          page_no
+        end
+      end
+      instance
+    end
+
+    def preprocessor(&block)
+      @preprocessors << block
+    end
+
+    def transformers(generator_name)
+      @transformers[generator_name] ||= []
+    end
+    
+    def generate(generator_name)
+      if @result[generator_name].nil?
+        transformers(generator_name).each { |t| t.transform @root }
+        @result[generator_name] = Document.generators[generator_name].new(@param).convert(@root.clone, @render_parameter)
+      end
+      @result[generator_name]
+    end
+
+    def render_parameter(param = {})
+      @render_parameter.merge! param
+      self
+    end
+
+    def add_transformer(generator: :html, text: nil, &block)
+      (@transformers[generator] ||= []) << TransformerFactory.create(text: text, &block)
+    end
+    
+    def initialize(param = {})
+      @param = param
+      @result = {}
+      @preprocessors = [
+                        Proc.new { |text| text.gsub(/\r?\n(\r?\n)+/, "\n\n") },
+                       ]
+      @document_name = param[:document_name] || "noramark_#{SecureRandom.uuid}"
+      @render_parameter = {}
+      @transformers = { }
+    end 
+  end
+end

data/lib/nora_mark/extensions.rb

@@ -0,0 +1,26 @@
+module NoraMark
+  class Extensions
+    def self.register_generator(generator)
+      if !generator.respond_to? :name
+        generator = load_generator(generator)
+      end
+      NoraMark::Document.register_generator(generator)
+    end
+    
+    def load_generator(generator)
+      module_name = '::NoraMark::#{generator.to_s.capitalize}::Generator'
+      return const_get(module_name) if const_defined? module_name.to_sym
+      path = "#{generator.to_s.lowercase}.rb"
+      current_dir_path = File.expand_path(File.join('.', '.noramark-plugins', path))
+      home_dir_path = File.expand_path(File.join(ENV['HOME'], '.noramark-plugins', path))
+      if File.exist? current_dir_path
+        require current_dir_path
+      elsif File.exist? home_dir_path
+        require home_dir_path
+      else
+        require "noramark/#{generator.to_s.lowercase}"
+      end
+      const_defined?(module_name.to_sym) ? const_get(module_name) : nil
+    end
+  end
+end

data/lib/nora_mark/html/context.rb

@@ -32,7 +32,7 @@ module NoraMark
       end
       
       def chop_last_space
-        @pages.last.sub!(/[[:space:]]+$/, '')
+        @pages.last.sub!(/[[:space:]]+\Z/, '')
       end
 
       def paragraph_style=(style)
@@ -68,14 +68,13 @@ module NoraMark
           page << f.call
         }
         page << "</head>\n"
-        page << "<body>\n"
         @pages << page
       end
 
       def end_html
+        return if @pages.size == 0
         page = @pages.last
         if !page.frozen?
-          page << "</body>\n"
           page << "</html>\n"
           page.freeze 
         end

data/lib/nora_mark/html/default_transformer.rb

@@ -0,0 +1,151 @@
+module NoraMark
+  module Html
+    DEFAULT_TRANSFORMER = TransformerFactory.create do
+      rename 'd', 'div'
+      rename 'art', 'article'
+      rename 'arti', 'article'
+      rename 'sec', 'section'
+      rename 'sect', 'section'
+      rename 'sp', 'span'
+
+      modify({type: :Root}) do
+        if (@options[:render_parameter] ||= {})[:nonpaged]
+          first_page = @node.first_child.remove
+          @node.children.each do |node|
+            if node.class == NoraMark::Page
+              first_page.append_child block('hr', classes: ['page-break'], body_empty: true)
+              node.remove
+              node.children.each do |cn|
+                first_page.append_child cn
+              end
+            else
+              first_page.append_child node
+            end
+          end
+          @node.prepend_child first_page
+        end
+      end
+      modify(/\A(l|link)\Z/) do
+        @node.name = 'a'
+        (@node.attrs ||= {}).merge!({href: [@node.params[0].text]})
+      end
+
+      modify 'ruby' do
+        @node.append_child inline 'rp', '('
+        @node.append_child inline 'rt', escape_html(@node.params[0].text.strip)
+        @node.append_child inline 'rp', ')'
+      end
+
+      modify 'tcy' do
+        @node.name = 'span'
+        @node.classes = ['tcy']
+      end
+
+      modify 'img' do
+        @node.body_empty = true
+        (@node.attrs ||= {}).merge!({src: [@node.params[0].text ]})        
+        @node.attrs.merge!({alt: [ escape_html(@node.params[1].text.strip)]}) if (@node.p.size > 1 && @node.params[1].text.size > 0)
+      end
+
+      replace 'image' do
+        newnode = block('figure',
+                        class_if_empty:'img-wrap',
+                        ids: @node.ids,
+                        children: [ inline('img', nil, attrs: {src: [ @node.params[0].text.strip],  alt: [ (@node.params[1].text ||'').strip ] }) ],
+                        template: @node) 
+        if !@node.children_empty?
+          if @node.n[:caption_before] 
+            newnode.prepend_child inline('figcaption', @node.children)
+          else
+            newnode.append_child inline('figcaption', @node.children)
+          end
+        end
+        newnode
+      end
+
+      replace({type: :OrderedList}) do
+        block('ol', template: @node)
+      end
+
+      replace({type: :UnorderedList}) do
+        block('ul', template: @node)
+      end
+
+      replace({type: :UlItem}) do
+        block('li', template: @node)
+      end
+
+      replace({type: :OlItem}) do
+        block('li', template: @node)
+      end
+
+      replace({type: :DefinitionList}) do
+        block('dl', template: @node)
+      end
+
+      replace({type: :DLItem}) do
+        [
+         block('dt', @node.p[0], n: {chop_last_space: true}),
+         block('dd', @node.children)
+        ]
+      end
+
+      replace({type: :Breakline}) do
+        newnode = block('br')
+        newnode.body_empty = true
+        newnode
+      end
+
+      replace({type: :HeadedSection}) do
+        block('section', [ block("h#{@node.level}", @node.heading, ids: @node.n[:heading_id], n: {chop_last_space: true}) ] + @node.children, template: @node)
+      end
+
+      replace ({type: :CodeInline}) do
+        inline('code', @node.content, line_no: @node.line_no, template: @node)
+      end
+      
+      replace ({type: :PreformattedBlock}) do
+        new_node = block('pre')
+        if @node.codelanguage
+          new_node.attrs = {'data-code-language' => [@node.codelanguage]}
+          new_node.classes =  (@node.classes ||[]) << "code-#{@node.codelanguage}"
+        end
+        if @node.name == 'code'
+          code = block('code', text(@node.content.join("\n"), raw_text: true))
+          new_node.children = [ code ]
+        else
+          new_node.children = [ text(@node.content.join("\n"), raw_text: true) ]
+        end
+        if (@node.p || []).size> 0
+          method = @node.n[:caption_after] ? :prepend : :append
+          new_node = new_node.wrap block('div', classes: ['pre'], children: [ block('p', children: @node.p.shift, classes: ['caption']) ]), method
+        end
+        new_node
+      end
+
+      modify 'video' do
+        @node.attrs ||= {}
+        @node.attrs.merge!({src: [@node.p.shift.text]})
+        @node.attrs.merge!({poster: [@node.n[:poster]]}) unless @node.n[:poster].nil?
+
+        options = @node.p.map { |opt| opt.text.strip }
+        ['autoplay', 'controls', 'loop', 'muted'].each do
+          |attr|
+          @node.attrs.merge!({attr.to_sym => true}) if options.member? attr
+        end
+      end
+
+      modify 'audio' do
+        @node.attrs ||= {}
+        @node.attrs.merge!({src: [@node.p.shift.text]})
+        @node.attrs.merge!({volume: [@node.n[:volume]]}) unless @node.n[:volume].nil?
+        options = @node.p.map { |opt| opt.text.strip }
+        ['autoplay', 'controls', 'loop', 'muted'].each do
+          |attr|
+          @node.attrs.merge!({attr.to_sym => true}) if options.member? attr
+        end
+      end
+    end
+    DEFAULT_TRANSFORMER.extend Util
+  end
+end

data/lib/nora_mark/html/generator.rb

@@ -5,163 +5,42 @@ require 'nora_mark/html/context'
 require 'nora_mark/html/tag_writer'
 require 'nora_mark/html/frontmatter_writer'
 require 'nora_mark/html/paragraph_writer'
-require 'nora_mark/html/writer_selector'
 require 'nora_mark/html/abstract_node_writer'
+require 'nora_mark/html/default_transformer'
+
 module NoraMark
   module Html
     class Generator
       include Util
       attr_reader :context
+      def self.name
+        :html
+      end
+
       def initialize(param = {})
         @context = Context.new(param)
-        article_writer = TagWriter.create('article', self)
-        section_writer = TagWriter.create('section', self)
-        link_writer = TagWriter.create('a', self, trailer: '', 
-                                       node_preprocessor: proc do |node|
-                                         (node.attrs ||= {}).merge!({href: [node.parameters[0]]})
-                                         node
-                                       end)
-
         frontmatter_writer = FrontmatterWriter.new self
         paragraph_writer = ParagraphWriter.new self
         abstract_node_writer = AbstractNodeWriter.new self
-          
-        newpage_writer = 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
-                           )
-        @hr_writer = TagWriter.create('hr', self, node_preprocessor: proc do |node|
-                           node.body_empty = true
-                           add_class node, 'page-break'
-                           node
-                         end)
-
+        page_writer = TagWriter.create('body', self,
+                                       node_preprocessor: proc do |node|
+                                         @context.end_html
+                                         if node.first_child.class == Frontmatter
+                                           frontmatter = node.first_child
+                                           frontmatter_writer.write frontmatter
+                                           frontmatter.remove
+                                         end
+                                         node
+                                       end);
+        
         @writers = {
           Paragraph => paragraph_writer,
           ParagraphGroup => paragraph_writer,
-          Breakline => 
-          TagWriter.create('br', self, node_preprocessor: proc do |node|
-                             node.body_empty = true
-                             node
-                           end),
-          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,
-                               'image' =>
-                               TagWriter.create('div', self,
-                                                node_preprocessor: proc do |node|
-                                                  add_class_if_empty node, 'img-wrap'
-                                                  node
-                                                end,
-                                                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(node)
-                                                    output "<p>"; write_children node; output "</p>"
-                                                  end
-                                                  :done
-                                                end
-                                                ),
-
-                             }),
-          Newpage => newpage_writer,
-          Inline =>
-          WriterSelector.new(self, 
-                             {
-                               'link' => link_writer,
-                               'l' => link_writer,
-                               's' => TagWriter.create('span', self),
-                               'img' =>
-                               TagWriter.create('img', self,
-                                                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,
-                                                node_preprocessor: proc do |node|
-                                                  add_class node, 'tcy'
-                                                  node
-                                                end),
-                               'ruby' =>
-                               TagWriter.create('ruby', self,
-                                                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:''
-                             ),
-          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_nodeset node.parameters[0]; output "</dt>\n"
-                             output "<dd>"; write_children node; output "</dd>\n"
-                             :done
-                           end),
-
+          Inline =>TagWriter.create(nil, self, trailer: ''),
+          Block => TagWriter.create(nil, self),
           Document =>  abstract_node_writer,
-          Page =>  abstract_node_writer,
-
-          #headed-section
-          HeadedSection => 
-          TagWriter.create('section', self, write_body_preprocessor: proc do |node|
-                             output "<h#{node.level}#{ids_string(node.named_parameters[:heading_id])}>"
-                             write_nodeset node.heading
-                             @generator.context.chop_last_space
-                             output "</h#{node.level}>\n"
-                             :continue
-                           end),
-          # frontmatter
+          Page =>  page_writer,
           Frontmatter =>  frontmatter_writer,
-          # pre-formatted
-          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),
           }
       end
 
@@ -180,7 +59,7 @@ module NoraMark
             end
             @id_pool[id] = x
           end
-          @headings << x if (x.kind_of?(Block) && x.name =~ /h[1-6]/) || x.kind_of?(HeadedSection)
+          @headings << x if (x.kind_of?(Block) && x.name =~ /h[1-6]/) 
         end
       end
       def assign_id_to_headings 
@@ -188,27 +67,24 @@ module NoraMark
         count = 1
         @headings.each do
           |heading|
-          if heading.ids.size == 0 || heading.kind_of?(HeadedSection)
+          if heading.ids.size == 0 
             begin 
               id = "heading_index_#{count}"
               count = count + 1
             end while @id_pool[id]
-            heading.kind_of?(HeadedSection) ? (heading.named_parameters[:heading_id] ||= []) << id : heading.ids << id
+            heading.ids << id
           end
         end
       end
 
       def convert(parsed_result, render_parameter = {})
-        @parsed_result = parsed_result
-
+        DEFAULT_TRANSFORMER.options[:render_parameter] = render_parameter
+        @parsed_result = DEFAULT_TRANSFORMER.transform parsed_result
         assign_id_to_headings 
 
         children = parsed_result.children
         @context.file_basename = parsed_result.document_name
         @context.render_parameter = render_parameter
-        if render_parameter[:nonpaged]
-          @writers[Newpage] = @hr_writer
-        end
         children.each {
           |node|
           to_html(node)