zenml 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bed76e79eaf3831d8c59b24e1a00533a03c3ee3213eb2f20dd94c8d8a709a84b
-  data.tar.gz: 0aa6f8c5b618d09409dd0003dadf1cc73b1f486480202283b7120023ea5311fa
+  metadata.gz: fa2dc3c1c455a8d8c9fb0fbc5f11a55a93db4ae6de31c3e72bfdb9c2a6a9a556
+  data.tar.gz: 31a7616c68e3aa6d8f7fb453b34f29b51a0f0c748496c3e0eaf6a44e6445441a
 SHA512:
-  metadata.gz: f4ddeef015698ad21610239840155a04266406adca2491f8f4d741f01275212fd60102c7356315defe57767112ccceae84d46b42ac40c258d8971d593c144af5
-  data.tar.gz: 8ce58dd4255cb435d4da9c95621c6fa34349d79cb8581648ba0b428234955d0081f614d09ded5cf3942474c59b02d436f1c93d19dc76e9baa689d956173ee12e
+  metadata.gz: fe8433f7f33ef8806233ff50666c09afe83c626edc16b9368c63d660196c70bd532dca705c9feae8413bb2b52f4906649d00d633adc8fdb426f47b081f0a8603
+  data.tar.gz: 063727ce5cb752ec122e1884b40b8dd55619462d5d9cfa9a3682388294d07262685d544a21fcf521bfaac2168550b40052bdb71babeb7c7b72eacedad1d0691c

data/source/zenml/parser.rb

@@ -14,9 +14,9 @@ module ZenithalParserMethod
   ATTRIBUTE_START = "|"
   ATTRIBUTE_END = "|"
   ATTRIBUTE_EQUAL = "="
-  ATTRIBUTE_VALUE_START = "\""
-  ATTRIBUTE_VALUE_END = "\""
   ATTRIBUTE_SEPARATOR = ","
+  STRING_START = "\""
+  STRING_END = "\""
   CONTENT_START = "<"
   CONTENT_END = ">"
   SPECIAL_ELEMENT_STARTS = {:brace => "{", :bracket => "[", :slash => "/"}
@@ -49,7 +49,7 @@ module ZenithalParserMethod
   def parse_document
     parser = Parser.build(self) do
       document = Document.new
-      children = +parse_nodes(false)
+      children = +parse_nodes({})
       +parse_eof
       children.each do |child|
         document.add(child)
@@ -59,72 +59,71 @@ module ZenithalParserMethod
     return parser
   end
 
-  def parse_nodes(verbal)
+  def parse_nodes(options)
     parser = Parser.build(self) do
-      parsers = [parse_text(verbal)]
-      unless verbal
-        parsers.push(parse_element, parse_line_comment, parse_block_comment)
+      parsers = [parse_text(options)]
+      unless options[:verbal]
+        parsers.push(parse_element(options), parse_line_comment(options), parse_block_comment(options))
         @special_element_names.each do |kind, name|
-          parsers.push(parse_special_element(kind))
+          parsers.push(parse_special_element(kind, options))
         end
       end
-      nodes = Nodes[]
       raw_nodes = +parsers.inject(:|).many
-      raw_nodes.each do |raw_node|
-        nodes << raw_node
-      end
+      nodes = raw_nodes.inject(Nodes[], :<<)
       next nodes
     end
     return parser
   end
 
-  def parse_element
+  def parse_element(options)
     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))
+      name = +parse_identifier(options)
+      marks = +parse_marks(options)
+      attributes = +parse_attributes(options).maybe || {}
+      next_options = determine_options(name, marks, attributes, start_char == MACRO_START, options)
+      children_list = +parse_children_list(next_options)
       if name == SYSTEM_INSTRUCTION_NAME
         +parse_space
       end
       if start_char == MACRO_START
-        marks.push(:macro)
+        next process_macro(name, marks, attributes, children_list, options)
+      else
+        next create_element(name, marks, attributes, children_list, options)
       end
-      next create_nodes(name, marks, attributes, children_list)
     end
     return parser
   end
 
