zenml 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 607af5731fb778c2c3de36cfcb3cb4a3c67d203b6b41ed020d4e5ac24e74451a
-  data.tar.gz: 21905106dd5237550faff1df06e4d61632c967aa3bef8b12e012fe72cf0d7f97
+  metadata.gz: e1d728cf53633e86d66698254bfd83f184360263c6c45d1c6713cd6879a1cf39
+  data.tar.gz: d7b9b1aa8c36692b4b7a81e286564c3a3f0b1d48fa1b71876f25d8b5028c0bb2
 SHA512:
-  metadata.gz: 75d4e5de085ed17a5870133bfc56217107c3afa40997b1b1e66511170f02d2d1f1effc93cfd5fed06df275698ad4ab35b9a4e09cb038a1d7c88b5517e3d5b40f
-  data.tar.gz: ae779f165f87b50fda1bc73a815d3319edf5fce618ed41e72a57991615d46a55fdacdcc7ebd6b447566720d78bea09946ca04281837f4e10d4b11587843e475d
+  metadata.gz: 3f11c1f41c8dc6b5734e6200ab8d9204b9abe21156bed9af52e5998cd01f215a24083285073adb41dd94ebc75c86292a5ad632eb2359ff3b9d0e46a6c39b3c20
+  data.tar.gz: faa1cae292f85d8fc75aa9724c73205a98ea87f07f05f5aabba91636a5bd9b90b958ae55c3f1b6f9b5861eb3a6b400017c2e0f9a782f4565c77c6ac8921391bc

data/source/zenml.rb

@@ -6,10 +6,11 @@ require 'zenml/utility'
 
 module Zenithal
 
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 
   require 'zenml/error'
   require 'zenml/reader'
+  require 'zenml/parser_utility'
   require 'zenml/parser'
   require 'zenml/converter'
 

data/source/zenml/error.rb

@@ -3,9 +3,8 @@
 
 class ZenithalParseError < StandardError
 
-  def initialize(reader, message = "")
-    whole_message = "[line #{reader.lineno}] #{message}"
-    super(whole_message)
+  def initialize(message = "")
+    super(message)
   end
 
 end

data/source/zenml/old_parser.rb

@@ -0,0 +1,550 @@
+# 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