zenml 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 588639c3751d09fb4485184ed90ff37680b490d7e5a4417142ca8587eb48242b
-  data.tar.gz: 63c74b6fee69636440dc0c26a3c74c2145c39a7e879c3d3094913fe8c12e44ad
+  metadata.gz: dc0c51d446a26f7b640f5a4ab3c4054d131ab89f98ab7c0effca28387e06b9b9
+  data.tar.gz: 43860c32ec5abf88af046191eeb57941ebc67cfde701229b459dfb2c9439f525
 SHA512:
-  metadata.gz: b62748fe59945691582eaec70ac2f1870133d4e4f661373dc10a8e3b40b2d8b879248b1a1f74571bb7e31acb314fb7c5b16171eebb303648984f6c55ce396008
-  data.tar.gz: 0e4042446f70cf50db75874407aa111be819d1c0683bcd96ee68affc059fc8993d22ce6f14edb46aed16d39c253ab3b6b1a1d7e81045bd2e4b9e9248f9c46d70
+  metadata.gz: baf2791fe4d95b718a2251152d8edb917e92c3d0da35ed9578ae1b4ac8fb2c48964223819eb9e06bd6619a25ee1e4bf84c4b10c81cf955f4a7b877a3a0db727d
+  data.tar.gz: 0e8b566980d4870679e70426c5da2114abb3927c9c59f077f0e100b5c6685fab507bc141708744fb1d37f5294eb401900bf5019fa76a39e6d5e4e24a84ff5986

data/source/zenml/converter.rb

@@ -18,8 +18,8 @@ class ZenithalConverter
     @configs = {}
     @templates = {}
     @functions = {}
-    @default_element_template = lambda{|s| (@type == :text) ? "" : Nodes[]}
-    @default_text_template = lambda{|s| (@type == :text) ? "" : Nodes[]}
+    @default_element_template = lambda{|_| empty_nodes}
+    @default_text_template = lambda{|_| empty_nodes}
   end
 
   def convert(initial_scope = "")
@@ -59,7 +59,7 @@ class ZenithalConverter
   end
 
   def apply(element, scope, *args)
-    nodes = (@type == :text) ? "" : Nodes[]
+    nodes = empty_nodes
     element.children.each do |child|
       case child
       when Element
@@ -78,7 +78,7 @@ class ZenithalConverter
   end
 
   def apply_select(element, xpath, scope, *args)
-    nodes = (@type == :text) ? "" : Nodes[]
+    nodes = empty_nodes
     element.each_xpath(xpath) do |child|
       case child
       when Element
@@ -97,7 +97,7 @@ class ZenithalConverter
   end
 
   def call(element, name, *args)
-    nodes = (@type == :text) ? "" : Nodes[]
+    nodes = empty_nodes
     @functions.each do |function_name, block|
       if function_name == name
         nodes = instance_exec(element, *args, &block)
@@ -123,6 +123,11 @@ class ZenithalConverter
     end
   end
 
+  def empty_nodes
+    return (@type == :text) ? "" : Nodes[]
+  end
+
+  ## Returns a simple converter that converts an XML document to the equivalent HTML document.
   def self.simple_html(document)
     converter = ZenithalConverter.new(document, :text)
     converter.add([//], [""]) do |element|

data/source/zenml/parser.rb

@@ -44,262 +44,271 @@ module ZenithalParserMethod
     0x3001..0xD7FF, 0xF900..0xFDCF, 0xFDF0..0xFFFD, 0x10000..0xEFFFF
   ]
 
+  def parse
+    unless @inside_run
+      warn("This method is now only for internal use. Use 'run' instead.", uplevel: 1)
+    end
+    if @whole
+      parse_document
+    else
+      parse_nodes({})
+    end
+  end
+
   private
 
   def parse_document
-    parser = Parser.build(self) do
-      document = Document.new
-      children = +parse_nodes({})
-      +parse_eof
-      children.each do |child|
-        document.add(child)
-      end
-      next document
+    document = Document.new
+    children = parse_nodes({})
+    if @exact
+      parse_eof 
     end
-    return parser
+    children.each do |child|
+      document.add(child)
+    end
+    return document
   end
 
   def parse_nodes(options)
-    parser = Parser.build(self) do
-      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, options))
+    nodes = nil
+    if options[:plugin]
+      nodes = options[:plugin].parse
+    elsif options[:verbal]
+      raw_nodes = many(->{parse_text(options)})
+      nodes = raw_nodes.inject(Nodes[], :<<)
+    else
+      parsers = []
+      parsers << ->{parse_element(options)}
+      if options[:in_slash]
+        next_options = options.clone
+        next_options.delete(:in_slash)
+      else
+        next_options = options
+      end
+      @special_element_names.each do |kind, name|
+        unless kind == :slash && options[:in_slash]
+          parsers << ->{parse_special_element(kind, next_options)}
         end
       end
