arti_mark 0.0.1.beta4 → 0.1.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: abd2001b34dc838a27ba1c9f1e188fde512e2468
-  data.tar.gz: 3d683b3d4c7e09efd3414ab6c62503d09d804503
+  metadata.gz: 62679290ba21c0b408d4fff89c820958fa789ff6
+  data.tar.gz: a16462606130c072726ce1d86bb0e677ce267ed3
 SHA512:
-  metadata.gz: a01c7e24864ca6fa710ca1b22e13c3c8e00f2ab13d2aa0036aa268be4501d63c82266d5a7192dc7420750816495417b46ca9d8090037c817711558037a592d14
-  data.tar.gz: 51e4d4bef90306fb68f879fcaf8db6305bc54a6b52a402f50b62cf4db2628d963352a9bfeac09a75e14e8973014152aab239dd53812fbfd88a09dc648f110976
+  metadata.gz: 33bdc6ff8f9b6bf47352876b60fbac750a6ea4f616c9f85197af9ce9a08d9773ac33ef6450ee4f63b33ac6bb6696eefa03a7f394c6d46243eb9ced1cc8977122
+  data.tar.gz: 946a6ef094042486ab500081851c7d8d19e613ae356d5fe0fc98c67eeb3780fe9dd271543f98f6a0cb2f9655849b6976d195126f02c6c951b9efd79c3c555e1c

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# version 0.1beta1 (pre NoraText)
+
+ * Totally rewrite using kpeg.
+ * degrage : toc feature removed (for the old toc feature is so poor)
+ * degrade : removed custom BlockParser. Instead of the feature, easy and powerful customization will be introduced in NoraText 0.1)
+ * markup change: alternate block notation starting with 'd{---' has removed
+ * markup change: inline image notation is changed form [img(alt-text){src}] to [img(src, alt)]
+
+ * will change the name from ArtiMark to NoraText on next release 0.1rc1
+ 
+ 
+ 

data/README.md

@@ -2,9 +2,9 @@
 
 ArtiMark is a simple text markup language. It is designed to create XHTML files for EPUB books. It is optimized for Japanese text for the present. 
 
-**CAUTION This is very early alpha version, so it's not stable at all. Even the markup syntax will change. **
+**CAUTION This is very early alpha version, so it's not stable at all.**
 
-I hope it will be partly stable by the end of Feburary, 2013
+Reimplemented new version will be released on the end of Feb. 2014. Some syntax will be changed on the new version. The name of the library may change.
 
 ## Installation
 

data/Rakefile

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

data/arti_mark.gemspec

@@ -15,6 +15,8 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = ArtiMark::VERSION
 
-  gem.add_development_dependency "rspec", "~> 2.11"
-  gem.add_development_dependency "nokogiri", "~> 1.5.6"
+  gem.required_ruby_version = '>= 2.0.0'
+  gem.add_dependency "kpeg"
+  gem.add_development_dependency "rspec", "~> 2.14"
+  gem.add_development_dependency "nokogiri", "~> 1.6.0"
 end

data/lib/arti_mark/block_image_parser.rb

@@ -19,8 +19,8 @@ module ArtiMark
       
       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 << "<img src='#{src}' alt='#{escape_html alt}' />"
+      r << "<p>#{escape_html caption}</p>" if !caption.nil?  && caption.size > 0 && !caption_before
       r << "</div>\n"
     end
   end

data/lib/arti_mark/{context.rb → html/context.rb}

@@ -1,4 +1,5 @@
 module ArtiMark
+module Html
   class Context
     attr_accessor :title, :head_inserters, :toc, :lang, :stylesheets, :enable_pgroup
     def initialize(param = {})
@@ -25,7 +26,10 @@ module ArtiMark
         ret
       end
     end
-  
+    def chop_last_space
+      @pages.last.sub!(/[[:space:]]+$/, '')
+    end
+
     def head_inserter(&block)
       head_inserters << block
     end
@@ -91,3 +95,4 @@ module ArtiMark
     end
   end
 end
+end

data/lib/arti_mark/html/generator.rb

