l43_rmap 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8ba2487a434243ab2888e9b24af15fd55a85c63aa15d6d3d5bb67aa52c4bc59
-  data.tar.gz: 32ebaa0d8ceb99d9f07361269dd9665ad03afcb437dda0aaabf2bcd31e1b04ed
+  metadata.gz: b95afae624f3dd5ce13c2761678d547694c5a9e11a80ea7ca23fb8cf94604b53
+  data.tar.gz: d813c9e6dc4186232cdacf3412d14c869cc40ec055a9f240e9a0774bed781fd8
 SHA512:
-  metadata.gz: 5ff67dc0c2829b61ba98bd427308b7bd5b8de03adfb8c12729412a8d68fb49036f4a76410c6fcff487af07bd8e78d73cd9d7f06e8b670dfb1663503637968691
-  data.tar.gz: 2d62c95dedcd2a9e7cb09feb8b7a654a9ce005cc0641bb90b188216410f34c9c55671c0cf3765340aa3f750db2c8aebf60e86256e38fec1f9fe7d6c3dcacaad6
+  metadata.gz: a7d2d9ac1512236a1a3d8f393284392e43bebaf58423842d61cff0f9ccc5b32b59457531d4791c6af26f0868abf02669e590812300f632c99be028852eb8cb73
+  data.tar.gz: 03d07b9bf563eb0ddb6a4cf2545cc66aba27a0d478745761756190d15f338275f62ac3b1533429092e2b8461855b6627a107525dcd89077857d727d5889d2627

data/lib/l43_rmap/cli/color.rb

@@ -4,10 +4,12 @@ module L43Rmap
   class Cli
     module Color
       def arg(name) = [:bold, :blue, "<#{name}>", :reset]
+      def arg1(name) = [:bold, :blue, name, :reset]
 
       def kwd(name) = [" kwd ", :bold, :cyan, name, ":", :reset]
 
       def named(field) = [2, :bold, :blue, "%", field, :reset]
+
       def puterr(*chunks)
         putcol(:red, :bold, "ERROR: ", :white, *chunks)
         false

data/lib/l43_rmap/cli/help.rb

@@ -65,6 +65,7 @@ module L43Rmap
         putcol
         putcol(:bold, :blue, "predefined patterns", :white, " are the following:")
         putcol
+        putcol(4, :bold, :magenta, "ignore_ws", :white, " same as ", arg1("(unless (m '\\A\\s*\\z') %)"))
         putcol(4, :bold, :magenta, "mv_to_ms", :white, " same as ", :bold, :blue, "mv %  %m-(lpad %n 0 4).(ext)")
         putcol(4, :bold, :magenta, "mv_to_mse", :white, " same as ", :bold, :blue, "mv (se) %m-(lpad %n 0 4).(ext)")
         :helped

data/lib/l43_rmap/cli.rb

@@ -50,6 +50,7 @@ module L43Rmap
         .flag(:help_pattern, desc: ["Describe ", :bold, :blue, "pattern"], stop: true)
         .flag(:help_predefined, desc: ["Describe ", :bold, :blue, "predefined patterns"], stop: true)
         .flag(:help_sexp, desc: ["Describe ", :bold, :blue, "s-expressions"], stop: true)
+        .flag(:randomize, :r, desc: ["Does not write to the ", arg1("output stream"), " immideately but into a buffer, the buffer is then randomized before being printed to ", arg1("output stream")])
         .section("Options")
         .keyword(:input, :i, desc: ["file to read from, defaults to ", :bold, :cyan, '$stdin'], default: $stdin)
         .keyword(:output, :o, desc: ["file to write to, defaults to ", :bold, :cyan, '$stdout'], default: $stdout)
@@ -62,7 +63,7 @@ module L43Rmap
     end
 
     def _run 
-      runtime.run(kwds.input, kwds.output)
+      runtime.run(kwds.input, kwds.output, randomize: kwds.randomize)
       :ok
     end
 

