zenml 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1d728cf53633e86d66698254bfd83f184360263c6c45d1c6713cd6879a1cf39
-  data.tar.gz: d7b9b1aa8c36692b4b7a81e286564c3a3f0b1d48fa1b71876f25d8b5028c0bb2
+  metadata.gz: bed76e79eaf3831d8c59b24e1a00533a03c3ee3213eb2f20dd94c8d8a709a84b
+  data.tar.gz: 0aa6f8c5b618d09409dd0003dadf1cc73b1f486480202283b7120023ea5311fa
 SHA512:
-  metadata.gz: 3f11c1f41c8dc6b5734e6200ab8d9204b9abe21156bed9af52e5998cd01f215a24083285073adb41dd94ebc75c86292a5ad632eb2359ff3b9d0e46a6c39b3c20
-  data.tar.gz: faa1cae292f85d8fc75aa9724c73205a98ea87f07f05f5aabba91636a5bd9b90b958ae55c3f1b6f9b5861eb3a6b400017c2e0f9a782f4565c77c6ac8921391bc
+  metadata.gz: f4ddeef015698ad21610239840155a04266406adca2491f8f4d741f01275212fd60102c7356315defe57767112ccceae84d46b42ac40c258d8971d593c144af5
+  data.tar.gz: 8ce58dd4255cb435d4da9c95621c6fa34349d79cb8581648ba0b428234955d0081f614d09ded5cf3942474c59b02d436f1c93d19dc76e9baa689d956173ee12e

data/source/zenml.rb

@@ -6,7 +6,7 @@ require 'zenml/utility'
 
 module Zenithal
 
-  VERSION = "1.1.0"
+  VERSION = "1.1.1"
 
   require 'zenml/error'
   require 'zenml/reader'

data/source/zenml/parser.rb

@@ -49,8 +49,8 @@ module ZenithalParserMethod
   def parse_document
     parser = Parser.build(self) do
       document = Document.new
-      children = !parse_nodes(false)
-      !parse_eof
+      children = +parse_nodes(false)
+      +parse_eof
       children.each do |child|
         document.add(child)
       end
@@ -69,7 +69,7 @@ module ZenithalParserMethod
         end
       end
       nodes = Nodes[]
-      raw_nodes = !parsers.inject(:|).many
+      raw_nodes = +parsers.inject(:|).many
       raw_nodes.each do |raw_node|
         nodes << raw_node
       end
@@ -80,13 +80,13 @@ module ZenithalParserMethod
 
   def parse_element
     parser = Parser.build(self) do
-      start_char = !parse_char_any([ELEMENT_START, MACRO_START])
-      name = !parse_identifier
-      marks = !parse_marks
-      attributes = !parse_attributes.maybe || {}
-      children_list = !parse_children_list(marks.include?(:verbal))
+      start_char = +parse_char_any([ELEMENT_START, MACRO_START])
+      name = +parse_identifier
+      marks = +parse_marks
+      attributes = +parse_attributes.maybe || {}
+      children_list = +parse_children_list(marks.include?(:verbal))
       if name == SYSTEM_INSTRUCTION_NAME
-        !parse_space
+        +parse_space
       end
       if start_char == MACRO_START
         marks.push(:macro)
@@ -99,11 +99,11 @@ module ZenithalParserMethod
   def parse_special_element(kind)
     parser = Parser.build(self) do
       unless @special_element_names[kind]
-        !parse_none
+        +parse_none
       end
-      !parse_char(SPECIAL_ELEMENT_STARTS[kind])
-      children = !parse_nodes(false)
-      !parse_char(SPECIAL_ELEMENT_ENDS[kind])
+      +parse_char(SPECIAL_ELEMENT_STARTS[kind])
+      children = +parse_nodes(false)
+      +parse_char(SPECIAL_ELEMENT_ENDS[kind])
       next create_nodes(@special_element_names[kind], [], {}, [children])
     end
     return parser
@@ -122,11 +122,11 @@ module ZenithalParserMethod
 
   def parse_attributes
     parser = Parser.build(self) do
