root/lang/ruby/wikiforme/trunk/core/wikiforme/block.rb @ 2297

class WikiForme::BlockElement

        # 包含可能要素の定義
        def self.contain(*names)
                const_get(:CONTAIN_NAMES).replace( names.map{|n| n.to_sym} )
        end
        def self.uncontain(*names)
                const_get(:UNCONTAIN_NAMES).replace( names.map{|n| n.to_sym} )
        end
        def self.add_contain(*names)
                const_get(:CONTAIN_NAMES).concat( names.map{|n| n.to_sym} )
        end
        def self.add_uncontain(*names)
                const_get(:UNCONTAIN_NAMES).concat( names.map{|n| n.to_sym} )
        end

        # 所属グループの定義
        def self.group(*names)
                const_get(:GROUP_NAMES).replace( names.map{|n| n.to_sym} )
        end
        def self.add_group(*names)
                const_get(:GROUP_NAMES).concat( names.map{|n| n.to_sym} )
        end

        # 親要素の定義
        def self.parent(name)
                const_get(:PARENT_COMPLETION_NAME).replace(name.to_sym)
        end
        def self.parent=(name) self.parent(name) end

        # デフォルトシンタックスの定義
        def self.default_syntax(syntax)
                const_get(:DEFAULT_SYNTAX).replace(syntax)
        end
        def self.default_syntax=(syntax) self.default_syntax(syntax) end

        # デフォルトprocesの定義
        def self.process
                define_method(:process_default) {
                        yield @text, @children, @lines
                }
        end

        # actionの定義
        def self.action
                define_method(:action) {
                        yield @text, @context, @lines
                }
        end

        # preprocessの定義
        def self.preprocess
                define_method(:preprocess) {
                        yield @text, @children
                }
        end

        # process_*の定義
        def self.method_missing(name, *args)
                if block_given? && name.to_s =~ /process_([^=]+)/
                        # process_*の定義
                        define_method(name) {
                                yield @text, @children, @lines
                        }
                        return
                end
                raise NameError, "undefined method `#{name}' for #{self.inspect}:#{self.class}"
        end

        # デフォルトprocessのデフォルト実装
        def process_default
                children.to_s
        end

        # preprocessのデフォルト実装
        def preprocess
                if self.class.action?
                        @text = text
                else
                        @text = Parser.inline.bless(@text)
                end
        end

        # multilineの終了マークの定義
        def self.multiline(end_mark)
                const_get(:MULTILINE).replace(end_mark)
        end
        def self.multiline=(end_mark) self.multiline(end_mark) end

        # closerの定義
        def self.closer
                const_get(:CLOSER).set
        end

        # 構造化用メソッド
        def initialize(parent, text, lines = [])
                @text      = text
                @parent    = parent
                @children  = Children.new
                @lines     = lines
                preprocess
        end
        attr_reader :parent, :text, :children, :lines

        def add_child(child)
                @children.push(child)
        end

        def self.containable?(element)
                self::UNCONTAIN.each {|c|
                        return false if element <= c
                }
                self::CONTAIN.each {|c|
                        return true if element <= c
                }
                return false
        end

        def self.action?
                method_defined?(:action)
        end

        def self.multiline?
                self::MULTILINE.set?
        end

        #MULTILINE_END_MARK_PAIRS = [
        #       '()[]{}<>',
        #       ')(][}{><'
        #]
        def self.multiline_end_mark
                # FIXME
                #if self::MULTILINE.obj.nil?
                #       # multiline_end_mark自動生成
                #       self::DEFAULT_SYNTAX
                #else
                        self::MULTILINE.obj
                #end
        end

        def self.closer?
                self::CLOSER.set?
        end


        # フォーマット変換用メソッド
        def self.inline_parser=(parser)
                @@inline = parser
        end

        def self.format_type=(format_type)
                @@format_type = format_type
                @@process_method = "process_#{format_type}".to_sym
        end

        def action_caller(context)
                @context = context
                action
                @context = nil
        end

        def process
                if self.class.method_defined?(@@process_method)
                        __send__(@@process_method)
                else
                        process_default
                end
        end
        alias :to_s :process

        class Children < Array
                def process
                        body = XMLRaw.new
                        each {|c|
                                body << c.process.to_s
                        }
                        body
                end
                alias :to_s :process
                alias :to_str :to_s
        end

end