data/lib/l43_rmap/functions/predefined/str.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module L43Rmap
+  module Functions
+    module Predefined
+      module Str extend self
+
+        def gsub(rt, subject, pattern, replacement=nil)
+          return _gsub(subject, pattern, replacement) if replacement
+
+          _gsub(rt.line, subject, pattern)
+        end
+
+        def lpad(_rt, subject, filler, length)
+          subject.to_s.rjust(length.to_i, filler.to_s)
+        end
+
+        def match(rt, rgx, subject=nil)
+          subject ||= rt.line
+          r = Regexp.compile(rgx)
+          r.match(subject)
+        end
+
+        def sub(rt, subject, pattern, replacement=nil)
+          return _sub(subject, pattern, replacement) if replacement
+
+          _sub(rt.line, subject, pattern)
+        end
+
+        private
+
+        def _gsub(subject, pattern, replacement)
+          rgx = _mk_rgx(pattern)
+          subject&.gsub(rgx, replacement)
+        end
+
+        def _mk_posix(pattern)
+          case pattern
+          in *klass, "*"
+            Regexp.compile("[[:#{klass.join}:]]*")
+          in *klass, "+"
+            Regexp.compile("[[:#{klass.join}:]]+")
+          in *klass, "?"
+            Regexp.compile("[[:#{klass.join}:]]?")
+          else 
+            Regexp.compile("[[:#{pattern.join}:]]")
+          end
+        end
+
+        def _mk_rgx(pattern)
+          case pattern
+          when Symbol
+            _mk_posix(pattern.to_s.grapheme_clusters)
+          when String
+            Regexp.compile(pattern)
+          else
+            raise ArgumentError, "pattern must be a String or Symbol, but was #{pattern.inspect}"
+          end
+        end
+
+        def _sub(subject, pattern, replacement)
+          rgx = _mk_rgx(pattern)
+          subject&.sub(rgx, replacement)
+        end
+
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/functions/predefined.rb

@@ -2,6 +2,7 @@
 
 require_relative '../evaluator/evaluations'
 require_relative 'predefined/shell'
+require_relative 'predefined/str'
 
 module L43Rmap
   module Functions
@@ -38,14 +39,12 @@ module L43Rmap
           end
         end
 
-        def lpad(_rt, subject, filler, length)
-          subject.to_s.rjust(length.to_i, filler.to_s)
-        end
-
-        def match(rt, rgx, subject=nil)
-          subject ||= rt.line
-          r = Regexp.compile(rgx)
-          r.match(subject)
+        def unless_fn(_rt, cond, false_branch, true_branch=nil)
+          if cond
+            true_branch
+          else
+            false_branch
+          end
         end
       end
 

data/lib/l43_rmap/functions.rb

@@ -35,11 +35,23 @@ module L43Rmap
 
     # Names only available inside of S-Expressions
     DefinedFunctions = {
+      # Logic
+      "if" => Function.new("if") { |*args| Predefined.if_fn(*args) },
+      "unless" => Function.new("unless") { |*args| Predefined.unless_fn(*args) },
+
+      # File
       "ext" => Function.new("ext") { |*args| Predefined.file_extension(*args) },
+
+      # Int
       "inc" => Function.new("inc") { |*args| Predefined.inc(*args) },
-      "if" => Function.new("if") { |*args| Predefined.if_fn(*args) },
-      "lpad" => Function.new("lpad")  { |*args| Predefined.lpad(*args) },
-      "m" => Function.new("match") { |*args| Predefined.match(*args) },
+
+      # Str
+      "lpad" => Function.new("lpad")  { |*args| Predefined::Str.lpad(*args) },
+      "gsub" => Function.new("gsub")  { |*args| Predefined::Str.gsub(*args) },
+      "m" => Function.new("match") { |*args| Predefined::Str.match(*args) },
+      "sub" => Function.new("sub")  { |*args| Predefined::Str.sub(*args) },
+
+      # Shell
       "se" => Function.new("se") { |*args| Predefined::Shell.se(*args) },
     }
 
@@ -57,10 +69,16 @@ module L43Rmap
           Function.new("fallback to #{name}") do |rt, rcv, *args|
             rcv.send(name, *args)
           rescue NoMethodError
-            rcv.to_i.send(name, *args)
+            try_sending(name, rcv, *args)
           end
         end
       end
+
+      def try_sending(name, rcv, *args)
+        rcv.to_i.send(name, *args)
+      rescue NoMethodError
+        rcv.to_s.send(name, *args)
+      end
     end
   end
 end

data/lib/l43_rmap/parsing/rgx_parsers.rb

@@ -54,7 +54,7 @@ module L43Rmap
       SQUOTE     = /\A'/
       SquoteParser = RgxParser.new(SQUOTE)
 