-      raw_nodes = +parsers.inject(:|).many
+      parsers << ->{parse_comment(options)}
+      parsers << ->{parse_text(options)}
+      raw_nodes = many(->{choose(*parsers)})
       nodes = raw_nodes.inject(Nodes[], :<<)
-      next nodes
     end
-    return parser
+    return nodes
   end
 
   def parse_element(options)
-    parser = Parser.build(self) do
-      start_char = +parse_char_any([ELEMENT_START, MACRO_START])
-      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
-        next process_macro(name, marks, attributes, children_list, options)
-      else
-        next create_element(name, marks, attributes, children_list, options)
-      end
+    start_char = parse_char_any([ELEMENT_START, MACRO_START])
+    name = parse_identifier(options)
+    marks = parse_marks(options)
+    attributes = maybe(->{parse_attributes(options)}) || {}
+    macro = start_char == MACRO_START
+    next_options = determine_options(name, marks, attributes, macro, options)
+    children_list = parse_children_list(next_options)
+    if name == SYSTEM_INSTRUCTION_NAME
+      parse_space
+    end
+    if start_char == MACRO_START
+      element = process_macro(name, marks, attributes, children_list, options)
+    else
+      element = create_element(name, marks, attributes, children_list, options)
     end
-    return parser
+    return element
   end
 
   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(options)
-      +parse_char(SPECIAL_ELEMENT_ENDS[kind])
-      next create_special_element(kind, children, options)
+    parse_char(SPECIAL_ELEMENT_STARTS[kind])
+    if kind == :slash
+      next_options = options.clone
+      next_options[:in_slash] = true
+    else
+      next_options = options
     end
-    return parser
+    children = parse_nodes(next_options)
+    parse_char(SPECIAL_ELEMENT_ENDS[kind])
+    element = create_special_element(kind, children, options)
+    return element
   end
 
   def parse_marks(options)
-    return parse_mark(options).many
+    marks = many(->{parse_mark(options)})
+    return marks
   end
   
   def parse_mark(options)
     parsers = MARKS.map do |mark, query|
-      next parse_char(query).map{|_| mark}
+      next ->{parse_char(query).yield_self{|_| mark}}
     end
-    return parsers.inject(:|)
+    mark = choose(*parsers)
+    return mark
   end
 
   def parse_attributes(options)
-    parser = Parser.build(self) do
-      +parse_char(ATTRIBUTE_START)
-      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
-    end
-    return parser
+    parse_char(ATTRIBUTE_START)
+    first_attribute = parse_attribute(true, options)
+    rest_attribtues = many(->{parse_attribute(false, options)})
+    attributes = first_attribute.merge(*rest_attribtues)
+    parse_char(ATTRIBUTE_END)
+    return attributes
   end
 
   def parse_attribute(first, options)
-    parser = Parser.build(self) do
-      +parse_char(ATTRIBUTE_SEPARATOR) unless first
-      +parse_space
-      name = +parse_identifier(options)
-      +parse_space
-      value = +parse_attribute_value(options).maybe || name
-      +parse_space
-      next {name => value}
+    unless first
+      parse_char(ATTRIBUTE_SEPARATOR) 
     end
-    return parser
+    parse_space
+    name = parse_identifier(options)
+    parse_space
+    value = maybe(->{parse_attribute_value(options)}) || name
+    parse_space
+    attribute = {name => value}
+    return attribute
   end
 
   def parse_attribute_value(options)