-      !parse_char(ATTRIBUTE_START)
-      first_attribute = !parse_attribute(false)
-      rest_attribtues = !parse_attribute(true).many
+      +parse_char(ATTRIBUTE_START)
+      first_attribute = +parse_attribute(false)
+      rest_attribtues = +parse_attribute(true).many
       attributes = first_attribute.merge(*rest_attribtues)
-      !parse_char(ATTRIBUTE_END)
+      +parse_char(ATTRIBUTE_END)
       next attributes
     end
     return parser
@@ -134,12 +134,12 @@ module ZenithalParserMethod
 
   def parse_attribute(comma)
     parser = Parser.build(self) do
-      !parse_char(ATTRIBUTE_SEPARATOR) if comma
-      !parse_space
-      name = !parse_identifier
-      !parse_space
-      value = !parse_attribute_value.maybe || name
-      !parse_space
+      +parse_char(ATTRIBUTE_SEPARATOR) if comma
+      +parse_space
+      name = +parse_identifier
+      +parse_space
+      value = +parse_attribute_value.maybe || name
+      +parse_space
       next {name => value}
     end
     return parser
@@ -147,9 +147,9 @@ module ZenithalParserMethod
 
   def parse_attribute_value
     parser = Parser.build(self) do
-      !parse_char(ATTRIBUTE_EQUAL)
-      !parse_space
-      value = !parse_quoted_string
+      +parse_char(ATTRIBUTE_EQUAL)
+      +parse_space
+      value = +parse_quoted_string
       next value
     end
     return parser
@@ -157,9 +157,9 @@ module ZenithalParserMethod
 
   def parse_quoted_string
     parser = Parser.build(self) do
-      !parse_char(ATTRIBUTE_VALUE_START)
-      texts = !(parse_quoted_string_plain | parse_escape).many
-      !parse_char(ATTRIBUTE_VALUE_END)
+      +parse_char(ATTRIBUTE_VALUE_START)
+      texts = +(parse_quoted_string_plain | parse_escape).many
+      +parse_char(ATTRIBUTE_VALUE_END)
       next texts.join
     end
     return parser
@@ -167,7 +167,7 @@ module ZenithalParserMethod
 
   def parse_quoted_string_plain
     parser = Parser.build(self) do
-      chars = !parse_char_out([ATTRIBUTE_VALUE_END, ESCAPE_START]).many(1)
+      chars = +parse_char_out([ATTRIBUTE_VALUE_END, ESCAPE_START]).many(1)
       next chars.join
     end
     return parser
@@ -175,8 +175,8 @@ module ZenithalParserMethod
 
   def parse_children_list(verbal)
     parser = Parser.build(self) do
-      first_children = !(parse_empty_children | parse_children(verbal))
-      rest_children_list = !parse_children(verbal).many
+      first_children = +(parse_empty_children | parse_children(verbal))
+      rest_children_list = +parse_children(verbal).many
       children_list = [first_children] + rest_children_list
       next children_list
     end
@@ -185,9 +185,9 @@ module ZenithalParserMethod
 
   def parse_children(verbal)
     parser = Parser.build(self) do
-      !parse_char(CONTENT_START)
-      children = !parse_nodes(verbal)
-      !parse_char(CONTENT_END)
+      +parse_char(CONTENT_START)
+      children = +parse_nodes(verbal)
+      +parse_char(CONTENT_END)
       next children
     end
     return parser
@@ -195,7 +195,7 @@ module ZenithalParserMethod
 
   def parse_empty_children
     parser = Parser.build(self) do
-      !parse_char(CONTENT_END)
+      +parse_char(CONTENT_END)
       next Nodes[]
     end
     return parser
@@ -203,7 +203,7 @@ module ZenithalParserMethod
 
   def parse_text(verbal)
     parser = Parser.build(self) do
-      texts = !(parse_text_plain(verbal) | parse_escape).many(1)
+      texts = +(parse_text_plain(verbal) | parse_escape).many(1)
       next Text.new(texts.join, true, nil, false)
     end
     return parser