-      SYMBOL     = /\A:([[:alpha:]][_[:alnum:]]*[\!\?]?)/
+      SYMBOL     = /\A:([^\s\)]+)/
       SymbolParser = RgxParser.new(SYMBOL) { Sym.new(it) }
 
       WS         = /\A\s+/

data/lib/l43_rmap/predefined_patterns.rb

@@ -4,6 +4,7 @@ module L43Rmap
   module PredefinedPatterns extend self
     
     Patterns = {
+      ignore_ws: "(unless (m '\A\s*\z') %)",
       mv_to_ms: 'mv %  (lpad %n 0 4).(ext)',
       mv_to_mse: 'mv (se) (lpad %n 0 4).(ext)',
     }

data/lib/l43_rmap/runtime.rb

@@ -5,19 +5,20 @@ require_relative 'runtime/line_time'
 
 module L43Rmap
   class Runtime
-    attr_reader :chunks, :current, :input_stream, :output_stream, :rand, :terminated, :time
+    # attr_reader :chunks, :current, :input_stream, :output_stream, :rand, :randomize, :terminated, :time
+    attr_reader :chunks, :current, :input_stream, :output_stream, :randomize, :terminated, :time
 
     DefaultDecRandomMax = 10_000
 
-    def run(input, output)
+    def run(input, output, randomize: false)
       @output_stream = make_output_stream(output)
       @input_stream = make_input_stream(input)
-      # @rand = SecureRandom.random_number
       @time = Time.now
-      # p(time1: time.to_f)
+      @randomize = randomize
 
       execute!
     rescue EOFError 
+      maybe_output_buffer
     end
 
     def random_hex =  @__randomhex__ ||= SecureRandom.hex
@@ -52,8 +53,7 @@ module L43Rmap
         in :terminate | :term
           break
         in Array
-          output_stream << result.join
-          output_stream << "\n" 
+          push_line(result.join)
         else
           raise "BAD RETURN FROM LineTime: #{result.inspect}"
         end
@@ -73,6 +73,28 @@ module L43Rmap
       return stream unless String === stream
       File.open(stream, 'w')
     end
+
+    def maybe_output_buffer
+      return unless randomize
+
+      output_buffer
+        .sort_by { rand }
+        .each do
+          output_stream << it
+          output_stream << "\n"
+        end
+    end
+
+    def output_buffer =  @__output_buffer__ ||= []
+
+    def push_line(line)
+      if randomize
+        output_buffer << line
+      else
+        output_stream << line
+        output_stream << "\n" 
+      end
+    end
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module L43Rmap
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: l43_rmap
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Robert Dober
 bindir: bin
 cert_chain: []
-date: 2026-06-03 00:00:00.000000000 Z
+date: 2026-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ostruct
@@ -91,6 +91,7 @@ files:
 - lib/l43_rmap/functions.rb
 - lib/l43_rmap/functions/predefined.rb
 - lib/l43_rmap/functions/predefined/shell.rb
+- lib/l43_rmap/functions/predefined/str.rb
 - lib/l43_rmap/parsing/chunk_parser.rb
 - lib/l43_rmap/parsing/input.rb
 - lib/l43_rmap/parsing/parse_state.rb
@@ -100,17 +101,6 @@ files:
 - 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

