l43_rmap 0.1.0

data/lib/peg.backup/parsers/base_parsers.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative 'true_set'
+module Peg
+  module Parsers
+    module BaseParsers
+
+      # Parses a character which is a member of any of the `char_classes`
+      def char_class_parser(*char_classes, name: nil)
+        case char_classes
+        in [char_class]
+          _1_char_class_parser(char_class, name:)
+        else
+          _char_classes_parser(*char_classes, name:)
+        end
+      end
+
+      def char_parser(set=nil, name: nil, negate: false)
+        set = mk_set(set)
+        name ||= "char_parser(#{set.inspect})"
+        Parser.new(name) do |input|
+          case input.content
+          in []
+            Result.nok(error: "unexpected end of input", input:, name:)
+          in [h, *]
+            if set.member?(h) && !negate || !set.member?(h) && negate
+              Result.ok(ast: h, input: input.advance)
+            else
+              Result.nok(input:, error: "#{h} is not member of the required set #{set}", name:)
+            end
+          end
+        end
+      end
+
+      def end_parser(name: nil)
+        name ||= "end_parser"
+        Parser.new(name) do |input|
+          case input.content
+          in []
+            Result.ok(ast: nil, input:)
+          in _
+            Result.nok(input: input, error: "not at end of input", name:)
+          end
+        end
+      end
+
+      def make_parser(parser)
+        case parser
+        when String
+          char_parser(parser)
+        else
+          parser
+        end
+      end
+
+      def make_parsers(*parsers)
+        parsers
+          .flatten
+          .map { make_parser it }
+      end
+
+      private
+
+      def _1_char_class_parser(char_class, name:)
+        rgx = Regexp.compile("[[:#{char_class}:]]")
+        name ||= "char_class_parser(:#{char_class})"
+        Parser.new(name) do |input|
+          case input.content
+          in []
+            Result.nok(error: "unexpected end of input", input:, name:)
+          in [h, *]
+            if rgx.match?(h)
+              Result.ok(ast: h, input: input.advance)
+            else
+              Result.nok(input:, name:, error: "#{h} does not match the char class: :#{char_class}")
+            end
+          end
+        end
+      end
+
+      def _char_classes_parser(*char_classes, name:)
+        rgx = Regexp.compile("[#{_compile_char_classes(char_classes)}]")
+        name ||= "char_class_parser(#{char_classes.inspect})"
+        Parser.new(name) do |input|
+          case input.content
+          in []
+            Result.nok(error: "unexpected end of input", input:, name:)
+          in [h, *]
+            if rgx.match?(h)
+              Result.ok(ast: h, input: input.advance)
+            else
+              Result.nok(input:, name:, error: "#{h} does not match the char class: :#{char_classes}")
+            end
+          end
+        end
+      end
+
+      def _compile_char_class(char_class)
+        case char_class
+        when Symbol
+          "[:#{char_class}:]"
+        when String
+          "[#{char_class}]"
+        end
+      end
+
+      def _compile_char_classes(char_classes)
+        "[" +
+          char_classes
+          .map { _compile_char_class it }
+          .join + "]"
+      end
+
+      def mk_set(set)
+        if set
+          Set.new(set.grapheme_clusters)
+        else
+          TrueSet
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg.backup/parsers/common_parsers.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../combinators'
+module Peg
+  module Parsers
+    module CommonParsers
+      include Peg::Combinators
+
+      def id_parser(name: nil, lead_class: :alpha, inner_class: [:alnum, "_"] )
+        sequence(char_class_parser(*Array(lead_class)),
+                 many(char_class_parser(*Array(inner_class)), name:),
+                  name:
+                ).map { 
+                  it.flatten.join.to_sym 
+                }
+      end
+
+
+      # Just parses any string starting with either a `+` or `-` sign followed by at least one
+      # _decimal digit_.
+      #
+      # **N.B.** that leading zeroes are parsed (and therefore ignored) and will not parse
+      # it as a hexadecimal or octal number
+      def int_parser(name=nil)
+        parser = sequence(
+          maybe(char_parser("+-")),
+          many(char_class_parser(:digit), min: 1),
+          name: name || "int_parser")
+        map_result(parser) { _make_int(it) }
+      end
+
+      def literal_set(set, name: nil, lead_class: :alpha, inner_class: [:alnum, "_"])
+        id_parser(name:, lead_class:, inner_class:)
+        .satisfy { set.member? it }
+      end
+
+      def ws_parser(name=nil)
+        map(
+               many(
+                 char_class_parser(:space),
+                 min: 1,
+                 name: "ws_parser"
+               )
+        ) {|_| nil}
+      end
+
+      private
+
+      def _make_int(result)
+        case result
+        in {ok: true, ast:}
+          result.merge(ast: ast.join.to_i)
+        in {input:}
+          result.merge(error: "Not an integer at #{input.show(10).inspect} in int_parser")
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg.backup/parsers/true_set.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Peg
+  module Parsers
+    module TrueSet extend self
+      def member?(_) = true
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg.backup/parsers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "parsers/base_parsers"
+require_relative "parsers/common_parsers"
+module Peg
+  module Parsers
+    extend BaseParsers
+    include BaseParsers
+
+    extend CommonParsers
+    include CommonParsers
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg.backup/result.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Peg
+  class Result
+    class IllegalState < RuntimeError
+    end
+
+    attr_reader :ast, :error, :input, :ok 
+
+    def self.ok(ast:, input:) = new(ok: true, ast:, input:) 
+
+    def self.nok(input:, error:, name: nil) 
+      error = error + " in parser: #{name}" if name
+      new(ok: false, input:, error:)
+    end
+
+    def deconstruct_keys(*, **) = to_h
+
+    def map(&blk)
+      return self unless ok
+      self.class.ok(ast: blk.(ast), input:)
+    end
+
+    def merge(ast: nil, error: nil, input: nil)
+      @ast = ast if ast
+      @error = error if error
+      @input = input if input
+      self
+    end
+
+    def or(input:, error:, name: nil) = self.class.nok(input:, error:, name:)
+
+    def reduce(values, &blk)
+      result = self
+      values.each do |ele|
+        result = blk.(result, ele)
+        break result unless result.ok
+      end
+      result
+    end
+
+    def to_h =  {ast:, error:, input:, ok:}  
+
+    def to_s = inspect
+
+    def update(&updater)
+      raise IllegalState, "must not update an error result" unless ok
+      map(&updater)
+    end
+
+    def update_or(input:, error:, name: nil, &updater)
+      return map(&updater) if ok
+
+      self.class.nok(input:, error:, name:)
+    end
+
+    def while(input: nil, error: nil, name: nil, &blk)
+      result = self
+      count = 0
+      loop do
+        return input ? self.class.nok(input:, error:, name:) : result unless result.ok
+        result = blk.(self, count)
+        count += 1
+      end
+      result
+    end
+
+    private
+    def initialize(ok:, input:, ast: nil, error: nil)
+      @ast = ast
+      @error = error
+      @input = input
+      @ok = ok
+    end
+
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: l43_rmap
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Robert Dober
+bindir: bin
+cert_chain: []
+date: 2026-06-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+- !ruby/object:Gem::Dependency
+  name: l43_open_object
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: l43_simple_color
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+- !ruby/object:Gem::Dependency
+  name: l43_peg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+description: 'A hybrid between awk and grep
+
+  '
+email: robert.dober@gmail.com
+executables:
+- rmap
+extensions: []
+extra_rdoc_files: []
+files:
+- LiCenSE
+- README.md
+- bin/rmap
+- lib/enumerable.rb
+- lib/l43_rmap.rb
+- lib/l43_rmap/ast.rb
+- lib/l43_rmap/chunk.rb
+- lib/l43_rmap/cli.rb
+- lib/l43_rmap/cli/color.rb
+- lib/l43_rmap/cli/help.rb
+- lib/l43_rmap/compiler.rb
+- lib/l43_rmap/evaluator.rb
+- lib/l43_rmap/evaluator/evaluations.rb
+- lib/l43_rmap/function.rb
+- lib/l43_rmap/functions.rb
+- lib/l43_rmap/functions/predefined.rb
+- lib/l43_rmap/functions/predefined/shell.rb
+- lib/l43_rmap/parsing/chunk_parser.rb
+- lib/l43_rmap/parsing/input.rb
+- lib/l43_rmap/parsing/parse_state.rb
+- lib/l43_rmap/parsing/rgx_parser.rb
+- lib/l43_rmap/parsing/rgx_parsers.rb
+- lib/l43_rmap/predefined_patterns.rb
+- lib/l43_rmap/runtime.rb
+- lib/l43_rmap/runtime/line_time.rb
+- lib/l43_rmap/version.rb
+- lib/peg.backup/all.rb
+- lib/peg.backup/combinators.rb
+- lib/peg.backup/combinators/implementation.rb
+- lib/peg.backup/parser.rb
+- lib/peg.backup/parser/input.rb
+- lib/peg.backup/parsers.rb
+- lib/peg.backup/parsers/advanced_parsers.rb
+- lib/peg.backup/parsers/base_parsers.rb
+- lib/peg.backup/parsers/common_parsers.rb
+- lib/peg.backup/parsers/true_set.rb
+- lib/peg.backup/result.rb
+homepage: https://codeberg.org/lab419/rmap
+licenses:
+- AGPL-3.0-or-later
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: A hybrid between awk and grep
+test_files: []