l43_peg 0.1.9 → 0.3.0

data/lib/l43_peg/combinators/sequence.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Combinators
+        
+      module Sequence extend self
+
+        def sequence(*parsers, name: nil, flatten: false, join: false, box: nil, &mapper)
+          name ||= "sequence(#{parsers.flatten.map(&:name).join(", ")})"
+          parser = Parser.new(name) {|input, _name=nil| _seq(input:, name:, parsers: parsers.flatten, flatten:, join:)}
+          if mapper
+            parser.map(name:, box:, &mapper)
+          elsif box
+            parser.map(name) { Box.make(box).new(it) } 
+          else
+            parser
+          end
+        end
+
+        private
+        def _seq(input:, name:, parsers:, flatten: false, join: false)
+          curr_input = input
+          ast = []
+          parsed = String.new
+          parsers.each do |parser|
+            result = parser.(curr_input)
+            # p result
+            case result
+            in L43Peg::Failure => failure
+              return failure.update(name:) 
+            in {ast: new_ast, rest: curr_input, parsed: new_parsed}
+              ast.push(new_ast) unless new_ast == nil
+              parsed << new_parsed
+            end
+          end
+          L43Peg::Success.new(ast:, rest: curr_input, parsed:) 
+        end
+      end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/combinators.rb

@@ -1,82 +1,71 @@
 # frozen_string_literal: true
 
-require_relative 'helper'
-require_relative 'mappers'
+require "l43_peg/combinators/boxed"
+require "l43_peg/combinators/choice"
+require "l43_peg/combinators/debug_parser"
+require "l43_peg/combinators/ignore"
+require "l43_peg/combinators/lazy"
+require "l43_peg/combinators/many"
+require "l43_peg/combinators/map"
+require "l43_peg/combinators/map_error"
+require "l43_peg/combinators/satisfy"
+require "l43_peg/combinators/sequence"
 
 module L43Peg
   module Combinators extend self
+    def boxed(parser, box, name: nil, &mapper) =
+      Boxed.boxed(parser, box, name:, &mapper)
 