data/lib/peg.backup/all.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'combinators'
-require_relative 'parsers'
-require_relative 'parsers'
-module Peg
-  module All
-    include Combinators
-    include Parsers
-  end
-end
-# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg.backup/combinators/implementation.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../enumerable'
-module Peg
-  class InfiniteLoop < Exception; end
-
-  module Combinators
-    module Implementation
-
-      def _debug(parser, name: nil)
-        Parser.new(parser.name) do |input, _name|
-          puts "debugging #{name || parser.name}: #{input.inspect}"
-          result = Parser.parse(parser, input)
-          puts "debugging #{name || parser.name}: #{result}"
-          result
-        end
-      end
-
-      def _lookahead(parsers, name:)
-        parser = _select(parsers)
-        Parser.new(name || "lookahead(#{parser.name})") do |input, name|
-          case Parser.parse(parser, input)
-          in {ok: true}
-            {ok: true, ast: nil, input:}
-          in error
-            error
-          end
-        end
-      end
-
-      # def _map(parser, name, mapper)
-      #   name ||= "map(#{parser.name})"
-      #   Parser.new(name) do |input, _name|
-      #     case Parser.parse(parser, input)
-      #     in {ok: true, ast: ast, input: new_input}
-      #       {ok: true, ast: mapper.(ast), input: new_input}
-      #     in error
-      #       error
-      #     end
-      #   end
-      # end
-
-      def _map_result(parser, name, mapper)
-        Parser.new(name) do |input, name|
-          result = Parser.parse(parser, input)
-          # require "debug"; binding.break
-          mapper.(result)
-        end
-      end
-
-      def _many(parser, max:, min:, name:)
-        Parser.new(name) do |input, _name|
-          total_ast = []
-          original_input = input
-          current_input = input
-          match_count = 0
-          loop do
-            if current_input.empty?
-              break Result.ok(ast: total_ast, input:) if match_count >= min
-              break Result.nok(error: "many #{name} did not succeed the required #{min} times, but only #{match_count}", input: original_input, name:)
-            end
-
-            case Parser.parse(parser, current_input)
-            in {ok: true, ast:, input:}
-              raise InfiniteLoop, "must not parse zero width inside many in parser: #{parser.name}" if input.pos == current_input.pos
-              current_input = input
-              total_ast = [*total_ast, ast]
-              match_count += 1
-              break Result.ok(ast: total_ast, input:) if max && match_count >= max
-            else
-              break Result.ok(ast: total_ast, input:) if match_count >= min
-              break Result.nok(error: "many #{name} did not succeed the required #{min} times, but only #{match_count}", input: original_input, name:)
-            end
-          end
-        end
-      end
-
-      def _satisfy(parser, name:, &satisfier)
-        Parser.new(name || "satisfy(#{parser.name})") do |input, name|
-          original_input = input
-          case Parser.parse(parser, input)
-          in {ok: false} => error
-            error
-          in {ok: true, ast:, input:} => result
-            ok = satisfier.(ast)
-            if ok == true
-              result
-            elsif ok
-              {ok: true, ast: ok, input:}
-            else
-              {ok: false, input: original_input, error: "satisfier #{name} failed", name: name}
-            end
-          end
-        end
-      end
-
-      def _select(*parsers, name: nil)
-        parsers = parsers.flatten
-        raise ArgumentError, "all parsers must be instances of Parser" unless parsers.all? { Parser === it }
-        Parser.new(name || "select #{parsers.map(&:name).join(", ")}") do |input, name|
-          result = {ok: false, error: "No parser matched in select named #{name}", input:}
-          parsers.each do |parser|
-            # case p(Parser.parse(parser, input))
-            this_result = Parser.parse(parser, input)
-            # require "debug"; binding.break
-            case this_result
-            in {ok: true} => result
-              break result
-            in _
-              nil
-            end
-          end
-          result
-        end
-      end
-
-      def _sequence(parsers, name)
-        name ||= "seq(#{parsers.map(&:name).join(", ")})"
-        Parser.new(name) do |input, _name|
-          original_input = input
-          result = parsers.reduce_while [input, []] do |(input, ast), parser|
-            # require "debug"; binding.break
-            parsed = Parser.parse(parser, input)
-            # p parsed
-            case parsed
-            in {ok: true, ast: ast_node, input:}
-              cont_reduce([input, [*ast, ast_node]])
-            in {ok: false, error:}
-              halt_reduce(Result.nok(input: original_input, error:, name: name))
-            end
-          end
-
-          case result
-          in {ok: false} => error
-            error
-          in [input, ast]
-            Result.ok(ast:, input:)
-          end
-        end
-      end
-    end
-  end
-end
-# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg.backup/combinators.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'parser'
-require_relative 'combinators/implementation'
-module Peg
-  module Combinators extend self
-    include Implementation
-
-    def lookahead(*parsers, name: nil)
-      parsers = make_parsers(*parsers)
-      _lookahead(parsers, name:)
-    end
-
-    def many(*parsers, max: nil, min: 0, name: nil)
-      name ||= "many(#{parsers.map(&:name).join(", ")})"
-      case parsers
-      in []
-        raise ArgumentError, "missing parser"
-      in [parser]
-        _many(parser, max:, min:, name:)
-      in _
-        many(select(*parsers), max:, min:, name:)
-      end
-    end
-
-    def map(parser, name: nil, &mapper)
-      raise ArgumentError, "missing mapper function" unless mapper
-      raise ArgumentError, "mapper function must have arity 1" unless mapper.arity == 1
-      name ||= "map(#{parser.name})"
-      Parser.new(name) do |input|
-        Parser.parse(parser, input).map(&mapper)
-      end
-    end
-    alias_method :_map, :map
-
-    def map_result(parser, name: nil, &mapper)
-      raise ArgumentError, "missing mapper function" unless mapper
-      raise ArgumentError, "mapper function must have arity 1" unless mapper.arity == 1
-      _map_result(parser, name || "map_result(#{parser.name})", mapper)
-    end
-
-    def maybe(parser, name: nil)
-      Parser.new(name || "maybe(#{parser.name})") do |input, name|
-        case Parser.parse(parser, input)
-        in {ok: false}
-          {ok: true, ast: nil, input:}
-        in success
-          success
-        end
-      end
-    end
-
-    def satisfy(parser, name: nil, &satisfier)
-      raise ArgumentError, "missing satisfier block" unless satisfier
-      parser = make_parser(parser)
-      _satisfy(parser, name, satisfier)
-    end
-
-    def select(*parsers, name: nil)
-      case parsers
-      in []
-        raise ArgumentError, "missing parser in select"
-      in [parser]
-        raise ArgumentError, "one parser in a selection is a NOP, remove the select call"
-      in _
-        _select(*make_parsers(parsers), name)
-      end
-    end
-
-    def sequence(*parsers, name: nil)
-      case parsers
-      in []
-        raise ArgumentError, "missing parser"
-      in [parser]
-        raise ArgumentError, "one parser in a sequence is a NOP, remove the sequence call"
-      in _
-        _sequence(make_parsers(parsers), name)
-      end
-    end
-  end
-end
-# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg.backup/parser/input.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Peg
-  class Parser
-    class Input
-      attr_reader :content, :pos
-
-      def advance(by=1)
-        self.class.new(content.drop(by), pos+by)
-      end
-
-      def empty? = content.empty?
-
-      def show(count)
-        raise ArgumentError, "count must be an integer > 5" unless Integer === count && count > 5
-        return content.join("") if content.length < count
-
-        "#{content.take(count-3).join}..."
-      end
-
-      def ==(other)
-        self.class === other &&
-          other.content == content &&
-          other.pos == pos
-      end
-
-      private
-      def initialize(content, pos=1)
-        @content = content
-        @pos = pos
-      end
-      
-    end
-  end
-end
-# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg.backup/parser.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'combinators/implementation'
-require_relative 'parser/input'
-require_relative 'parsers'
-require_relative 'result'
-
-module Peg
-  class Parser
-    include Peg::Combinators::Implementation
-
-    attr_reader :parse_fn, :name
-
-    def self.parse(parser, input)
-      raise ArgumentError, "parser must be an instance of #{self}" unless self === parser
-      case input
-      when String
-        parser.parse_fn.(Peg::Parser::Input.new(input.grapheme_clusters))
-      when Peg::Parser::Input
-        parser.parse_fn.(input)
-      else
-        raise ArgumentError, "input must be a string or instance of Input" unless self.class === parser
-      end
-    end
-
-    def and(*parsers, name:  nil) = _sequence([self, *parsers], name)
-
-    def debug(name: nil) = _debug(self, name:)
-
-    def many(name: nil, max: nil, min: 0) = _many(self, name:, max:, min:)
-    def map(name: nil, &blk) = Peg::Combinators.map(self, name:, &blk)
-
-    def or(*parsers, name: nil) = _select(self, *parsers, name:)
-
-    def satisfy(name: nil, &satisfier) = _satisfy(self, name:, &satisfier)
-
-    private
-    def initialize(name, &blk)
-      raise ArgumentError, "blk must be provided as a parse function" unless blk
-      @name = name
-      @parse_fn = blk
-    end
-    
-  end
-end
-# SPDX-License-Identifier: AGPL-3.0-or-later

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../combinators'
-require_relative '../parsers'
-module Peg
-  module Parsers
-    module AdvancedParsers
-      include Peg::Combinators
-      include Peg::Parsers
-
-      def list_parser(element_parser:, seperator_parser:, name: "list parser")
-        sequence(
-          element_parser,
-          many(
-            sequence(
-              seperator_parser, element_parser
-            )
-              .map { it[1] }
-          )
-        )
-          .map { it.flatten.compact }
-      end
-    end
-  end
-end
-# SPDX-License-Identifier: AGPL-3.0-or-later

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

@@ -1,124 +0,0 @@
-# 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

@@ -1,60 +0,0 @@
-# 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

@@ -1,10 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-# 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

@@ -1,78 +0,0 @@
-# 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