-    parser = Parser.build(self) do
-      +parse_char(ATTRIBUTE_EQUAL)
-      +parse_space
-      value = +parse_string(options)
-      next value
-    end
-    return parser
+    parse_char(ATTRIBUTE_EQUAL)
+    parse_space
+    value = parse_string(options)
+    return value
   end
 
   def parse_string(options)
-    parser = Parser.build(self) do
-      +parse_char(STRING_START)
-      strings = +(parse_string_plain(options) | parse_escape(:string, options)).many
-      +parse_char(STRING_END)
-      next strings.join
-    end
-    return parser
+    parse_char(STRING_START)
+    strings = many(->{parse_string_plain_or_escape(options)})
+    parse_char(STRING_END)
+    string = strings.join
+    return string
   end
 
   def parse_string_plain(options)
-    parser = Parser.build(self) do
-      chars = +parse_char_out([STRING_END, ESCAPE_START]).many(1)
-      next chars.join
-    end
-    return parser
+    chars = many(->{parse_char_out([STRING_END, ESCAPE_START])}, 1..)
+    string = chars.join
+    return string
+  end
+
+  def parse_string_plain_or_escape(options)
+    string = choose(->{parse_escape(:string, options)}, ->{parse_string_plain(options)})
+    return string
   end
 
   def parse_children_list(options)
-    parser = Parser.build(self) do
-      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
+    first_children = choose(->{parse_empty_children(options)}, ->{parse_children(options)})
+    rest_children_list = many(->{parse_children(options)})
+    children_list = [first_children] + rest_children_list
+    return children_list
   end
 
   def parse_children(options)
-    parser = Parser.build(self) do
-      +parse_char(CONTENT_START)
-      children = +parse_nodes(options)
-      +parse_char(CONTENT_END)
-      next children
-    end
-    return parser
+    parse_char(CONTENT_START)
+    children = parse_nodes(options)
+    parse_char(CONTENT_END)
+    return children
   end
 
   def parse_empty_children(options)
-    parser = Parser.build(self) do
-      +parse_char(CONTENT_END)
-      next Nodes[]
-    end
-    return parser
+    parse_char(CONTENT_END)
+    children = Nodes[]
+    return children
   end
 
   def parse_text(options)
-    parser = Parser.build(self) do
-      raw_texts = +(parse_text_plain(options) | parse_escape(:text, options)).many(1)
-      next create_text(raw_texts.join, options)
-    end
-    return parser
+    raw_texts = many(->{parse_text_plain_or_escape(options)}, 1..)
+    text = create_text(raw_texts.join, options)
+    return text
   end
 
   def parse_text_plain(options)
-    parser = Parser.build(self) do
-      out_chars = [ESCAPE_START, CONTENT_END]
-      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
-        end
+    out_chars = [ESCAPE_START, CONTENT_END]
+    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])
       end
-      chars = +parse_char_out(out_chars).many(1)
-      next chars.join
     end
-    return parser
+    chars = many(->{parse_char_out(out_chars)}, 1..)
+    string = chars.join
+    return string
+  end
+
+  def parse_text_plain_or_escape(options)
+    string = choose(->{parse_escape(:text, options)}, ->{parse_text_plain(options)})
+    return string
+  end
+
+  def parse_comment(options)
+    parse_char(COMMENT_DELIMITER)
+    comment = choose(->{parse_line_comment(options)}, ->{parse_block_comment(options)})
+    return comment
   end
 
   def parse_line_comment(options)
-    parser = Parser.build(self) do
-      +parse_char(COMMENT_DELIMITER)
-      +parse_char(COMMENT_DELIMITER)
-      content = +parse_line_comment_content(options)
-      +parse_char("\n")
-      next create_comment(:line, content, options)
-    end
-    return parser
+    parse_char(COMMENT_DELIMITER)
+    content = parse_line_comment_content(options)
+    parse_char("\n")
+    comment = create_comment(:line, content, options)
+    return comment
   end
 
   def parse_line_comment_content(options)
