zenml 1.0.1 → 1.1.0

data/source/zenml/parser_utility.rb

@@ -0,0 +1,223 @@
+# coding: utf-8
+
+
+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 !
+    result = self.exec
+    if result.success?
+      return result.value
+    else
+      throw(:error, result.message)
+    end
+  end
+
+  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
+      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
+    end
+    return parser
+  end
+
+  def maybe
+    return self.many(0, 1).map{|s| s.first}
+  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
+  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.
+  def parse_char(query)
+    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}'"
+        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"))
+      end
+    end
+    return parser
+  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(:|)
+  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.
+  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))
+      end
+    end
+    return parser
+  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
+    end
+    return parser
+  end
+
+  # Returns a parser which always fails.
+  # That is, it always returns an error result.
+  def parse_none
+    parser = Parser.new(self) do
+      next Result.error(error_message("This cannot happen"))
+    end
+    return parser
+  end
+
+end
+
+
+class Result
+
+  attr_reader :value
+  attr_reader :message
+
+  def initialize(value, message)
+    @value = value
+    @message = message
+  end
+  
+  def self.success(value)
+    return Result.new(value, nil)
+  end
+
+  def self.error(message)
+    return Result.new(nil, message)
+  end
+
+  def value=(value)
+    if self.success?
+      @value = value
+    end
+  end
+
+  def success?
+    return !@message
+  end
+
+  def error?
+    return !!@message
+  end
+
+end

data/source/zenml/reader.rb

@@ -35,4 +35,13 @@ class StringReader
     end
   end
 
+  def mark
+    return [@pos, @lineno]
+  end
+
+  def reset(mark)
+    @pos = mark[0]
+    @lineno = mark[1]
+  end
+
 end

data/source/zenml/utility.rb

@@ -41,6 +41,19 @@ class Element
     end
   end
 
+  def get_texts_recursive
+    texts = []
+    self.children.each do |child|
+      case child
+      when Text
+        texts << child
+      when Element
+        texts.concat(child.get_texts_recursive)
+      end
+    end
+    return texts
+  end
+
   def self.build(name, &block)
     element = Element.new(name)
     block.call(element)
@@ -85,6 +98,33 @@ class Nodes < Array
     return Nodes.new(super(other))
   end
 
+  def trim_indents
+    texts = []
+    if self.last.is_a?(Text)
+      self.last.value = self.last.value.rstrip
+    end
+    self.each do |child|
+      case child
+      when Text
+        texts << child
+      when Element
+        texts.concat(child.get_texts_recursive)
+      end
+    end
+    indent_length = Float::INFINITY
+    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 self.first.is_a?(Text)
+      self.first.value = self.first.value.lstrip
+    end
+  end
+
 end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zenml
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Ziphil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-19 00:00:00.000000000 Z
+date: 2019-09-28 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,9 @@ 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
 - source/zenml/utility.rb
 homepage: https://github.com/Ziphil/Zenithal