l43_simple_peg 0.1.0.pre.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 23eaccca5eeb68df26e134c6f18f27b1d5507a629bc710c1a1a21ba22e2958ab
+  data.tar.gz: 0f3c03a9c45fbd0eb55df8fd8448106cb5ce26a215b8031352fdb7d069e21629
+SHA512:
+  metadata.gz: 0ce27fab43a70fea75c7e257418e600690f182a0e903104beeb35397097b1c2d633059b2548608bf7d23acf0d11211c666d20142e6a044df38f89a46ae195b49
+  data.tar.gz: 9dc045b2b19bfc1265e6576554c5d44574405d9666a39729f5d8da1374f732a2b4e0a8d0d1ecf72ed3062094d739db9cf3a4ebfae08f5204a5a0ec077764af92

data/lib/peg/class_methods.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'combinators'
+class Peg
+  module ClassMethods
+
+    PredefinedSymbols = {
+      dot: "\\.",
+      ws: ["\\s", :ignore],
+      wss: ["\\s*", :ignore],
+    }
+
+    def choice(*pegs, name: nil, &blk) = Combinators::Choice.new(*pegs, name:, &blk)
+
+    def ignore(peg, name: nil)
+      parser = Peg(peg)
+      name ||= "ignored(#{parser.name})"
+      parser.ignore
+    end
+
+    def list(ele_peg, sep_peg, min: 1, name: nil, &blk) = Combinators::List.new(ele_peg, sep_peg, min:, name:, &blk)
+
+    def from_sym(sym, name: nil, &blk)
+      regex = PredefinedSymbols.fetch(sym) do
+        return posix(sym, name:, &blk)
+      end
+
+      predefined_name = name || "predefined(#{sym})"
+      case regex
+      in rgx, :ignore
+        rgx(rgx, name: predefined_name, &blk).ignore
+      else
+        rgx(regex, name: predefined_name, &blk)
+      end
+    end
+
+    def posix(desc, name: nil, &blk)
+      name ||= "posix(#{desc.inspect})"
+      peg = if desc.to_s.end_with?("s")
+        rgx("[[:#{desc.to_s[0...-1]}:]]+", name:)
+      else
+        rgx("[[:#{desc.to_s}:]]", name:)
+      end
+      return peg unless blk
+      peg.map(&blk)
+    end
+
+    def rgx(source, name: nil)
+      name ||= "rgx(#{source.inspect})"
+      regexp = Regexp.compile("\\A#{source}")
+      new(name:) do |input|
+        if regexp.match(input) in MatchData => md
+          [md.match(0), input[md.match_length(0)..]]
+        end
+      end
+    end
+
+    def seq(*parsers, name: nil) = Combinators::Seq.new(*parsers, name:)
+
+    def set(chars, name: nil)
+      name ||= "Set(#{chars})"
+      rgx("[#{chars}]", name:)
+    end
+  end
+  extend ClassMethods
+    
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later
+