-    parser = Parser.build(self) do
-      chars = +parse_char_out(["\n"]).many
-      next chars.join
-    end
-    return parser
+    chars = many(->{parse_char_out(["\n"])})
+    content = chars.join
+    return content
   end
 
   def parse_block_comment(options)
-    parser = Parser.build(self) do
-      +parse_char(COMMENT_DELIMITER)
-      +parse_char(CONTENT_START)
-      content = +parse_block_comment_content(options)
-      +parse_char(CONTENT_END)
-      +parse_char(COMMENT_DELIMITER)
-      next create_comment(:block, content, options)
-    end
-    return parser
+    parse_char(CONTENT_START)
+    content = parse_block_comment_content(options)
+    parse_char(CONTENT_END)
+    parse_char(COMMENT_DELIMITER)
+    comment = create_comment(:block, content, options)
+    return comment
   end
 
   def parse_block_comment_content(options)
-    parser = Parser.build(self) do
-      chars = +parse_char_out([CONTENT_END]).many
-      next chars.join
-    end
-    return parser
+    chars = many(->{parse_char_out([CONTENT_END])})
+    content = chars.join
+    return content
   end
 
   def parse_escape(place, options)
-    parser = Parser.build(self) do
-      +parse_char(ESCAPE_START)
-      char = +parse_char
-      next create_escape(place, char, options)
-    end
-    return parser
+    parse_char(ESCAPE_START)
+    char = parse_char
+    escape = create_escape(place, char, options)
+    return escape
   end
 
   def parse_identifier(options)
-    parser = Parser.build(self) do
-      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
+    first_char = parse_first_identifier_char(options)
+    rest_chars = many(->{parse_middle_identifier_char(options)})
+    identifier = first_char + rest_chars.join
+    return identifier
   end
 
   def parse_first_identifier_char(options)
-    return parse_char_any(VALID_FIRST_IDENTIFIER_CHARS)
+    char = parse_char_any(VALID_FIRST_IDENTIFIER_CHARS)
+    return char
   end
 
   def parse_middle_identifier_char(options)
-    return parse_char_any(VALID_MIDDLE_IDENTIFIER_CHARS)
+    char = parse_char_any(VALID_MIDDLE_IDENTIFIER_CHARS)
+    return char
   end
 
   def parse_space
-    return parse_char_any(SPACE_CHARS).many
+    space = many(->{parse_char_any(SPACE_CHARS)})
+    return space
   end
 
-  # 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
+    if macro && @plugins.key?(name)
+      options = options.clone
+      options[:plugin] = @plugins[name].call(attributes)
+    end
     return options
   end
 
@@ -312,12 +321,12 @@ module ZenithalParserMethod
     end
     if marks.include?(:instruction)
       unless children_list.size <= 1
-        throw(:error, error_message("Processing instruction cannot have more than one argument"))
+        throw_custom(error_message("Processing instruction cannot have more than one argument"))
       end
       nodes = create_instruction(name, attributes, children_list.first, options)
     else
       unless marks.include?(:multiple) || children_list.size <= 1
-        throw(:error, error_message("Normal node cannot have more than one argument"))
+        throw_custom(error_message("Normal element cannot have more than one argument"))
       end
       nodes = create_normal_element(name, attributes, children_list, options)
     end
@@ -369,21 +378,27 @@ module ZenithalParserMethod
 
   def create_special_element(kind, children, options)
     name = @special_element_names[kind]
-    nodes = create_element(name, [], {}, [children], options)
+    if name
+      nodes = create_element(name, [], {}, [children], options)
+    else
+      throw_custom(error_message("No name specified for #{kind} elements"))
+    end
     return nodes
   end
 
   def create_text(raw_text, options)
-    return Text.new(raw_text, true, nil, false)
+    text = Text.new(raw_text, true, nil, false)
+    return text
   end
 
   def create_comment(kind, content, options)
-    return Comment.new(" " + content.strip + " ")
+    comment = Comment.new(" " + content.strip + " ")
+    return comment
   end
 
   def create_escape(place, char, options)
     unless ESCAPE_CHARS.include?(char)