@@ -218,7 +218,7 @@ module ZenithalParserMethod
           out_chars.push(SPECIAL_ELEMENT_STARTS[kind], SPECIAL_ELEMENT_ENDS[kind]) if name
         end
       end
-      chars = !parse_char_out(out_chars).many(1)
+      chars = +parse_char_out(out_chars).many(1)
       next chars.join
     end
     return parser
@@ -226,9 +226,9 @@ module ZenithalParserMethod
 
   def parse_line_comment
     parser = Parser.build(self) do
-      !parse_char(COMMENT_DELIMITER)
-      !parse_char(COMMENT_DELIMITER)
-      content = !parse_line_comment_content
+      +parse_char(COMMENT_DELIMITER)
+      +parse_char(COMMENT_DELIMITER)
+      content = +parse_line_comment_content
       next Comment.new(" " + content.strip + " ")
     end
     return parser
@@ -236,8 +236,8 @@ module ZenithalParserMethod
 
   def parse_line_comment_content
     parser = Parser.build(self) do
-      chars = !parse_char_out(["\n"]).many
-      !parse_char("\n")
+      chars = +parse_char_out(["\n"]).many
+      +parse_char("\n")
       next chars.join
     end
     return parser
@@ -245,11 +245,11 @@ module ZenithalParserMethod
 
   def parse_block_comment
     parser = Parser.build(self) do
-      !parse_char(COMMENT_DELIMITER)
-      !parse_char(CONTENT_START)
-      content = !parse_block_comment_content
-      !parse_char(CONTENT_END)
-      !parse_char(COMMENT_DELIMITER)
+      +parse_char(COMMENT_DELIMITER)
+      +parse_char(CONTENT_START)
+      content = +parse_block_comment_content
+      +parse_char(CONTENT_END)
+      +parse_char(COMMENT_DELIMITER)
       next Comment.new(" " + content.strip + " ")
     end
     return parser
@@ -257,7 +257,7 @@ module ZenithalParserMethod
 
   def parse_block_comment_content
     parser = Parser.build(self) do
-      chars = !parse_char_out([CONTENT_END]).many
+      chars = +parse_char_out([CONTENT_END]).many
       next chars.join
     end
     return parser
@@ -265,8 +265,8 @@ module ZenithalParserMethod
 
   def parse_escape
     parser = Parser.build(self) do
-      !parse_char(ESCAPE_START)
-      char = !parse_char_any(ESCAPE_CHARS)
+      +parse_char(ESCAPE_START)
+      char = +parse_char_any(ESCAPE_CHARS)
       next char
     end
     return parser
@@ -274,8 +274,8 @@ module ZenithalParserMethod
 
   def parse_identifier
     parser = Parser.build(self) do
-      first_char = !parse_first_identifier_char
-      rest_chars = !parse_middle_identifier_char.many
+      first_char = +parse_first_identifier_char
+      rest_chars = +parse_middle_identifier_char.many
       identifier = first_char + rest_chars.join
       next identifier
     end

data/source/zenml/parser_utility.rb

@@ -29,7 +29,7 @@ class Parser
     return @builder.instance_eval(&@method)
   end
 
-  def !
+  def exec_get
     result = self.exec
     if result.success?
       return result.value
@@ -38,6 +38,9 @@ class Parser
     end
   end
 
+  alias -@ exec
+  alias +@ exec_get
+
   def |(other)
     this = self
     if this.builder.equal?(other.builder)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zenml
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Ziphil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-28 00:00:00.000000000 Z
+date: 2019-10-01 00:00:00.000000000 Z
 dependencies: []
 description: |
   This gem serves a tool for parsing a document written in ZenML, an alternative new syntax for XML, to an XML node tree.
@@ -22,7 +22,6 @@ files:
 - source/zenml.rb
 - source/zenml/converter.rb
 - source/zenml/error.rb
-- source/zenml/old_parser.rb
 - source/zenml/parser.rb
 - source/zenml/parser_utility.rb
 - source/zenml/reader.rb

data/source/zenml/old_parser.rb