-    require 'l43_peg/combinators/debug_parser'
-    require 'l43_peg/combinators/many'
-    require 'l43_peg/combinators/sel'
-    require 'l43_peg/combinators/seq'
-
-    include L43Peg::Helper
-    include L43Peg::Mappers
-    include L43Peg::Parsers
-
-    def args_parser(definitions, name: nil, stop: nil, &block)
-      parser = tokens_parser(definitions, stop:, &block)
-      name   = name || "args_parser(#{definitions.inspect})"
-      inner  = many(parser)
-      map(inner, name:, fn: join_maps)
-    end
-
-    def debug_parser(parser, name: nil, level: :default)
-      name ||= "debug_parser(#{parser.name})"
-      Parser.new(name, &DebugParser.parse_with_debug(parser:, level:, name:))
-    end
-
-    def many(parser, name: nil, min: 0, max: nil)
-      Parser.new(name || "many(#{parser.name})") {|input, cache, name1=nil| Many.many(input:, cache:, name: name1 || name, parser:, min:, max:)}
-    end
-
-    def map(parser, name: nil, fn: nil, &mapper)
-      raise ArgumentError, "must not provide keyword parameyer fn and a block" if fn && mapper
-      mapper = fn || mapper
-      raise ArgumentError, "must provide keyword parameyer fn or a block" unless mapper
-      Parser.new(name || "map(#{parser.name})") {|input, cache, name=nil| _map(input:, cache:, name:, parser:, mapper:)}
-    end
-
-    def rgx_tokenize(rgx_specs, name: nil)
-      name = name || "rgx_tokenize(#{rgx_specs.inspect})"
-      many(sel_rgx_parser(rgx_specs, name:))
-    end
-
-    def sel(parsers, name: nil)
-      name ||= "sel(#{parsers.map(&:name).join(", ")})"
-      Parser.new(name) { |input, cache, name1=nil| Sel.sel(input:, cache:, name: name1 || name, parsers:) }
-    end
-
-    def sel_rgx_parser(rgx_specs, name: nil)
-      name = name || "sel_rgx_parser(#{rgx_specs.inspect})"
-      parsers = rgx_specs.map(&_mk_rgx_parser)
-      sel(parsers, name:)
-    end
-
-    def seq(*parsers, name: nil)
-      name ||= "seq(#{parsers.map(&:name).join(", ")})"
-      Parser.new(name) {|input, cache, _name=nil| Seq.seq(input:, cache:, name:, parsers:)}
-    end
-
-    private
-
-    def _map(input:, cache:, name:, parser:, mapper:)
-      case parser.(input, cache:)
-      in L43Peg::Failure => failure
-        failure
-      in L43Peg::Success => success
-        success.map(&mapper)
-      end
-    end
-
-    def _mk_rgx_parser
-      -> rgxspec do
-        name, rgx, capture, fn = rgxspec
-        fn ||= -> (captures) { [name, captures] }
-        map(Parsers.rgx_parser(rgx, capture:), &fn)
-      end
-    end
+    def choice(*parsers, name: nil) =
+      Choice.choice(*parsers, name:)
+
+    def debug_parser(parser:, name:, level:) =
+      DebugParser.debug_parser(parser:, name:, level:)
+
+    def ignore(parser, name: nil) = 
+       Ignore.ignore(parser, name:)
+
+    def lazy(name: nil, &parser) = Lazy.lazy(name:, &parser)
+
+    def many(parser, name: nil, min: 0, max: nil) =
+      Many.many(parser, name:, min:, max:)
+
+    def map(parser, name: nil, fn: nil, box: nil, &mapper) =
+      Map.map(parser, name:, fn:, box:, &mapper)
+
+    def map_error(parser, name: nil, reason: nil) =
+      MapError.map_error(parser, name:, reason:)
+
+    def satisfy(parser, name: nil, fn: nil, &satisfier) =
+      Satisfy.satisfy(parser, name:, fn:, &satisfier)
+
+    def sequence(*parsers, name: nil, flatten: false, join: false, box: nil, &mapper) =
+      Sequence.sequence(*parsers, name:, flatten:, join:, box:, &mapper)
+  end
+
+  class Parser
+    def boxed(box, name: nil, &mapper) =
+      Combinators::Boxed.boxed(self, box, name:, &mapper)
+
+    def debug(name: nil,  level: 10) =
+      Combinators::DebugParser.debug_parser(parser: self, name:,  level:)
+
+    def ignore(name: nil) = 
+       Combinators::Ignore.ignore(self, name:)
+
+    def lazy(name: nil) = Lazy.lazy(self, name:)
+
+    def many(name: nil, min: 0, max: nil) =
+      Combinators::Many.many(self, name:, min:, max:)
+
+    def map(name: nil, fn: nil, box: nil, &mapper) =
+      Combinators::Map.map(self, name:, fn:, box:, &mapper)
+
+    def map_error(name: nil, reason: nil) =
+      Combinators::MapError.map_error(self, name:, reason:)
+
+    def satisfy(name: nil, fn: nil, &satisfier) =
+      Combinators::Satisfy.satisfy(self, name:, fn:, &satisfier)
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module L43Peg
+  BadParserResult = Class.new(RuntimeError)
+  NotABox = Class.new(RuntimeError)
+
+  module Errors extend self
+    def bad_parser_result(msg) = raise BadParserResult, msg
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/failure.rb

@@ -3,9 +3,25 @@
 module L43Peg
   class Failure
     extend L43::OpenObject
-    attributes cache: nil, input: nil, parsed_by: nil, position: [1, 1], reason: ""
+    attributes name:, parsed_by: nil, position: [1, 1], reason: ""
+
+    def deconstruct(*) = [:error, named_reason]
+
+    def map(name:, reason:)
+      update_attribute(:reason, reason)
+        .update_attribute_if(:name, name)
+    end
+
+    def named_reason
+      if name
+        "#{reason} (in #{name})"
+      else
+        reason
+      end
+    end
 
     def position_hr = "@#{position}"
+
   end
 end
 # SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg/input.rb