-      throw(:error, "Invalid escape")
+      throw_custom(error_message("Invalid escape"))
     end
     return char
   end
@@ -395,44 +410,57 @@ module ZenithalParserMethod
       raw_elements.each do |raw_element|
         elements << raw_element
       end
+    elsif @plugins.key?(name)
+      elements = children_list.first
     else
-      throw(:error, error_message("No such macro"))
+      throw_custom(error_message("No such macro '#{name}'"))
     end
     return elements
   end
 
-  def error_message(message)
-    return "[line #{@source.lineno}] #{message}"
-  end
-
 end
 
 
-class ZenithalParser
+class ZenithalParser < Parser
 
-  include CommonParserMethod
   include ZenithalParserMethod
 
-  attr_reader :source
+  attr_accessor :exact
+  attr_accessor :whole
 
   def initialize(source)
-    @source = StringReader.new(source)
+    super(source)
     @version = nil
+    @exact = true
+    @whole = true
     @special_element_names = {:brace => nil, :bracket => nil, :slash => nil}
     @macros = {}
+    @plugins = {}
   end
 
-  def parse
-    result = parse_document.exec
-    if result.success?
-      return result.value
-    else
-      raise ZenithalParseError.new(result.message)
+  # Registers a macro.
+  # To the argument block will be passed two arguments: the first is a hash of the attributes, the second is a list of the children nodes.
+  def register_macro(name, &block)
+    @macros.store(name, block)
+  end
+
+  def unregister_macro(name)
+    @macros.delete(name)
+  end
+
+  # Registers a plugin, which enables us to apply another parser in certain macros.
+  # If a class instance is passed, simply an instance of that class will be created and used as a custom parser.
+  # If a block is passed, it will be called to create a custom parser.
+  # To this block will be passed one argument: the attributes which are specified to the macro.
+  def register_plugin(name, clazz = nil, &block)
+    if clazz
+      block = lambda{|_| clazz.new(@source)}
     end
+    @plugins.store(name, block)
   end
 
-  def register_macro(name, &block)
-    @macros.store(name, block)
+  def unregister_plugin(name)
+    @plugins.delete(name)
   end
 
   def brace_name=(name)

data/source/zenml/parser_utility.rb

@@ -3,227 +3,209 @@
 
 class Parser
 
-  attr_reader :builder
-
-  def initialize(builder, &method)
-    @builder = builder
-    @method = method
-  end
-
-  def self.build(source, &block)
-    parser = Parser.new(source) do
-      value = nil
-      message = catch(:error) do
-        value = block.call
-      end
-      if value
-        next Result.success(value)
-      else
-        next Result.error(message)
-      end
-    end
-    return parser
-  end
-
-  def exec
-    return @builder.instance_eval(&@method)
-  end
-
-  def exec_get
-    result = self.exec
-    if result.success?
-      return result.value
+  ERROR_TAG = Object.new
+
+  def initialize(source)
+    case source
+    when StringReader
+      @source = source
+    when File
+      @source = StringReader.new(source.read)
     else
-      throw(:error, result.message)
+      @source = StringReader.new(source.to_s)
     end
+    @inside_run = false
   end
 
-  alias -@ exec
-  alias +@ exec_get
-
-  def |(other)
-    this = self
-    if this.builder.equal?(other.builder)
-      parser = Parser.new(this.builder) do
-        mark = source.mark
-        result = this.exec
-        if result.success?
-          next result
-        else
-          source.reset(mark)
-          result = other.exec
-          next result
-        end
+  def run
+    value = nil
+    message = catch(ERROR_TAG) do
+      begin
+        @inside_run = true
+        value = parse
+      ensure
+        @inside_run = false
       end
-      return parser
-    else
-      raise StandardError.new("Different source")
     end
-  end
-
-  def many(lower_limit = 0, upper_limit = nil)
-    this = self
-    parser = Parser.new(this.builder) do
-      values, count = [], 0
-      loop do
-        mark = source.mark
-        each_result = this.exec
-        if each_result.success?
-          values << each_result.value
-          count += 1
-          if upper_limit && count >= upper_limit
-            break
-          end
-        else
-          source.reset(mark)
-          break
-        end
-      end
-      if count >= lower_limit
-        next Result.success(values)
-      else
-        next Result.error("")
-      end
+    unless value
+      raise ZenithalParseError.new(message)
     end
