arti_mark 0.1.beta3 → 0.1.beta5

data/lib/arti_mark/syntax.rb

@@ -1,147 +0,0 @@
-module ArtiMark
-  class Syntax
-    include CommandLexer
-
-    attr_accessor :inline_handler, :linecommand_handler
-
-    def initialize
-      @inline_handler = Class.new do extend CommandLexer end
-      @linecommand_handler = Class.new do extend CommandLexer end
-      @block_parsers = []
-      @block_parsers <<
-        [
-          Proc.new { |lines| lex_line_command(lines[0])[:cmd] == 'newpage' },
-          Proc.new { 
-            |lines, context, syntax|
-            lexed = lex_line_command(lines.shift)
-            if lexed[:params].size > 0
-              title = escape_html lexed[:params].first
-            else 
-              title = nil
-            end
-            context.start_html(title)
-          }
-        ]
-
-      [DivParser.instance, ArticleParser.instance, ParagraphParser.instance, HeadParser.instance, BlockImageParser.instance, OrderedListParser.instance, UnorderedListParser.instance, DefinitionListParser.instance].each {
-          |parser|
-          @block_parsers << [
-            parser.method(:accept?),
-            parser.method(:parse)
-          ]
-        }
-      def @inline_handler.l(lexed, context)
-        ref = lexed[:params][0].strip
-        "<a#{ids_string(lexed[:ids])}#{class_string(lexed[:cls])} href='#{ref}'>#{lexed[:text].strip}</a>"
-      end
-
-      def @inline_handler.link(lexed, context)
-        l(lexed, context)
-      end
-
-      def @inline_handler.s(lexed, context)
-        cls, text = lexed[:cls], lexed[:text]
-        "<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#{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#{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#{ids_string(lexed[:ids])}#{class_string(cls)}>#{text.strip}</span>"
-      end
-
-      # universal inline command handler
-      def @inline_handler.method_missing(cmd, *args)
-        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#{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|
-            s.strip!
-            if s =~ /^(.+?\.css):\((.+?)\)$/
-              [$1, $2]
-            else
-              s
-            end
-          }
-        ''
-      end
-
-      def @linecommand_handler.title(lexed, context)
-        context.title = lexed[:text].strip
-        ''
-      end
-
-      def @linecommand_handler.lang(lexed, context)
-        context.lang = lexed[:text].strip
-        ''
-      end
-
-      #univarsal line command handler
-      def @linecommand_handler.method_missing(cmd, *args)
-        "<#{cmd}#{ids_string(args[0][:ids])}#{class_string(args[0][:cls])}>#{args[0][:text].strip}</#{cmd}>\n"
-      end
-    end
-
-    def determine_parser(lines, opt = {})
-      @block_parsers.each {
-        |accept, parser|
-        return parser if accept.call(lines)
-      }
-
-      if UniversalBlockParser.instance.accept?(lines)
-        UniversalBlockParser.instance.method(:parse)
-      elsif opt[:get_default]
-          default_parser
-      else
-          nil
-      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
-
-    def parse(lines, context)
-      throw "something wrong: #{lines}" if lines[0] == '}'  # TODO: should do something here with paragraph_parser
-      if parser = determine_parser(lines)
-        parser.call(lines, context, self)
-      else
-        default_parser.call(lines, context, self)
-      end
-    end
-
-  end
-end

data/lib/arti_mark/universal_block_parser.rb

@@ -1,10 +0,0 @@
-require 'singleton'
-
-module ArtiMark
-  class UniversalBlockParser
-    include CommonBlockParser, Singleton
-    def initialize
-      @command = /\w+/
-    end
-  end
-end

data/lib/arti_mark/unordered_list_parser.rb

@@ -1,14 +0,0 @@
-# -*- encoding: utf-8 -*-
-require 'singleton'
-
-module ArtiMark
-  class UnorderedListParser
-    include ListParser, Singleton
- 
-    def initialize
-      @cmd = /\*/
-      @blockname = 'ul'
-    end
-
-  end
-end