pegparse 0.1.0

data/samples/bsh_parser.rb

@@ -0,0 +1,337 @@
+require_relative '../lib/pegparse'
+require 'set'
+
+module Pegparse::Sample
+end
+
+class Pegparse::Sample::BshParser < Pegparse::ParserBase
+  def initialize(context_or_scanner)
+    super(context_or_scanner)
+    self.start_rule_symbol = :start_rule
+  end
+
+  def line_comment
+    read(/#.*/)
+  end
+
+  def inline_sp
+    read(/( |\\\n)*/)
+  end
+
+  def lf
+    choice(
+      ->{ super() },
+      ->{
+        sp()
+        read(';')
+      },
+    )
+  end
+
+  def keyword(key)
+    read(key)
+    backtrack if peek(/[A-Za-z0-9_]/)
+  end
+
+  def start_rule
+    ret = pipelines()
+    sp()
+    ret
+  end
+
+  def pipelines
+    zero_or_more {
+      sp()
+      pipeline()
+    }
+  end
+
+  BshBiopParser = Pegparse::BiopRuleChain.based_on(self) do
+    def operator_sp
+      inline_sp()
+    end
+
+    def operand_sp
+      inline_sp()
+    end
+  end
+  rule def pipeline
+    biop_parser = BshBiopParser.new(nil)
+    biop_parser
+      .left_op(['&&', '||'])
+      .left_op('|')
+      .term(->{ sentence() })
+    ret = biop_parser.parse(@context)
+
+    pipeline_closer = optional{
+      inline_sp()
+      read(/[&;]/)
+    }
+    if pipeline_closer == '&'
+      [:bg, ret]
+    else
+      ret
+    end
+  end
+
+  rule def sentence
+    choice(
+      ->{ if_sentence() },
+      ->{ while_sentence() },
+      ->{ for_sentence() },
+      ->{ case_sentence() },
+      ->{ command_sentence() },
+    )
+  end
+
+  rule def if_sentence
+    keyword('if')
+    sp()
+    cond = pipeline()
+    sp()
+    keyword('then')
+    sp()
+    if_body = pipelines()
+    elif_cond_bodies = zero_or_more {
+      sp()
+      keyword('elif')
+      sp()
+      elif_cond = pipeline()
+      sp()
+      keyword('then')
+      sp()
+      elif_body = pipelines()
+      [elif_cond, elif_body]
+    }
+    else_body = optional{
+      sp()
+      keyword('else')
+      sp()
+      pipelines()
+    }
+    sp()
+    keyword('fi')
+    if else_body
+      [:if, [cond, if_body], *elif_cond_bodies, [nil, else_body]]
+    else
+      [:if, [cond, if_body], *elif_cond_bodies]
+    end
+  end
+
+  rule def while_sentence
+    keyword('while')
+    sp()
+    backtrack
+  end
+
+  rule def for_sentence
+    keyword('for')
+    sp()
+    var = assign_varname()
+    sp()
+    keyword('in')
+    list = zero_or_more {
+      inline_sp()
+      normal_operand()
+    }
+    lf()
+    sp()
+    keyword('do')
+    body = pipelines()
+    keyword('done')
+    [:for, var, list, body]
+  end
+
+  rule def case_sentence
+    keyword('case')
+    sp()
+    backtrack
+  end
+
+  rule def command_sentence
+    envs = zero_or_more {
+      inline_sp()
+      assign_exp()
+    }
+    main = optional{
+      inline_sp()
+      cmd = execute_target_exp()
+
+      operands = zero_or_more {
+        inline_sp()
+        choice(
+          ->{ redirect_operand() },
+          ->{ normal_operand() }
+        )
+      }
+
+      redirects, normals = operands.partition{|op| op[0] == :redirect}
+      [cmd, redirects, operands]
+    }
+    backtrack if envs.empty? && !main
+
+    main ? [:command, envs, main[1], main[0], *main[2]] : [:env, envs]
+  end
+
+  rule def assign_exp
+    varname = assign_varname()
+    read('=')
+    val = assign_value()
+    ['=', varname, val]
+  end
+
+  def assign_varname
+    read(/[A-Za-z][A-Za-z0-9_]*/)
+  end
+
+  def assign_value
+    normal_operand()
+  end
+
+  def execute_target_exp
+    normal_operand()
+  end
+
+  rule def redirect_operand
+    src_fd = optional{
+      read(/[0-9]+/)
+    }
+    redirect = read(/>|>>|<|&>/)
+    inline_sp()
+    dest = normal_operand()
+    [:redirect, redirect, src_fd, dest]
+  end
+
+  rule def normal_operand
+    concats = one_or_more {
+      choice(
+        ->{ string_double_quote() },
+        ->{ string_single_quote() },
+        ->{ backquote_operand() },
+        ->{ raw_operand() },
+      )
+    }
+    if concats.size > 1
+      [:concat, *concats]
+    else
+      concats.first
+    end
+  end
+
+  def string_double_quote_special_process
+    choice(
+      ->{
+        read('\\')
+        escaped = read(/./m)
+        case escaped
+        when 'n'
+          "\n"
+        when "\n"
+          ""
+        else
+          escaped
+        end
+      },
+      ->{
+        inline_command()
+      },
+      ->{
+        variable_reference()
+      }
+    )
+  end
+
+  rule def string_double_quote
+    read('"')
+    ret = string_like('"', /[^"\\$]*/) {
+      string_double_quote_special_process()
+    }
+    read('"')
+    [:dquote, *ret]
+  end
+
+  rule def inline_command
+    read('$(')
+    body = pipelines()
+    read(')')
+    [:inline, body]
+  end
+
+  rule def variable_reference
+    read('$')
+    ref = choice(
+      ->{
+        name = read(/[A-Za-z0-9_]+/)
+        [name, nil]
+      },
+      ->{
+        read('{')
+        name = read(/[A-Za-z0-9_]+/)
+        substr = optional {
+          variable_expansion()
+        }
+        read('}')
+        [name, substr]
+      },
+    )
+    [:var, *ref]
+  end
+
+  rule def variable_expansion
+    choice(
+      ->{
+        read(':-')
+        backtrack
+      },
+      ->{
+        read('-')
+        exp = variable_expansion_string()
+        ['-', exp]
+      },
+    )
+  end
+
+  rule def variable_expansion_string
+    ret = string_like('}', /[^\\$}]*/) {
+      string_double_quote_special_process()
+    }
+    if ret.size > 1
+      ret
+    elsif ret.size == 1
+      ret.first
+    else
+      ''
+    end
+  end
+
+  rule def string_single_quote
+    read("'")
+    val = read(/[^']*/)
+    read("'")
+    val
+  end
+
+  rule def backquote_operand
+    read('`')
+    read('`')
+    backtrack
+  end
+
+  RESERVED_WORDS = %w(
+    if then elif else fi while do for in done
+  ).to_set
+  rule def raw_operand
+    backtrack if RESERVED_WORDS.include?(peek(/[^\s]*/))
+
+    ret = string_like(/[\s&|><;]/, /[^\s&|><;\\$]*/) {
+      string_double_quote_special_process()
+    }
+    if ret.size > 1
+      ret
+    elsif ret.size == 0 || ret.first.size == 0
+      backtrack()
+    else
+      ret.first
+    end
+  end
+end

data/samples/calc_parser.rb

@@ -0,0 +1,55 @@
+require_relative '../lib/pegparse'
+
+module Pegparse::Sample
+end
+
+class Pegparse::Sample::CalcParser < Pegparse::ParserBase
+  def initialize(context_or_scanner)
+    super(context_or_scanner)
+    self.start_rule_symbol = :expression
+  end
+
+  CalcBiopParser = Pegparse::BiopRuleChain.based_on(self) do
+    def operator_sp
+      read(/ */)
+    end
+    def operand_sp
+      read(/ */)
+    end
+    def construct_result(lhs, op, rhs)
+      case op
+      when '+'
+        lhs + rhs
+      when '-'
+        lhs - rhs
+      when '*'
+        lhs * rhs
+      when '/'
+        lhs / rhs
+      end
+    end
+  end
+  rule def expression
+    biop = CalcBiopParser.new(nil)
+    biop
+      .left_op(['+', '-'])
+      .left_op(['*', '/'])
+      .term(->{ term() })
+    biop.parse(@context)
+  end
+
+  rule def term
+    choice(
+      ->{
+        read(/[0-9]+(\.[0-9]+)?/).to_f
+      },
+      ->{
+        read('(')
+        exp = expression()
+        read(')')
+        exp
+      }
+    )
+  end
+
+end

data/samples/json_parser.rb

@@ -0,0 +1,92 @@
+require_relative '../lib/pegparse'
+
+module Pegparse::Sample
+end
+
+class Pegparse::Sample::JsonParser < Pegparse::ParserBase
+  class JsonNullNode
+  end
+
+  def initialize(context_or_scanner)
+    super(context_or_scanner)
+    self.start_rule_symbol = :start_rule
+  end
+
+  def start_rule
+    sp()
+    json_node()
+  end
+
+  rule def json_node
+    choice(
+      ->{ json_number_node() },
+      ->{ json_string_node() },
+      ->{ json_null_node() },
+      ->{ json_bool_node() },
+      ->{ json_object_node() },
+      ->{ json_array_node() },
+    )
+  end
+
+  def json_number_node
+    str = read(/[0-9]+(\.[0-9]+)?/)
+    str.to_f
+  end
+
+  rule def json_string_node
+    read('"')
+    ret = string_like('"', /[^"\\]*/){
+      read("\\")
+      read(/./m)
+    }
+    read('"')
+    ret[0]
+  end
+
+  def json_null_node
+    read('null')
+    JsonNullNode.new
+  end
+
+  def json_bool_node
+    choice(
+      ->{
+        read('true')
+        true
+      },
+      ->{
+        read('false')
+        false
+      },
+    )
+  end
+
+  rule def json_object_node
+    read('{')
+    sp()
+    pairs = separative(',') {
+      key = json_object_key()
+      sp()
+      read(':')
+      sp()
+      val = json_node()
+      [key, val]
+    }
+    sp()
+    read('}')
+    pairs.to_h
+  end
+
+  def json_object_key
+    json_string_node()
+  end
+
+  rule def json_array_node
+    read('[')
+    sp()
+    elements = separative(',') { json_node() }
+    sp()
+    read(']')
+    elements
+  end
+end

data/samples/xml_parser.rb

@@ -0,0 +1,182 @@
+require_relative '../lib/pegparse'
+
+module Pegparse::Sample
+end
+
+class Pegparse::Sample::XmlParser < Pegparse::ParserBase
+  XmlNode = Struct.new(
+    :tag, :attrs, :inner_nodes,
+    keyword_init: true,
+  )
+
+  XmlAttr = Struct.new(
+    :name, :value,
+    keyword_init: true,
+  )
+
+  def initialize(context_or_scanner)
+    super(context_or_scanner)
+    self.start_rule_symbol = :start_rule
+  end
+
+  rule def block_comment
+    read('<!--')
+    read(/.*?-->/m)
+  end
+
+  def start_rule
+    sp()
+    decl = optional{ doc_declaration() }
+    nodes = xml_nodes()
+    [decl, nodes]
+  end
+
+  def intag_sp!
+    read(/\s+/)
+  end
+
+  def intag_sp
+    read(/\s*/)
+  end
+
+  def doc_declaration
+    choice(
+      ->{ xml_declaration() },
+      ->{ html_declaration() },
+    )
+  end
+
+  rule def xml_declaration
+    read('<?xml')
+    attrs = xml_attributes()
+    intag_sp()
+    read('>')
+    attrs
+  end
+
+  rule def html_declaration
+    read(/<!doctype html>/i)
+  end
+
+  def xml_attributes
+    attrs = zero_or_more {
+      intag_sp!()
+      xml_attribute_pair()
+    }
+    attrs
+  end
+
+  def xml_attribute_pair
+    name = xml_attribute_name()
+    read('=')
+    val = xml_attribute_value()
+    XmlAttr.new(name: name, value: val)
+  end
+
+  rule def xml_attribute_name
+    read(/[A-Za-z][A-Za-z0-9\-]*/)
+  end
+
+  rule def xml_tag_name
+    read(/[A-Za-z][A-Za-z0-9\-]*/)
+  end
+
+  rule def xml_attribute_value
+    choice(
+      ->{ single_quote_string() },
+      ->{ double_quote_string() },
+    )
+  end
+
+  def single_quote_string
+    read("'")
+    ret = string_like("'", /[^'\\]*/){
+      read('\\')
+      read(/./m)
+    }
+    read("'")
+    ret[0]
+  end
+
+  def double_quote_string
+    read('"')
+    ret = string_like('"', /[^"\\]*/){
+      read('\\')
+      read(/./m)
+    }
+    read('"')
+    ret[0]
+  end
+
+  rule def xml_open_tag
+    read('<')
+    name = xml_tag_name()
+    attrs = xml_attributes()
+    intag_sp()
+    read('>')
+    [name, attrs]
+  end
+
+  rule def xml_close_tag
+    read('</')
+    intag_sp()
+    name = xml_tag_name()
+    intag_sp()
+    read('>')
+    name
+  end
+
+  rule def xml_empty_element_tag
+    read('<')
+    name = xml_tag_name()
+    attrs = xml_attributes()
+    intag_sp()
+    read('/>')
+    [name, attrs]
+  end
+
+  SPECIAL_NONEST_TAG = %w(meta br)
+  rule def html_special_empty_element_tag
+    read('<')
+    name = xml_tag_name()
+    backtrack() unless SPECIAL_NONEST_TAG.include?(name)
+    attrs = xml_attributes()
+    intag_sp()
+    read(/\/?>/)
+    [name, attrs]
+  end
+
+  def xml_node
+    choice(
+      ->{
+        block_comment()
+      },
+      ->{
+        text = read(/[^<]+/)
+        text
+      },
+      ->{
+        tag = xml_empty_element_tag()
+        XmlNode.new(tag: tag[0], attrs: tag[1], inner_nodes: nil)
+      },
+      ->{
+        tag = html_special_empty_element_tag()
+        XmlNode.new(tag: tag[0], attrs: tag[1], inner_nodes: nil)
+      },
+      ->{
+        opentag = xml_open_tag()
+        inner = xml_nodes()
+        closetag = xml_close_tag()
+        backtrack if opentag[0] != closetag
+        XmlNode.new(tag: opentag[0], attrs: opentag[1], inner_nodes: inner)
+      }
+    )
+  end
+
+  def xml_nodes
+    nodes = zero_or_more {
+      xml_node()
+    }
+    nodes
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: pegparse
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Riki Ishikawa
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-12-20 00:00:00.000000000 Z
+dependencies: []
+description: provide base class for PEG like recursive descent parser.
+email:
+- riki.ishikawa@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/pegparse.rb
+- lib/pegparse/biop_rule_chain.rb
+- lib/pegparse/borrowed_areas.rb
+- lib/pegparse/line_counter.rb
+- lib/pegparse/parser_base.rb
+- lib/pegparse/parser_context.rb
+- lib/pegparse/parser_core.rb
+- lib/pegparse/parser_errors.rb
+- lib/pegparse/version.rb
+- pegparse.gemspec
+- samples/bsh_parser.rb
+- samples/calc_parser.rb
+- samples/json_parser.rb
+- samples/xml_parser.rb
+homepage: https://github.com/jljse/pegparse
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jljse/pegparse
+  source_code_uri: https://github.com/jljse/pegparse
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: library to create recursive descent parser.
+test_files: []