l43_peg 0.0.1 → 0.1.1

data/lib/l43_peg/parsers/tokens_parser.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Parsers
+    class TokensParser < L43Peg::Parser
+
+      private
+
+      def initialize(map, name: nil, &blk)
+        map = _check_arg!(map)
+        name = name || "tokens_parser(#{map.inspect})"
+        super(name) do |tokens, cache, _name|
+          case _find_matching(map, tokens)
+          in [token, success]
+            _succeed(tokens:, token:, success:, &blk)
+          else
+            reason = "no token matches (in #{name})"
+            L43Peg::Failure.new(cache:, input: tokens, parsed_by: self, reason:)
+          end
+        end
+
+      end
+
+      def _check_arg!(map)
+        case map
+        when Hash
+          _mk_tokens(map)
+        else
+          raise ArgumentError, "#{map.inspect} must be a regular expression or a string"
+        end
+      end
+
+      def _find_matching(map, tokens)
+        map.each do |token, token_parser|
+          case token_parser.(tokens)
+          in L43Peg::Success => success
+            return [token, success]
+          else
+          end
+        end
+        nil
+      end
+
+      def _mk_tokens(map)
+        map.map do |token, spec|
+          [token, TokenParser.new(Regexp.compile(spec), capture: 1)]
+        end.to_h
+      end
+
+      def _succeed(success:, token:, tokens:, &blk)
+        result = if blk
+                   blk.(success.ast)
+                 else
+                   success.ast
+                 end
+        L43Peg::Success.new(ast: {token => result}, cache: success.cache, rest: success.rest, position: tokens.position)
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers/verb_parser.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Parsers
+    class VerbParser < L43Peg::Parser
+
+      private
+
+      def initialize(verb, name: nil)
+        name = name || "verb_parser(#{verb.inspect})"
+        super(name) do |input, cache, _name|
+          if input.input.start_with?(verb)
+            L43Peg::Success.new(ast: verb, cache:, rest: input.drop(verb), position: input.position)
+          else
+            L43Peg::Failure.new(cache:, input:, parsed_by: self, reason: "input does not start with #{verb.inspect} (in #{name})")
+          end
+        end
+      end
+
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'combinators'
+require_subdir {}
+
+module L43Peg
+  module Parsers extend self
+    def args_parser(args, name: nil)      = L43Peg::Parsers::ArgsParser.new(args, name:)
+    def char_parser(charset = nil)        = L43Peg::Parsers::CharParser.new(charset)
+    def end_parser                        = L43Peg::Parsers::EndParser.instance
+    def failure_parser                    = L43Peg::Parsers::FailureParser.instance
+    def int_parser                        = L43Peg::Parsers::IntParser.instance
+    def rgx_parser(rgx, name: nil, **o)   = L43Peg::Parsers::RgxParser.new(rgx, name:, **o)
+    def token_parser(spc, name: nil, **o) = L43Peg::Parsers::TokenParser.new(spc, name:, **o)
+    def tokens_parser(map, name: nil, &b) = L43Peg::Parsers::TokensParser.new(map, name:, &b)
+    def verb_parser(verb, name: nil)      = L43Peg::Parsers::VerbParser.new(verb, name:)
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg/success.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module L43Peg
+  class Success
+    def _init
+      return if @position
+      @position = _position
+    end
+    extend L43::OpenObject
+
+    attributes ast: nil, cache: nil, position: nil, rest: nil
+
+    def map(&mapper)
+      self.class.new(ast: mapper.(ast), cache:, position:, rest:)
+    end
+
+    private
+
+
+    def _position
+      case @rest
+      when Tokens
+        1
+      else
+        [1, 1]
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg/tokens.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module L43Peg
+  class Tokens
+    extend L43::OpenObject
+
+    attributes tnb: 1, tokens: [], context: {}
+    
+    def drop(by=nil)
+      by = by || 1
+      return self if empty?
+      self.class.new(tokens: input.drop(by), context:, tnb: tnb + by)
+    end
+
+    def empty? = tokens.empty?
+    def head = tokens.first
+    def input = tokens
+
+    def match(str_or_rgx, option)
+      return if empty?
+
+      case str_or_rgx
+      when String
+        head == str_or_rgx && head
+      when Regexp
+        _match_rgx(str_or_rgx, option || 0)
+      end
+    end
+
+    def position = tnb
+
+    private
+
+    def _match_rgx(rgx, option)
+      md = rgx.match(head)
+      return unless md
+
+      if option == :all
+        md.to_a
+      else
+        md[option]
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+require_relative 'l43/require_helper'
+require_relative 'l43/open_object'
+require_subdir {}
+
 module L43Peg
-  VERSION = "0.0.1"
-  
+  VERSION = "0.1.1"
 end
-# SPDX-License-Identifier: Apache-2.0
+# SPDX-License-Identifier: AGPL-3.0-or-later

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: l43_peg
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - Robert Dober
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-10 00:00:00.000000000 Z
+date: 2024-04-22 00:00:00.000000000 Z
 dependencies: []
 description: |
   **PLACEHOLDER**
@@ -26,7 +26,30 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- lib/l43/match_data_extenstion.rb
+- lib/l43/open_object.rb
+- lib/l43/require_helper.rb
 - lib/l43_peg.rb
+- lib/l43_peg/cache.rb
+- lib/l43_peg/combinators.rb
+- lib/l43_peg/combinators/many.rb
+- lib/l43_peg/combinators/seq.rb
+- lib/l43_peg/failure.rb
+- lib/l43_peg/helper.rb
+- lib/l43_peg/input.rb
+- lib/l43_peg/mappers.rb
+- lib/l43_peg/parser.rb
+- lib/l43_peg/parsers.rb
+- lib/l43_peg/parsers/char_parser.rb
+- lib/l43_peg/parsers/end_parser.rb
+- lib/l43_peg/parsers/failure_parser.rb
+- lib/l43_peg/parsers/int_parser.rb
+- lib/l43_peg/parsers/rgx_parser.rb
+- lib/l43_peg/parsers/token_parser.rb
+- lib/l43_peg/parsers/tokens_parser.rb
+- lib/l43_peg/parsers/verb_parser.rb
+- lib/l43_peg/success.rb
+- lib/l43_peg/tokens.rb
 homepage: https://gitlab.com/l43-gems/l43_peg
 licenses:
 - Apache-2.0