-    return parser
-  end
-
-  def maybe
-    return self.many(0, 1).map{|s| s.first}
+    return value
   end
 
-  def map(&block)
-    this = self
-    parser = Parser.new(this.builder) do
-      result = this.exec
-      if result.success?
-        next Result.success(block.call(result.value))
-      else
-        next result
-      end
-    end
-    return parser
+  # Parses a whole data.
+  # This method is intended to be overridden in subclasses.
+  def parse
+    throw_custom("Not implemented")
+    return nil
   end
 
-end
-
-
-module CommonParserMethod
-
   private
 
   # 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.
+  # If the next character does not match the query or the end of file is reached, then an error occurs and no input is consumed.
+  # Otherwise, a string which consists of the matched single chracter is returned.
   def parse_char(query = nil)
-    parser = Parser.new(self) do
-      char = source.read
-      unless char == nil
-        predicate, message = false, nil
-        case query
-        when String
-          predicate = query == char
-          message = "Expected '#{query}'"
-        when Regexp
-          predicate = query =~ char
-          message = "Expected /#{query}/"
-        when Integer
-          predicate = query == char.ord
-          message = "Expected '#{query.chr}'"
-        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)
-        else
-          next Result.error(error_message(message))
-        end
-      else
-        next Result.error(error_message("Unexpected end of file"))
+    char = @source.peek
+    if char
+      predicate, message = false, nil
+      case query
+      when String
+        predicate = query == char
+        message = "Expected '#{query}' but got '#{char}'"
+      when Regexp
+        predicate = query =~ char
+        message = "Expected /#{query}/ but got '#{char}'"
+      when Integer
+        predicate = query == char.ord
+        message = "Expected '##{query}' but got '#{char}'"
+      when Range
+        predicate = query.cover?(char.ord)
+        symbol = (query.exclude_end?) ? "..." : ".."
+        message = "Expected '##{query.begin}'#{symbol}'##{query.end}' but got '#{char}'"
+      when NilClass
+        predicate = true
+        message = ""
+      end
+      unless predicate
+        throw_custom(error_message(message))
       end
+    else
+      throw_custom(error_message("Unexpected end of file"))
     end
-    return parser
+    char = @source.read
+    return char
   end
 
   # Parses a single character which matches any of the specified queries.
   def parse_char_any(queries)
-    return queries.map{|s| parse_char(s)}.inject(:|)
+    parsers = []
+    queries.each do |query|
+      parsers << ->{parse_char(query)}
+    end
+    char = choose(*parsers)
+    return char
   end
 
   # Parses a single character other than the specified characters.
-  # If the next character coincides with any of the elements of the arguments, an error result is returned.
-  # Otherwise, a success result with a string containing the next chracter is returned.
+  # If the next character coincides with any of the elements of the arguments, then an error occurs and no input is consumed.
+  # Otherwise, a string which consists of the next single chracter is returned.
   def parse_char_out(chars)
-    parser = Parser.new(self) do
-      char = source.read
-      if char && chars.all?{|s| s != char}
-        next Result.success(char)
-      else
-        message = "Expected other than " + chars.map{|s| "'#{s}'"}.join(", ")
-        next Result.error(error_message(message))
+    char = @source.peek
+    if char
+      if chars.any?{|s| s == char}
+        chars_string = chars.map{|s| "'#{s}'"}.join(", ")
+        throw_custom(error_message("Expected other than #{chars_string} but got '#{char}'"))
       end
+    else
+      throw_custom(error_message("Unexpected end of file"))
     end
-    return parser
+    char = @source.read
+    return char
   end
 
   def parse_eof
-    parser = Parser.new(self) do
-      char = source.read
-      if char == nil
-        next Result.success(true)
-      else
-        next Result.error(error_message("Document ends before reaching end of file"))
-      end
+    char = @source.peek
+    if char
+      throw_custom(error_message("Document ends before reaching end of file"))
     end