-  def parse_special_element(kind)
+  def parse_special_element(kind, options)
     parser = Parser.build(self) do
       unless @special_element_names[kind]
         +parse_none
       end
       +parse_char(SPECIAL_ELEMENT_STARTS[kind])
-      children = +parse_nodes(false)
+      children = +parse_nodes(options)
       +parse_char(SPECIAL_ELEMENT_ENDS[kind])
-      next create_nodes(@special_element_names[kind], [], {}, [children])
+      next create_special_element(kind, children, options)
     end
     return parser
   end
 
-  def parse_marks
-    return parse_mark.many
+  def parse_marks(options)
+    return parse_mark(options).many
   end
   
-  def parse_mark
+  def parse_mark(options)
     parsers = MARKS.map do |mark, query|
       next parse_char(query).map{|_| mark}
     end
     return parsers.inject(:|)
   end
 
-  def parse_attributes
+  def parse_attributes(options)
     parser = Parser.build(self) do
       +parse_char(ATTRIBUTE_START)
-      first_attribute = +parse_attribute(false)
-      rest_attribtues = +parse_attribute(true).many
+      first_attribute = +parse_attribute(true, options)
+      rest_attribtues = +parse_attribute(false, options).many
       attributes = first_attribute.merge(*rest_attribtues)
       +parse_char(ATTRIBUTE_END)
       next attributes
@@ -132,68 +131,68 @@ module ZenithalParserMethod
     return parser
   end
 
-  def parse_attribute(comma)
+  def parse_attribute(first, options)
     parser = Parser.build(self) do
-      +parse_char(ATTRIBUTE_SEPARATOR) if comma
+      +parse_char(ATTRIBUTE_SEPARATOR) unless first
       +parse_space
-      name = +parse_identifier
+      name = +parse_identifier(options)
       +parse_space
-      value = +parse_attribute_value.maybe || name
+      value = +parse_attribute_value(options).maybe || name
       +parse_space
       next {name => value}
     end
     return parser
   end
 
-  def parse_attribute_value
+  def parse_attribute_value(options)
     parser = Parser.build(self) do
       +parse_char(ATTRIBUTE_EQUAL)
       +parse_space
-      value = +parse_quoted_string
+      value = +parse_string(options)
       next value
     end
     return parser
   end
 
-  def parse_quoted_string
+  def parse_string(options)
     parser = Parser.build(self) do
-      +parse_char(ATTRIBUTE_VALUE_START)
-      texts = +(parse_quoted_string_plain | parse_escape).many
-      +parse_char(ATTRIBUTE_VALUE_END)
-      next texts.join
+      +parse_char(STRING_START)
+      strings = +(parse_string_plain(options) | parse_escape(:string, options)).many
+      +parse_char(STRING_END)
+      next strings.join
     end
     return parser
   end
 
-  def parse_quoted_string_plain
+  def parse_string_plain(options)
     parser = Parser.build(self) do
-      chars = +parse_char_out([ATTRIBUTE_VALUE_END, ESCAPE_START]).many(1)
+      chars = +parse_char_out([STRING_END, ESCAPE_START]).many(1)
       next chars.join
     end
     return parser
   end
 
-  def parse_children_list(verbal)
+  def parse_children_list(options)
     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(options) | parse_children(options))
+      rest_children_list = +parse_children(options).many
       children_list = [first_children] + rest_children_list
       next children_list
     end
     return parser
   end
 
-  def parse_children(verbal)
+  def parse_children(options)
     parser = Parser.build(self) do
       +parse_char(CONTENT_START)
-      children = +parse_nodes(verbal)
+      children = +parse_nodes(options)
       +parse_char(CONTENT_END)
       next children
     end
     return parser
   end
 
-  def parse_empty_children
+  def parse_empty_children(options)
     parser = Parser.build(self) do
       +parse_char(CONTENT_END)
       next Nodes[]
@@ -201,18 +200,18 @@ module ZenithalParserMethod
     return parser
   end
 
-  def parse_text(verbal)
+  def parse_text(options)
     parser = Parser.build(self) do
-      texts = +(parse_text_plain(verbal) | parse_escape).many(1)
-      next Text.new(texts.join, true, nil, false)
+      raw_texts = +(parse_text_plain(options) | parse_escape(:text, options)).many(1)
+      next create_text(raw_texts.join, options)
     end
     return parser
   end
 