data/lib/peg/combinators/choice.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class Peg
+  module Combinators
+    class Choice < Peg
+      attr_reader :name, :fn, :pegs
+
+      private
+      def initialize(*pegs, name: nil)
+        @pegs = pegs.map { Peg(it) }
+        @name = name || pegs.map(&:name).join(" & ")
+        @fn = ->(input) { _parse(input) } 
+      end
+
+      def _parse(input)
+        pegs.each do |peg|
+          if peg.(input) in [_, _] => result
+            return result
+          end
+        end
+        nil
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg/combinators/list.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class Peg
+  module Combinators
+    class List < Peg
+      attr_reader :ele_peg, :fn, :min, :name, :sep_peg
+
+      private
+      def initialize(ele_peg, sep_peg, name: nil, min: 1, &blk)
+        @ele_peg = Peg(ele_peg, &blk)
+        @sep_peg = Peg(sep_peg)
+        @min = min
+
+        @name = name || "list(#{@ele_peg.name}, #{@sep_peg.name})"
+        @fn = ->(input) { _parse(input) } 
+      end
+
+      def _parse(input)
+        ast = []
+        count = min 
+
+        if ele_peg.(input) in ele, input
+          ast << ele
+          count -= 1
+        else
+          return nil
+        end
+
+        _parse_tail(ast, count: min - 1, input:)
+      end
+
+      def _parse_tail(ast, count:, input:)
+        loop do
+          if sep_peg.(input) in _, rest
+            if ele_peg.(rest) in ele, input
+              count -= 1
+              ast << ele
+            else
+              if count.positive?
+                return nil
+              else
+                return [ast, input]
+              end
+            end
+          else
+            if count.positive?
+              return nil
+            else
+              return [ast, input]
+            end
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg/combinators/many.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Peg
+  module Combinators
+    class Many < Peg
+      attr_reader :fn, :min, :name, :peg
+
+      private
+      def initialize(peg, name: nil, min: 1)
+        @peg = peg
+        @min = min
+        @name = name || "many(#{peg.name}, min: #{min})"
+        @fn = ->(input) { _parse(input) } 
+      end
+
+      def _parse(input)
+        count = min
+        ast = []
+        loop do
+          case peg.(input)
+          in partial_ast, input
+            count -= 1
+            ast << partial_ast
+          else
+            return if count.positive?
+            return [ast, input]
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg/combinators/seq.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Peg
+  module Combinators
+    class Seq < Peg
+      attr_reader :name, :fn, :pegs
+
+      private
+      def initialize(*pegs, name: nil)
+        @pegs = pegs.map { Peg(it) }
+        @name = name || @pegs.map(&:name).join(" & ")
+        @fn = ->(input) { _parse(input) } 
+      end
+
+      def _parse(input)
+        pegs.inject([[], input]) do |(ast, inp), peg|
+          # p(inp:, peg: peg.name, ast:)
+          if peg.(inp) in [partial, inp]
+            # p(partial:, inp:)
+            peg.ignore? ? [ast, inp] : [[*ast, partial], inp]
+          else
+            return nil
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg/combinators.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'combinators/choice'
+require_relative 'combinators/list'
+require_relative 'combinators/many'
+require_relative 'combinators/seq'
+class Peg
+  module Combinators
+      
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg/helpers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'class_methods'
+class Peg
+  module Helpers extend self
+      
+  end
+end
+
+def Peg(peg, name: nil)
+  name ||= "Peg(#{peg.inspect})"
+  case peg
+  when String
+    Peg.rgx(peg, name:)
+  when Symbol
+    Peg::Helpers.from_symbol
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg/parsers/time_parser/time_helper.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+class Time
+  def deconstruct(*)
+    [year, month, day, hour, min, seconds]
+  end
+
+  def deconstruct_keys(*)
+    {
+      year:,
+      month:,
+      day:,
+      hour:,
+      min:,
+      seconds:,
+    }
+  end
+
+  def seconds
+    s = to_f
+    s = sec + (s - s.floor) 
+  end
+end
+
+class Peg
+  module Parsers
+    module TimeParser
+      module TimeHelper extend self
+        Units = {
+          "s" => 1,
+          "m" => 60,
+          "h" => 3600,
+          "d" => 86400,
+          "w" => 604800,
+        }
+        def add_units(units)
+          units => sign, [*pairs]
+          sign = sign == "-" ? -1 : 1
+          sign * _add_pairs(pairs)
+        end
+
+        def complete_datetime(parts)
+          Time.now => {**} => now 
+          case parts
+          in :date, date
+            _complete_date(date, now)
+          in :time, time
+            _complete_time(time, now)
+          in [:date, date], [[:time, time]]
+            _complete_datetime(date, time, now)
+          end
+        end
+
+        private
+        def _add_pairs(pairs)
+          pairs.inject(0) do |result, (amount, unit)|
+            result + amount.to_i * Units.fetch(unit)
+          end
+        end
+
+        def _complete_date(date, now)
+          case date
+          in 0, d
+            [now.year, now.month, d, now.hour, now.min, now.seconds]
+          in m, d
+            [now.year, m, d, now.hour, now.min, now.seconds]
+          in y, m, d
+            [now.year/100 * 100 + y, m, d, now.hour, now.min, now.seconds]
+          else
+            raise ArgumentError, "need a pair or triplet, got: #{date.inspect}"
+          end
+        end
+
+        def _complete_datetime(date, time, now)
+          date_triplet = _complete_date(date, now)[0..2]
+          time_triplet = _complete_time(time, now)[3..]
+          date_triplet + time_triplet
+        end
+
+        def _complete_time(time, now)
+          case time
+          in 0, s
+            [now.year, now.month, now.day, now.hour, now.min, s]
+          in m, s
+            [now.year, now.month, now.day, now.hour, m, s]
+          in h, m, s
+            [now.year, now.month, now.day, h, m, s]
+          else
+            raise ArgumentError, "need a pair or triplet, got: #{time.inspect}"
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg/parsers/time_parser.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'peg'
+require_relative 'time_parser/time_helper'
+class Peg
+  module Parsers
+    module TimeParser extend self
+
+      def datetime_parser =  @__datetime_parser__ ||= _datetime_parser
+
+      def time_parser =  @__time_parser__ ||= _time_parser
+
+      def timestamp_parser =  @__timestamp_parser__ ||= _timestamp_parser
+      def timestamp_float_parser =  @__timestamp_float_parser__ ||= _timestamp_float_parser
+      def timestamp_int_parser =  @__timestamp_int_parser__ ||= _timestamp_int_parser
+
+      def offset_parser =  @__offset_parser__ ||= _offset_parser
+      def offset_in_seconds_parser =  @__offset_in_seconds_parser__ ||= _offset_in_seconds_parser
+      def offset_in_float_seconds_parser =  @__offset_in_float_seconds_parser__ ||= _offset_in_float_seconds_parser
+      def offset_in_int_seconds_parser =  @__offset_in_int_seconds_parser__ ||= _offset_in_int_seconds_parser
+      def offset_with_units_parser =  @__offset_with_units_parser__ ||= _offset_with_units_parser
+
+      def only_date_parser =  @__only_date_parser__ ||= _only_date_parser
+      def only_time_parser =  @__only_time_parser__ ||= _only_time_parser
+
+      private
+
+      def _datetime_parser
+        Peg.choice(
+          Peg.seq(only_date_parser, Peg.seq(Peg.ignore("T"), only_time_parser)),
+          only_date_parser,
+          only_time_parser,
+        ).map{ [:datetime, TimeHelper.complete_datetime(it)] }
+      end
+
+      def _offset_in_float_seconds_parser
+        Peg.seq(Peg.set("+-"), :digits, "\\.", :digits, name: "offset in float seconds parser")
+          .joined.map(&:to_f)
+      end
+
+      def _offset_in_int_seconds_parser
+        Peg.seq(Peg.set("+-"), :digits, name: "offset in int seconds parser")
+          .joined.map(&:to_i)
+      end
+
+      def _offset_in_seconds_parser
+        offset_in_float_seconds_parser.or(offset_in_int_seconds_parser)
+      end
+
+      def _offset_parser
+        Peg.choice(
+          offset_with_units_parser,
+          offset_in_seconds_parser,
+          name: "offset parser"
+        ).map { [:offset, it] }
+      end
+
+      def _offset_with_units_parser
+        Peg.seq(Peg.set("-+").optional, _time_unit_parser).map { TimeHelper.add_units(it) }
+      end
+
+      def _only_date_parser
+        Peg.list(:digits, "-", min: 2, &:to_i).map { [:date, it] }
+      end
+
+      def _only_time_parser
+        Peg.list(:digits, ":", min: 2, &:to_i).map { [:time, it] }
+      end
+
+      def _time_parser
+        Peg.choice(
+          offset_parser,
+          datetime_parser,
+          timestamp_parser
+        )
+      end
+
+      def _time_unit_parser
+        unit_parser = Peg.seq(:digits, Peg.set(TimeHelper::Units.keys.join))
+        unit_parser.many
+      end
+
+      def _timestamp_parser
+        Peg.choice(
+          timestamp_float_parser,
+          timestamp_int_parser
+        ).map { [:timestamp, it] }
+      end
+
+      def _timestamp_float_parser
+        Peg.seq(:digits, :dot, :digits).joined.map(&:to_f)
+      end
+
+      def _timestamp_int_parser
+        Peg.seq(:digits).joined.map(&:to_i)
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg/result.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Peg
+  class Result
+    attr_reader :ast, :name, :rest
+
+    def deconstruct(*) = [ast, rest] 
+
+    def deconstruct_keys(*) = {
+      ast:,
+      name:,
+      rest:,
+    }
+
+      def ==(other) 
+        self.class === other && ast == other.ast && rest == other.rest
+      end
+
+      def len = match.length
+
+      def ignore? = @ignore
+
+      private
+      def initialize(ast, rest, name: nil)
+        @ast = ast
+        @rest = rest
+        @name = name
+      end
+
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg/set.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Peg
+  class Set < Peg
+    private
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Peg
+  VERSION = '0.1.0-pre'
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later
+

