zenml 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e8f6ba9bb6cc03e22732185de42330b26830f08969a66bdf05505bb5496d912c
+  data.tar.gz: de83a4ddb2279cebf137063824a77d0abe19e7ec02bba86088d0576e57e9e4b9
+SHA512:
+  metadata.gz: 11b28b5b90e795615d061e98de97b53f481fe02e457547921736ff3fcbf2f90217fe36a9118b8e210b3f8184ea5164c77b3ac2355cec6b35a31b5a635c7df1db
+  data.tar.gz: 11460ba91e5b265e1b89ce684f7ca4c70dbd71dfb09f94bdf2f7072faddcc390f990bce7f67136003a72eb2ccc89698fd91423a85fc23adc5185ba23ddaafd96

data/source/zenml.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+
+
+module Zenithal
+
+  VERSION = "1.0.0"
+
+end
+
+
+require 'zenml/error'
+require 'zenml/reader'
+require 'zenml/utility'
+require 'zenml/parser'
+require 'zenml/converter'

data/source/zenml/converter.rb

@@ -0,0 +1,124 @@
+# coding: utf-8
+
+
+require 'pp'
+require 'rexml/document'
+include REXML
+
+
+class Zenithal::ZenithalConverter
+
+  attr_reader :configs
+
+  def initialize(document, type = :node)
+    @document = document
+    @type = type
+    @configs = {}
+    @templates = {}
+    @functions = {}
+    @default_element_template = lambda{|s| (@type == :text) ? "" : Nodes[]}
+    @default_text_template = lambda{|s| (@type == :text) ? "" : Nodes[]}
+  end
+
+  def convert(initial_scope = "")
+    document = nil
+    if @type == :text
+      document = convert_element(@document.root, initial_scope)
+    else
+      document = Document.new
+      children = convert_element(@document.root, initial_scope)
+      children.each do |child|
+        document.add(child)
+      end
+    end
+    return document
+  end
+
+  def convert_element(element, scope, *args)
+    nodes = nil
+    @templates.each do |(element_pattern, scope_pattern), block|
+      if element_pattern != nil && element_pattern.any?{|s| s === element.name} && scope_pattern.any?{|s| s === scope}
+        nodes = instance_exec(element, scope, *args, &block)
+        break
+      end
+    end
+    return nodes || @default_element_template.call(element)
+  end
+
+  def convert_text(text, scope, *args)
+    nodes = nil
+    @templates.each do |(element_pattern, scope_pattern), block|
+      if element_pattern == nil && scope_pattern.any?{|s| s === scope}
+        nodes = instance_exec(text, scope, *args, &block)
+        break
+      end
+    end
+    return nodes || @default_text_template.call(text)
+  end
+
+  def apply(element, scope, *args)
+    nodes = (@type == :text) ? "" : Nodes[]
+    element.children.each do |child|
+      case child
+      when Element
+        result_nodes = convert_element(child, scope, *args)
+        if result_nodes
+          nodes << result_nodes
+        end
+      when Text
+        result_nodes = convert_text(child, scope, *args)
+        if result_nodes
+          nodes << result_nodes
+        end
+      end
+    end
+    return nodes
+  end
+
+  def apply_select(element, xpath, scope, *args)
+    nodes = (@type == :text) ? "" : Nodes[]
+    element.each_xpath(xpath) do |child|
+      case child
+      when Element
+        result_nodes = convert_element(child, scope, *args)
+        if result_nodes
+          nodes << result_nodes
+        end
+      when Text
+        result_nodes = convert_text(child, scope, *args)
+        if result_nodes
+          nodes << result_nodes
+        end
+      end
+    end
+    return nodes
+  end
+
+  def call(element, name, *args)
+    nodes = (@type == :text) ? "" : Nodes[]
+    @functions.each do |function_name, block|
+      if function_name == name
+        nodes = instance_exec(element, *args, &block)
+        break
+      end
+    end
+    return nodes
+  end
+
+  def add(element_pattern, scope_pattern, &block)
+    @templates.store([element_pattern, scope_pattern], block)
+  end
+
+  def set(name, &block)
+    @functions.store(name, block)
+  end
+
+  def add_default(element_pattern, &block)
+    if element_pattern
+      @default_element_template = block
+    else
+      @default_text_template = block
+    end
+  end
+
+end