-  def parse_text_plain(verbal)
+  def parse_text_plain(options)
     parser = Parser.build(self) do
       out_chars = [ESCAPE_START, CONTENT_END]
-      unless verbal
+      unless options[:verbal]
         out_chars.push(ELEMENT_START, MACRO_START, CONTENT_START, COMMENT_DELIMITER)
         @special_element_names.each do |kind, name|
           out_chars.push(SPECIAL_ELEMENT_STARTS[kind], SPECIAL_ELEMENT_ENDS[kind]) if name
@@ -224,38 +223,38 @@ module ZenithalParserMethod
     return parser
   end
 
-  def parse_line_comment
+  def parse_line_comment(options)
     parser = Parser.build(self) do
       +parse_char(COMMENT_DELIMITER)
       +parse_char(COMMENT_DELIMITER)
-      content = +parse_line_comment_content
-      next Comment.new(" " + content.strip + " ")
+      content = +parse_line_comment_content(options)
+      +parse_char("\n")
+      next create_comment(:line, content, options)
     end
     return parser
   end
 
-  def parse_line_comment_content
+  def parse_line_comment_content(options)
     parser = Parser.build(self) do
       chars = +parse_char_out(["\n"]).many
-      +parse_char("\n")
       next chars.join
     end
     return parser
   end
 
-  def parse_block_comment
+  def parse_block_comment(options)
     parser = Parser.build(self) do
       +parse_char(COMMENT_DELIMITER)
       +parse_char(CONTENT_START)
-      content = +parse_block_comment_content
+      content = +parse_block_comment_content(options)
       +parse_char(CONTENT_END)
       +parse_char(COMMENT_DELIMITER)
-      next Comment.new(" " + content.strip + " ")
+      next create_comment(:block, content, options)
     end
     return parser
   end
 
-  def parse_block_comment_content
+  def parse_block_comment_content(options)
     parser = Parser.build(self) do
       chars = +parse_char_out([CONTENT_END]).many
       next chars.join
@@ -263,30 +262,30 @@ module ZenithalParserMethod
     return parser
   end
 
-  def parse_escape
+  def parse_escape(place, options)
     parser = Parser.build(self) do
       +parse_char(ESCAPE_START)
-      char = +parse_char_any(ESCAPE_CHARS)
-      next char
+      char = +parse_char
+      next create_escape(place, char, options)
     end
     return parser
   end
 
-  def parse_identifier
+  def parse_identifier(options)
     parser = Parser.build(self) do
-      first_char = +parse_first_identifier_char
-      rest_chars = +parse_middle_identifier_char.many
+      first_char = +parse_first_identifier_char(options)
+      rest_chars = +parse_middle_identifier_char(options).many
       identifier = first_char + rest_chars.join
       next identifier
     end
     return parser
   end
 
-  def parse_first_identifier_char
+  def parse_first_identifier_char(options)
     return parse_char_any(VALID_FIRST_IDENTIFIER_CHARS)
   end
 
-  def parse_middle_identifier_char
+  def parse_middle_identifier_char(options)
     return parse_char_any(VALID_MIDDLE_IDENTIFIER_CHARS)
   end
 
@@ -294,33 +293,39 @@ module ZenithalParserMethod
     return parse_char_any(SPACE_CHARS).many
   end
 
-  def create_nodes(name, marks, attributes, children_list)
+  # Determines options which are used when parsing the children nodes.
+  # This method may be overrided in order to change the parsing behaviour for another format based on ZenML.
+  def determine_options(name, marks, attributes, macro, options)
+    if marks.include?(:verbal)
+      options = options.clone
+      options[:verbal] = true
+    end
+    return options
+  end
+
+  def create_element(name, marks, attributes, children_list, options)
     nodes = Nodes[]
-    unless marks.include?(:macro)
-      if marks.include?(:trim)
-        children_list.each do |children|
-          children.trim_indents
-        end
+    if marks.include?(:trim)
+      children_list.each do |children|
+        children.trim_indents
       end
