nora_mark 0.2beta4 → 0.2beta5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 19152110e62f57084dafc55a167fff6204065720
-  data.tar.gz: a860f6160b5f15d5571cfe8785ae56a107e2d24f
+  metadata.gz: 70b55ff7edfd0ea3832a9d7f239471c408dc640c
+  data.tar.gz: e3f7e05cdfb71d9681a4ce4dc3a609cde17206e8
 SHA512:
-  metadata.gz: 438c2688705e6d8cdb66d8387b806c6878232e357f026951b9bac73adf5a3334814239af291fdf1308311161b0f0efc1202edec3eb1da283a1c4b799b517c213
-  data.tar.gz: 516efbd14c9176760df9a7a40ed0d87b5bf8b4e40157654e1b941caf377ddfcaef76d01fe9d3f3d171978bcff26cdabf0a859cdf35974e1f907cdc027181b450
+  metadata.gz: de1829be0f4054b59effdfa4f46e418865e916ba2d96125682e165b37f4eb7afc18f62b8729bbbf90f565ff58d6bf3e12ca611bf8bda89fa1ccc4f6a9ffc11d8
+  data.tar.gz: cb44418db3abd96505643d739501785595aa94b9eef5b596b6e185ee9ff475677fc323f768c859ae4cd3a532ace6ee243a47c61ccbe118c1064166adc97f25ae

data/Rakefile

@@ -1,12 +1,14 @@
 #!/usr/bin/env rake
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 rule(/\.kpeg\.rb/ => proc {|task_name| task_name.sub(/kpeg\.rb$/, 'kpeg')}) do
   |t|
   system "kpeg -f #{t.prerequisites[0]}"
 end
 
+RSpec::Core::RakeTask.new(:spec)
+
 desc "run rspec"
-task :test => ["lib/nora_mark/parser.kpeg.rb"] do
-  system 'rspec'
-end
+task :test => ["lib/nora_mark/parser.kpeg.rb", :spec]
+

data/bin/nora2html

@@ -0,0 +1,15 @@
+require 'nora_mark'
+require 'optparse'
+require 'kconv'
+
+auto_convert_encode = false
+opt = OptionParser.new
+opt.on('--kconv') {
+  auto_convert_encode = true
+}
+
+args = opt.parse(ARGV)
+input = args.length > 0 ? File.open(args[0]).read : STDIN.read
+input = Kconv.toutf8(input) if auto_convert_encode
+
+puts NoraMark::Document::parse(input).render_parameter(nonpaged: true).html[0]

data/lib/nora_mark/html/context.rb

@@ -1,7 +1,7 @@
 module NoraMark
   module Html
     class Context
-      attr_accessor :title, :head_inserters, :toc, :lang, :stylesheets, :enable_pgroup
+      attr_accessor :title, :head_inserters, :toc, :lang, :stylesheets, :enable_pgroup, :render_parameter
       def initialize(param = {})
         @head_inserters = []
         @toc = []
@@ -12,6 +12,7 @@ module NoraMark
         self.paragraph_style= param[:paragraph_style]
         @pages = Pages.new(param[:sequence_format])
         @block_delimiter_stack = []
+        @render_parameter = {}
         head_inserter do
           ret = ""
           @stylesheets.each { |s|

data/lib/nora_mark/html/generator.rb

@@ -25,6 +25,28 @@ module NoraMark
         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)
+
         @writers = {
           Paragraph => paragraph_writer,
           ParagraphGroup => paragraph_writer,
@@ -69,22 +91,7 @@ module NoraMark
                                '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
-                           ),
+          Newpage => newpage_writer,
           Inline =>
           WriterSelector.new(self, 
                              {
@@ -162,9 +169,13 @@ module NoraMark
           }
       end
 
-      def convert(parsed_result)
+      def convert(parsed_result, render_parameter = {})
         children = parsed_result.content
         @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)