@@ -4,11 +4,11 @@ module L43Peg
   class Input
     extend L43::OpenObject
 
-    attributes col: 1, input: "", lnb: 1, context: {}
+    attributes col: 1, src: "", lnb: 1
     
     def debug
       "Input<" +
-      ["col:#{col}", "input:#{input.inspect}", "lnb:#{lnb}", "context:#{context.inspect}"].join(" ") +
+      ["col:#{col}", "src:#{src.inspect}", "lnb:#{lnb}"].join(" ") +
       ">"
     end
 
@@ -23,13 +23,15 @@ module L43Peg
       end
     end
 
-    def empty? = input.empty?
+    def empty? = src.empty?
+
+    def first(n=1) = src[0...n]
 
     def head_hr(n, position: false)
       if position
-        "Input<#{input[0...n].inspect}@#{position_hr}>"
+        "Input<#{src[0...n].inspect}@#{position_hr}>"
       else
-        "Input<#{input[0...n].inspect}>"
+        "Input<#{src[0...n].inspect}>"
       end
     end
 
@@ -40,17 +42,17 @@ module L43Peg
     private
 
     def _drop_by_n(n)
-      return self if input.empty?
-      _split(n) => col, lnb, head, tail
-      self.class.new(input: tail, context:, col:, lnb:)
+      return self if src.empty?
+      _split(n) => col, lnb, _head, tail
+      self.class.new(src: tail, col:, lnb:)
     end
 
     # Very inefficent but sufficent for my use cases so far
     # and convenient for regex parsers
     def _split(n)
-      head = input.slice(0...n)
+      head = src.slice(0...n)
       lines = head.count("\n")
-      tail = input.slice(n..-1) || ''
+      tail = src.slice(n..-1) || ''
       new_col = 
         if lines.zero?
           col + n

data/lib/l43_peg/mappers.rb

@@ -1,14 +1,32 @@
 # frozen_string_literal: true
+# :markup: markdown
 
+require_relative 'box'
 module L43Peg
-  module Mappers
+  module Mappers extend self
+    ##
+    #  coming soon
+    #  @return instance of a class names `class_name`
+    def box(class_name, value)
+      # klass = BoxFactory.make_a_box_class(class_name)
+      klass = Box.make(class_name)
+      klass.new(value)
+    end
+
+    def boxed(class_name, &blk) # :nodoc:
+      # klass = BoxFactory.make_a_box_class(class_name)
+      klass = Box.make(class_name)
+      -> (ast) { klass.new(ast, &blk) }
+    end
 
-    def join_and_to_i
+    def join_and_to_i # :nodoc:
       -> list do
         list.join.to_i
       end
     end
-    
+
+    ##
+    # Returns a mapper that maps the ast on a list of maps
     def join_maps
       -> maps do
         maps.reduce Hash.new do |map, entry|

data/lib/l43_peg/parser.rb

@@ -1,16 +1,12 @@
 # frozen_string_literal: true
 
 module L43Peg
-  # A wrapper
   class Parser
 
     attr_reader :fn, :name
 
-    # Calls the parse function of this parser instance.
-    #
-    # @param input [L43Peg::Input] to be parsed
-    def call(input, cache: L43Peg::Cache.new) 
-      fn.(input, cache, name)
+    def call(input) 
+      fn.(input)
     end
 
     private
@@ -19,7 +15,7 @@ module L43Peg
       @name = name
       @fn = fn
     end
-    
+
   end
 end
-# SPDX-License-Identifier: Apache-2.0
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers/char_parser.rb

@@ -1,27 +1,67 @@
 # frozen_string_literal: true
 
+require 'l43_peg/parser'
 module L43Peg
   module Parsers
     class CharParser < L43Peg::Parser
 
       private
 
-      def initialize(charset=nil)
+      def initialize(charset=nil, name: nil, allow_eol: false)
+        raise ArgumentError, "must not provide a set of characters and allow_eol: true" if charset && allow_eol
+
         charset = _mk_set(charset)