-      if marks.include?(:instruction)
-        unless children_list.size <= 1
-          throw(:error, error_message("Processing instruction cannot have more than one argument"))
-        end
-        nodes = create_instructions(name, attributes, children_list.first)
-      else
-        unless marks.include?(:multiple) || children_list.size <= 1
-          throw(:error, error_message("Normal node cannot have more than one argument"))
-        end
-        nodes = create_elements(name, attributes, children_list)
+    end
+    if marks.include?(:instruction)
+      unless children_list.size <= 1
+        throw(:error, error_message("Processing instruction cannot have more than one argument"))
       end
+      nodes = create_instruction(name, attributes, children_list.first, options)
     else
-      nodes = process_macro(name, attributes, children_list)
+      unless marks.include?(:multiple) || children_list.size <= 1
+        throw(:error, error_message("Normal node cannot have more than one argument"))
+      end
+      nodes = create_normal_element(name, attributes, children_list, options)
     end
     return nodes
   end
 
-  def create_instructions(target, attributes, children)
-    instructions = Nodes[]
+  def create_instruction(target, attributes, children, options)
+    nodes = Nodes[]
     if target == SYSTEM_INSTRUCTION_NAME
       @version = attributes["version"] if attributes["version"]
       @special_element_names[:brace] = attributes["brace"] if attributes["brace"]
@@ -331,7 +336,7 @@ module ZenithalParserMethod
       instruction.version = attributes["version"] || XMLDecl::DEFAULT_VERSION
       instruction.encoding = attributes["encoding"]
       instruction.standalone = attributes["standalone"]
-      instructions << instruction
+      nodes << instruction
     else
       instruction = Instruction.new(target)
       actual_contents = []
@@ -342,13 +347,13 @@ module ZenithalParserMethod
         actual_contents << children.first
       end
       instruction.content = actual_contents.join(" ")
-      instructions << instruction
+      nodes << instruction
     end
-    return instructions
+    return nodes
   end
 
-  def create_elements(name, attributes, children_list)
-    elements = Nodes[]
+  def create_normal_element(name, attributes, children_list, options)
+    nodes = Nodes[]
     children_list.each do |children|
       element = Element.new(name)
       attributes.each do |key, value|
@@ -357,12 +362,33 @@ module ZenithalParserMethod
       children.each do |child|
         element.add(child)
       end
-      elements << element
+      nodes << element
     end
-    return elements
+    return nodes
+  end
+
+  def create_special_element(kind, children, options)
+    name = @special_element_names[kind]
+    nodes = create_element(name, [], {}, [children], options)
+    return nodes
+  end
+
+  def create_text(raw_text, options)
+    return Text.new(raw_text, true, nil, false)
+  end
+
+  def create_comment(kind, content, options)
+    return Comment.new(" " + content.strip + " ")
+  end
+
+  def create_escape(place, char, options)
+    unless ESCAPE_CHARS.include?(char)
+      throw(:error, "Invalid escape")
+    end
+    return char
   end
 
-  def process_macro(name, attributes, children_list)
+  def process_macro(name, marks, attributes, children_list, options)
     elements = Nodes[]
     if @macros.key?(name)
       raw_elements = @macros[name].call(attributes, children_list)

data/source/zenml/parser_utility.rb

@@ -115,7 +115,7 @@ module CommonParserMethod
   # Parses a single character which matches the specified query.
   # If the next character does not match the query or the end of file is reached, an error result is returned.
   # Otherwise, a success result with a string containing the matched chracter is returned.
-  def parse_char(query)
+  def parse_char(query = nil)
     parser = Parser.new(self) do
       char = source.read
       unless char == nil
@@ -133,6 +133,9 @@ module CommonParserMethod
         when Range
           predicate = query.cover?(char.ord)
           message = "Expected '#{query.begin}'..'#{query.end}'"
+        when NilClass
+          predicate = true
+          message = ""
         end
         if predicate
           next Result.success(char)

data/source/zenml/utility.rb

@@ -92,6 +92,7 @@ class Nodes < Array
     else
       old_push(object)
     end
+    return self
   end
 
   def +(other)

data/source/zenml.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zenml
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
 platform: ruby
 authors:
 - Ziphil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-01 00:00:00.000000000 Z
+date: 2019-10-02 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.