data/lib/peg.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'peg/class_methods'
+require_relative 'peg/result'
+class Peg
+  attr_reader :fn, :name
+
+  def call(input)
+    fn.(input).tap do |result|
+      # $stderr.puts(input) if $debug # :nocov:
+      # $stderr.puts({name:, result:}.inspect) if $debug # :nocov:
+    end
+  end
+
+  def ignore
+    @ignore = true
+    self
+  end
+
+  def ignore? = @ignore
+
+  def joined(joiner: "", name: nil)
+    name ||= "joined(#{self.name})"
+    Peg.new(name:) do |input|
+      case fn.(input)
+      in ast, rest
+        [ast.join(joiner), rest]
+      else
+        nil
+      end
+    end
+  end
+
+  def many(name: nil, min: 1)
+    name ||= "many(#{self.name}, min: #{min})"
+    Combinators::Many.new(self, name:, min:)
+  end
+
+  def map(name: nil, &mapper)
+    name ||= "map(#{self.name})"
+    Peg.new(name:) do |input|
+      case fn.(input)
+      in ast, rest
+        [mapper.(ast), rest]
+      else
+        nil
+      end
+    end
+  end
+
+  def or(peg, name: nil, &blk) = Combinators::Choice.new(self, peg, name:, &blk)
+
+  def parse(input)
+    case self.(input)
+    in ast, rest
+      Result.new(ast, rest, name:)
+    else
+      nil
+    end
+  end
+
+  def optional(name: nil)
+    name ||= "optional(#{self.name})"
+    self.class.new(name:) do |input|
+      if fn.(input) in [_, _] => result
+        result
+      else
+        [nil, input]
+      end
+    end
+  end
+
+  private
+  def initialize(name: nil, &fn)
+    @name = name
+    @fn = fn
+    @ignore = false
+  end
+end
+
+def Peg(peg, name: nil, &blk)
+  name ||= "Peg(#{peg.inspect})"
+  case peg
+  when String
+    Peg.rgx(peg, name:, &blk)
+  when Symbol
+    Peg.from_sym(peg, name:, &blk)
+  when Peg
+    peg
+  else
+    raise ArgumentError, "unexpected arg: #{peg.inspect}, need a String, Symbol or Peg instance"
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: l43_simple_peg
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre.pre
+platform: ruby
+authors:
+- Robert Dober
+bindir: bin
+cert_chain: []
+date: 2026-09-28 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
+description: 'peg
+
+  '
+email: robert.dober@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/peg.rb
+- lib/peg/class_methods.rb
+- lib/peg/combinators.rb
+- lib/peg/combinators/choice.rb
+- lib/peg/combinators/list.rb
+- lib/peg/combinators/many.rb
+- lib/peg/combinators/seq.rb
+- lib/peg/helpers.rb
+- lib/peg/parsers/time_parser.rb
+- lib/peg/parsers/time_parser/time_helper.rb
+- lib/peg/result.rb
+- lib/peg/set.rb
+- lib/peg/version.rb
+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.19
+specification_version: 4
+summary: peg
+test_files: []