data/lib/nora_mark/parser.kpeg

@@ -42,12 +42,22 @@ CommandName = Word:name IdNames?:idnames ClassNames?:classes  { {name: name, ids
 ParameterNormal = < /[^,)]/* > { text }
 ParameterQuoted = '"' < /[^"]/* > '"' - &/[,)]/  { text }
 ParameterSingleQuoted = "'" < /[^']/* > "'" - &/[,)]/ { text }
-Parameter = (ParameterQuoted | ParameterSingleQuoted | ParameterNormal ):value { value }
-Parameters = Parameter:parameter (',' - Parameter)*:rest_parameters { [parameter] + rest_parameters }
+Parameter = (ParameterQuoted
+           | ParameterSingleQuoted
+           | ParameterNormal ):value { value }
+
+Parameters = Parameter:parameter ',' - Parameters:parameters { [ parameter ] + parameters }
+           | Parameter:parameter { [ parameter ] }
+
 Command = CommandName:cn ('(' - Parameters:args - ')')? { args ||= []; cn.merge({ args: args }) }
 
 # paragraph
 ImplicitParagraph = - !ParagraphDelimiter Comment* DocumentLine:content  Comment* EofComment? ~paragraph([],[], [], content)
+
+# explicit paragraph
+ExplicitParagraphCommand = Command:c &{ c[:name] == 'p' }
+ExplicitParagraph = - ExplicitParagraphCommand:c ':' - DocumentContent?:content Le EmptyLine* ~paragraph(c[:ids], c[:classes], c[:args], content)
+
 Paragraph = ExplicitParagraph | ImplicitParagraph 
 
 # paragraph_group
@@ -88,10 +98,6 @@ CommandNameForSpecialLineCommand = NewpageCommand | ExplicitParagraphCommand
 NewpageCommand = Command:command &{ command[:name] == 'newpage' }
 Newpage = - NewpageCommand:c ':' - DocumentContent?:content - Nl ~newpage(c[:ids],c[:classes],c[:args], content)
 
-# explicit paragraph
-ExplicitParagraphCommand = Command:c &{ c[:name] == 'p' }
-ExplicitParagraph = - ExplicitParagraphCommand:c ':' - DocumentContent?:content Le EmptyLine* ~paragraph(c[:ids], c[:classes], c[:args], content)
-
 
 # unordered list
 UnorderedList = UnorderedItem+:items ~unordered_list([],[],[], items)
@@ -168,10 +174,11 @@ DocumentLine = DocumentContent:content Le { content }
 
 #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 }
+Pages = Page:page Newpage:newpage Pages:pages { [ page, newpage ] + pages }
+      | Page:page { [ page ] }  
 
 #root
-root = Page:page NewpagedPage*:pages - EofComment? Eof { [ page ] + pages }
+root = Pages:pages - EofComment? Eof { pages }
 
 
 

data/lib/nora_mark/parser.kpeg.rb

@@ -921,56 +921,67 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # Parameters = Parameter:parameter ("," - Parameter)*:rest_parameters { [parameter] + rest_parameters }
+  # Parameters = (Parameter:parameter "," - Parameters:parameters { [ parameter ] + parameters } | Parameter:parameter { [ parameter ] })
   def _Parameters
 
     _save = self.pos
-    while true # sequence
-      _tmp = apply(:_Parameter)
-      parameter = @result
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      _ary = []
-      while true
+    while true # choice
 
-        _save2 = self.pos
-        while true # sequence
-          _tmp = match_string(",")
-          unless _tmp
-            self.pos = _save2
-            break
-          end
-          _tmp = apply(:__hyphen_)
-          unless _tmp
-            self.pos = _save2
-            break
-          end
-          _tmp = apply(:_Parameter)
-          unless _tmp
-            self.pos = _save2
-          end
+      _save1 = self.pos
+      while true # sequence
+        _tmp = apply(:_Parameter)
+        parameter = @result
+        unless _tmp
+          self.pos = _save1
           break
-        end # end sequence
+        end
+        _tmp = match_string(",")
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:__hyphen_)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_Parameters)
+        parameters = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        @result = begin;  [ parameter ] + parameters ; end
+        _tmp = true
+        unless _tmp
+          self.pos = _save1
+        end
+        break
+      end # end sequence
 
-        _ary << @result if _tmp
-        break unless _tmp
-      end
-      _tmp = true
-      @result = _ary
-      rest_parameters = @result
-      unless _tmp
-        self.pos = _save
+      break if _tmp
+      self.pos = _save
+
+      _save2 = self.pos
+      while true # sequence
+        _tmp = apply(:_Parameter)
+        parameter = @result
+        unless _tmp
+          self.pos = _save2
+          break
+        end
+        @result = begin;  [ parameter ] ; end
+        _tmp = true
+        unless _tmp
+          self.pos = _save2
+        end
         break
-      end
-      @result = begin;  [parameter] + rest_parameters ; end
-      _tmp = true
-      unless _tmp
-        self.pos = _save
-      end
+      end # end sequence
+
+      break if _tmp
+      self.pos = _save
       break
-    end # end sequence
+    end # end choice
 
     set_failed_rule :_Parameters unless _tmp
     return _tmp
@@ -1103,6 +1114,94 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
+  # ExplicitParagraphCommand = Command:c &{ c[:name] == 'p' }
+  def _ExplicitParagraphCommand
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_Command)
+      c = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save1 = self.pos
+      _tmp = begin;  c[:name] == 'p' ; end
+      self.pos = _save1
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_ExplicitParagraphCommand unless _tmp
+    return _tmp
+  end
+
+  # ExplicitParagraph = - ExplicitParagraphCommand:c ":" - DocumentContent?:content Le EmptyLine* {paragraph(c[:ids], c[:classes], c[:args], content)}
+  def _ExplicitParagraph
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_ExplicitParagraphCommand)
+      c = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = match_string(":")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save1 = self.pos
+      _tmp = apply(:_DocumentContent)
+      @result = nil unless _tmp
+      unless _tmp
+        _tmp = true
+        self.pos = _save1
+      end
+      content = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_Le)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      while true
+        _tmp = apply(:_EmptyLine)
+        break unless _tmp
+      end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; paragraph(c[:ids], c[:classes], c[:args], content); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_ExplicitParagraph unless _tmp
+    return _tmp
+  end
+
   # Paragraph = (ExplicitParagraph | ImplicitParagraph)
   def _Paragraph
 
@@ -2042,94 +2141,6 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # ExplicitParagraphCommand = Command:c &{ c[:name] == 'p' }
-  def _ExplicitParagraphCommand
-
-    _save = self.pos
-    while true # sequence
-      _tmp = apply(:_Command)
-      c = @result
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      _save1 = self.pos
-      _tmp = begin;  c[:name] == 'p' ; end
-      self.pos = _save1
-      unless _tmp
-        self.pos = _save
-      end
-      break
-    end # end sequence
-
-    set_failed_rule :_ExplicitParagraphCommand unless _tmp
-    return _tmp
-  end
-
-  # ExplicitParagraph = - ExplicitParagraphCommand:c ":" - DocumentContent?:content Le EmptyLine* {paragraph(c[:ids], c[:classes], c[:args], content)}
-  def _ExplicitParagraph
-
-    _save = self.pos
-    while true # sequence
-      _tmp = apply(:__hyphen_)
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      _tmp = apply(:_ExplicitParagraphCommand)
-      c = @result
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      _tmp = match_string(":")
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      _tmp = apply(:__hyphen_)
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      _save1 = self.pos
-      _tmp = apply(:_DocumentContent)
-      @result = nil unless _tmp
-      unless _tmp
-        _tmp = true
-        self.pos = _save1
-      end
-      content = @result
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      _tmp = apply(:_Le)
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      while true
-        _tmp = apply(:_EmptyLine)
-        break unless _tmp
-      end
-      _tmp = true
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      @result = begin; paragraph(c[:ids], c[:classes], c[:args], content); end
-      _tmp = true
-      unless _tmp
-        self.pos = _save
-      end
-      break
-    end # end sequence
-
-    set_failed_rule :_ExplicitParagraph unless _tmp
-    return _tmp
-  end
-
   # UnorderedList = UnorderedItem+:items {unordered_list([],[],[], items)}
   def _UnorderedList
 
@@ -3549,54 +3560,74 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # NewpagedPage = Newpage:newpage Page:page { page.content = page.content.unshift newpage; page }
-  def _NewpagedPage
+  # Pages = (Page:page Newpage:newpage Pages:pages { [ page, newpage ] + pages } | Page:page { [ page ] })
+  def _Pages
 
     _save = self.pos
-    while true # sequence
-      _tmp = apply(:_Newpage)
-      newpage = @result
-      unless _tmp
-        self.pos = _save
+    while true # choice
+
+      _save1 = self.pos
+      while true # sequence
+        _tmp = apply(:_Page)
+        page = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_Newpage)
+        newpage = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_Pages)
+        pages = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        @result = begin;  [ page, newpage ] + pages ; end
+        _tmp = true
+        unless _tmp
+          self.pos = _save1
+        end
         break
-      end
-      _tmp = apply(:_Page)
-      page = @result
-      unless _tmp
-        self.pos = _save
+      end # end sequence
+
+      break if _tmp
+      self.pos = _save
+
+      _save2 = self.pos
+      while true # sequence
+        _tmp = apply(:_Page)
+        page = @result
+        unless _tmp
+          self.pos = _save2
+          break
+        end
+        @result = begin;  [ page ] ; end
+        _tmp = true
+        unless _tmp
+          self.pos = _save2
+        end
         break
-      end
-      @result = begin;  page.content = page.content.unshift newpage; page ; end
-      _tmp = true
-      unless _tmp
-        self.pos = _save
-      end
+      end # end sequence
+
+      break if _tmp
+      self.pos = _save
       break
-    end # end sequence
+    end # end choice
 
-    set_failed_rule :_NewpagedPage unless _tmp
+    set_failed_rule :_Pages unless _tmp
     return _tmp
   end
 
-  # root = Page:page NewpagedPage*:pages - EofComment? Eof { [ page ] + pages }
+  # root = Pages:pages - EofComment? Eof { pages }
   def _root
 
     _save = self.pos
     while true # sequence
-      _tmp = apply(:_Page)
-      page = @result
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      _ary = []
-      while true
-        _tmp = apply(:_NewpagedPage)
-        _ary << @result if _tmp
-        break unless _tmp
-      end
-      _tmp = true
-      @result = _ary
+      _tmp = apply(:_Pages)
       pages = @result
       unless _tmp
         self.pos = _save
@@ -3607,11 +3638,11 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      _save2 = self.pos
+      _save1 = self.pos
       _tmp = apply(:_EofComment)
       unless _tmp
         _tmp = true
-        self.pos = _save2
+        self.pos = _save1
       end
       unless _tmp
         self.pos = _save
@@ -3622,7 +3653,7 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin;  [ page ] + pages ; end
+      @result = begin;  pages ; end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -3654,9 +3685,11 @@ class NoraMark::Parser < KPeg::CompiledParser
   Rules[:_ParameterQuoted] = rule_info("ParameterQuoted", "\"\\\"\" < /[^\"]/* > \"\\\"\" - &/[,)]/ { text }")
   Rules[:_ParameterSingleQuoted] = rule_info("ParameterSingleQuoted", "\"'\" < /[^']/* > \"'\" - &/[,)]/ { text }")
   Rules[:_Parameter] = rule_info("Parameter", "(ParameterQuoted | ParameterSingleQuoted | ParameterNormal):value { value }")
-  Rules[:_Parameters] = rule_info("Parameters", "Parameter:parameter (\",\" - Parameter)*:rest_parameters { [parameter] + rest_parameters }")
+  Rules[:_Parameters] = rule_info("Parameters", "(Parameter:parameter \",\" - Parameters:parameters { [ parameter ] + parameters } | Parameter:parameter { [ parameter ] })")
   Rules[:_Command] = rule_info("Command", "CommandName:cn (\"(\" - Parameters:args - \")\")? { args ||= []; cn.merge({ args: args }) }")
   Rules[:_ImplicitParagraph] = rule_info("ImplicitParagraph", "- !ParagraphDelimiter Comment* DocumentLine:content Comment* EofComment? {paragraph([],[], [], content)}")
+  Rules[:_ExplicitParagraphCommand] = rule_info("ExplicitParagraphCommand", "Command:c &{ c[:name] == 'p' }")
+  Rules[:_ExplicitParagraph] = rule_info("ExplicitParagraph", "- ExplicitParagraphCommand:c \":\" - DocumentContent?:content Le EmptyLine* {paragraph(c[:ids], c[:classes], c[:args], content)}")
   Rules[:_Paragraph] = rule_info("Paragraph", "(ExplicitParagraph | ImplicitParagraph)")
   Rules[:_ParagraphGroup] = rule_info("ParagraphGroup", "Paragraph+:p EmptyLine* {paragraph_group([],[],[],p)}")
   Rules[:_BlockHead] = rule_info("BlockHead", "- Command:command - \"{\" - Nl EmptyLine* { command }")
@@ -3679,8 +3712,6 @@ class NoraMark::Parser < KPeg::CompiledParser
   Rules[:_CommandNameForSpecialLineCommand] = rule_info("CommandNameForSpecialLineCommand", "(NewpageCommand | ExplicitParagraphCommand)")
   Rules[:_NewpageCommand] = rule_info("NewpageCommand", "Command:command &{ command[:name] == 'newpage' }")
   Rules[:_Newpage] = rule_info("Newpage", "- NewpageCommand:c \":\" - DocumentContent?:content - Nl {newpage(c[:ids],c[:classes],c[:args], content)}")
-  Rules[:_ExplicitParagraphCommand] = rule_info("ExplicitParagraphCommand", "Command:c &{ c[:name] == 'p' }")
-  Rules[:_ExplicitParagraph] = rule_info("ExplicitParagraph", "- ExplicitParagraphCommand:c \":\" - DocumentContent?:content Le EmptyLine* {paragraph(c[:ids], c[:classes], c[:args], content)}")
   Rules[:_UnorderedList] = rule_info("UnorderedList", "UnorderedItem+:items {unordered_list([],[],[], items)}")
   Rules[:_UnorderedItem] = rule_info("UnorderedItem", "\"*:\" - DocumentContent:content Le {ul_item([], [], [], content)}")
   Rules[:_OrderedList] = rule_info("OrderedList", "OrderedItem+:items {ordered_list([],[],[], items)}")
@@ -3712,7 +3743,7 @@ class NoraMark::Parser < KPeg::CompiledParser
   Rules[:_DocumentContent] = rule_info("DocumentContent", "(Inline | DocumentText)+:content { content }")
   Rules[:_DocumentLine] = rule_info("DocumentLine", "DocumentContent:content Le { content }")
   Rules[:_Page] = rule_info("Page", "Frontmatter?:frontmatter - (!Newpage Block)*:blocks {page(([frontmatter] +  blocks).select{ |x| !x.nil?})}")
-  Rules[:_NewpagedPage] = rule_info("NewpagedPage", "Newpage:newpage Page:page { page.content = page.content.unshift newpage; page }")
-  Rules[:_root] = rule_info("root", "Page:page NewpagedPage*:pages - EofComment? Eof { [ page ] + pages }")
+  Rules[:_Pages] = rule_info("Pages", "(Page:page Newpage:newpage Pages:pages { [ page, newpage ] + pages } | Page:page { [ page ] })")
+  Rules[:_root] = rule_info("root", "Pages:pages - EofComment? Eof { pages }")
   # :startdoc:
 end

data/lib/nora_mark/version.rb

@@ -1,3 +1,3 @@
 module NoraMark
-  VERSION = "0.2beta4"
+  VERSION = "0.2beta5"
 end

data/lib/nora_mark.rb

@@ -33,10 +33,15 @@ module NoraMark
 
     def html
       if @html.nil?
-        @html = @html_generator.convert(self)
+        @html = @html_generator.convert(self, @render_parameter)
       end
       @html
     end
+
+    def render_parameter(param = {})
+      @render_parameter.merge! param
+      self
+    end
     
     def initialize(param = {})
       @preprocessors = [
@@ -44,6 +49,7 @@ module NoraMark
                        ]
       @html_generator = Html::Generator.new(param)
       @document_name = param[:document_name] || "noramark_#{SecureRandom.uuid}"
+      @render_parameter = {}
     end 
 
 

data/spec/nora_mark_spec.rb

@@ -946,7 +946,23 @@ EOF
 
       end
     end
-
+    describe 'nonpaged mode' do
+      it 'should create single html' do
+        text = "some text\nnewpage:\nnext page"
+        noramark = NoraMark::Document.parse(text, lang: 'ja', title:'the document title')
+        converted = noramark.render_parameter(nonpaged: true).html
+        expect(converted.size).to eq 1
+        body = Nokogiri::XML::Document.parse(converted[0]).root.at_xpath('xmlns:body')
+        expect(body.element_children[0].selector_and_children).to eq(
+        ['div.pgroup',
+         ['p', 'some text']])
+        expect(body.element_children[1].selector_and_children).to eq(
+        ['hr.page-break'])
+        expect(body.element_children[2].selector_and_children).to eq(
+        ['div.pgroup',
+         ['p', 'next page']])
+      end
+    end
     describe 'create file' do
       before { @basedir = File.join(File.dirname(__FILE__), 'created_files') }
       after { Dir.glob(File.join(@basedir, '*.xhtml')) { |file| File.delete file } }
@@ -960,9 +976,9 @@ EOF
         text = "some text\nnewpage:\nnext page"
         noramark = NoraMark::Document.parse(text, lang: 'ja', title:'the document title', document_name: 'nora-test-file', sequence_format: '%03d' )
         noramark.html.write_as_files(directory: @basedir)
-        files = Dir.glob(File.join(@basedir, '*.xhtml'))
-        expect(File.basename(files[0])).to eq 'nora-test-file_001.xhtml'
-        expect(File.basename(files[1])).to eq 'nora-test-file_002.xhtml'
+        files = Dir.glob(File.join(@basedir, '*.xhtml')).map { |file| File.basename(file) }
+        expect(files).to include 'nora-test-file_001.xhtml'
+        expect(files).to include 'nora-test-file_002.xhtml'
       end
     end
     describe 'parse and create manual' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nora_mark
 version: !ruby/object:Gem::Version
-  version: 0.2beta4
+  version: 0.2beta5
 platform: ruby
 authors:
 - KOJIMA Satoshi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-05 00:00:00.000000000 Z
+date: 2014-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kpeg
@@ -69,7 +69,8 @@ dependencies:
 description: simple and customizable text markup language for EPUB
 email:
 - skoji@mac.com
-executables: []
+executables:
+- nora2html
 extensions: []
 extra_rdoc_files: []
 files:
@@ -80,6 +81,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- bin/nora2html
 - example/nora-simple.css
 - example/noramark-reference-ja.nora
 - example/noramark-reference-ja_00001.xhtml