-        super("char_parser(#{charset})") do |input, cache, name|
-          if input.input.empty?
-            L43Peg::Failure.new(cache:, input:, parsed_by: self, reason: "cannot parse at end of input #{name}")
-          elsif charset.nil? || charset.member?(input.input[0])
-            L43Peg::Success.new(ast: input.input[0], cache:, rest: input.drop, position: input.position)
+        name ||= _mk_name(charset:, allow_eol:)
+
+          if charset
+            super(name) { parse_in_set(it, charset:, name:) }
           else
-            L43Peg::Failure.new(cache:, input:, parsed_by: self, reason: "char #{input.input[0].inspect}")
+            super(name) { parse_any_char(it, name:, allow_eol:) }
           end
+
+      end
+
+      def parse_in_set(input, name:, charset:)
+        if input.empty?
+          return L43Peg::Failure.new(parsed_by: self, reason: 'cannot parse at end of input', name:)
+        end
+        ast = input.first
+        if charset.member?(ast)
+          L43Peg::Success.new(ast:, rest: input.drop, parsed: ast, position: input.position)
+        else
+          L43Peg::Failure.new(
+            parsed_by: self, 
+            reason: "char #{ast.inspect} is not in required set",
+            name:)
+        end
+      end
+
+      def parse_any_char(input, name:, allow_eol:)
+        if input.empty?
+          return L43Peg::Failure.new(parsed_by: self, reason: 'cannot parse at end of input', name:)
+        end
+        ast = input.first
+        if ast == "\n" && !allow_eol
+          reason = "cannot parse at end of line, this can be allowed by providing 'allow_eol: true'"
+          L43Peg::Failure.new(parsed_by: self, reason:, name:)
+        else
+          L43Peg::Success.new(ast:, rest: input.drop, parsed: ast, position: input.position)
+        end
+      end
+
+      def _mk_name(charset:, allow_eol:)
+        if charset
+          "char_parser(#{charset&.join&.inspect})"
+        else
+          "char_parser(allow_eol: #{allow_eol})"
         end
       end
 
       def _mk_set(charset)
         return unless charset
         case charset
+        when Integer
+          Set.new([charset.chr])
         when String
           Set.new(charset.split(""))
         when Set
@@ -33,4 +73,4 @@ module L43Peg
     end
   end
 end
-# SPDX-License-Identifier: AGPL-3.0-or-later
+  # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers/end_parser.rb

@@ -1,25 +1,26 @@
 # frozen_string_literal: true
 
-require_relative '../parsers'
 
 module L43Peg
   module Parsers
     class EndParser < L43Peg::Parser
+      class << self
+        def instance
+          @__instance__ ||= _mk_end_parser
+        end
 
-      def self.instance
-        @__instance__ ||= new
-      end
-
-      private
+        private
 
-      def initialize
-        super('end_parser') do |input, cache, _name=nil|
-          if input.input.empty?
-            L43Peg::Success.new(cache:, rest: input, position: input.position)
-          else
-            L43Peg::Failure.new(cache:, input:, parsed_by: self, reason: "not at end of input")
+        def _mk_end_parser
+          Parser.new('end_parser') do |input|
+            if input.empty?
+              L43Peg::Success.new(ast: nil, rest: input, parsed: "")
+            else
+              L43Peg::Failure.new(name: 'end_parser', parsed_by: self, reason: 'not at end of input', position: input.position) 
+            end
           end
         end
+
       end
     end
   end

