arti_mark 0.0.1.beta3 → 0.0.1.beta4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: abd2001b34dc838a27ba1c9f1e188fde512e2468
+  data.tar.gz: 3d683b3d4c7e09efd3414ab6c62503d09d804503
+SHA512:
+  metadata.gz: a01c7e24864ca6fa710ca1b22e13c3c8e00f2ab13d2aa0036aa268be4501d63c82266d5a7192dc7420750816495417b46ca9d8090037c817711558037a592d14
+  data.tar.gz: 51e4d4bef90306fb68f879fcaf8db6305bc54a6b52a402f50b62cf4db2628d963352a9bfeac09a75e14e8973014152aab239dd53812fbfd88a09dc648f110976

data/lib/arti_mark/base_parser.rb

@@ -23,4 +23,4 @@ module ArtiMark
       end
     end
   end
-end
+end

data/lib/arti_mark/block_image_parser.rb

@@ -13,12 +13,15 @@ module ArtiMark
       lines.shift
       lexed[:cls] << 'img-wrap' if lexed[:cls].size == 0
       src = lexed[:params][0].strip
-      alt = lexed[:params][1].strip
+      alt = lexed[:params][1].strip if !lexed[:params][1].nil?
       caption = lexed[:text].strip
-
-      r << "<div#{class_string(lexed[:cls])}><img src='#{src}' alt='#{alt}' />"
-      r << "<p>#{caption}</p>" if !caption.nil?  && caption.size > 0
+      caption_before = lexed[:named_params][:caption_before]
+      
+      r << "<div#{ids_string(lexed[:ids])}#{class_string(lexed[:cls])}>"
+      r << "<p>#{caption}</p>" if !caption.nil?  && caption.size > 0 && caption_before
+      r << "<img src='#{src}' alt='#{alt}' />"
+      r << "<p>#{caption}</p>" if !caption.nil?  && caption.size > 0 && !caption_before
       r << "</div>\n"
     end
   end
-end
+end

data/lib/arti_mark/command_lexer.rb