@@ -1,550 +0,0 @@
-# coding: utf-8
-
-
-require 'pp'
-require 'rexml/document'
-include REXML
-
-
-class ZenithalOldParser
-
-  TAG_START = "\\"
-  MACRO_START = "&"
-  ESCAPE_START = "`"
-  ATTRIBUTE_START = "|"
-  ATTRIBUTE_END = "|"
-  ATTRIBUTE_EQUAL = "="
-  ATTRIBUTE_VALUE_START = "\""
-  ATTRIBUTE_VALUE_END = "\""
-  ATTRIBUTE_SEPARATOR = ","
-  CONTENT_START = "<"
-  CONTENT_END = ">"
-  BRACE_START = "{"
-  BRACE_END = "}"
-  BRACKET_START = "["
-  BRACKET_END = "]"
-  SLASH_START = "/"
-  SLASH_END = "/"
-  COMMENT_DELIMITER = "#"
-  INSTRUCTION_MARK = "?"
-  TRIM_MARK = "*"
-  VERBAL_MARK = "~"
-  MULTIPLE_MARK = "+"
-  SYSTEM_INSTRUCTION_NAME = "zml"
-  ENTITIES = {"amp" => "&", "lt" => "<", "gt" => ">", "apos" => "'", "quot" => "\"",
-              "lcub" => "{",  "rcub" => "}", "lbrace" => "{",  "rbrace" => "}", "lsqb" => "[",  "rsqb" => "]", "lbrack" => "[",  "rbrack" => "]",
-              "sol" => "/", "bsol" => "\\", "verbar" => "|", "vert" => "|", "grave" => "`", "num" => "#"}
-  ESCAPES = ["&", "<", ">", "'", "\"", "{", "}", "[", "]", "/", "\\", "|", "`", "#"]
-  VALID_START_CHARS = [0x3A, 0x41..0x5A, 0x5F, 0x61..0x7A, 0xC0..0xD6, 0xD8..0xF6, 0xF8..0x2FF, 0x370..0x37D, 0x37F..0x1FFF, 0x200C..0x200D, 
-                       0x2070..0x218F, 0x2C00..0x2FEF, 0x3001..0xD7FF, 0xF900..0xFDCF, 0xFDF0..0xFFFD, 0x10000..0xEFFFF]
-  VALID_MIDDLE_CHARS = [0x2D, 0x2E, 0x30..0x39, 0xB7, 0x0300..0x036F, 0x203F..0x2040]
-
-  attr_writer :brace_name
-  attr_writer :bracket_name
-  attr_writer :slash_name
-
-  def initialize(source)
-    @source = StringReader.new(source)
-    @version = nil
-    @brace_name = nil
-    @bracket_name = nil
-    @slash_name = nil
-    @macros = {}
-  end
-
-  def parse
-    document = Document.new
-    children = parse_nodes
-    children.each do |child|
-      document.add(child)
-    end
-    return document
-  end
-
-  def parse_nodes(option = {}, in_slash = false)
-    children = []
-    while char = @source.read
-      if char == TAG_START || char == MACRO_START
-        @source.unread
-        children.concat(parse_element)
-      elsif @brace_name && char == BRACE_START
-        @source.unread
-        children << parse_brace
-      elsif @bracket_name && char == BRACKET_START
-        @source.unread
-        children << parse_bracket
-      elsif @slash_name && !in_slash && char == SLASH_START
-        @source.unread
-        children << parse_slash
-      elsif char == COMMENT_DELIMITER
-        @source.unread
-        children << parse_comment
-      elsif char == CONTENT_END || (@brace_name && char == BRACE_END) || (@bracket_name && char == BRACKET_END) || (@slash_name && char == SLASH_END)
-        @source.unread
-        break
-      else
-        @source.unread
-        children << parse_text(option)
-      end
-    end
-    return children
-  end
-
-  def parse_verbal_nodes(option = {})
-    children = []
-    while char = @source.read
-      next_char = @source.peek
-      if char == CONTENT_END
-        @source.unread
-        break
-      else
-        @source.unread
-        children << parse_verbal_text(option)
-      end
-    end
-    return children
-  end
-
-  def parse_element
-    first_char = @source.read
-    unless first_char == TAG_START || first_char == MACRO_START
-      raise ZenithalParseError.new(@source)
-    end
-    name, option = parse_element_name
-    if first_char == MACRO_START
-      option[:macro] = true
-    end
-    attributes = parse_attributes
-    children_list = parse_children_list(option)
-    nodes = create_nodes(name, attributes, children_list, option)
-    return nodes
-  end
-
-  def parse_element_name
-    name, marks, option = "", [], {}
-    while char = @source.read
-      if char == ATTRIBUTE_START || char == CONTENT_START || char == CONTENT_END || char =~ /\s/
-        @source.unread
-        break
-      elsif char == INSTRUCTION_MARK || char == TRIM_MARK || char == VERBAL_MARK || char == MULTIPLE_MARK
-        marks << char
-      elsif name.empty? && marks.empty? && ZenithalOldParser.valid_start_char?(char)
-        name << char
-      elsif !name.empty? && marks.empty? && ZenithalOldParser.valid_char?(char)
-        name << char
-      else
-        raise ZenithalParseError.new(@source)
-      end
-    end
-    skip_spaces
-    if marks.include?(INSTRUCTION_MARK)
-      option[:instruction] = true
-    end
-    if marks.include?(TRIM_MARK)
-      option[:trim_indents] = true
-    end
-    if marks.include?(VERBAL_MARK)
-      option[:verbal] = true
-    end
-    if marks.include?(MULTIPLE_MARK)
-      option[:multiple] = true
-    end
-    return name, option
-  end
-
-  def parse_attributes
-    attributes = {}
-    if @source.read == ATTRIBUTE_START
-      current_key = nil
-      skip_spaces
-      loop do
-        key, value = parse_attribute
-        attributes[key] = value
-        char = @source.read
-        if char == ATTRIBUTE_SEPARATOR
-          skip_spaces
-        elsif char == ATTRIBUTE_END
-          @source.unread
-          break
-        else
-          raise ZenithalParseError.new(@source)
-        end
-      end
-      unless @source.read == ATTRIBUTE_END
-        raise ZenithalParseError.new(@source)
-      end
-    else
-      @source.unread
-    end
-    return attributes
-  end
-
-  def parse_attribute
-    key = parse_attribute_key
-    skip_spaces
-    if @source.read == ATTRIBUTE_EQUAL
-      skip_spaces
-      value = parse_attribute_value
-    else
-      @source.unread
-      value = key
-    end
-    skip_spaces
-    return key, value
-  end
-
-  def parse_attribute_key
-    key = ""
-    while char = @source.read
-      if char == ATTRIBUTE_EQUAL || char == ATTRIBUTE_END || char =~ /\s/
-        @source.unread
-        break
-      elsif key.empty? && ZenithalOldParser.valid_start_char?(char)
-        key << char
-      elsif !key.empty? && ZenithalOldParser.valid_char?(char)
-        key << char
-      else
-        raise ZenithalParseError.new(@source)
-      end
-    end
-    return key
-  end
-
-  def parse_attribute_value
-    unless @source.read == ATTRIBUTE_VALUE_START
-      raise ZenithalParseError.new(@source)
-    end
-    value = ""
-    while char = @source.read
-      next_char = @source.peek
-      if char == ATTRIBUTE_VALUE_END
-        break
-      elsif char == ESCAPE_START && ESCAPES.include?(next_char)
-        @source.unread
-        value << parse_escape_string
-      else
-        value << char
-      end
-    end
-    return value
-  end
-
-  def parse_children_list(option = {})
-    children_list = []
-    first_char = @source.read
-    if first_char == CONTENT_START
-      loop do
-        children = []
-        if option[:verbal] || option[:instruction]
-          children = parse_verbal_nodes(option)
-        else
-          children = parse_nodes(option)
-        end
-        if option[:trim_indents]
-          trim_indents(children)
-        end
-        children_list << children
-        unless @source.read == CONTENT_END
-          raise ZenithalParseError.new(@source)
-        end
-        space_count = skip_spaces
-        unless @source.read == CONTENT_START
-          @source.unread(space_count + 1)
-          break
-        end
-      end
-    elsif first_char == CONTENT_END
-      children_list << []
-    else
-      raise ZenithalParseError.new(@source)
-    end
-    return children_list
-  end
-
-  def create_nodes(name, attributes, children_list, option = {})
-    nodes = []
-    unless option[:macro]
-      if option[:instruction]
-        unless children_list.size <= 1
-          raise ZenithalParseError.new(@source)
-        end
-        nodes = create_instructions(name, attributes, children_list.first)
-        if name == SYSTEM_INSTRUCTION_NAME
-          skip_spaces
-        end
-      else
-        unless option[:multiple] || children_list.size <= 1
-          raise ZenithalParseError.new(@source)
-        end
-        nodes = create_elements(name, attributes, children_list)
-      end
-    else
-      nodes = process_macro(name, attributes, children_list)
-    end
-    return nodes
-  end
-
-  def create_elements(name, attributes, children_list)
-    elements = []
-    children_list.each do |children|
-      element = Element.new(name)
-      attributes.each do |key, value|
-        element.add_attribute(key, value)
-      end
-      children.each do |child|
-        element.add(child)
-      end
-      elements << element
-    end
-    return elements
-  end
-
-  def create_instructions(target, attributes, children)
-    instructions = []
-    if target == SYSTEM_INSTRUCTION_NAME
-      @version = attributes["version"] if attributes["version"]
-      @brace_name = attributes["brace"] if attributes["brace"]
-      @bracket_name = attributes["bracket"] if attributes["bracket"]
-      @slash_name = attributes["slash"] if attributes["slash"]
-    elsif target == "xml"
-      instruction = XMLDecl.new
-      instruction.version = attributes["version"] || XMLDecl::DEFAULT_VERSION
-      instruction.encoding = attributes["encoding"]
-      instruction.standalone = attributes["standalone"]
-      instructions << instruction
-    else
-      instruction = Instruction.new(target)
-      actual_contents = []
-      attributes.each do |key, value|
-        actual_contents << "#{key}=\"#{value}\""
-      end
-      if children.first && !children.first.empty?
-        actual_contents << children.first
-      end
-      instruction.content = actual_contents.join(" ")
-      instructions << instruction
-    end
-    return instructions
-  end
-
-  def process_macro(name, attributes, children_list)
-    elements = []
-    if @macros.key?(name)
-      elements = @macros[name].call(attributes, children_list)
-    elsif ENTITIES.key?(name)
-      text = Text.new(ENTITIES[name], true, nil, false)
-      elements << text      
-    else
-      raise ZenithalParseError.new(@source)
-    end
-    return elements
-  end
-
-  def register_macro(name, &block)
-    @macros.store(name, block)
-  end
-
-  def parse_brace
-    unless @source.read == BRACE_START
-      raise ZenithalParseError.new(@source)
-    end
-    children = parse_nodes
-    unless @source.read == BRACE_END
-      raise ZenithalParseError.new(@source)
-    end
-    element = Element.new(@brace_name)
-    children.each do |child|
-      element.add(child)
-    end
-    return element
-  end
-
-  def parse_bracket
-    unless @source.read == BRACKET_START
-      raise ZenithalParseError.new(@source)
-    end
-    children = parse_nodes
-    unless @source.read == BRACKET_END
-      raise ZenithalParseError.new(@source)
-    end
-    element = Element.new(@bracket_name)
-    children.each do |child|
-      element.add(child)
-    end
-    return element
-  end
-
-  def parse_slash
-    unless @source.read == SLASH_START
-      raise ZenithalParseError.new(@source)
-    end
-    children = parse_nodes({}, true)
-    unless @source.read == SLASH_END
-      raise ZenithalParseError.new(@source)
-    end
-    element = Element.new(@slash_name)
-    children.each do |child|
-      element.add(child)
-    end
-    return element
-  end
-
-  def parse_comment
-    unless @source.read == COMMENT_DELIMITER
-      raise ZenithalParseError.new(@source)
-    end
-    char = @source.read
-    string = ""
-    if char == COMMENT_DELIMITER
-      while char = @source.read
-        if char == "\n"
-          @source.unread
-          break
-        else
-          string << char
-        end
-      end
-    elsif char == CONTENT_START
-      while char = @source.read
-        if char == CONTENT_END
-          next_char = @source.read
-          if next_char == COMMENT_DELIMITER
-            break
-          else
-            string << char
-            @source.unread
-          end
-        else
-          string << char
-        end
-      end
-    else
-      raise ZenithalParseError.new(@source)
-    end
-    comment = Comment.new(" #{string.strip} ")
-    return comment
-  end
-
-  def parse_text(option = {})
-    string = ""
-    while char = @source.read
-      next_char = @source.peek
-      if char == TAG_START || char == MACRO_START
-        @source.unread
-        break
-      elsif (@brace_name && char == BRACE_START) || (@bracket_name && char == BRACKET_START) || (@slash_name && char == SLASH_START)
-        @source.unread
-        break 
-      elsif char == CONTENT_END
-        @source.unread
-        break
-      elsif (@brace_name && char == BRACE_END) || (@bracket_name && char == BRACKET_END) || (@slash_name && char == SLASH_END)
-        @source.unread
-        break
-      elsif char == COMMENT_DELIMITER
-        @source.unread
-        break
-      elsif char == ESCAPE_START && ESCAPES.include?(next_char)
-        @source.unread
-        string << parse_escape_string
-      else
-        string << char
-      end
-    end
-    text = Text.new(string, true, nil, false)
-    return text
-  end
-
-  def parse_verbal_text(option = {})
-    string = ""
-    while char = @source.read
-      next_char = @source.peek
-      if char == CONTENT_END
-        @source.unread
-        break
-      elsif char == ESCAPE_START && ESCAPES.include?(next_char)
-        @source.unread
-        string << parse_escape_string
-      else
-        string << char
-      end
-    end
-    text = Text.new(string, true, nil, false)
-    return text
-  end
-
-  def parse_escape_string
-    unless @source.read == ESCAPE_START
-      raise ZenithalParseError.new(@source)
-    end
-    char = @source.read
-    return char
-  end
-
-  def skip_spaces
-    count = 0
-    while @source.read =~ /\s/
-      count += 1
-    end
-    @source.unread
-    return count
-  end
-
-  def trim_spaces(children)
-    if children.first.is_a?(Text)
-      children.first.value = children.first.value.lstrip
-    end
-    if children.last.is_a?(Text)
-      children.last.value = children.last.value.rstrip
-    end
-  end
-
-  def trim_indents(children)
-    texts = []
-    if children.last.is_a?(Text)
-      children.last.value = children.last.value.rstrip
-    end
-    children.each do |child|
-      case child
-      when Text
-        texts << child
-      when Parent
-        texts.concat(ZenithalOldParser.get_all_texts(child))
-      end
-    end
-    indent_length = 10000
-    texts.each do |text|
-      text.value.scan(/\n(\x20+)/) do |match|
-        indent_length = [match[0].length, indent_length].min
-      end
-    end
-    texts.each do |text|
-      text.value = text.value.gsub(/\n(\x20+)/){"\n" + " " * ($1.length - indent_length)}
-    end
-    if children.first.is_a?(Text)
-      children.first.value = children.first.value.lstrip
-    end
-  end
-
-  def self.valid_start_char?(char)
-    return VALID_START_CHARS.any?{|s| s === char.ord}
-  end
-
-  def self.valid_char?(char)
-    return VALID_START_CHARS.any?{|s| s === char.ord} || VALID_MIDDLE_CHARS.any?{|s| s === char.ord}
-  end
-
-  def self.get_all_texts
-    texts = []
-    self.children.each do |child|
-      case child
-      when Text
-        texts << child
-      when Parent
-        texts.concat(get_all_texts(child))
-      end
-    end
-    return texts
-  end
-
-end