data/lib/l43_peg/parsers/eol_parser.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Parsers
+    class EolParser < L43Peg::Parser
+
+      class << self
+        def eol_parser(succeed_at_end: false)
+          if succeed_at_end
+            @__eol_at_end_parser__ ||= eol_at_end_parser
+          else
+            @__eol_parser__ ||= eol_not_end_parser
+          end
+        end
+
+        private
+        def eol_at_end_parser
+          Parser.new('eol_parser(succeed_at_end: true)', &parse_eol_at_end)
+        end
+
+        def eol_not_end_parser
+          Parser.new('eol_parser(succeed_at_end: false)', &parse_eol)
+        end
+
+        def parse_eol_at_end
+          -> input do
+            if input.first == "\n"
+              L43Peg::Success.new(ast: "\n", parsed: "\n", rest: input.drop)
+            elsif input.empty?
+              L43Peg::Success.new(ast: nil, parsed: "", rest: input)
+            else
+              L43Peg::Failure.new(name: 'eol_parser(succeed_at_end: true)', reason: 'not at end of line')
+            end
+          end
+        end
+
+        def parse_eol
+          -> input do
+            if input.first == "\n"
+              L43Peg::Success.new(ast: "\n", parsed: "\n", rest: input.drop)
+            elsif input.empty?
+              reason = "end of input not considered end of line unless activated with succeed_at_end: true"
+              L43Peg::Failure.new(name: 'eol_parser(succeed_at_end: false)', reason:)
+            else
+              L43Peg::Failure.new(
+                name: 'eol_parser(succeed_at_end: false)',
+                reason: 'not at end of line')
+            end
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers/escape_parser.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Parsers
+    module EscapeParser extend self
+      def escape_parser(escape_char_set, escapees=nil, name: nil, with_box: nil)
+        name = name || "escape_parser(#{escape_char_set.inspect}, #{escapees.inspect})"
+          s = Combinators.sequence(
+            Parsers.char_parser(escape_char_set),
+            Parsers.char_parser(escapees)
+          )
+        if with_box
+          s.map(name:) { |_, escaped| escaped }.boxed(with_box)
+        else
+          s.map(name:) { |_, escaped| escaped }
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers/failure_parser.rb

@@ -11,8 +11,8 @@ module L43Peg
       private
 
       def initialize
-        super('failure_parser') do |input, cache, _name=nil|
-          L43Peg::Failure.new(cache:, input:, parsed_by: self, reason: "this parser always fails")
+        super('failure_parser') do |_|
+          L43Peg::Failure.new(parsed_by: self, reason: "this parser always fails", name: nil)
         end
       end
     end

data/lib/l43_peg/parsers/int_parser.rb

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-require_relative '../parsers'
-
 module L43Peg
   module Parsers
     class IntParser < L43Peg::Parser
-      extend L43Peg::Combinators
-      extend L43Peg::Mappers
-
       class << self
+        include Combinators
         def instance
           @__instance__ ||= _mk_int_parser
         end
@@ -16,10 +12,16 @@ module L43Peg
         private
 
         def _mk_int_parser
-          map(seq(many(Parsers.char_parser("+-"), max: 1), many(Parsers.char_parser("0".."9"), min: 1), name: "int_parser"), &join_and_to_i)
+          s = sequence(
+            many(Parsers.char_parser("+-"), max: 1),
+            many(Parsers.char_parser("0".."9"), min: 1),
+            name: "int_parser"
+          )
+          s = map(s, &Mappers.join_and_to_i)
+          map_error(s, name: 'int_parser', reason: 'could not parse int')
         end
-      end
 
+      end
     end
   end
 end

data/lib/l43_peg/parsers/list_parser.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Parsers
+    module ListParser extend self
+
+      def list_parser(
+        element_parser:,
+        name: nil, head_parser: nil, open_parser: nil, close_parser: nil, sep_parser: nil
+      )
+        name = name || "list_parser(#{element_parser.name})"
+        open_parser ||= char_parser(40).ignore # avoid literal open_paren for nvim indent for now
+        close_parser ||= char_parser(41).ignore # idem
+        sep_parser ||= ws_parser(min: 1).ignore
+        head_parser ||= element_parser
+
+        sequence(
+          open_parser,
+          head_parser,
+          many(
+            sequence(
+              sep_parser,
+              element_parser
+            ).map(&:first)
+          ),
+          close_parser
+        )
+          .map { |h, t| [h, *t] }
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers/literal_parser.rb

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

data/lib/l43_peg/parsers/name_parser.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Parsers
+    module NameParser extend self
+      def name_parser(name: nil, begin_rgx: :alpha, inner_rgx: /[_[:alnum:]]*/, with_box: nil)
+        name = name || "name_parser"
+        Combinators.map(RgxParser.new(begin_rgx, inner_rgx, name:), name:, &:to_sym)
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later