@@ -8,45 +8,70 @@ module ArtiMark
         gsub('"', """)
     end
 
-    def class_string(cls_array)
-      if cls_array.size == 0
+    def attr_string(the_array, attr_name) 
+      if the_array.size == 0
         ''
       else
-        " class='#{cls_array.join(' ')}'"
+        " #{attr_name}='#{the_array.join(' ')}'"
       end
     end
 
-    def class_array(cls_part)
-      cls_array = []
-      if !cls_part.nil? && cls_part.size > 0
-        cls_array = cls_part[1..-1].split('.')
+    def class_string(cls_array)
+      attr_string(cls_array, 'class')
+    end
+
+    def ids_string(ids_array)
+      attr_string(ids_array, 'id')
+    end
+    def attr_array(part, separator=".") 
+      the_array = []
+      if !part.nil? && part.size > 0
+        the_array = part[1..-1].split(separator)
       end
-      cls_array
+      the_array
+    end
+    def id_array(id_part)
+      attr_array(id_part, '#')
     end
 
-    def param_array(param_part)
+    def class_array(cls_part)
+      attr_array(cls_part, '.')
+    end
+
+    def param_parse(param_part)
       r = []
+      named = {}
       if !param_part.nil? && param_part.size > 0
         r = param_part.split(',')
       end
-      r
-    end 
+      r.each {
+        |param|
+        splitted = param.split(':', 2)
+        if (splitted.size == 2)
+          named[splitted[0].strip.to_sym] = splitted[1]
+        end
+      }
+      return r, named
+    end
 
     def lex_line_command(line)
-        line =~ /^([\w\*;]+?)((?:\.[A-Za-z0-9_\-]+?)*)(?:\((.+?)\))?\s*:(.*?)$/
-        return { :cmd => $1, :cls => class_array($2), :params => param_array($3), :text => $4 }
+      line =~ /^([\w\*;]+?)((?:\#[A-Za-z0-9_\-]+?)*)((?:\.[A-Za-z0-9_\-]+?)*)(?:\((.+?)\))?\s*:(.*?)$/
+      all_params, named_params = param_parse($4)
+      return { :cmd => $1, :ids => id_array($2), :cls => class_array($3), :params => all_params, :named_params => named_params, :text => $5 }
     end
 
     def lex_block_command(line)
-        line =~ /^(\w+?)((?:\.[A-Za-z0-9_\-]+?)*)(?:\((.+?)\))?\s*(?:{(---)?)\s*$/
-        return { :cmd => $1, :cls => class_array($2), :params => param_array($3), :delimiter => $4||''}
+      line =~ /^(\w+?)((?:\#[A-Za-z0-9_\-]+?)*)((?:\.[A-Za-z0-9_\-]+?)*)(?:\((.+?)\))?\s*(?:{(---)?)\s*$/
+      not_named, named = param_parse($4)
+      return { :cmd => $1, :ids => id_array($2), :cls => class_array($3), :params => not_named, :named_params => named, :delimiter => $5||''}
     end
 
     def replace_inline_commands(line, syntax, context)
-      line.gsub(/\[(\w+?)((?:\.[A-Za-z0-9_\-]+?)*)(?:\((.+?)\))?\s*{(.*?)}\]/) {
+      line.gsub(/\[(\w+?)((?:\#[A-Za-z0-9_\-]+?)*)((?:\.[A-Za-z0-9_\-]+?)*)(?:\((.+?)\))?\s*{(.*?)}\]/) {
         |matched|
-        lexed = {:cmd => $1, :cls => class_array($2), :params => param_array($3), :text => $4 }
-        if !lexed[:cmd].nil? 
+        not_named, named = param_parse($4)        
+        lexed = {:cmd => $1, :ids => id_array($2), :cls => class_array($3), :params => not_named, :named_params => named, :text => $5 }
+        if !lexed[:cmd].nil?
           syntax.inline_handler.send(lexed[:cmd], lexed, context)
         else
           matched
@@ -55,4 +80,4 @@ module ArtiMark
     end
 
   end
-end
+end

data/lib/arti_mark/common_block_parser.rb

@@ -13,13 +13,13 @@ module ArtiMark
       throw 'something wrong here #{lines}' unless lexed[:cmd] =~ @command
       @markup = lexed[:cmd] if @markup.nil?
       r.enter_block(lexed)
-      process_block(lines, r, syntax, lexed[:cls], lexed[:params])
+      process_block(lines, r, syntax, lexed[:ids], lexed[:cls], lexed[:params])
       r.exit_block(lexed)
     end
     
-    def process_block(lines, r, syntax, cls_array, params)
+    def process_block(lines, r, syntax, ids_array, cls_array, params)
       previous_pgroup , r.enable_pgroup = r.enable_pgroup , false if params.member? 'wo-pgroup'
-      r << "<#{@markup}#{class_string(cls_array)}>\n"
+      r << "<#{@markup}#{ids_string(ids_array)}#{class_string(cls_array)}>\n"
       while lines.size > 0
         if r.block_close? lines[0] 
           lines.shift

data/lib/arti_mark/head_parser.rb

@@ -8,11 +8,13 @@ module ArtiMark
     end
 
     def parse(lines, r, syntax)
-      lexed = lex_line_command(lines[0])
+      line = escape_html lines[0]
+      line = replace_inline_commands(line, syntax, r)      
+      lexed = lex_line_command(line)
       raise 'HeadParser called for #{lines[0]}' unless lexed[:cmd] =~ /h([1-6])/
       lines.shift
-      r << "<#{lexed[:cmd]}#{class_string(lexed[:cls])}>#{escape_html lexed[:text].strip}</#{lexed[:cmd]}>\n"
+      r << "<#{lexed[:cmd]}#{ids_string(lexed[:ids])}#{class_string(lexed[:cls])}>#{lexed[:text].strip}</#{lexed[:cmd]}>\n"
       r.toc = lexed[:text].strip if lexed[:params].member? 'in-toc'
     end
   end
-end
+end

data/lib/arti_mark/list_parser.rb

@@ -10,7 +10,7 @@ module ArtiMark
 
     def parse(lines, r, syntax)
       lexed = lex_line_command(lines[0])
-      r << "<#{@blockname}#{class_string(lexed[:cls])}>\n"
+      r << "<#{@blockname}#{ids_string(lexed[:ids])}#{class_string(lexed[:cls])}>\n"
       process_block(lines, r, syntax)
       r << "</#{@blockname}>\n"
     end

data/lib/arti_mark/syntax.rb

@@ -30,10 +30,9 @@ module ArtiMark
             parser.method(:parse)
           ]
         }
-
       def @inline_handler.l(lexed, context)
         ref = lexed[:params][0].strip
-        "<a#{class_string(lexed[:cls])} href='#{ref}'>#{lexed[:text].strip}</a>"
+        "<a#{ids_string(lexed[:ids])}#{class_string(lexed[:cls])} href='#{ref}'>#{lexed[:text].strip}</a>"
       end
 
       def @inline_handler.link(lexed, context)
@@ -42,38 +41,38 @@ module ArtiMark
 
       def @inline_handler.s(lexed, context)
         cls, text = lexed[:cls], lexed[:text]
-        "<span#{class_string(cls)}>#{text.strip}</a>"
+        "<span#{ids_string(lexed[:ids])}#{class_string(cls)}>#{text.strip}</span>"
       end
 
       def @inline_handler.img(lexed, context)
         cls, param, text = lexed[:cls], lexed[:params], lexed[:text]
-        "<img#{class_string(cls)} src='#{text.strip}' alt='#{param.join(' ')}' />"
+        "<img#{ids_string(lexed[:ids])}#{class_string(cls)} src='#{text.strip}' alt='#{param.join(' ')}' />"
       end
 
       def @inline_handler.ruby(lexed, context)
         cls, param, text = lexed[:cls], lexed[:params], lexed[:text]
-        "<ruby#{class_string(cls)}>#{text.strip}<rp>(</rp><rt>#{param.join}</rt><rp>)</rp></ruby>"
+        "<ruby#{ids_string(lexed[:ids])}#{class_string(cls)}>#{text.strip}<rp>(</rp><rt>#{param.join}</rt><rp>)</rp></ruby>"
       end
 
       def @inline_handler.tcy(lexed, context)
         cls, text = lexed[:cls],  lexed[:text]
         cls << 'tcy'
-        "<span#{class_string(cls)}>#{text.strip}</span>"
+        "<span#{ids_string(lexed[:ids])}#{class_string(cls)}>#{text.strip}</span>"
       end
 
       # universal inline command handler
       def @inline_handler.method_missing(cmd, *args)
-        cls, text = args[0][:cls], args[0][:text]
-        "<#{cmd}#{class_string(cls)}>#{text.strip}</#{cmd}>"
+        ids, cls, text = args[0][:ids], args[0][:cls], args[0][:text]
+        "<#{cmd}#{ids_string(ids)}#{class_string(cls)}>#{text.strip}</#{cmd}>"
       end
 
       def @linecommand_handler.p(lexed, context)
         cls, text = lexed[:cls], lexed[:text]
-        "<p#{class_string(cls)}>#{text.strip}</p>\n"
+        "<p#{ids_string(lexed[:ids])}#{class_string(cls)}>#{text.strip}</p>\n"
       end
 
       def @linecommand_handler.stylesheets(lexed, context)
-          context.stylesheets =  lexed[:text].split(',').map {|s|
+          context.stylesheets = lexed[:text].split(',').map {|s|
             s.strip!
             if s =~ /^(.+?\.css):\((.+?)\)$/
               [$1, $2]
@@ -96,10 +95,8 @@ module ArtiMark
 
       #univarsal line command handler
       def @linecommand_handler.method_missing(cmd, *args)
-        "<#{cmd}#{class_string(args[0][:cls])}>#{args[0][:text].strip}</#{cmd}>\n"
+        "<#{cmd}#{ids_string(args[0][:ids])}#{class_string(args[0][:cls])}>#{args[0][:text].strip}</#{cmd}>\n"
       end
-
-
     end
 
     def determine_parser(lines, opt = {})
@@ -117,6 +114,22 @@ module ArtiMark
       end
     end
 
+    def append_parser(parser)
+      if parser.respond_to?(:accept?) && parser.respond_to?(:parse)
+        @block_parsers << [
+                           parser.method(:accept?),
+                           parser.method(:parse)
+                          ]
+      elsif parser[:accept?] && parser[:parse]
+        @block_parsers << [
+                           parser[:accept?],
+                           parser[:parse]
+                          ]
+      else
+        raise 'parser should define accept? and parse' if !(parser.respond_to?(:accept?) && parser.respond_to?(:parse))
+      end
+    end
+    
     def default_parser
       ParagraphParser.instance.method(:parse)
     end

data/lib/arti_mark/version.rb

@@ -1,3 +1,3 @@
 module ArtiMark
-  VERSION = "0.0.1.beta3"
+  VERSION = "0.0.1.beta4"
 end

data/lib/arti_mark.rb

@@ -25,13 +25,17 @@ module ArtiMark
       @syntax = Syntax.new
       @preprocessors = [
                         Proc.new { |text| text.gsub(/\r?\n(\r?\n)+/, "\n\n") },
-                        Proc.new { |text| text.strip.gsub(/　/, ' ') } # Japanese full-width spece to half space width
+                        Proc.new { |text| text.strip.gsub(/　/, ' ') } # convert Japanese full-width spece to normal space
                        ]
     end 
 
     def preprocessor(&block)
       @preprocessors << block
     end
+
+    def parser(parser)
+        @syntax.append_parser(parser)
+    end
     
     def convert(text)
       @preprocessors.each {

data/spec/arti_mark_spec.rb

@@ -123,6 +123,18 @@ describe ArtiMark do
       )
     end
 
+    it 'should convert div with id and class' do
+      text = "d#thecontents.preface-one {\n h1: title.\n}"
+      artimark = ArtiMark::Document.new(:lang => 'ja', :title => 'the document title')
+      converted = artimark.convert(text)
+      body = Nokogiri::XML::Document.parse(converted[0]).root.at_xpath('xmlns:body')
+      expect(body.element_children[0].selector_and_children).to eq(
+        ['div#thecontents.preface-one',
+         ['h1', 'title.']
+        ]
+      )
+    end
+
     it 'should convert nested div' do
       text = "d.preface {\n outer div. \n d.nested {\n nested!\n}\nouter div again.\n}"
       artimark = ArtiMark::Document.new(:lang => 'ja', :title => 'the document title')
@@ -222,6 +234,25 @@ describe ArtiMark do
       )      
     end
 
+    it 'should handle block image with before caption' do
+      text = "this is normal line.\nimage(./image1.jpg, alt text, caption_before: true): caption text"
+      artimark = ArtiMark::Document.new(:lang => 'ja', :title => 'the document title')
+      converted = artimark.convert(text)
+      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', 'this is normal line.']
+       ]
+      )      
+      expect(body.element_children[1].selector_and_children).to eq(
+       ['div.img-wrap',
+        ['p', 'caption text'],
+        ["img[src='./image1.jpg'][alt='alt text']", '']
+       ]
+      )      
+    end
+
+    
     it 'should handle page change article' do
       text = "this is start.\nnewpage(page changed):\nthis is second page.\nnewpage:\nand the third."
       artimark = ArtiMark::Document.new(:lang => 'ja', :title => 'the document title')
@@ -381,6 +412,14 @@ describe ArtiMark do
       expect(toc[3]).to eq('3rd chapter')
     end
 
+    it 'should convert inline command within line block' do
+      text = "h1: [tcy{20}]縦中横タイトル"
+      artimark = ArtiMark::Document.new(:lang => 'ja', :title => 'the document title')
+      converted = artimark.convert(text)
+      body = Nokogiri::XML::Document.parse(converted[0]).root.at_xpath('xmlns:body')
+      expect(body.element_children[0].selector_and_children).to eq ['h1', ['span.tcy', '20'], '縦中横タイトル']
+    end
+
     it 'should handle ruby' do
       text = "[ruby(とんぼ){蜻蛉}]の[ruby(めがね){眼鏡}]はみずいろめがね"
       artimark = ArtiMark::Document.new(:lang => 'ja', :title => 'the document title')
@@ -568,6 +607,58 @@ describe ArtiMark do
         ]
       )
     end
+    it 'should handle custom block parser' do
+      class TheParser
+        include ArtiMark::BaseParser
+        def accept?(lines)
+          lex_line_command(lines[0])[:cmd] =~ /svg/
+        end
+        def parse(lines, r, syntax)
+          lexed = lex_line_command(lines[0])
+          lines.shift
+          src = lexed[:params][0].strip
+          caption = lexed[:text].strip
+          r << "<div><svg xmlns='http://www.w3.org/2000/svg' version='1.1' xmlns:xlink='http://www.w3.org/1999/xlink' width='100%' height='100%' viewBox='0 0 200 200' ><image xlink:href='#{src}' /><p>#{caption}</p></sgv></div>"
+        end
+      end
+      text="svg(img.jpg):caption"
+      artimark = ArtiMark::Document.new(:lang => 'ja', :title => 'the document title')
+      artimark.parser(TheParser.new)
+      converted = artimark.convert(text)
+      body = Nokogiri::XML::Document.parse(converted[0]).root.at_xpath('xmlns:body')      
+      expect(body.element_children[0].selector_and_children).to eq(
+        ['div', 
+         ["svg[version='1.1'][width='100%'][height='100%'][viewBox='0 0 200 200']", ["image[href='img.jpg']", ''], ['p', 'caption']]
+        ]
+      )
+    end
+    it 'should handle custom block parser with named param' do
+      class TheParser
+        include ArtiMark::BaseParser
+        def accept?(lines)
+          lex_line_command(lines[0])[:cmd] =~ /svg/
+        end
+        def parse(lines, r, syntax)
+          lexed = lex_line_command(lines[0])
+          lines.shift
+          src = lexed[:params][0].strip
+          width = lexed[:named_params][:width]
+          height = lexed[:named_params][:height]
+          caption = lexed[:text].strip
+          r << "<div><svg xmlns='http://www.w3.org/2000/svg' version='1.1' xmlns:xlink='http://www.w3.org/1999/xlink' width='100%' height='100%' viewBox='0 0 200 200' ><image xlink:href='#{src}' width='#{width}' height='#{height}' /><p>#{caption}</p></sgv></div>"
+        end
+      end
+      text="svg(img.jpg, width:200, height:200):caption"
+      artimark = ArtiMark::Document.new(:lang => 'ja', :title => 'the document title')
+      artimark.parser(TheParser.new)
+      converted = artimark.convert(text)
+      body = Nokogiri::XML::Document.parse(converted[0]).root.at_xpath('xmlns:body')      
+      expect(body.element_children[0].selector_and_children).to eq(
+        ['div', 
+         ["svg[version='1.1'][width='100%'][height='100%'][viewBox='0 0 200 200']", ["image[href='img.jpg'][width='200'][height='200']", ''], ['p', 'caption']]
+        ]
+      )
+    end
   end
 end
 

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: arti_mark
 version: !ruby/object:Gem::Version
-  version: 0.0.1.beta3
-  prerelease: 6
+  version: 0.0.1.beta4
 platform: ruby
 authors:
 - KOJIMA Satoshi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-14 00:00:00.000000000 Z
+date: 2013-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -22,7 +20,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -30,7 +27,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -38,7 +34,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -66,7 +61,6 @@ files:
 - lib/arti_mark/definition_list_parser.rb
 - lib/arti_mark/div_parser.rb
 - lib/arti_mark/head_parser.rb
-- lib/arti_mark/head_parser_flymake.rb
 - lib/arti_mark/list_parser.rb
 - lib/arti_mark/ordered_list_parser.rb
 - lib/arti_mark/paragraph_parser.rb
@@ -82,27 +76,26 @@ files:
 - spec/spec_helper.rb
 homepage: ''
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>'
+  - - '>'
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: simple and customizable text markup language for EPUB
 test_files:
 - spec/arti_mark_spec.rb

data/lib/arti_mark/head_parser_flymake.rb

@@ -1,18 +0,0 @@
-#require 'singleton'
-
-module ArtiMark
-  class HeadParser
-    include BaseParser, Singleton
-    def accept?(lines)
-      lex_line_command(lines[0])[:cmd] =~ /h[1-6]/
-    end
-
-    def parse(lines, r, syntax)
-      lexed = lex_line_command(lines[0])
-      raise 'HeadParser called for #{lines[0]}' unless lexed[:cmd] =~ /h([1-6])/
-      lines.shift
-      r << "<#{lexed[:cmd]}#{class_string(lexed[:cls])}>#{escape_html lexed[:text].strip}</#{lexed[:cmd]}>\n"
-      r.toc = lexed[:text].strip if lexed[:params].member? 'in-toc'
-    end
-  end
-end