data/source/zenml/error.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+
+
+class Zenithal::ZenithalParseError < StandardError
+
+  def initialize(reader, message = "")
+    whole_message = "[line #{reader.lineno}] #{message}"
+    super(whole_message)
+  end
+
+end

data/source/zenml/parser.rb

@@ -0,0 +1,550 @@
+# coding: utf-8
+
+
+require 'pp'
+require 'rexml/document'
+include REXML
+
+
+class Zenithal::ZenithalParser
+
+  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? && ZenithalParser.valid_start_char?(char)
+        name << char
+      elsif !name.empty? && marks.empty? && ZenithalParser.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? && ZenithalParser.valid_start_char?(char)
+        key << char
+      elsif !key.empty? && ZenithalParser.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(ZenithalParser.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

data/source/zenml/reader.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+
+class Zenithal::StringReader
+
+  attr_reader :lineno
+
+  def initialize(string)
+    @string = string.chars
+    @pos = -1
+    @lineno = 1
+  end
+
+  def read
+    @pos += 1
+    char = @string[@pos]
+    if char == "\n"
+      @lineno += 1
+    end
+    return char
+  end
+
+  def peek
+    char = @string[@pos + 1]
+    return char
+  end
+
+  def unread(size = 1)
+    size.times do
+      char = @string[@pos]
+      @pos -= 1
+      if char == "\n"
+        @lineno -= 1
+      end
+    end
+  end
+
+end

data/source/zenml/utility.rb

@@ -0,0 +1,86 @@
+# coding: utf-8
+
+
+require 'rexml/document'
+include REXML
+
+
+class Element
+
+  def [](key)
+    return attribute(key).to_s
+  end
+
+  def []=(key, value)
+    add_attribute(key, value)
+  end
+
+  def each_xpath(*args, &block)
+    if block
+      XPath.each(self, *args) do |element|
+        block.call(element)
+      end
+    else
+      enumerator = Enumerator.new do |yielder|
+        XPath.each(self, *args) do |element|
+          yielder << element
+        end
+      end
+      return enumerator
+    end
+  end
+
+  def self.build(name, &block)
+    element = Element.new(name)
+    block.call(element)
+    return element
+  end
+
+end
+
+
+class Parent
+
+  alias old_push <<
+
+  def <<(object)
+    if object.is_a?(Nodes)
+      object.each do |child|
+        old_push(child)
+      end
+    else
+      old_push(object)
+    end
+  end
+
+end
+
+
+class Nodes < Array
+
+  alias old_push <<
+
+  def <<(object)
+    if object.is_a?(Nodes)
+      object.each do |child|
+        old_push(child)
+      end
+    else
+      old_push(object)
+    end
+  end
+
+  def +(other)
+    return Nodes.new(super(other))
+  end
+
+end
+
+
+class String
+
+  def ~
+    return Text.new(self, true, nil, true)
+  end
+
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: zenml
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Ziphil
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-06-08 00:00:00.000000000 Z
+dependencies: []
+description: |
+  This gem serves a tool for parsing a ZenML, an alternative new symtax for XML, to an XML node tree.
+  This also contains some utility classes to transform XML documents.
+email:
+- ziphil.shaleiras@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- source/zenml.rb
+- source/zenml/converter.rb
+- source/zenml/error.rb
+- source/zenml/parser.rb
+- source/zenml/reader.rb
+- source/zenml/utility.rb
+homepage: https://github.com/Ziphil/Zenithal
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- source
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Alternative syntax for XML
+test_files: []