@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+require 'arti_mark/html/util'
+require 'arti_mark/html/result'
+require 'arti_mark/html/context'
+require 'arti_mark/html/tag_writer'
+require 'arti_mark/html/header_writer'
+require 'arti_mark/html/writer_selector'
+module ArtiMark
+  module Html
+    class Generator
+      include Util
+      attr_reader :context
+      def initialize(param = {})
+        @context = Context.new(param)
+        article_writer = TagWriter.create('article', self)
+        link_writer = TagWriter.create('a', self, trailer: '', 
+                                       item_preprocessor: proc do |item|
+                                         (item[:attrs] ||= {}).merge!({:href => [ item[:args][0] ]})
+                                         item
+                                       end)
+
+        header_writer = HeaderWriter.new self
+
+        @writers = {
+          :paragraph =>
+          TagWriter.create('p', self, chop_last_space: true,
+                           item_preprocessor: proc do |item|
+                             add_class(item, 'noindent') if item[:children][0] =~/^(「|『|（)/  # TODO: should be plaggable}
+                             item
+                           end
+                           ),
+          :paragraph_group =>
+          TagWriter.create("div", self,
+                           item_preprocessor: proc do |item|
+                             add_class item, 'pgroup'
+                             item[:no_tag] = true unless @context.enable_pgroup
+                             item
+                           end
+                           ),
+
+          :block =>
+          WriterSelector.new(self,
+                             {
+                               'd' => TagWriter.create('div', self),
+                               'art' => article_writer,
+                               'article' => article_writer
+                             }),
+          :line_command =>
+          WriterSelector.new(self,
+                             {
+                               'image' =>
+                               TagWriter.create('div', self,
+                                                item_preprocessor: proc do |item|
+                                                  add_class_if_empty item, 'img-wrap'
+                                                  item
+                                                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>"
+                                                  end
+                                                  output "<img src='#{src}' alt='#{escape_html alt}' />"
+                                                  if !caption_before && children_not_empty(item)
+                                                    output "<p>"; write_children item; output "</p>"
+                                                  end
+                                                  :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.start_html(title)
+                                                  :done
+                                                end
+                                                ),
+
+                               }),
+          :inline =>
+          WriterSelector.new(self, 
+                             {
+                               'link' => link_writer,
+                               'l' => link_writer,
+                               '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
+                                                end)  ,
+                               'tcy' =>
+                               TagWriter.create('span', self,
+                                                item_preprocessor: proc do |item|
+                                                  add_class item, 'tcy'
+                                                  item
+                                                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>"
+                                                  :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>"
+                             :done
+                           end),
+          # headers
+          :stylesheets => header_writer,
+          :title => header_writer,
+          :lang => header_writer,
+          }
+      end
+
+      def convert(parsed_result)
+        parsed_result.each {
+          |item|
+          to_html(item)
+        }
+        @context.result
+      end
+      def to_html(item)
+        if item.is_a? String
+          @context << escape_html(item)
+        else
+          writer = @writers[item[:type]]
+          if writer.nil?
+            warn "can't find html generator for \"#{item}\""
+            @context << escape_html(item[:raw_text])
+          else
+            writer.write(item)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arti_mark/html/header_writer.rb

@@ -0,0 +1,32 @@
+module ArtiMark
+  module Html
+    class HeaderWriter
+      include Util
+      def initialize(generator)
+        @generator = generator
+        @context = generator.context
+        @writers = {
+          :stylesheets => proc do |item|
+            @context.stylesheets.concat( item[:stylesheets].map do
+              |s|
+              if s =~ /^(.+?\.css):\((.+?)\)$/
+                [$1, $2]
+              else
+                s
+              end
+            end)
+          end,
+          :title => proc do |item|
+            @context.title = escape_html item[:title].strip
+          end,
+          :lang => proc do |item|
+            @context.lang = escape_html item[:lang].strip
+          end
+        }
+      end
+      def write(item)
+        @writers[item[:type]].call item
+      end
+    end
+  end
+end

data/lib/arti_mark/html/result.rb

@@ -0,0 +1,27 @@
+module ArtiMark
+  module Html
+    class Context
+      class Result < Array
+        def initialize
+          super
+        end
+
+        def write_as_files(prefix, format='%03d')
+          self.each_with_index {
+            |converted, i|
+            File.open("#{prefix}_#{format%(i+1)}.xhtml", 'w+') {
+              |file|
+              file << converted
+            }
+          }
+        end 
+        def write_as_single_file(filename)
+          File.open(filename, 'w+') {
+            |file|
+            file << self[0]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/arti_mark/html/tag_writer.rb

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

data/lib/arti_mark/html/util.rb

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

data/lib/arti_mark/html/writer_selector.rb

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

data/lib/arti_mark/parser.kpeg

@@ -0,0 +1,97 @@
+%% name = ArtiMark::Parser
+
+# literals
+eof = !.
+space = ' ' | '\t' 
+eof_comment = lh space* "#" (!eof .)*
+comment =   lh space* "#" (!nl .)* nl
+
+- =  ( space | comment )*
+empty_line = lh - nl
+nl = /\r?\n/
+lh = /^/
+le = nl | /$/
+word  = < /[\w0-9]/ ( '-' | /[\w0-9]/ )* >  { text }
+num = < [0-9]+ > { text.to_i }
+
+#common syntax
+classname = '.' word:classname { classname }
+classnames = (classname)*:classnames { classnames }
+idname = '#' word:idname { idname }
+idnames = (idname)*:idnames { idnames }
+
+commandname = word:name idnames?:idnames classnames?:classes  { {:name => name, :ids => idnames, :classes => classes} }
+parameter = < ( /[^,)]/* | '"' /[^"]/* '"' | "'" /[^']/* "'" ) > { text }
+parameters = < parameter (',' parameter)* > { text }
+command = commandname:commandname ('(' - parameters:arg - ')')? { arg ||= ''; commandname.merge({ :args => arg.split(',') }) }
+
+# paragraph
+implicit_paragraph = < (!paragraph_delimiter - documentline - ):paragraph > { create_item(:paragraph, nil, paragraph, raw: text) }
+paragraph = explicit_paragraph | implicit_paragraph 
+
+# paragraph_group
+paragraph_group = < (paragraph nl | paragraph )+:paragraphs empty_line* > { create_item(:paragraph_group, nil, paragraphs, raw: text) }
+
+# explicit block 
+blockhead = lh - command:command - '{' - le { command }
+blockend = lh - '}' - le
+blockbody = (!blockend block)+:body { body } 
+explicit_block = < blockhead:head blockbody:body blockend > { create_item(:block, head, body, raw: text) }
+
+# inline command
+inline = img_inline | common_inline
+common_inline = < '[' command:command '{' documentcontent_except('}'):content '}' ']' > { create_item(:inline, command, content, raw: text) }
+
+#img inline
+img_command = command:command &{ command[:name] == 'img' && command[:args].size == 2}
+img_inline = < '[' img_command:command  ']' > { create_item(:inline, command, nil, raw: text) } 
+
+# special line commands
+# newpage
+newpage = line_command:item &{ item[:name] == 'newpage' }
+# explicit paragraph
+explicit_paragraph_command = command:command &{ command[:name] == 'p' }
+explicit_paragraph = < lh - explicit_paragraph_command:command ':' documentcontent?:content le > { create_item(:paragraph, command, content, raw:text) }
+
+# unordered list
+unordered_list = < unordered_item+:items > { create_item(:ul, nil, items, raw: text) }
+unordered_item = < lh '*:' documentcontent:content le > { create_item(:li, nil, content, raw: text) }
+
+# ordered list
+ordered_list = < ordered_item+:items > { create_item(:ol, nil, items, raw: text) }
+ordered_item = < lh num ':' documentcontent:content le > { create_item(:li, nil, content, raw: text) }
+
+# definition list
+definition_list = < definition_item+:items > { create_item(:dl, nil, items, raw: text) }
+definition_item = < lh ';:' - documentcontent_except(':'):term ':' - documentcontent:definition le > { create_item(:dtdd, {:args => [term, definition]}, nil, raw: text) }
+
+items_list = unordered_list | ordered_list | definition_list
+
+
+# generic line command
+line_command = < lh - (!explicit_paragraph_command command):command ':' documentcontent?:content le > { create_item(:line_command, command, content, raw: text) }
+
+# blocks
+block = items_list | line_command  | explicit_block | paragraph_group | empty_line+
+block_delimiter = blockhead | blockend | newpage 
+paragraph_delimiter = block | block_delimiter
+
+# texts
+char = < /[[:print:]]/ > { text }
+charstring = < char* > { text }
+char_except(e) = char:c &{ c != e }
+charstring_except(e) = < char_except(e)* > { text }
+documentcontent_except(e) = (inline | !inline char_except(e))+:content ~parse_text(content)
+documentcontent = (inline | !inline char)+:content  ~parse_text(content)
+documentline = lh documentcontent:content /$/ { content }
+
+#header
+stylesheets = < lh - 'stylesheets:' (!le charstring):stylesheets le  > { create_item(:stylesheets, {:stylesheets => stylesheets.split(',').map(&:strip)}, nil, raw:text) }
+title = < lh - 'title:' (!le charstring):title le  > { create_item(:title, {:title => title }, nil, raw:text) }
+lang = < lh - 'lang:' (!le charstring):lang le  > { create_item(:lang, {:lang => lang }, nil, raw:text) }
+header = stylesheets | title | lang
+
+#root
+root = header*:headers block*:blocks eof_comment? eof { headers + blocks }
+
+