-    return parser
+    char = @source.read
+    return true
   end
 
-  # Returns a parser which always fails.
-  # That is, it always returns an error result.
+  # Parses nothing; thus an error always occur.
   def parse_none
-    parser = Parser.new(self) do
-      next Result.error(error_message("This cannot happen"))
+    throw_custom(error_message("This cannot happen"))
+    return nil
+  end
+
+  # Simply executes the specified parser, but additionally performs backtracking on error.
+  # If an error occurs in executing the parser, this method rewinds the state of the input to that before executing, and then raises an error.
+  # Otherwise, a result obtained by the parser is returned.
+  def try(parser)
+    mark = @source.mark
+    value = nil
+    message = catch_custom do
+      value = parser.call
     end
-    return parser
+    unless value
+      @source.reset(mark)
+      throw_custom(message)
+    end
+    return value
   end
 
-end
-
-
-class Result
-
-  attr_reader :value
-  attr_reader :message
-
-  def initialize(value, message)
-    @value = value
-    @message = message
+  # First this method executes the first specified parser.
+  # If it fails without consuming any input, then this method tries the next specified parser and repeats this procedure.
+  def choose(*parsers)
+    value, message = nil, ""
+    parsers.each do |parser|
+      mark = @source.mark
+      message = catch_custom do
+        value = parser.call
+      end
+      if value
+        break
+      elsif mark != @source.mark
+        break
+      end
+    end
+    unless value
+      throw_custom(message)
+    end
+    return value
   end
-  
-  def self.success(value)
-    return Result.new(value, nil)
+
+  def many(parser, range = 0..)
+    values, message, count = [], "", 0
+    lower_limit, upper_limit = range.begin, range.end
+    if upper_limit && range.exclude_end?
+      upper_limit -= 1
+    end
+    loop do
+      mark = @source.mark
+      value = nil
+      message = catch_custom do
+        value = parser.call
+      end
+      if value
+        values << value
+        count += 1
+        if upper_limit && count >= upper_limit
+          break
+        end
+      else
+        if mark != @source.mark
+          throw_custom(message)
+        end
+        break
+      end
+    end
+    unless count >= lower_limit
+      throw_custom(message)
+    end
+    return values
   end
 
-  def self.error(message)
-    return Result.new(nil, message)
+  def maybe(parser)
+    value = many(parser, 0..1).first
+    return value
   end
 
-  def value=(value)
-    if self.success?
-      @value = value
-    end
+  # Catch a parse error.
+  # Do not use the standard exception mechanism during parsing.
+  def catch_custom(&block)
+    catch(ERROR_TAG, &block)
   end
 
-  def success?
-    return !@message
+  # Raises a parse error.
+  # Do not use the standard exception mechanism during parsing, and always use this method to avoid creating an unnecessary stacktrace.
+  def throw_custom(message)
+    throw(ERROR_TAG, message)
   end
 
-  def error?
-    return !!@message
+  def error_message(message)
+    return "[line #{@source.lineno}, column #{@source.columnno}] #{message}"
   end
 
 end

data/source/zenml/reader.rb

@@ -4,18 +4,22 @@
 class StringReader
 
   attr_reader :lineno
+  attr_reader :columnno
 
   def initialize(string)
     @string = string.chars
     @pos = -1
     @lineno = 1
+    @columnno = 1
   end
 
   def read
     @pos += 1
+    @columnno += 1
     char = @string[@pos]
     if char == "\n"
       @lineno += 1
+      @columnno = 1
     end
     return char
   end
@@ -25,23 +29,14 @@ class StringReader
     return char
   end
 
-  def unread(size = 1)
-    size.times do
-      char = @string[@pos]
-      @pos -= 1
-      if char == "\n"
-        @lineno -= 1
-      end
-    end
-  end
-
   def mark
-    return [@pos, @lineno]
+    return [@pos, @lineno, @columnno]
   end
 
   def reset(mark)
     @pos = mark[0]
     @lineno = mark[1]
+    @columnno = mark[2]
   end
 
 end

data/source/zenml.rb

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

metadata

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