l43_peg 0.0.2 → 0.1.1

data/lib/l43/open_object.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module L43
+  module OpenObject
+    def attributes(*atts, **defaults)
+      attr_reader(*atts)
+      attr_reader(*defaults.keys)
+
+      define_method :== do |other|
+        other&.to_h == to_h
+      end
+
+      define_method :initialize do |**kwds|
+        missing = atts - kwds.keys
+        raise ArgumentError, "missing required keyword parameters: #{missing.inspect}" unless missing.empty?
+        spurious = kwds.keys - atts - defaults.keys
+        raise ArgumentError, "spurious keyword parameters: #{spurious.inspect}" unless spurious.empty?
+
+        values = defaults.merge(kwds)
+        values.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+        _init if respond_to?(:_init)
+      end
+
+      define_method :to_h do |*|
+        first = atts.inject Hash.new do |h, attribute|
+          h.update(attribute => send(attribute))
+        end
+      defaults.keys.inject first do |h, attribute|
+        h.update(attribute => send(attribute))
+      end
+      end
+      alias_method :deconstruct_keys, :to_h
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/require_helper.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Object
+  def require_subdir(path=nil, &blk)
+    Dir.glob(File.join([File.dirname(blk.source_location.first), path, '/**/*.rb'].compact)).each { require _1}
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/cache.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module L43Peg
+  class Cache
+    extend L43::OpenObject
+    attributes cache: {}
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg/combinators/many.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+module L43Peg
+  module Combinators
+    module Many extend self
+
+      include L43Peg::Helper
+      def many(input:, cache:, name:, parser:, min:, max:)
+        curr_input = input
+        curr_cache = cache
+        count = 0
+        ast   = []
+
+        loop do
+          if max && count == max
+            return succeed_parser(ast, curr_input, cache: curr_cache)
+          end
+          case parser.(curr_input, cache: curr_cache)
+          in L43Peg::Success => success
+            ast.push(success.ast)
+            curr_input = success.rest
+            curr_cache = success.cache
+            count += 1
+          in L43Peg::Failure
+            if count < min
+              return fail_parser("many #{name} should match at least #{min} times but did only #{count} times")
+            end
+            return succeed_parser(ast, curr_input, cache: curr_cache)
+          end
+        end
+      end
+
+    end
+  end
+end
+
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/combinators/seq.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../helper"
+module L43Peg
+  module Combinators
+    module Seq extend self
+
+      include L43Peg::Helper
+      def seq(input:, cache:, name:, parsers:)
+        curr_input = input
+        curr_cache = cache
+        ast = []
+        parsers.each do |parser|
+          case parser.(curr_input, cache: curr_cache)
+          in L43Peg::Failure => failure
+            return L43Peg::Failure.new(reason: "#{failure.reason} in (#{name})", position: failure.position, input:)
+          in L43Peg::Success => success
+            ast.push(success.ast)
+            curr_input = success.rest
+            curr_cache = success.cache
+          end
+        end
+        succeed_parser(ast, curr_input, cache: curr_cache) 
+      end
+
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/combinators.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require_relative 'mappers'
+require_relative 'parser'
+require_relative 'parsers'
+require_subdir('combinators') {}
+
+module L43Peg
+  module Combinators extend self
+
+    include L43Peg::Helper
+    include L43Peg::Mappers
+    include L43Peg::Parsers
+
+    def args_parser(definitions, name: nil, &block)
+      parser = tokens_parser(definitions, &block)
+      name   = name || "args_parser(#{definitions.inspect})"
+      inner  = many(parser)
+      map(inner, name:, fn: join_maps)
+    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 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
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/failure.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module L43Peg
+  class Failure
+    extend L43::OpenObject
+    attributes cache: nil, input: nil, parsed_by: nil, position: [1, 1], reason: ""
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg/helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Helper
+    def fail_parser(reason)
+      L43Peg::Failure.new(reason:)
+    end
+    def succeed_parser(ast, input, cache: nil)
+      L43Peg::Success.new(ast:, rest: input, cache: cache || input.cache)
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/input.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module L43Peg
+  class Input
+    extend L43::OpenObject
+
+    attributes col: 1, input: "", lnb: 1, context: {}
+    
+    def drop(by=nil)
+      case by
+      when nil
+        _drop_by_n(1)
+      when String
+        _drop_by_n(by.length)
+      else
+        _drop_by_n(by)
+      end
+    end
+
+    def empty? = input.empty?
+
+    def position = [@col, @lnb]
+
+    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:)
+    end
+
+    # Very inefficent but sufficent for my use cases so far
+    # and convenient for regex parsers
+    def _split(n)
+      head = input.slice(0...n)
+      lines = head.count("\n")
+      tail = input.slice(n..-1) || ''
+      new_col = 
+        if lines.zero?
+          col + n
+        else
+          1 + head.sub(%r{\A.*\n}m, "").length
+        end
+      [new_col, lnb + lines, head, tail]
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg/mappers.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Mappers
+
+    def join_and_to_i
+      -> list do
+        list.join.to_i
+      end
+    end
+    
+    def join_maps
+      -> maps do
+        maps.reduce Hash.new do |map, entry|
+          map.merge(entry) { |*args| args.drop(1).flatten }
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg/parser.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module L43Peg
+  class Parser
+
+    attr_reader :fn, :name
+
+    def call(input, cache: L43Peg::Cache.new) = fn.(input, cache, name)
+
+    private
+
+    def initialize(name, &fn)
+      @name = name
+      @fn = fn
+    end
+    
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg/parsers/char_parser.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Parsers
+    class CharParser < L43Peg::Parser
+
+      private
+
+      def initialize(charset=nil)
+        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)
+          else
+            L43Peg::Failure.new(cache:, input:, parsed_by: self, reason: "char #{input.input[0].inspect}")
+          end
+        end
+      end
+
+      def _mk_set(charset)
+        return unless charset
+        case charset
+        when String
+          Set.new(charset.split(""))
+        when Set
+          charset
+        else
+          Set.new(charset)
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers/end_parser.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../parsers'
+
+module L43Peg
+  module Parsers
+    class EndParser < L43Peg::Parser
+
+      def self.instance
+        @__instance__ ||= new
+      end
+
+      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")
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg/parsers/failure_parser.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Parsers
+    class FailureParser < L43Peg::Parser
+
+      def self.instance
+        @__instance__ ||= new
+      end
+
+      private
+
+      def initialize
+        super('failure_parser') do |input, cache, _name=nil|
+          L43Peg::Failure.new(cache:, input:, parsed_by: self, reason: "this parser always fails")
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers/int_parser.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../parsers'
+
+module L43Peg
+  module Parsers
+    class IntParser < L43Peg::Parser
+      extend L43Peg::Combinators
+      extend L43Peg::Mappers
+
+      class << self
+        def instance
+          @__instance__ ||= _mk_int_parser
+        end
+
+        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)
+        end
+      end
+
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/l43_peg/parsers/rgx_parser.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Parsers
+    class RgxParser < L43Peg::Parser
+
+      private
+
+      def initialize(rgx, name: nil, **options)
+        name = name || "rgx_parser(#{rgx.inspect})"
+        rgx = _mk_rgx(rgx)
+        super(name) do |input, cache, _name|
+          case rgx.match(input.input)
+          in MatchData => md
+            ast = _from_match(md, options) 
+            L43Peg::Success.new(ast:, cache:, rest: input.drop(md[0]), position: input.position)
+          else
+            L43Peg::Failure.new(cache:, input:, parsed_by: self, reason: "input does not match #{rgx.inspect} (in #{name})")
+          end
+        end
+      end
+
+      def _from_match(md, options)
+        case options[:capture]
+        in NilClass
+          md[1] || md[0]
+        in Integer => n
+          md[n]
+        in :all
+          md.to_a
+        end
+      end
+
+      def _mk_rgx(rgx)
+        case rgx
+        when String
+          Regexp.compile("\\A#{rgx}")
+        else
+         rgx
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_peg/parsers/token_parser.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module L43Peg
+  module Parsers
+    class TokenParser < L43Peg::Parser
+
+      private
+
+      def initialize(token_spec, name: nil, **options)
+        _check_arg!(token_spec)
+        name = name || "token_parser(#{token_spec.inspect})"
+        super(name) do |tokens, cache, _name|
+          if result = tokens.match(token_spec, options[:capture])
+            L43Peg::Success.new(ast: result, cache:, rest: tokens.drop(1), position: tokens.position)
+          else
+            reason = "token #{tokens.head.inspect} does not match #{token_spec.inspect} (in #{name})"
+            L43Peg::Failure.new(cache:, input: tokens, parsed_by: self, reason:)
+          end
+        end
+      end
+
+      def _check_arg!(token_spec)
+        case token_spec
+        when Regexp, String
+        else
+          raise ArgumentError, "#{token_spec.inspect} must be a regular expression or a string"
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

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.2"
-  
+  VERSION = "0.1.1"
 end
-# SPDX-License-Identifier: Apache-2.0
+# SPDX-License-Identifier: AGPL-3.0-or-later